Java IoCallback类代码示例

import io.undertow.io.IoCallback; //导入依赖的package包/类
private boolean writeBuffer(final ByteBuffer buffer, final IoCallback callback) {
    StringBuilder builder = new StringBuilder();
    try {
        builder.append(charsetDecoder.decode(buffer));
    } catch (CharacterCodingException e) {
        callback.onException(exchange, this, e);
        return false;
    }
    String data = builder.toString();
    writer.write(data);
    if (writer.checkError()) {
        callback.onException(exchange, this, new IOException());
        return false;
    }
    return true;
}
 

import io.undertow.io.IoCallback; //导入依赖的package包/类
private void queue(final ByteBuffer[] byteBuffers, final IoCallback ioCallback) {
    //if data is sent from withing the callback we queue it, to prevent the stack growing indefinitely
    if (next != null || pendingFile != null) {
        throw UndertowMessages.MESSAGES.dataAlreadyQueued();
    }
    StringBuilder builder = new StringBuilder();
    for (ByteBuffer buffer : byteBuffers) {
        try {
            builder.append(charsetDecoder.decode(buffer));
        } catch (CharacterCodingException e) {
            ioCallback.onException(exchange, this, e);
            return;
        }
    }
    this.next = builder.toString();
    queuedCallback = ioCallback;
}
 

import io.undertow.io.IoCallback; //导入依赖的package包/类
@Override
public UndertowResponse writeBinary(ISObject binary) {
    beforeWritingContent();
    File file = tryGetFileFrom(binary);
    if (null == file) {
        byte[] ba = binary.asByteArray();
        ByteBuffer buffer = ByteBuffer.wrap(ba);
        hse.getResponseSender().send(buffer);
    } else {
        try {
            hse.getResponseSender().transferFrom(FileChannel.open(file.toPath()), IoCallback.END_EXCHANGE);
            endAsync = true;
        } catch (IOException e) {
            endAsync = false;
            throw E.ioException(e);
        }
    }
    afterWritingContent();
    return this;
}
 

import io.undertow.io.IoCallback; //导入依赖的package包/类
@Test
public void onException() throws Exception {
  IOException x = new IOException("intentional err");
  new MockUnit(IoCallback.class, HttpServerExchange.class, Sender.class, Logger.class)
      .expect(unit -> {
        unit.mockStatic(LoggerFactory.class);

        Logger log = unit.get(Logger.class);
        log.error("execution of {} resulted in exception", "/assets/main.js", x);

        expect(LoggerFactory.getLogger(NativeResponse.class)).andReturn(log);
        HttpServerExchange exchange = unit.get(HttpServerExchange.class);
        expect(exchange.getRequestPath()).andReturn("/assets/main.js");
        unit.get(IoCallback.class).onException(exchange, unit.get(Sender.class), x);
      })
      .run(unit -> {
        new LogIoCallback(unit.get(IoCallback.class))
            .onException(unit.get(HttpServerExchange.class), unit.get(Sender.class), x);
      });
}
 

import io.undertow.io.IoCallback; //导入依赖的package包/类
@Test
public void send() throws Exception {
  byte[] bytes = {0};
  CountDownLatch latch = new CountDownLatch(1);
  new MockUnit(HttpServerExchange.class, Sender.class)
    .expect(unit -> {
      Sender sender = unit.get(Sender.class);
      sender.send(eq(ByteBuffer.wrap(bytes)), unit.capture(IoCallback.class));

      HttpServerExchange exchange = unit.get(HttpServerExchange.class);
      expect(exchange.getResponseSender()).andReturn(sender);
    })
    .run(unit -> {
      new UndertowSse(unit.get(HttpServerExchange.class))
        .send(Optional.of("id"), bytes).whenComplete((id, x) -> {
        if (id != null) {
          assertEquals("id", id.get());
          latch.countDown();
        }
      });
    }, unit -> {
      IoCallback callback = unit.captured(IoCallback.class).iterator().next();
      callback.onComplete(unit.get(HttpServerExchange.class), unit.get(Sender.class));
      latch.await();
    });
}
 

import io.undertow.io.IoCallback; //导入依赖的package包/类
@Test
public void sendNoIoThread2Chunks() throws Exception {
  new MockUnit(ReadableByteChannel.class, HttpServerExchange.class, IoCallback.class,
      Sender.class, PooledByteBuffer.class)
      .expect(exchange)
      .expect(noIoThread)
      .expect(pooled)
      .expect(readLargeChunk)
      .expect(transferEncoding)
      .expect(sendChunk)
      .expect(noIoThread)
      .expect(pooled)
      .expect(readChunk)
      .expect(sendChunk)
      .run(unit -> {
        ChunkedStream chunkedStream = new ChunkedStream();
        chunkedStream.send(unit.get(ReadableByteChannel.class),
            unit.get(HttpServerExchange.class), unit.get(IoCallback.class));
        chunkedStream.onComplete(unit.get(HttpServerExchange.class), unit.get(Sender.class));
      });
}
 

import io.undertow.io.IoCallback; //导入依赖的package包/类
@Test
public void sendNoIoThread2ChunksWithLen() throws Exception {
  new MockUnit(ReadableByteChannel.class, HttpServerExchange.class, IoCallback.class,
      Sender.class, PooledByteBuffer.class)
      .expect(exchange)
      .expect(noIoThread)
      .expect(pooled)
      .expect(readLargeChunk)
      .expect(len)
      .expect(sendChunk)
      .expect(noIoThread)
      .expect(pooled)
      .expect(readChunk)
      .expect(sendChunk)
      .run(unit -> {
        ChunkedStream chunkedStream = new ChunkedStream();
        chunkedStream.send(unit.get(ReadableByteChannel.class),
            unit.get(HttpServerExchange.class), unit.get(IoCallback.class));
        chunkedStream.onComplete(unit.get(HttpServerExchange.class), unit.get(Sender.class));
      });
}
 

import io.undertow.io.IoCallback; //导入依赖的package包/类
@Test
public void sendIoThread() throws Exception {
  new MockUnit(ReadableByteChannel.class, HttpServerExchange.class, IoCallback.class,
      Sender.class, PooledByteBuffer.class)
      .expect(exchange)
      .expect(ioThread)
      .expect(pooled)
      .expect(readChunk)
      .expect(nolen)
      .expect(sendChunk)
      .run(unit -> {
        ChunkedStream chunkedStream = new ChunkedStream();
        chunkedStream.send(unit.get(ReadableByteChannel.class),
            unit.get(HttpServerExchange.class), unit.get(IoCallback.class));
        chunkedStream.run();
      });
}
 

import io.undertow.io.IoCallback; //导入依赖的package包/类
@Override
public void send(final ByteBuffer buffer, final IoCallback callback) {
    if (inCall) {
        queue(new ByteBuffer[]{buffer}, callback);
        return;
    }
    if (writeBuffer(buffer, callback)) {
        invokeOnComplete(callback);
    }
}
 

import io.undertow.io.IoCallback; //导入依赖的package包/类
@Override
public void transferFrom(FileChannel source, IoCallback callback) {
    if (inCall) {
        queue(source, callback);
        return;
    }
    performTransfer(source, callback);
}
 

import io.undertow.io.IoCallback; //导入依赖的package包/类
private void performTransfer(FileChannel source, IoCallback callback) {

        ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
        try {
            long pos = source.position();
            long size = source.size();
            while (size - pos > 0) {
                int ret = source.read(buffer);
                if (ret <= 0) {
                    break;
                }
                pos += ret;
                buffer.flip();
                if (!writeBuffer(buffer, callback)) {
                    return;
                }
                buffer.clear();
            }

            if (pos != size) {
                throw new EOFException("Unexpected EOF reading file");
            }

        } catch (IOException e) {
            callback.onException(exchange, this, e);
        }
        invokeOnComplete(callback);
    }
 

import io.undertow.io.IoCallback; //导入依赖的package包/类
/**
 * Sends a continuation using async IO, and calls back when it is complete.
 *
 * @param exchange The exchange
 * @param callback The completion callback
 */
public static void sendContinueResponse(final HttpServerExchange exchange, final IoCallback callback) {
    if (!exchange.isResponseChannelAvailable()) {
        callback.onException(exchange, null, UndertowMessages.MESSAGES.cannotSendContinueResponse());
        return;
    }
    internalSendContinueResponse(exchange, callback);
}
 

import io.undertow.io.IoCallback; //导入依赖的package包/类
@Override
public void send(final ByteBuffer[] srcs, final IoCallback callback) {
    ByteBuffer[] origSrc = new ByteBuffer[srcs.length];
    long total = 0;
    for (int i = 0; i < srcs.length; i++) {
        origSrc[i] = srcs[i].duplicate();
        total += origSrc[i].remaining();
    }
    handleUpdate(origSrc, total);
    delegate.send(srcs, callback);
}
 

import io.undertow.io.IoCallback; //导入依赖的package包/类
@Override
public void close(final IoCallback callback) {
    if (written != length) {
        cacheEntry.disable();
        cacheEntry.dereference();
    }
    delegate.close();
}
 

import io.undertow.io.IoCallback; //导入依赖的package包/类
public void send(final ReadableByteChannel source, final HttpServerExchange exchange,
        final IoCallback callback) {
    this.source = source;
    this.exchange = exchange;
    this.callback = callback;
    this.sender = exchange.getResponseSender();
    ServerConnection connection = exchange.getConnection();
    this.pooled = connection.getByteBufferPool().allocate();
    this.bufferSize = connection.getBufferSize();

    onComplete(exchange, sender);
}