private static void writePromiseCombiner(ChannelHandlerContext ctx, CodecOutputList out, ChannelPromise promise) { final PromiseCombiner combiner = new PromiseCombiner(); for (int i = 0; i < out.size(); i++) { combiner.add(ctx.write(out.getUnsafe(i))); } combiner.finish(promise); }
private static void writePromiseCombiner(ChannelHandlerContext ctx, CodecOutputList out, ChannelPromise promise) { final PromiseCombiner combiner = new PromiseCombiner(); for (int i = 0; i < out.size(); i++) { combiner.add(ctx.write(out.getUnsafe(i))); } combiner.finish(promise); }
combiner.finish(p); } catch (Throwable cause) { p.setFailure(cause);
promiseCombiner.finish(writePromise);
combiner.finish(p); } catch (Throwable cause) { p.setFailure(cause);
combiner.finish(p); } catch (Throwable cause) { p.setFailure(cause);
promiseCombiner.finish(writePromise);
buf = nextBuf; combiner.finish(promise); } catch (Throwable cause) { promise.tryFailure(cause);
private static void writePromiseCombiner(ChannelHandlerContext ctx, CodecOutputList out, ChannelPromise promise) { final PromiseCombiner combiner = new PromiseCombiner(); for (int i = 0; i < out.size(); i++) { combiner.add(ctx.write(out.getUnsafe(i))); } combiner.finish(promise); }
private void executeStopHooks(Promise<Void> hooksFuture) { log.info("Executing stop hooks..."); PromiseCombiner combiner = new PromiseCombiner(); this.serverStopHook.forEach(hook->combiner.add(hook.executeStop(executor()))); combiner.finish(hooksFuture); }
private Future<Void> executeStartHooks() { Promise<Void> hooksPromise = executor().newPromise(); PromiseCombiner combiner = new PromiseCombiner(); this.serverStartHook.forEach(hook->combiner.add(hook.executeStart(executor()))); combiner.finish(hooksPromise); return hooksPromise; }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (msg instanceof Message) { Message message = (Message) msg; Request request = message.getRequest(); if (request.expectsResponse()) { setRequest(ctx.channel().attr(KEY).get(), request); } PromiseCombiner combiner = new PromiseCombiner(); combiner.add(write(ctx, message.getPayload())); combiner.add(write(ctx, message)); combiner.finish(promise); } else { throw new RuntimeException("Only Message objects can be written to ClientCodec"); } } }
public Future<Void> write(Channel channel) { if (isEmpty()) { return channel.eventLoop().newSucceededFuture(null); } Promise<Void> promise = channel.eventLoop().newPromise(); PromiseCombiner combiner = new PromiseCombiner(); PendingMessage write = head; head = tail = null; while (write != null) { PendingMessage next = write.next(); Object msg = write.msg(); Promise<Void> writePromise = write.promise(); write.recycle(); combiner.add(channel.pipeline().writeAndFlush(msg).addListener(f->{ if(f.isSuccess()) { writePromise.setSuccess(null); }else { writePromise.setFailure(f.cause()); } })); write = next; } combiner.finish(promise); return promise; }
private void writeContent(ChannelHandlerContext ctx, SegmentedData data, ChannelPromise promise) { Headers trailingHeaders = data.trailingHeaders(); boolean hasTrailing = trailingHeaders != null && trailingHeaders.size() > 0; boolean dataEos = data.endOfMessage() && !hasTrailing; int streamId = data.streamId(); Http2Request request = Http2Request.build(streamId, new DefaultHttp2DataFrame(data.content(), dataEos), dataEos); if (hasTrailing) { Http2Headers headers = trailingHeaders.http2Headers(); Http2Request last = Http2Request.build(streamId, headers, true); PromiseCombiner combiner = new PromiseCombiner(); combiner.add(ctx.write(request, ctx.newPromise())); combiner.add(ctx.write(last, ctx.newPromise())); combiner.finish(promise); } else { ctx.write(request, promise); } }
@Override public void sendAsync(List<Append> appends, CompletedCallback callback) { recentMessage.set(true); Channel ch; try { ch = getChannel(); } catch (ConnectionFailedException e) { callback.complete(new ConnectionFailedException("Connection to " + connectionName + " is not established.")); return; } PromiseCombiner combiner = new PromiseCombiner(); for (Append append : appends) { batchSizeTracker.recordAppend(append.getEventNumber(), append.getData().readableBytes()); combiner.add(ch.write(append)); } ch.flush(); ChannelPromise promise = ch.newPromise(); promise.addListener(new GenericFutureListener<Future<? super Void>>() { @Override public void operationComplete(Future<? super Void> future) throws Exception { Throwable cause = future.cause(); callback.complete(cause == null ? null : new ConnectionFailedException(cause)); } }); combiner.finish(promise); }
@SuppressWarnings("unchecked") private void start(Promise<T> startPromise) { PromiseCombiner combiner = new PromiseCombiner(); Promise<Void> bindPromise = executor().newPromise(); combiner.add(bind(executor())); combiner.finish(bindPromise); bindPromise.addListener(f->{ if(f.isSuccess()) { startPromise.setSuccess((T) this); }else { stop().addListener(ignore -> startPromise.setFailure(bindPromise.cause())); } }); }
protected Future<Void> bind(EventLoop executor){ Promise<Void> aggregated = executor.newPromise(); PromiseCombiner combiner = new PromiseCombiner(); if(config.insecuredPort()>0) { combiner.add(bind(executor,config.insecuredPort())); } if(config.securedPort()>0) { combiner.add(bind(executor,config.securedPort())); } combiner.finish(aggregated); return aggregated; }
private void writeResponse(ChannelHandlerContext ctx, Response response, ChannelPromise promise) { if (!response.headers().contains(HttpHeaderNames.CONTENT_TYPE)) { response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8"); } Http2MessageSession messageSession = lazyCreateSession(ctx); int streamId = response.streamId(); Http2Headers headers = response.headers().http2Headers(); headers.status(response.status().codeAsText()); if (response instanceof FullResponse) { messageSession.onOutboundResponse(response); ByteBuf body = response.body(); if (body != null && body.readableBytes() > 0) { PromiseCombiner combiner = new PromiseCombiner(); combiner.add(ctx.write(Http2Response.build(streamId, headers, false), ctx.newPromise())); Http2DataFrame data = new DefaultHttp2DataFrame(body, true); combiner.add(ctx.write(Http2Response.build(streamId, data, true), ctx.newPromise())); combiner.finish(promise); } else { ctx.write(Http2Response.build(streamId, headers, true), promise); } } else { ctx.write(Http2Response.build(streamId, headers, false), promise); } messageSession.flush(streamId); }
private void writeRequest(ChannelHandlerContext ctx, Request request, ChannelPromise promise) { /* // TOOD(CK): define ACCEPT? if (!response.headers().contains(HttpHeaderNames.CONTENT_TYPE)) { response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8"); } */ Http2Headers headers = request.headers().http2Headers(); headers.authority(request.host()).method(request.method().asciiName()).path(request.path()); int streamId = request.streamId(); if (request instanceof FullRequest) { if (request.body().readableBytes() > 0) { PromiseCombiner combiner = new PromiseCombiner(); combiner.add(ctx.write(Http2Request.build(streamId, headers, false), ctx.newPromise())); Http2DataFrame data = new DefaultHttp2DataFrame(request.body(), true); combiner.add(ctx.write(Http2Request.build(streamId, data, true), ctx.newPromise())); combiner.finish(promise); } else { ctx.write(Http2Request.build(streamId, headers, true), promise); } } else { ctx.write(Http2Request.build(streamId, headers, false), promise); } }
void writeContent(ChannelHandlerContext ctx, SegmentedData data, ChannelPromise promise) { Http2MessageSession messageSession = lazyCreateSession(ctx); messageSession.onOutboundResponseData(data); boolean dataEos = data.endOfMessage() && data.trailingHeaders().size() == 0; Http2Response response = Http2Response.build( data.streamId(), new DefaultHttp2DataFrame(data.content(), dataEos), dataEos); Headers trailingHeaders = data.trailingHeaders(); if (trailingHeaders != null && trailingHeaders.size() != 0) { Http2Headers headers = trailingHeaders.http2Headers(); Http2Response last = Http2Response.build(data.streamId(), headers, true); PromiseCombiner combiner = new PromiseCombiner(); combiner.add(ctx.write(response, ctx.newPromise())); combiner.add(ctx.write(last, ctx.newPromise())); combiner.finish(promise); } else { ctx.write(response, promise); } }