@Override public void handleEvent(final StreamSinkChannel channel) { if(callback != null) { callback.onComplete(exchange, AsyncSenderImpl.this); } } }, new ChannelExceptionHandler<StreamSinkChannel>() {
@Override public void close(final IoCallback callback) { try { outputStream.close(); invokeOnComplete(callback); } catch (IOException e) { callback.onException(exchange, this, e); } }
private static void internalSendContinueResponse(final HttpServerExchange exchange, final IoCallback callback) { if(exchange.getAttachment(ALREADY_SENT) != null) { callback.onComplete(exchange, null); return; exchange.dispatch(); } else { callback.onComplete(exchange, null); callback.onException(exchange, null, e);
private void invokeOnComplete(final IoCallback callback) { inCall = true; try { callback.onComplete(exchange, this); } finally { inCall = false; } while (next != null) { String next = this.next; IoCallback queuedCallback = this.queuedCallback; this.next = null; this.queuedCallback = null; writer.write(next); if (writer.checkError()) { queuedCallback.onException(exchange, this, new IOException()); } else { inCall = true; try { queuedCallback.onComplete(exchange, this); } finally { inCall = false; } } } }
private void invokeOnException(IoCallback callback, IOException e) { if (pooledBuffers != null) { for (PooledByteBuffer buffer : pooledBuffers) { buffer.close(); } pooledBuffers = null; } callback.onException(exchange, this, e); }
@Override public void onComplete(final HttpServerExchange exchange, final Sender sender) { callback.onComplete(exchange, sender); }
@Override public void serve(final Sender sender, final HttpServerExchange exchange, final IoCallback ioCallback) { exchange.startBlocking(); final OutputStream outStream = exchange.getOutputStream(); try { Files.copy(path, outStream); ioCallback.onComplete(exchange, sender); } catch (IOException e) { LOG.error("Could not serve content file", e); ioCallback.onException(exchange, sender, e); } }
@Override public void onException(final HttpServerExchange exchange, final Sender sender, final IOException x) { log.error("execution of {} resulted in exception", exchange.getRequestPath(), x); callback.onException(exchange, sender, x); }
@Override public void onComplete(final HttpServerExchange exchange, final Sender sender) { try { entry.dereference(); } finally { callback.onComplete(exchange, sender); } }
private static void internalSendContinueResponse(final HttpServerExchange exchange, final IoCallback callback) { if(exchange.getAttachment(ALREADY_SENT) != null) { callback.onComplete(exchange, null); return; exchange.dispatch(); } else { callback.onComplete(exchange, null); callback.onException(exchange, null, e);
@Override public void onException(final HttpServerExchange exchange, final Sender sender, final IOException ex) { done(); callback.onException(exchange, sender, ex); }
private void invokeOnComplete(final IoCallback callback) { inCall = true; try { callback.onComplete(exchange, this); } finally { inCall = false; } while (next != null || pendingFile != null) { ByteBuffer[] next = this.next; IoCallback queuedCallback = this.queuedCallback; FileChannel file = this.pendingFile; this.next = null; this.queuedCallback = null; this.pendingFile = null; if (next != null) { for (ByteBuffer buffer : next) { writeBuffer(buffer, queuedCallback); } } else if (file != null) { performTransfer(file, queuedCallback); } inCall = true; try { queuedCallback.onComplete(exchange, this); } finally { inCall = false; } } }
private static void internalSendContinueResponse(final HttpServerExchange exchange, final IoCallback callback) { if(exchange.getAttachment(ALREADY_SENT) != null) { callback.onComplete(exchange, null); return; exchange.dispatch(); } else { callback.onComplete(exchange, null); callback.onException(exchange, null, e);
@Override public void onException(final HttpServerExchange exchange, final Sender sender, final IOException exception) { UndertowLogger.REQUEST_IO_LOGGER.ioException(exception); try { entry.dereference(); } finally { callback.onException(exchange, sender, exception); } } }
callback.onComplete(exchange, this); } else { int i = 0;
private void performTransfer(FileChannel source, IoCallback callback) { if (outputStream instanceof BufferWritableOutputStream) { try { ((BufferWritableOutputStream) outputStream).transferFrom(source); } catch (IOException e) { callback.onException(exchange, this, e); } } else { try (PooledByteBuffer pooled = exchange.getConnection().getByteBufferPool().getArrayBackedPool().allocate()){ ByteBuffer buffer = pooled.getBuffer(); long pos = source.position(); long size = source.size(); while (size - pos > 0) { int ret = source.read(buffer); if (ret <= 0) { break; } pos += ret; outputStream.write(buffer.array(), buffer.arrayOffset(), ret); buffer.clear(); } if (pos != size) { throw new EOFException("Unexpected EOF reading file"); } } catch (IOException e) { callback.onException(exchange, this, e); } } }
if (count == -1 || (len != -1 && total >= len)) { done(); callback.onComplete(exchange, sender); } else { total += count;
return true; } catch (IOException e) { callback.onException(exchange, this, e); return false; outputStream.write(buffer.array(), buffer.arrayOffset(), buffer.remaining()); } catch (IOException e) { callback.onException(exchange, this, e); return false; outputStream.write(pooled.getBuffer().array(), pooled.getBuffer().arrayOffset(), toRead); } catch (IOException e) { callback.onException(exchange, this, e); return false;
do { if (buffer.remaining() == 0) { callback.onComplete(exchange, this); return;
/** * 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); }