Representing a Buffer as a NIO ByteBuffer

I recently needed to turn a Okio Buffer into a NIO ByteBuffer so I could pass it to AsynchronousSocketChannel to perform reads from the channel using Kotlin coroutines.

private suspend fun AsynchronousSocketChannel.aRead(
  buffer: Buffer,
  cursor: Buffer.UnsafeCursor
): Long {
  buffer.readAndWriteUnsafe(cursor).use {
    val oldSize = buffer.size()
    cursor.seek(oldSize)

    cursor.expandBuffer(8192)
    val length = cursor.end - cursor.start
    val read = aRead(ByteBuffer.wrap(cursor.data, cursor.start, length), 5, TimeUnit.SECONDS)

    if (read == -1) {
      cursor.resizeBuffer(oldSize)
      return -1
    } else {
      cursor.resizeBuffer(oldSize + read)
      return read.toLong()
    }
  }
}

Is this pattern worth a sample? Another use case for Buffer cursors that show off some their power. Maybe demonstrate how to turn a ReadableByteChannel/WriteableByteChannel into a Source/Sink? Happy to put something together and open a pull-request just wanted to make sure it was something worthwhile.

final class ByteChannelSource implements Source {
  private final ReadableByteChannel channel;
  private final Buffer.UnsafeCursor cursor = new Buffer.UnsafeCursor();

  public ByteChannelSource(ReadableByteChannel channel) {
    this.channel = channel;
  }

  @Override
  public long read(Buffer sink, long byteCount) throws IOException {
    try (Buffer.UnsafeCursor ignored = sink.readAndWriteUnsafe(cursor)) {
      long oldSize = sink.size();
      cursor.seek(oldSize);

      cursor.expandBuffer(8192);
      long length = Math.min(cursor.end - cursor.start, byteCount);
      int read = channel.read(ByteBuffer.wrap(cursor.data, cursor.start, (int) length));

      if (read == -1) {
        cursor.resizeBuffer(oldSize);
        return -1;
      } else {
        cursor.resizeBuffer(oldSize + read);
        return read;
      }
    }
  }

  @Override
  public Timeout timeout() {
    return Timeout.NONE;
  }

  @Override
  public void close() throws IOException {
    channel.close();
  }
}

[bnorm]

Finally got back around to this a little. I put together a gist showing extension functions for reading and writing to async socket and file channels using a Buffer as the source/sink.

As for Dispatcher, coroutines already allow you to jump between context/thread pools. So your example could become something like this:

suspend fun Http2Reader.readAllFrames(
    ioContext: CoroutineContext, handler Http2Reader.Handler) {
  while (true) {
    while (!hasFullFrame(source.buffer)) {
      withContext(ioContext) {
        source.read()
      }
    }
    // Decode frame and call handler.
  }
}

Where ioContext would be a dedicated thread pool of some kind and where everything in the withContext block would be executed on. I think all of the coroutine behavior you want already exists. However, this would require a dependency on the kotlinx.coroutines library unless you want to re-implement a small part of that library for Okio.

[bnorm]

I’m guessing this ticket can be closed and the coroutine discussion can continue in #501. The ByteChannel side of this ticket is resolved.