@Override public NextAction handleRead(final FilterChainContext ctx) throws IOException { String message = (String) ctx.getMessage(); logger.log(Level.INFO, "First chunk come: {0}", message); intermResultQueue.add(message); Connection connection = ctx.getConnection(); connection.setBlockingReadTimeout(10, TimeUnit.SECONDS); try { for (int i = 0; i < clientMsgs - 1; i++) { final ReadResult rr = ctx.read(); final String blckMsg = (String) rr.getMessage(); rr.recycle(); logger.log(Level.INFO, "Blocking chunk come: {0}", blckMsg); intermResultQueue.add(blckMsg); message += blckMsg; } } catch (Exception e) { intermResultQueue.add(e); return ctx.getStopAction(); } ctx.setMessage(message); return ctx.getInvokeAction(); }
@Override public NextAction handleClose(final FilterChainContext ctx) throws IOException { Socket tunnelSocket = tunnelSockets.get(ctx.getConnection()); if (tunnelSocket != null) { tunnelSocket.close(); } return ctx.getStopAction(); }
@Override public NextAction handleRead(FilterChainContext ctx) throws IOException { // Take ADD-service response final AddResponseMessage addResponseMessage = ctx.getMessage(); // do output LOGGER.log(Level.INFO, "Result={0}", addResponseMessage.getResult()); return ctx.getStopAction(); }
@Override public NextAction handleRead(FilterChainContext ctx) throws IOException { final Buffer content = ctx.getMessage(); try { future.result(content); } catch (Exception e) { future.failure(e); e.printStackTrace(); } return ctx.getStopAction(); }
/* * 接收 * * @param context 上下文 * @param channel 通道 * @param buffer 缓存 * @param readable 缓存可读 * @param bytes 输入缓存 * @param offset 指向已读数据的偏移量,off之前的数据都是已用过的 * @param limit 有效长度,limit之后的长度是空白或无效数据,off到limit之间的数据是准备使用的数据 * @return 后续动作 * @throws IOException */ private NextAction receive( FilterChainContext context, Channel channel, Buffer buffer, int readable, byte[] bytes, int offset, int limit) throws IOException { for (; ; ) { int read = Math.min(readable, bytes.length - limit); // 取bytes缓存空闲区,和可读取新数据,的最小值,即:此次最多读写数据的大小 buffer.get(bytes, limit, read); // 从可读取新数据中,读取数据,尽量填满bytes缓存空闲区 limit += read; // 有效数据变长 readable -= read; // 可读数据变少 UnsafeByteArrayInputStream input = new UnsafeByteArrayInputStream( bytes, offset, limit - offset); // 将bytes缓存转成InputStream,不需要关闭 Object msg = upstreamCodec.decode(channel, input); // 调用Codec接口,解码数据 if (msg == Codec.NEED_MORE_INPUT) { // 如果Codec觉得数据不够,不足以解码成一个对象 if (readable == 0) { // 如果没有更多可读数据 channel.setAttribute( BUFFER_KEY, new Object[] {bytes, offset, limit}); // 放入通道属性中,等待下一个Buffer的到来 return context.getStopAction(); } else { // 扩充或挪出空闲区,并循环,直到可读数据都加载到bytes缓存 if (offset == 0) { // 如果bytes缓存全部没有被使用,如果这时数据还不够 bytes = Bytes.copyOf(bytes, bytes.length << 1); // 将bytes缓存扩大一倍 } else { // 如果bytes缓存有一段数据已被使用 int len = limit - offset; // 计算有效数据长度 System.arraycopy( bytes, offset, bytes, 0, len); // 将数据向前移到,压缩到已使用的部分,这样limit后面就会多出一些空闲,可以放数据 offset = 0; // 移到后,bytes缓存没有数据被使用 limit = len; // 移到后,有效数据都在bytes缓存最前面 } } } else { // 如果解析出一个结果 int position = input.position(); // 记录InputStream用了多少 if (position == offset) { // 如果InputStream没有被读过,就返回了数据,直接报错,否则InputStream永远读不完,会死递归 throw new IOException("Decode without read data."); } offset = position; // 记录已读数据 context.setMessage(msg); // 将消息改为解码后的对象,以便被后面的Filter使用。 if (limit - offset > 0 || readable > 0) { // 如果有效数据没有被读完,或者Buffer区还有未读数据 return context.getInvokeAction( new Object[] { buffer, readable, bytes, offset, limit }); // 正常执行完Filter,并重新发起一轮Filter,继续读 } else { // 否则所有数据读完 return context.getInvokeAction(); // 正常执行完Filter } } } }
@Override public NextAction handleRead(final FilterChainContext ctx) throws IOException { final HttpContent httpContent = ctx.getMessage(); if (httpContent.isLast()) { // Perform the cleanup logic if it's the last chunk of the payload final HttpResponsePacket response = (HttpResponsePacket) httpContent.getHttpHeader(); recycleRequestResponsePackets(ctx.getConnection(), response); return ctx.getStopAction(); } return ctx.getInvokeAction(); }
@Override public NextAction handleWrite(final FilterChainContext ctx) throws IOException { Object message = ctx.getMessage(); if (message instanceof RequestInfoHolder) { ctx.setMessage(null); if (!sendAsGrizzlyRequest((RequestInfoHolder) message, ctx)) { return ctx.getSuspendAction(); } } else if (message instanceof Buffer) { return ctx.getInvokeAction(); } return ctx.getStopAction(); }
@Override public NextAction handleRead(FilterChainContext ctx) throws IOException { HttpContent c = (HttpContent) ctx.getMessage(); Buffer b = c.getContent(); if (b.hasRemaining()) { sb.append(b.toStringContent()); } // Last content from the server, set the future result so // the client can display the result and gracefully exit. if (c.isLast()) { future.result(sb.toString()); } return ctx.getStopAction(); // discontinue filter chain execution }
@SuppressWarnings("unchecked") @Override public NextAction handleEvent(final FilterChainContext ctx, final FilterChainEvent event) throws IOException { final Object type = event.type(); if (type == ContinueEvent.class) { final ContinueEvent continueEvent = (ContinueEvent) event; ((ExpectHandler) continueEvent.getContext().getBodyHandler()).finish(ctx); } else if (type == TunnelRequestEvent.class) { // Disable SSL for the time being... ctx.notifyDownstream(new SSLSwitchingEvent(false, ctx.getConnection())); ctx.suspend(); TunnelRequestEvent tunnelRequestEvent = (TunnelRequestEvent) event; final ProxyServer proxyServer = tunnelRequestEvent.getProxyServer(); final URI requestUri = tunnelRequestEvent.getUri(); RequestBuilder builder = new RequestBuilder(); builder.setMethod(Method.CONNECT.getMethodString()); builder.setUrl("http://" + getAuthority(requestUri)); Request request = builder.build(); AsyncHandler handler = new AsyncCompletionHandler() { @Override public Object onCompleted(Response response) throws Exception { if (response.getStatusCode() != 200) { PROXY_AUTH_FAILURE.set(ctx.getConnection(), Boolean.TRUE); } ctx.notifyDownstream(new SSLSwitchingEvent(true, ctx.getConnection())); ctx.notifyDownstream(event); return response; } }; final GrizzlyResponseFuture future = new GrizzlyResponseFuture(grizzlyAsyncHttpProvider, request, handler, proxyServer); future.setDelegate(SafeFutureImpl.create()); grizzlyAsyncHttpProvider.execute( ctx.getConnection(), request, handler, future, HttpTxContext.get(ctx)); return ctx.getSuspendAction(); } return ctx.getStopAction(); }
@Override public NextAction handleRead(FilterChainContext context) throws IOException { Object message = context.getMessage(); Connection<?> connection = context.getConnection(); Channel channel = GrizzlyChannel.getOrAddChannel(connection, url, handler); try { if (message instanceof Buffer) { // 收到新的数据包 Buffer buffer = (Buffer) message; // 缓存 int readable = buffer.capacity(); // 本次可读取新数据的大小 if (readable == 0) { return context.getStopAction(); } byte[] bytes; // byte[]缓存区,将Buffer转成byte[],再转成UnsafeByteArrayInputStream int offset; // 指向已用数据的偏移量,off之前的数据都是已用过的 int limit; // 有效长度,limit之后的长度是空白或无效数据,off到limit之间的数据是准备使用的有效数据 Object[] remainder = (Object[]) channel.getAttribute(BUFFER_KEY); // 上次序列化剩下的数据 channel.removeAttribute(BUFFER_KEY); if (remainder == null) { // 如果没有,创建新的bytes缓存 bytes = new byte[bufferSize]; offset = 0; limit = 0; } else { // 如果有,使用剩下的bytes缓存 bytes = (byte[]) remainder[0]; offset = (Integer) remainder[1]; limit = (Integer) remainder[2]; } return receive(context, channel, buffer, readable, bytes, offset, limit); } else if (message instanceof Object[]) { // 同一Buffer多轮Filter,即:一个Buffer里有多个请求 Object[] remainder = (Object[]) message; Buffer buffer = (Buffer) remainder[0]; int readable = (Integer) remainder[1]; byte[] bytes = (byte[]) remainder[2]; int offset = (Integer) remainder[3]; int limit = (Integer) remainder[4]; return receive(context, channel, buffer, readable, bytes, offset, limit); } else { // 其它事件直接往下传 return context.getInvokeAction(); } } finally { GrizzlyChannel.removeChannelIfDisconnectd(connection); } }
@Override public NextAction handleRead(FilterChainContext ctx) throws IOException { final Object message = ctx.getMessage(); if (_logger.isDebugEnabled()) { _logger.debug(String.format("%s: Got [%s] from [%s].", this, message, ctx.getAddress())); } String responseXML = _coreCommandProcessor.processCommand((String) message); if (_logger.isDebugEnabled()) { _logger.debug( String.format("%s: Returning [%s] to [%s].", this, responseXML, ctx.getAddress())); } ctx.write(ctx.getAddress(), responseXML, null); // Close the connection ctx.getConnection().closeSilently(); return ctx.getStopAction(); }
@SuppressWarnings({"unchecked"}) @Override public NextAction handleConnect(FilterChainContext ctx) throws IOException { System.out.println("\nClient connected!\n"); HttpRequestPacket request = createRequest(); System.out.println("Writing request:\n"); System.out.println(request.toString()); ctx.write(request); // write the request // for each of the content parts in CONTENT, wrap in a Buffer, // create the HttpContent to wrap the buffer and write the // content. MemoryManager mm = ctx.getMemoryManager(); for (int i = 0, len = CONTENT.length; i < len; i++) { HttpContent.Builder contentBuilder = request.httpContentBuilder(); Buffer b = Buffers.wrap(mm, CONTENT[i]); contentBuilder.content(b); HttpContent content = contentBuilder.build(); System.out.printf("(Client writing: %s)\n", b.toStringContent()); ctx.write(content); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } // since the request created by createRequest() is chunked, // we need to write the trailer to signify the end of the // POST data ctx.write(request.httpTrailerBuilder().build()); System.out.println("\n"); return ctx.getStopAction(); // discontinue filter chain execution }
@Override public NextAction handleRead(FilterChainContext ctx) throws IOException { // Get the parsed HttpContent (we assume prev. filter was HTTP) HttpContent message = ctx.getMessage(); Socket tunnelSocket = tunnelSockets.get(ctx.getConnection()); if (tunnelSocket == null) { // handle connection procedure return GrizzlyModProxy.this.handleConnect(ctx, message); } if (message.getContent().hasRemaining()) { // relay the content to the tunnel connection Buffer buffer = message.getContent(); message.recycle(); tunnelSocket .getOutputStream() .write(buffer.array(), buffer.arrayOffset(), buffer.remaining()); } return ctx.getStopAction(); }
/** * Method invoked when a first massage (Assumed to be HTTP) is received. Normally this would be * HTTP CONNECT and this method processes it and opens a connection to the destination (the server * that the client wants to access). * * <p>This method can be overridden to provide a test-specific handling of the CONNECT method. */ protected NextAction handleConnect(FilterChainContext ctx, HttpContent content) { System.out.println("Handle CONNECT start . . ."); HttpHeader httpHeader = content.getHttpHeader(); HttpRequestPacket requestPacket = (HttpRequestPacket) httpHeader.getHttpHeader(); if (!requestPacket.getMethod().matchesMethod("CONNECT")) { System.out.println("Received method is not CONNECT"); writeHttpResponse(ctx, 400); return ctx.getStopAction(); } String destinationUri = requestPacket.getRequestURI(); // We expect URI in form host:port, this is not flexible, but we use it only to test our clients int colonIdx = destinationUri.indexOf(':'); if (colonIdx == -1) { System.out.println("Destination URI not in host:port format: " + destinationUri); writeHttpResponse(ctx, 400); return ctx.getStopAction(); } String hostName = destinationUri.substring(0, colonIdx); String portStr = destinationUri.substring(colonIdx + 1); int port; try { port = Integer.parseInt(portStr); } catch (Throwable t) { System.out.println("Could not parse destination port: " + portStr); writeHttpResponse(ctx, 400); return ctx.getStopAction(); } try { Socket tunnelSocket = new Socket(hostName, port); Connection grizzlyConnection = ctx.getConnection(); tunnelSockets.set(grizzlyConnection, tunnelSocket); TunnelSocketReader tunnelSocketReader = new TunnelSocketReader(tunnelSocket, grizzlyConnection); executorService.submit(tunnelSocketReader::read); } catch (IOException e) { writeHttpResponse(ctx, 400); return ctx.getStopAction(); } // Grizzly does not like CONNECT method and sets "keep alive" to false, if it is present // This hacks Grizzly, so it will keep the connection open HttpRequestPacket request = getHttpRequest(ctx); request.getResponse().getProcessingState().setKeepAlive(true); request.getResponse().setContentLength(0); request.setMethod("GET"); // end of hack writeHttpResponse(ctx, 200); System.out.println("Connection to proxy established."); return ctx.getStopAction(); }
/** * Initiates asynchronous data receiving. * * <p>This is service method, usually users don't have to call it explicitly. */ public void initiateAsyncronousDataReceiving() { // fork the FilterChainContext execution // keep the current FilterChainContext suspended, but make a copy and resume it ctx.fork(ctx.getStopAction()); }