Sending message with external call in netty socket

Question

I'm new to socket programming and Netty framework. I was trying to modify the Echo Server example so that the message is not sent from client as soon as a message is received, but a call from another thread would trigger the client send a message to the server.

The problem is, the server does not get the message unless the client sends it from readChannel or MessageReceived or channelActive which are where the server is specified with a parameter (ChannelHandlerContext). I couldn't manage to find a way to save the server channel and send a message later and repeatedly.

Here's my Client Handler code;

import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;

public class EchoClientHandler extends ChannelHandlerAdapter {

    ChannelHandlerContext server;

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        this.server = ctx; 
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
       // ctx.write(msg);  //not
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
       //ctx.flush();
    }
    public void externalcall(String msg) throws Exception {
        if(server!=null){
            server.writeAndFlush("[" + "] " + msg + '\n');
        }
    }
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        // Close the connection when an exception is raised.
        ctx.close();
    }
}

When Client creates the handler, it also creates a thread with a "SourceGenerator" object which gets the handler as parameter so as to call the externalcall() method.

    import io.netty.bootstrap.Bootstrap;
    import io.netty.channel.ChannelFuture;
    import io.netty.channel.ChannelInitializer;
    import io.netty.channel.ChannelOption;
    import io.netty.channel.EventLoopGroup;
    import io.netty.channel.nio.NioEventLoopGroup;
    import io.netty.channel.socket.SocketChannel;
    import io.netty.channel.socket.nio.NioSocketChannel;

    /**
     * Sends one message when a connection is open and echoes back any received
     * data to the server.  Simply put, the echo client initiates the ping-pong
     * traffic between the echo client and server by sending the first message to
     * the server.
     */
    public class EchoClient {

        private final String host;
        private final int port;

        public EchoClient(String host, int port, int firstMessageSize) {
            this.host = host;
            this.port = port;
        }
        public void run() throws Exception {
            // Configure the client.
            EventLoopGroup group = new NioEventLoopGroup();
            final EchoClientHandler x = new EchoClientHandler();
            SourceGenerator sg = new SourceGenerator(x);
            new Thread(sg).start();
            try {
                Bootstrap b = new Bootstrap();
                b.group(group)
                 .channel(NioSocketChannel.class)
                 .option(ChannelOption.TCP_NODELAY, true)
                 .handler(new ChannelInitializer<SocketChannel>() {
                     @Override
                     public void initChannel(SocketChannel ch) throws Exception {
                         ch.pipeline().addLast(x);
                     }
                 });

                // Start the client.
                ChannelFuture f = b.connect(host, port).sync();

                // Wait until the connection is closed.
                f.channel().closeFuture().sync();
            } finally {
                // Shut down the event loop to terminate all threads.
                group.shutdownGracefully();
            }
        }

        public static void main(String[] args) throws Exception {
            // Print usage if no argument is specified.
            if (args.length < 2 || args.length > 3) {
                System.err.println(
                        "Usage: " + EchoClient.class.getSimpleName() +
                        " <host> <port> [<first message size>]");
                return;
            }
            // Parse options.
            final String host = args[0];
            final int port = Integer.parseInt(args[1]);
            final int firstMessageSize;
            if (args.length == 3) {
                firstMessageSize = Integer.parseInt(args[2]);
            } else {
                firstMessageSize = 256;
            }

            new EchoClient(host, port, firstMessageSize).run();
        }
    }

and the SourceGenerator class;

public class SourceGenerator implements Runnable {
    public String dat;
    public EchoClientHandler asd;
    public SourceGenerator(EchoClientHandler x) {
        asd = x;
        System.out.println("initialized source generator");
        dat = "";
    }

    @Override
    public void run() {
        try{
            while(true){
                Thread.sleep(2000);
                dat += "a"; 
                asd.externalcall(dat);
                System.out.print("ha!");
            }
        }catch(Exception e){
            e.printStackTrace();

        }
    }
}

Thanks in advance!

Answer 1

If you want to write a String you need to have the StringEncoder in the ChannelPipeline.

Otherwise you can only send ByteBuf instances.