private void getReadyToSendWebSocketMessages(ChannelHandler webSocketFrameEncoder, ChannelPipeline p) { p.replace("encoder", "wsencoder", webSocketFrameEncoder); }
@Override public void messageReceived(final ChannelHandlerContext ctx, MessageEvent e) throws Exception { if (e.getMessage() instanceof HttpRequest) { HttpRequest req = (HttpRequest) e.getMessage(); if (req.getMethod() != GET) { sendHttpResponse(ctx, req, new DefaultHttpResponse(HTTP_1_1, FORBIDDEN)); return; } final WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory( getWebSocketLocation(ctx.getPipeline(), req, websocketPath), subprotocols, allowExtensions); final WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(req); if (handshaker == null) { wsFactory.sendUnsupportedWebSocketVersionResponse(ctx.getChannel()); } else { final ChannelFuture handshakeFuture = handshaker.handshake(ctx.getChannel(), req); handshakeFuture.addListener(new ChannelFutureListener() { public void operationComplete(ChannelFuture future) throws Exception { if (!future.isSuccess()) { Channels.fireExceptionCaught(ctx, future.getCause()); } } }); WebSocketServerProtocolHandler.setHandshaker(ctx, handshaker); ctx.getPipeline().replace(this, "WS403Responder", WebSocketServerProtocolHandler.forbiddenHttpRequestResponder()); } } }
private void getReadyToReceiveWebSocketMessages(ChannelHandler webSocketFrameDecoder, ChannelHandler webSocketConnectionHandler, ChannelPipeline p, Channel channel) { StaleConnectionTrackingHandler staleConnectionTracker = (StaleConnectionTrackingHandler) p.remove("staleconnectiontracker"); staleConnectionTracker.stopTracking(channel); p.remove("aggregator"); p.replace("decoder", "wsdecoder", webSocketFrameDecoder); p.replace("handler", "wshandler", webSocketConnectionHandler); }
public void connectRequested(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { InetSocketAddress remoteInetSocketAddress = (InetSocketAddress) e.getValue(); String peerHost = remoteInetSocketAddress.getHostString(); int peerPort = remoteInetSocketAddress.getPort(); SslHandler sslHandler = channelManager.createSslHandler(peerHost, peerPort); ctx.getPipeline().replace(ChannelManager.SSL_HANDLER, ChannelManager.SSL_HANDLER, sslHandler); ctx.sendDownstream(e); } }
private void getReadyToSendEventSourceMessages(ChannelHandler eventSourceConnectionHandler) { ChannelPipeline p = ctx.getChannel().getPipeline(); StaleConnectionTrackingHandler staleConnectionTracker = (StaleConnectionTrackingHandler) p.remove("staleconnectiontracker"); staleConnectionTracker.stopTracking(ctx.getChannel()); p.remove("aggregator"); p.replace("handler", "ssehandler", eventSourceConnectionHandler); }
private void getReadyToSendWebSocketMessages(ChannelHandler webSocketFrameEncoder, ChannelPipeline p) { p.replace("encoder", "wsencoder", webSocketFrameEncoder); }
@Override public ChannelPipeline getPipeline() throws Exception { ChannelPipeline pipeline = super.getPipeline(); pipeline.replace("handler", "handler", handler); return pipeline; } }
private void getReadyToReceiveWebSocketMessages(ChannelHandler webSocketFrameDecoder, ChannelHandler webSocketConnectionHandler, ChannelPipeline p, Channel channel) { StaleConnectionTrackingHandler staleConnectionTracker = (StaleConnectionTrackingHandler) p.remove("staleconnectiontracker"); staleConnectionTracker.stopTracking(channel); p.remove("aggregator"); p.replace("decoder", "wsdecoder", webSocketFrameDecoder); p.replace("handler", "wshandler", webSocketConnectionHandler); }
private void addOrReplaceHandler(ChannelPipeline pipeline, ChannelHandler channelHandler, String handleName) { synchronized (pipeline) { if (pipeline.get(handleName) == null) { pipeline.addLast(handleName, channelHandler); } else { pipeline.replace(handleName, handleName, channelHandler); } } }
public void connectRequested(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { InetSocketAddress remoteInetSocketAddress = (InetSocketAddress) e.getValue(); String peerHost = remoteInetSocketAddress.getHostName(); int peerPort = remoteInetSocketAddress.getPort(); SslHandler sslHandler = channelManager.createSslHandler(peerHost, peerPort); ctx.getPipeline().replace(ChannelManager.SSL_HANDLER, ChannelManager.SSL_HANDLER, sslHandler); ctx.sendDownstream(e); } }
public void connectRequested(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { InetSocketAddress remoteInetSocketAddress = (InetSocketAddress) e.getValue(); String peerHost = remoteInetSocketAddress.getHostString(); int peerPort = remoteInetSocketAddress.getPort(); SslHandler sslHandler = channelManager.createSslHandler(peerHost, peerPort); ctx.getPipeline().replace(ChannelManager.SSL_HANDLER, ChannelManager.SSL_HANDLER, sslHandler); ctx.sendDownstream(e); } }
@Override public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { String path = url.getPath(); if (url.getQuery() != null && url.getQuery().length() > 0) { path = url.getPath() + "?" + url.getQuery(); } HttpRequest request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, path); request.addHeader(Names.UPGRADE, Values.WEBSOCKET); request.addHeader(Names.CONNECTION, Values.UPGRADE); request.addHeader(Names.HOST, url.getHost()); request.addHeader(Names.ORIGIN, "http://" + url.getHost()); e.getChannel().write(request); ctx.getPipeline().replace("encoder", "ws-encoder", new WebSocketFrameEncoder()); channel = e.getChannel(); }
public void run() { connectionMap.put(ch, wsConn); try { HttpResponse resp = shake.generateResponse(request, serverOrigin); ChannelPipeline p = ch.getPipeline(); p.replace("decoder", "wsdecoder", shake.getDecoder()); ch.write(resp); p.replace("encoder", "wsencoder", shake.getEncoder(true)); } catch (Exception e) { log.error("Failed to generate shake response", e); } } };
public void upgradePipelineForWebSockets(ChannelPipeline pipeline) { pipeline.replace(HTTP_HANDLER, WS_ENCODER_HANDLER, new WebSocket08FrameEncoder(true)); pipeline.addBefore(WS_PROCESSOR, WS_DECODER_HANDLER, new WebSocket08FrameDecoder(false, false, 10 * 1024)); }
@Override public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent event) throws Exception { String path = url.getPath(); if (url.getQuery() != null && url.getQuery().length() > 0) { path = url.getPath() + "?" + url.getQuery(); } HttpRequest request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, path); request.headers().add(Names.UPGRADE, Values.WEBSOCKET); request.headers().add(Names.CONNECTION, Values.UPGRADE); request.headers().add(Names.HOST, url.getHost()); request.headers().add(Names.ORIGIN, "http://" + url.getHost()); event.getChannel().write(request); ctx.getPipeline().replace("encoder", "ws-encoder", new WebSocket00FrameEncoder()); this.channel = event.getChannel(); }
private void handleServiceHandshake(MessageEvent e, ChannelPipeline pipeline, ConnectionHeader incomingHeader) { GraphName serviceName = GraphName.of(incomingHeader.getField(ConnectionHeaderFields.SERVICE)); Preconditions.checkState(serviceManager.hasServer(serviceName)); DefaultServiceServer<?, ?> serviceServer = serviceManager.getServer(serviceName); e.getChannel().write(serviceServer.finishHandshake(incomingHeader)); String probe = incomingHeader.getField(ConnectionHeaderFields.PROBE); if (probe != null && probe.equals("1")) { e.getChannel().close(); } else { pipeline.replace(TcpServerPipelineFactory.LENGTH_FIELD_PREPENDER, "ServiceResponseEncoder", new ServiceResponseEncoder()); pipeline.replace(this, "ServiceRequestHandler", serviceServer.newRequestHandler()); } }
@Override public void channelConnected(ChannelHandlerContext ctx, final ChannelStateEvent e) throws Exception { Channel channel = e.getChannel(); ChannelPipeline childPipeline = channel.getPipeline(); IoSessionFactoryChannelHandler newHandler = new IoSessionFactoryChannelHandler(connector, connectFuture, sessionInitializer); childPipeline.replace(this, "factory", newHandler); ChannelHandlerContext childCtx = childPipeline.getContext(newHandler); newHandler.channelConnected(childCtx, e); }
private void getReadyToSendEventSourceMessages(ChannelHandler eventSourceConnectionHandler) { ChannelPipeline p = ctx.getChannel().getPipeline(); StaleConnectionTrackingHandler staleConnectionTracker = (StaleConnectionTrackingHandler) p.remove("staleconnectiontracker"); staleConnectionTracker.stopTracking(ctx.getChannel()); p.remove("aggregator"); p.replace("handler", "ssehandler", eventSourceConnectionHandler); }
@Override protected void handleControlFrame(ChannelHandlerContext channelContext, StompFrame frame) { String version = frame.getHeader( Header.VERSION ); if (version != null) { getClientContext().setVersion( Version.forVersionString( version ) ); } Channel channel = channelContext.getChannel(); channelContext.sendUpstream( new UpstreamChannelStateEvent( channel, ChannelState.CONNECTED, channel.getRemoteAddress() ) ); channelContext.getPipeline().replace( this, "stomp-disconnection-negotiator", new StompDisconnectionNegotiator( getClientContext() ) ); getClientContext().setConnectionState( State.CONNECTED ); }
public void upgradeProtocol(ChannelPipeline pipeline, String scheme, String host, int port) throws IOException, GeneralSecurityException { if (pipeline.get(HTTP_HANDLER) != null) pipeline.remove(HTTP_HANDLER); if (isSecure(scheme)) if (isSslHandlerConfigured(pipeline)){ pipeline.addAfter(SSL_HANDLER, HTTP_HANDLER, newHttpClientCodec()); } else { pipeline.addFirst(HTTP_HANDLER, newHttpClientCodec()); pipeline.addFirst(SSL_HANDLER, createSslHandler(host, port)); } else pipeline.addFirst(HTTP_HANDLER, newHttpClientCodec()); if (isWebSocket(scheme)) pipeline.replace(HTTP_PROCESSOR, WS_PROCESSOR, wsProcessor); }