org.glassfish.grizzly.nio.AbstractNIOAsyncQueueWriter java code examples

/**
 * {@inheritDoc}
 */
@Deprecated
@Override
public boolean canWrite(final Connection<SocketAddress> connection,
    final int size) {
  return canWrite(connection);
}

/**
 * {@inheritDoc}
 */
@Deprecated
@Override
public void notifyWritePossible(final Connection<SocketAddress> connection,
    final WriteHandler writeHandler, final int size) {
  notifyWritePossible(connection, writeHandler);
}

@Override
public void write(final Connection<SocketAddress> connection,
    final SocketAddress dstAddress, final WritableMessage message,
    final CompletionHandler<WriteResult<WritableMessage, SocketAddress>> completionHandler,
    final MessageCloner<WritableMessage> cloner) {
  write(connection, dstAddress, message, completionHandler, null, cloner);
}

final AsyncWriteQueueRecord queueRecord = createRecord(
    nioConnection, message, completionHandler,
    dstAddress, pushBackHandler,
  onWriteFailure(nioConnection, queueRecord,
      nioConnection.getCloseReason().getCause());
  return;
  doFineLog("AsyncQueueWriter.write connection={0}, record={1}, "
      + "directWrite={2}, size={3}, isUncountable={4}, "
      + "bytesToReserve={5}, pendingBytes={6}",
        cloneRecordIfNeeded(nioConnection, cloner, message));
    final RecordWriteResult writeResult = write0(nioConnection, queueRecord);
    final int bytesToRelease = (int) writeResult.bytesToReleaseAfterLastWrite();
      doFineLog("AsyncQueueWriter.write directWrite connection={0}, record={1}, "
          + "isFinished={2}, remaining={3}, isUncountable={4}, "
          + "bytesToRelease={5}, pendingBytesAfterRelease={6}",
      cloneRecordIfNeeded(nioConnection, cloner, message));
    doFineLog("AsyncQueueWriter.write queuing connection={0}, record={1}, "
        + "size={2}, isUncountable={3}",
        nioConnection, queueRecord, queueRecord.remaining(),
    onReadyToWrite(nioConnection);
  } else {

while ((queueRecord = aggregate(writeTaskQueue)) != null) {
  if (isLogFine) {
    doFineLog("AsyncQueueWriter.processAsync beforeWrite "
        + "connection={0} record={1}",
        nioConnection, queueRecord);
  final RecordWriteResult writeResult = write0(nioConnection, queueRecord);
  final int bytesToRelease = (int) writeResult.bytesToReleaseAfterLastWrite();
    doFineLog("AsyncQueueWriter.processAsync written "
        + "connection={0}, written={1}, done={2}, "
        + "bytesToRelease={3}, bytesReleased={4}",
    finishQueueRecord(nioConnection, queueRecord);
  } else { // if there is still some data in current message
    queueRecord.notifyIncomplete();
    writeTaskQueue.setCurrentElement(queueRecord);
    if (isLogFine) {
      doFineLog("AsyncQueueWriter.processAsync onReadyToWrite "
          + "connection={0} peekRecord={1}",
          nioConnection, queueRecord);
      && writeTaskQueue.spaceInBytes() - bytesReleased <= 0) {
    if (isLogFine) {
      doFineLog("AsyncQueueWriter.processAsync setManualIOEventControl "
          + "connection={0}", nioConnection);
  doFineLog("AsyncQueueWriter.processAsync exit "
      + "connection={0}, done={1}, isComplete={2}, "

private static void finishQueueRecord(final NIOConnection nioConnection,
    final AsyncWriteQueueRecord queueRecord) {
  final boolean isLogFine = LOGGER.isLoggable(Level.FINEST);
  
  if (isLogFine) {
    doFineLog("AsyncQueueWriter.processAsync finished "
        + "connection={0} record={1}",
        nioConnection, queueRecord);
  }
  if (queueRecord != null) {
    queueRecord.notifyCompleteAndRecycle();
  }
  
  if (isLogFine) {
    doFineLog("AsyncQueueWriter.processAsync finishQueueRecord "
        + "connection={0} queueRecord={1}",
        nioConnection, queueRecord);
  }
}

final AsyncWriteQueueRecord queueRecord = createRecord(
    nioConnection, message, completionHandler,
    dstAddress, pushBackHandler,
  onWriteFailure(nioConnection, queueRecord,
      nioConnection.getCloseReason().getCause());
  return;
  doFineLog("AsyncQueueWriter.write connection={0}, record={1}, "
      + "directWrite={2}, size={3}, isUncountable={4}, "
      + "bytesToReserve={5}, pendingBytes={6}",
        cloneRecordIfNeeded(nioConnection, cloner, message));
    final RecordWriteResult writeResult = write0(nioConnection, queueRecord);
    final int bytesToRelease = (int) writeResult.bytesToReleaseAfterLastWrite();
      doFineLog("AsyncQueueWriter.write directWrite connection={0}, record={1}, "
          + "isFinished={2}, remaining={3}, isUncountable={4}, "
          + "bytesToRelease={5}, pendingBytesAfterRelease={6}",
      cloneRecordIfNeeded(nioConnection, cloner, message));
    doFineLog("AsyncQueueWriter.write queuing connection={0}, record={1}, "
        + "size={2}, isUncountable={3}",
        nioConnection, queueRecord, queueRecord.remaining(),
    onReadyToWrite(nioConnection);
  } else {

while ((queueRecord = aggregate(writeTaskQueue)) != null) {
  if (isLogFine) {
    doFineLog("AsyncQueueWriter.processAsync beforeWrite "
        + "connection={0} record={1}",
        nioConnection, queueRecord);
  final RecordWriteResult writeResult = write0(nioConnection, queueRecord);
  final int bytesToRelease = (int) writeResult.bytesToReleaseAfterLastWrite();
    doFineLog("AsyncQueueWriter.processAsync written "
        + "connection={0}, written={1}, done={2}, "
        + "bytesToRelease={3}, bytesReleased={4}",
    finishQueueRecord(nioConnection, queueRecord);
  } else { // if there is still some data in current message
    queueRecord.notifyIncomplete();
    writeTaskQueue.setCurrentElement(queueRecord);
    if (isLogFine) {
      doFineLog("AsyncQueueWriter.processAsync onReadyToWrite "
          + "connection={0} peekRecord={1}",
          nioConnection, queueRecord);
      && writeTaskQueue.spaceInBytes() - bytesReleased <= 0) {
    if (isLogFine) {
      doFineLog("AsyncQueueWriter.processAsync setManualIOEventControl "
          + "connection={0}", nioConnection);
  doFineLog("AsyncQueueWriter.processAsync exit "
      + "connection={0}, done={1}, isComplete={2}, "

private static void finishQueueRecord(final NIOConnection nioConnection,
    final AsyncWriteQueueRecord queueRecord) {
  final boolean isLogFine = LOGGER.isLoggable(Level.FINEST);
  
  if (isLogFine) {
    doFineLog("AsyncQueueWriter.processAsync finished "
        + "connection={0} record={1}",
        nioConnection, queueRecord);
  }
  if (queueRecord != null) {
    queueRecord.notifyCompleteAndRecycle();
  }
  
  if (isLogFine) {
    doFineLog("AsyncQueueWriter.processAsync finishQueueRecord "
        + "connection={0} queueRecord={1}",
        nioConnection, queueRecord);
  }
}

final AsyncWriteQueueRecord queueRecord = createRecord(
    nioConnection, message, completionHandler,
    dstAddress, pushBackHandler,
  onWriteFailure(nioConnection, queueRecord,
      nioConnection.getCloseReason().getCause());
  return;
  doFineLog("AsyncQueueWriter.write connection={0}, record={1}, "
      + "directWrite={2}, size={3}, isUncountable={4}, "
      + "bytesToReserve={5}, pendingBytes={6}",
        cloneRecordIfNeeded(nioConnection, cloner, message));
    final RecordWriteResult writeResult = write0(nioConnection, queueRecord);
    final int bytesToRelease = (int) writeResult.bytesToReleaseAfterLastWrite();
      doFineLog("AsyncQueueWriter.write directWrite connection={0}, record={1}, "
          + "isFinished={2}, remaining={3}, isUncountable={4}, "
          + "bytesToRelease={5}, pendingBytesAfterRelease={6}",
      cloneRecordIfNeeded(nioConnection, cloner, message));
    doFineLog("AsyncQueueWriter.write queuing connection={0}, record={1}, "
        + "size={2}, isUncountable={3}",
        nioConnection, queueRecord, queueRecord.remaining(),
    onReadyToWrite(nioConnection);
  } else {

while ((queueRecord = aggregate(writeTaskQueue)) != null) {
  if (isLogFine) {
    doFineLog("AsyncQueueWriter.processAsync beforeWrite "
        + "connection={0} record={1}",
        nioConnection, queueRecord);
  final RecordWriteResult writeResult = write0(nioConnection, queueRecord);
  final int bytesToRelease = (int) writeResult.bytesToReleaseAfterLastWrite();
    doFineLog("AsyncQueueWriter.processAsync written "
        + "connection={0}, written={1}, done={2}, "
        + "bytesToRelease={3}, bytesReleased={4}",
    finishQueueRecord(nioConnection, queueRecord);
  } else { // if there is still some data in current message
    queueRecord.notifyIncomplete();
    writeTaskQueue.setCurrentElement(queueRecord);
    if (isLogFine) {
      doFineLog("AsyncQueueWriter.processAsync onReadyToWrite "
          + "connection={0} peekRecord={1}",
          nioConnection, queueRecord);
      && writeTaskQueue.spaceInBytes() - bytesReleased <= 0) {
    if (isLogFine) {
      doFineLog("AsyncQueueWriter.processAsync setManualIOEventControl "
          + "connection={0}", nioConnection);
  doFineLog("AsyncQueueWriter.processAsync exit "
      + "connection={0}, done={1}, isComplete={2}, "

@Override
public void write(final Connection<SocketAddress> connection,
    final SocketAddress dstAddress, final WritableMessage message,
    final CompletionHandler<WriteResult<WritableMessage, SocketAddress>> completionHandler,
    final MessageCloner<WritableMessage> cloner) {
  write(connection, dstAddress, message, completionHandler, null, cloner);
}

/**
 * {@inheritDoc}
 */
@Deprecated
@Override
public void notifyWritePossible(final Connection<SocketAddress> connection,
    final WriteHandler writeHandler, final int size) {
  notifyWritePossible(connection, writeHandler);
}

/**
 * {@inheritDoc}
 */
@Deprecated
@Override
public boolean canWrite(final Connection<SocketAddress> connection,
    final int size) {
  return canWrite(connection);
}

private static void finishQueueRecord(final NIOConnection nioConnection,
    final AsyncWriteQueueRecord queueRecord) {
  final boolean isLogFine = LOGGER.isLoggable(Level.FINEST);
  
  if (isLogFine) {
    doFineLog("AsyncQueueWriter.processAsync finished "
        + "connection={0} record={1}",
        nioConnection, queueRecord);
  }
  if (queueRecord != null) {
    queueRecord.notifyCompleteAndRecycle();
  }
  
  if (isLogFine) {
    doFineLog("AsyncQueueWriter.processAsync finishQueueRecord "
        + "connection={0} queueRecord={1}",
        nioConnection, queueRecord);
  }
}

final AsyncWriteQueueRecord queueRecord = createRecord(
    nioConnection, message, completionHandler,
    dstAddress, pushBackHandler,
  onWriteFailure(nioConnection, queueRecord,
      nioConnection.getCloseReason().getCause());
  return;
  doFineLog("AsyncQueueWriter.write connection={0}, record={1}, "
      + "directWrite={2}, size={3}, isUncountable={4}, "
      + "bytesToReserve={5}, pendingBytes={6}",
        cloneRecordIfNeeded(nioConnection, cloner, message));
    final RecordWriteResult writeResult = write0(nioConnection, queueRecord);
    final int bytesToRelease = (int) writeResult.bytesToReleaseAfterLastWrite();
      doFineLog("AsyncQueueWriter.write directWrite connection={0}, record={1}, "
          + "isFinished={2}, remaining={3}, isUncountable={4}, "
          + "bytesToRelease={5}, pendingBytesAfterRelease={6}",
      cloneRecordIfNeeded(nioConnection, cloner, message));
    doFineLog("AsyncQueueWriter.write queuing connection={0}, record={1}, "
        + "size={2}, isUncountable={3}",
        nioConnection, queueRecord, queueRecord.remaining(),
    onReadyToWrite(nioConnection);
  } else {

while ((queueRecord = aggregate(writeTaskQueue)) != null) {
  if (isLogFine) {
    doFineLog("AsyncQueueWriter.processAsync beforeWrite "
        + "connection={0} record={1}",
        nioConnection, queueRecord);
  final RecordWriteResult writeResult = write0(nioConnection, queueRecord);
  final int bytesToRelease = (int) writeResult.bytesToReleaseAfterLastWrite();
    doFineLog("AsyncQueueWriter.processAsync written "
        + "connection={0}, written={1}, done={2}, "
        + "bytesToRelease={3}, bytesReleased={4}",
    finishQueueRecord(nioConnection, queueRecord);
  } else { // if there is still some data in current message
    queueRecord.notifyIncomplete();
    writeTaskQueue.setCurrentElement(queueRecord);
    if (isLogFine) {
      doFineLog("AsyncQueueWriter.processAsync onReadyToWrite "
          + "connection={0} peekRecord={1}",
          nioConnection, queueRecord);
      && writeTaskQueue.spaceInBytes() - bytesReleased <= 0) {
    if (isLogFine) {
      doFineLog("AsyncQueueWriter.processAsync setManualIOEventControl "
          + "connection={0}", nioConnection);
  doFineLog("AsyncQueueWriter.processAsync exit "
      + "connection={0}, done={1}, isComplete={2}, "

@Override
public void write(final Connection<SocketAddress> connection,
    final SocketAddress dstAddress, final WritableMessage message,
    final CompletionHandler<WriteResult<WritableMessage, SocketAddress>> completionHandler,
    final MessageCloner<WritableMessage> cloner) {
  write(connection, dstAddress, message, completionHandler, null, cloner);
}

/**
 * {@inheritDoc}
 */
@Deprecated
@Override
public void notifyWritePossible(final Connection<SocketAddress> connection,
    final WriteHandler writeHandler, final int size) {
  notifyWritePossible(connection, writeHandler);
}

/**
 * {@inheritDoc}
 */
@Deprecated
@Override
public boolean canWrite(final Connection<SocketAddress> connection,
    final int size) {
  return canWrite(connection);
}

Javadoc

The AsyncQueueWriter implementation, based on the Java NIO

Most used methods

aggregate
Aggregates records in a queue to be written as one chunk.
canWrite
cloneRecordIfNeeded
createRecord
doFineLog
finishQueueRecord
notifyWritePossible
onReadyToWrite
onWriteFailure
write
write0

write0

Popular in Java

Running tasks concurrently on multiple threads
scheduleAtFixedRate (Timer)
getSupportFragmentManager (FragmentActivity)
getResourceAsStream (ClassLoader)
EOFException (java.io)
Thrown when a program encounters the end of a file or stream during an input operation.
PrintWriter (java.io)
Wraps either an existing OutputStream or an existing Writerand provides convenience methods for prin
ConnectException (java.net)
A ConnectException is thrown if a connection cannot be established to a remote host on a specific po
SimpleDateFormat (java.text)
Formats and parses dates in a locale-sensitive manner. Formatting turns a Date into a String, and pa
Calendar (java.util)
Calendar is an abstract base class for converting between a Date object and a set of integer fields
Timer (java.util)
Timers schedule one-shot or recurring TimerTask for execution. Prefer java.util.concurrent.Scheduled
Top 12 Jupyter Notebook extensions

How to useAbstractNIOAsyncQueueWriter in org.glassfish.grizzly.nio

Best Java code snippets using org.glassfish.grizzly.nio.AbstractNIOAsyncQueueWriter (Showing top 20 results out of 315)

How to use
AbstractNIOAsyncQueueWriter
in
org.glassfish.grizzly.nio