@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (LOG.isTraceEnabled()) { promise.addListener((future) -> { LOG.trace("write {}", future.isSuccess() ? "complete" : "failed"); }); } super.write(ctx, msg, promise); }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { super.write(ctx, msg, promise); NettyChannel channel = NettyChannel.getOrAddChannel(ctx.channel(), url, handler); try { handler.sent(channel, msg); } finally { NettyChannel.removeChannelIfDisconnected(ctx.channel()); } }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise prm) throws Exception { String uri = ctx.channel().attr(URI_ATTRIBUTE).get(); if (uri == null) { ctx.write(msg, prm); return; } if ("/unsampled".equals(uri)) { unsampled.write(ctx, msg, prm); } else if ("/traced".equals(uri)) { traced.write(ctx, msg, prm); } else if ("/traced128".equals(uri)) { traced128.write(ctx, msg, prm); } else { ctx.write(msg, prm); } } }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (msg instanceof QueueCommand) { QueueCommand data = (QueueCommand) msg; QueueCommandHolder holder = queue.peek(); if (holder != null && holder.getCommand() == data) { super.write(ctx, msg, promise); } else { queue.add(new QueueCommandHolder(data, promise)); sendData(ctx.channel()); } } else { super.write(ctx, msg, promise); } }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (msg instanceof QueueCommand) { QueueCommand data = (QueueCommand) msg; QueueCommandHolder holder = queue.peek(); if (holder != null && holder.getCommand() == data) { super.write(ctx, msg, promise); } else { queue.add(new QueueCommandHolder(data, promise)); sendData(ctx.channel()); } } else { super.write(ctx, msg, promise); } }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { outPackets.incrementAndGet(); if (msg instanceof ByteBuf) { outSize.addAndGet(((ByteBuf) msg).readableBytes()); } else if (msg instanceof DatagramPacket) { outSize.addAndGet(((DatagramPacket) msg).content().readableBytes()); } super.write(ctx, msg, promise); } }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { log(ctx, true, msg); super.write(ctx, msg, promise); }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (needsToFilterUpgradeRequest) { needsToFilterUpgradeRequest = false; final FullHttpRequest req = (FullHttpRequest) msg; req.headers().set(HttpHeaderNames.CONNECTION, CONNECTION_VALUE); if (!needsToFilterUpgradeResponse) { ctx.pipeline().remove(this); } } super.write(ctx, msg, promise); } }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { InetSocketAddress sa = (InetSocketAddress) ctx.channel().localAddress(); MetricsCollector metricsCollector = MetricsCollector.getCollector(sa.getPort()); metricsCollector.incrementWroteBytes(((ByteBuf) msg).readableBytes()); metricsCollector.incrementWroteMsgs(1); super.write(ctx, msg, promise); }
@Override public void write(final ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (State.Paused == state) { // Add the timeout handler when write is complete. promise.addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception { if (State.Paused == state) { /* * Multiple writes can all add a listener, till it is active again (on write success), so it is * required to only schedule next when the state is actually paused. */ scheduleAfresh(ctx); } } }); } super.write(ctx, msg, promise); }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (msg instanceof HttpResponse) { promise.addListener((future) -> { if (! future.isSuccess()) { fireWriteError("response headers", future.cause(), ctx); } }); super.write(ctx, msg, promise); } else if (msg instanceof HttpContent) { promise.addListener((future) -> { if (! future.isSuccess()) { fireWriteError("response content", future.cause(), ctx); } }); super.write(ctx, msg, promise); } else { //should never happen ReferenceCountUtil.release(msg); throw new ZuulException("Attempt to write invalid content type to client: "+msg.getClass().getSimpleName(), true); } }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { super.write(ctx, msg, promise); final NettyChannel channel = NettyChannel.getOrAddChannel(ctx.channel(), url, handler); final boolean isRequest = msg instanceof Request; // We add listeners to make sure our out bound event is correct. // If our out bound event has an error (in most cases the encoder fails), // we need to have the request return directly instead of blocking the invoke process. promise.addListener(future -> { try { if (future.isSuccess()) { // if our future is success, mark the future to sent. handler.sent(channel, msg); return; } Throwable t = future.cause(); if (t != null && isRequest) { Request request = (Request) msg; Response response = buildErrorResponse(request, t); handler.received(channel, response); } } finally { NettyChannel.removeChannelIfDisconnected(ctx.channel()); } }); }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (!ctx.channel().isActive()) { ReferenceCountUtil.release(msg); return; } if (msg instanceof HttpRequestMessage) { promise.addListener((future) -> { if (!future.isSuccess()) { fireWriteError("request headers", future.cause(), ctx); } }); HttpRequestMessage zuulReq = (HttpRequestMessage) msg; preWriteHook(ctx, zuulReq); super.write(ctx, buildOriginHttpRequest(zuulReq), promise); } else if (msg instanceof HttpContent) { promise.addListener((future) -> { if (!future.isSuccess()) { fireWriteError("request content chunk", future.cause(), ctx); } }); super.write(ctx, msg, promise); } else { //should never happen ReferenceCountUtil.release(msg); throw new ZuulException("Received invalid message from client", true); } }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { try { if (ByteBuf.class.isAssignableFrom(msg.getClass())) { publishBytesWritten(((ByteBuf) msg).readableBytes(), promise); } else if (ByteBufHolder.class.isAssignableFrom(msg.getClass())) { publishBytesWritten(((ByteBufHolder)msg).content().readableBytes(), promise); } else if (FileRegion.class.isAssignableFrom(msg.getClass())) { publishBytesWritten(((FileRegion) msg).count(), promise); } } catch (Exception e) { logger.warn("Failed to publish bytes write metrics event. This does *not* stop the pipeline processing.", e); } finally { super.write(ctx, msg, promise); } }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (msg instanceof HttpResponse) { HttpResponse response = (HttpResponse) msg; if (HttpChannelFlags.CLOSE_AFTER_RESPONSE.get(ctx)) { // Add header to tell client that they should close this connection. response.headers().set(HttpHeaderNames.CONNECTION, "close"); } } super.write(ctx, msg, promise); // Close the connection immediately after LastContent is written, rather than // waiting until the graceful-delay is up if this flag is set. if (msg instanceof LastHttpContent) { if (HttpChannelFlags.CLOSE_AFTER_RESPONSE.get(ctx)) { promise.addListener(future -> { ctx.close(); }); } } }
@Override public void write(final ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (msg instanceof HttpRequest && WebSocketExtensionUtil.isWebsocketUpgrade(((HttpRequest) msg).headers())) { HttpRequest request = (HttpRequest) msg; String headerValue = request.headers().getAsString(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS); for (WebSocketClientExtensionHandshaker extensionHandshaker : extensionHandshakers) { WebSocketExtensionData extensionData = extensionHandshaker.newRequestData(); headerValue = WebSocketExtensionUtil.appendExtension(headerValue, extensionData.name(), extensionData.parameters()); } request.headers().set(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS, headerValue); } super.write(ctx, msg, promise); }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (msg instanceof HttpResponse) { promise.addListener((future) -> { if (! future.isSuccess()) { fireWriteError("response headers", future.cause(), ctx); } }); super.write(ctx, msg, promise); } else if (msg instanceof HttpContent) { promise.addListener((future) -> { if (! future.isSuccess()) { fireWriteError("response content", future.cause(), ctx); } }); super.write(ctx, msg, promise); } else { //should never happen ReferenceCountUtil.release(msg); throw new ZuulException("Attempt to write invalid content type to client: "+msg.getClass().getSimpleName(), true); } }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (!ctx.channel().isActive()) { ReferenceCountUtil.release(msg); return; } if (msg instanceof HttpRequestMessage) { promise.addListener((future) -> { if (!future.isSuccess()) { fireWriteError("request headers", future.cause(), ctx); } }); HttpRequestMessage zuulReq = (HttpRequestMessage) msg; preWriteHook(ctx, zuulReq); super.write(ctx, buildOriginHttpRequest(zuulReq), promise); } else if (msg instanceof HttpContent) { promise.addListener((future) -> { if (!future.isSuccess()) { fireWriteError("request content chunk", future.cause(), ctx); } }); super.write(ctx, msg, promise); } else { //should never happen ReferenceCountUtil.release(msg); throw new ZuulException("Received invalid message from client", true); } }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (msg instanceof HttpResponse) { HttpResponse response = (HttpResponse) msg; if (HttpChannelFlags.CLOSE_AFTER_RESPONSE.get(ctx)) { // Add header to tell client that they should close this connection. response.headers().set(HttpHeaderNames.CONNECTION, "close"); } } super.write(ctx, msg, promise); // Close the connection immediately after LastContent is written, rather than // waiting until the graceful-delay is up if this flag is set. if (msg instanceof LastHttpContent) { if (HttpChannelFlags.CLOSE_AFTER_RESPONSE.get(ctx)) { promise.addListener(future -> { ctx.close(); }); } } }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { // modify message on way out to add headers if needed if (msg instanceof HttpResponse) { final HttpResponse response = (HttpResponse) msg; trackResponse(response); // Assume the response writer knows if they can persist or not and sets isKeepAlive on the response if (!isKeepAlive(response) || !isSelfDefinedMessageLength(response)) { // No longer keep alive as the client can't tell when the message is done unless we close connection pendingResponses = 0; persistentConnection = false; } // Server might think it can keep connection alive, but we should fix response header if we know better if (!shouldKeepAlive()) { setKeepAlive(response, false); } } if (msg instanceof LastHttpContent && !shouldKeepAlive()) { promise = promise.unvoid().addListener(ChannelFutureListener.CLOSE); } super.write(ctx, msg, promise); }