Java tutorial
/* * (C) Copyright 2013 Kurento (http://kurento.org/) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.kurento.jsonrpc.client; import java.io.IOException; import java.util.concurrent.TimeoutException; import javax.net.ssl.SSLException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import io.netty.bootstrap.Bootstrap; import io.netty.channel.Channel; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelFutureListener; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io.netty.channel.ChannelPipeline; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioSocketChannel; import io.netty.handler.codec.http.DefaultHttpHeaders; import io.netty.handler.codec.http.FullHttpResponse; import io.netty.handler.codec.http.HttpClientCodec; import io.netty.handler.codec.http.HttpObjectAggregator; import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame; import io.netty.handler.codec.http.websocketx.ContinuationWebSocketFrame; import io.netty.handler.codec.http.websocketx.TextWebSocketFrame; import io.netty.handler.codec.http.websocketx.WebSocketClientHandshaker; import io.netty.handler.codec.http.websocketx.WebSocketClientHandshakerFactory; import io.netty.handler.codec.http.websocketx.WebSocketFrame; import io.netty.handler.codec.http.websocketx.WebSocketHandshakeException; import io.netty.handler.codec.http.websocketx.WebSocketVersion; import io.netty.handler.codec.http.websocketx.extensions.compression.WebSocketClientCompressionHandler; import io.netty.handler.ssl.SslContext; import io.netty.handler.ssl.SslContextBuilder; import io.netty.handler.ssl.util.InsecureTrustManagerFactory; import io.netty.handler.timeout.IdleStateEvent; import io.netty.handler.timeout.IdleStateHandler; import io.netty.util.CharsetUtil; public class JsonRpcClientNettyWebSocket extends AbstractJsonRpcClientWebSocket { public class JsonRpcWebSocketClientHandler extends AbstractJsonRpcWebSocketClientHandler { private StringBuilder partialText = new StringBuilder(); public JsonRpcWebSocketClientHandler(WebSocketClientHandshaker handshaker) { super(handshaker); } @Override public void handlerAdded(ChannelHandlerContext ctx) { handshakeFuture = ctx.newPromise(); } @Override public void channelActive(ChannelHandlerContext ctx) { log.debug("{} channel active", label); handshaker.handshake(ctx.channel()); } @Override public void channelWritabilityChanged(ChannelHandlerContext ctx) { log.debug("{} channel inactive", label); handleReconnectDisconnection(0, "Unknown reason"); } @Override public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception { if (evt instanceof IdleStateEvent) { log.debug("{} Idle state event received", label); handleReconnectDisconnection(0, "Idle event received"); } } @Override public void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception { Channel ch = ctx.channel(); if (!handshaker.isHandshakeComplete()) { handshaker.finishHandshake(ch, (FullHttpResponse) msg); log.debug("{} WebSocket Client connected!", label); handshakeFuture.setSuccess(); return; } if (msg instanceof FullHttpResponse) { FullHttpResponse response = (FullHttpResponse) msg; throw new IllegalStateException("Unexpected FullHttpResponse (getStatus=" + response.status() + ", content=" + response.content().toString(CharsetUtil.UTF_8) + ')'); } WebSocketFrame frame = (WebSocketFrame) msg; if (frame instanceof TextWebSocketFrame) { TextWebSocketFrame textFrame = (TextWebSocketFrame) frame; if (textFrame.isFinalFragment()) { receivedTextMessage(textFrame.text()); } else { partialText.append(textFrame.text()); } } else if (frame instanceof ContinuationWebSocketFrame) { ContinuationWebSocketFrame continuationFrame = (ContinuationWebSocketFrame) frame; partialText.append(continuationFrame.text()); if (continuationFrame.isFinalFragment()) { receivedTextMessage(partialText.toString()); partialText.setLength(0); } } else if (frame instanceof CloseWebSocketFrame) { CloseWebSocketFrame closeFrame = (CloseWebSocketFrame) frame; log.info("{} Received close frame from server. Will close client! Reason: {}", label, closeFrame.reasonText()); } else { log.warn("{} Received frame of type {}. Will be ignored", label, frame.getClass().getSimpleName()); } } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { log.warn("{} Exception caught in Netty websocket handler", label, cause); if (!handshakeFuture.isDone()) { handshakeFuture.setFailure(cause); } try { close(); } catch (IOException e) { log.warn("{} Exception closing Netty websocket client", label); } } } private static final Logger log = LoggerFactory.getLogger(JsonRpcClientNettyWebSocket.class); private volatile Channel channel; private volatile EventLoopGroup group; private volatile JsonRpcWebSocketClientHandler handler; public JsonRpcClientNettyWebSocket(String url) { this(url, null); } public JsonRpcClientNettyWebSocket(String url, JsonRpcWSConnectionListener connectionListener) { super(url, connectionListener); log.debug("{} Creating JsonRPC NETTY Websocket client", label); } @Override protected void sendTextMessage(String jsonMessage) throws IOException { if (channel == null || !channel.isWritable() || !channel.isActive()) { throw new IllegalStateException( label + " JsonRpcClient is disconnected from WebSocket server at '" + this.uri + "'"); } synchronized (channel) { channel.writeAndFlush(new TextWebSocketFrame(jsonMessage)); } } @Override protected boolean isNativeClientConnected() { return channel != null && channel.isActive(); } @Override protected void connectNativeClient() throws TimeoutException, Exception { if (channel == null || !channel.isActive() || group == null || group.isShuttingDown() || group.isShutdown()) { log.info("{} Connecting native client", label); final boolean ssl = "wss".equalsIgnoreCase(this.uri.getScheme()); final SslContext sslCtx; try { sslCtx = ssl ? SslContextBuilder.forClient().trustManager(InsecureTrustManagerFactory.INSTANCE).build() : null; } catch (SSLException e) { log.error("{} Could not create SSL Context", label, e); throw new IllegalArgumentException("Could not create SSL context. See logs for more details", e); } final String scheme = uri.getScheme() == null ? "ws" : uri.getScheme(); final String host = uri.getHost() == null ? "127.0.0.1" : uri.getHost(); final int port; if (uri.getPort() == -1) { if ("ws".equalsIgnoreCase(scheme)) { port = 80; } else if ("wss".equalsIgnoreCase(scheme)) { port = 443; } else { port = -1; } } else { port = uri.getPort(); } if (group == null || group.isShuttingDown() || group.isShutdown() || group.isTerminated()) { log.info("{} Creating new NioEventLoopGroup", label); group = new NioEventLoopGroup(); } if (channel != null) { log.info("{} Closing previously existing channel when connecting native client", label); closeChannel(); } Bootstrap b = new Bootstrap(); b.group(group).channel(NioSocketChannel.class).handler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) { log.info("{} Inititating new Netty channel. Will create new handler too!", label); handler = new JsonRpcWebSocketClientHandler(WebSocketClientHandshakerFactory.newHandshaker(uri, WebSocketVersion.V13, null, true, new DefaultHttpHeaders(), maxPacketSize)); ChannelPipeline p = ch.pipeline(); p.addLast("idleStateHandler", new IdleStateHandler(0, 0, idleTimeout / 1000)); if (sslCtx != null) { p.addLast(sslCtx.newHandler(ch.alloc(), host, port)); } p.addLast(new HttpClientCodec(), new HttpObjectAggregator(8192), WebSocketClientCompressionHandler.INSTANCE, handler); } }).option(ChannelOption.CONNECT_TIMEOUT_MILLIS, this.connectionTimeout); int numRetries = 0; final int maxRetries = 5; while (channel == null || !channel.isOpen()) { try { channel = b.connect(host, port).sync().channel(); handler.handshakeFuture().sync(); } catch (InterruptedException e) { // This should never happen log.warn("{} ERROR connecting WS Netty client, opening channel", label, e); } catch (Exception e) { if (e.getCause() instanceof WebSocketHandshakeException && numRetries < maxRetries) { log.warn( "{} Upgrade exception when trying to connect to {}. Try {} of {}. Retrying in 200ms ", label, uri, numRetries + 1, maxRetries); Thread.sleep(200); numRetries++; } else { throw e; } } } channel.closeFuture().addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception { log.info("{} channel closed", label); handleReconnectDisconnection(1001, "Channel closed"); } }); } } @Override public void closeNativeClient() { closeChannel(); if (group != null) { group.shutdownGracefully(); } else { log.warn("{} Trying to close a JsonRpcClientNettyWebSocket with group == null", label); } group = null; handler = null; } private void closeChannel() { if (channel != null) { log.debug("{} Closing client", label); try { channel.close().sync(); } catch (Exception e) { log.debug("{} Could not properly close websocket client. Reason: {}", label, e.getMessage(), e); } channel = null; } else { log.warn("{} Trying to close a JsonRpcClientNettyWebSocket with channel == null", label); } } }