@Deprecated
public class WebSocketClientHandler extends SimpleChannelInboundHandler<Object> {
- private static final Logger LOGGER = LoggerFactory.getLogger(WebSocketClientHandler.class.toString());
+ private static final Logger LOG = LoggerFactory.getLogger(WebSocketClientHandler.class);
private final WebSocketClientHandshaker handshaker;
private final ClientMessageCallback messageListener;
@Override
public void channelInactive(final ChannelHandlerContext ctx) throws Exception {
- LOGGER.info("WebSocket Client disconnected!");
+ LOG.info("WebSocket Client disconnected!");
}
@Override
Channel ch = ctx.channel();
if (!handshaker.isHandshakeComplete()) {
handshaker.finishHandshake(ch, (FullHttpResponse) msg);
- LOGGER.info("WebSocket Client connected!");
+ LOG.info("WebSocket Client connected!");
handshakeFuture.setSuccess();
return;
}
if (frame instanceof TextWebSocketFrame) {
TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
- LOGGER.info("WebSocket Client received message: "
+ LOG.info("WebSocket Client received message: "
+ textFrame.text());
} else if (frame instanceof PongWebSocketFrame) {
- LOGGER.info("WebSocket Client received pong");
+ LOG.info("WebSocket Client received pong");
} else if (frame instanceof CloseWebSocketFrame) {
- LOGGER.info("WebSocket Client received closing");
+ LOG.info("WebSocket Client received closing");
ch.close();
}
}
@Deprecated
public class WebSocketClientTest {
- private static final Logger logger = LoggerFactory.getLogger(WebSocketClientTest.class.toString());
+ private static final Logger LOG = LoggerFactory.getLogger(WebSocketClientTest.class);
private static final String MESSAGE = "Take me to your leader!";
private Thread webSocketServerThread;
webSocketServerThread.start();
port = webSocketServer.getPort().get();
} catch (Exception e) {
- logger.trace("Error starting websocket server");
+ LOG.trace("Error starting websocket server");
}
}
URI uri = null;
try {
uri = new URI(String.format("ws://localhost:%d/websocket", port));
- logger.info("CLIENT: " + uri);
+ LOG.info("CLIENT: " + uri);
ClientMessageCallback messageCallback = new ClientMessageCallback();
WebSocketIClient wsClient = new WebSocketIClient(uri,messageCallback);
try {
webSocketServerThread.interrupt();
} catch (InterruptedException e) {
- logger.info("WebSocket client couldn't connect to : " + uri);
+ LOG.info("WebSocket client couldn't connect to : " + uri);
Assert.fail("WebSocker client could not connect to : " + uri);
} catch (ExecutionException | TimeoutException toe) {
- logger.info("Message not received");
+ LOG.info("Message not received");
Assert.fail(toe.toString());
}
} catch (URISyntaxException e) {
- logger.info("There is an error in URL sytnax {}",e);
+ LOG.info("There is an error in URL sytnax {}",e);
Assert.fail("There is an error in URL sytnax");
}
}
private class ClientMessageCallback implements org.opendaylight.yangtools.websocket.client.callback.ClientMessageCallback {
@Override
public void onMessageReceived(final Object message) {
- logger.info("received message {}",message);
+ LOG.info("received message {}",message);
messageReceived.set(true);
}
}
private final ServerBootstrap bootstrap = new ServerBootstrap();
private final EventLoopGroup bossGroup = new NioEventLoopGroup();
private final EventLoopGroup workerGroup = new NioEventLoopGroup();
- private static final Logger logger = LoggerFactory.getLogger(WebSocketServer.class.toString());
+ private static final Logger LOG = LoggerFactory.getLogger(WebSocketServer.class);
public WebSocketServer(final int inPort) {
try {
startServer();
} catch (Exception e) {
- logger.info("Exception occured while starting webSocket server {}",e);
+ LOG.info("Exception occured while starting webSocket server {}",e);
}
}
} catch (ClassCastException cce) {
throw new ExecutionException("Unknown socket address type", cce);
}
- logger.info("Web socket server started at port " + port.get() + '.');
- logger.info("Open your browser and navigate to http://localhost:" + port.get() + '/');
+ LOG.info("Web socket server started at port " + port.get() + '.');
+ LOG.info("Open your browser and navigate to http://localhost:" + port.get() + '/');
try {
ch.closeFuture().sync();
*/
@Deprecated
public class WebSocketServerHandler extends SimpleChannelInboundHandler<Object> {
- private static final Logger logger = LoggerFactory.getLogger(WebSocketServerHandler.class.getName());
+ private static final Logger LOG = LoggerFactory.getLogger(WebSocketServerHandler.class);
private static final String WEBSOCKET_PATH = "/websocket";
// Send the uppercase string back.
String request = ((TextWebSocketFrame) frame).text();
- logger.debug(String.format("%s received %s", ctx.channel(), request));
+ LOG.debug(String.format("%s received %s", ctx.channel(), request));
ctx.channel().write(new TextWebSocketFrame(request.toUpperCase()));
}
@Override
public void exceptionCaught(final ChannelHandlerContext ctx, final Throwable cause) throws Exception {
- logger.info("Exception caught {}",cause);
+ LOG.info("Exception caught {}",cause);
ctx.close();
}
public abstract class AbstractImmutableNormalizedValueNode<K extends PathArgument, V> extends
AbstractImmutableNormalizedNode<K, V> {
- private static final Logger LOGGER = LoggerFactory.getLogger(AbstractImmutableNormalizedValueNode.class);
+ private static final Logger LOG = LoggerFactory.getLogger(AbstractImmutableNormalizedValueNode.class);
@Nullable
private final V value;
* Null value is allowed for empty type definition so it should be debug,
* but still we are logging it in case we need to debug missing values.
*/
- LOGGER.debug("The value of node {} is null",nodeIdentifier.getNodeType());
+ LOG.debug("The value of node {} is null",nodeIdentifier.getNodeType());
}
this.value = value;
}
@RunWith(Parameterized.class)
public class NormalizedNodeXmlTranslationTest {
- private static final Logger logger = LoggerFactory.getLogger(NormalizedNodeXmlTranslationTest.class);
+ private static final Logger LOG = LoggerFactory.getLogger(NormalizedNodeXmlTranslationTest.class);
private final SchemaContext schema;
@Parameterized.Parameters()
}
System.err.println(built);
- logger.info("{}", built);
+ LOG.info("{}", built);
final Element elementNS = XmlDocumentUtils.getDocument().createElementNS(
containerNode.getQName().getNamespace().toString(), containerNode.getQName().getLocalName());