title: Sending message with external call in netty socket programming
body: <p>I'm new to socket programming and Netty framework. I was trying to modify the <a href="https://github.com/netty/netty/tree/master/example/src/main/java/io/netty/example/echo" rel="nofollow">Echo Server example</a> 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.</p>
  
  <p>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.</p>
  
  
  
  <p>Here's my Client Handler code;</p>
  
  <pre class="lang-java prettyprint-override"><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();
      }
  }
  </code></pre>
  
  <p>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.</p>
  
  <pre class="lang-java prettyprint-override"><code>    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&lt;SocketChannel&gt;() {
                       @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 &lt; 2 || args.length &gt; 3) {
                  System.err.println(
                          "Usage: " + EchoClient.class.getSimpleName() +
                          " &lt;host&gt; &lt;port&gt; [&lt;first message size&gt;]");
                  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();
          }
      }
  </code></pre>
  
  <p>and the SourceGenerator class; </p>
  
  <pre class="lang-java prettyprint-override"><code>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();
  
          }
      }
  }
  </code></pre>
  
  <p>Thanks in advance!</p>