private void keepAliveFilterForIdleStatus(IdleStatus status) throws Exception {
    NioSocketConnector connector = new NioSocketConnector();
    KeepAliveFilter filter =
        new KeepAliveFilter(new ClientFactory(), status, EXCEPTION, INTERVAL, TIMEOUT);
    filter.setForwardEvent(true);
    connector.getFilterChain().addLast("keep-alive", filter);

    final AtomicBoolean gotException = new AtomicBoolean(false);
    connector.setHandler(
        new IoHandlerAdapter() {
          @Override
          public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
            // cause.printStackTrace();
            gotException.set(true);
          }

          @Override
          public void sessionIdle(IoSession session, IdleStatus status) throws Exception {
            // Do nothing
          }
        });

    ConnectFuture future =
        connector.connect(new InetSocketAddress("127.0.0.1", port)).awaitUninterruptibly();
    IoSession session = future.getSession();
    assertNotNull(session);

    Thread.sleep((INTERVAL + TIMEOUT + 1) * 1000);

    assertFalse("got an exception on the client", gotException.get());

    session.close(true);
    connector.dispose();
  }
Example #2
0
 public static CmdClient getCmdClient(long connectTimeoutInMillis) {
   if (cmdClient == null) {
     cmdClient = new CmdClient(connectTimeoutInMillis);
   } else if (connector.getConnectTimeoutMillis() != connectTimeoutInMillis) {
     connector.setConnectTimeoutMillis(connectTimeoutInMillis);
   }
   return cmdClient;
 }
Example #3
0
 private CmdClient(long connectTimeoutInMillis) {
   connector.setConnectTimeoutMillis(connectTimeoutInMillis);
   connector
       .getFilterChain()
       .addLast(
           "codec", new ProtocolCodecFilter(new CmdRequestEncoder(), new CmdResponseDecoder()));
   connector.getFilterChain().addLast("threadPool", new ExecutorFilter(executor));
   connector.setHandler(this);
 }
 private NioSocketConnector setupConnector(IoHandlerAdapter handler) {
   NioSocketConnector connector = new NioSocketConnector();
   connector.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 300);
   connector.setConnectTimeoutCheckInterval(5);
   connector
       .getFilterChain()
       .addLast(
           "codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
   connector.setHandler(handler);
   return connector;
 }
Example #5
0
  private void init() {
    connector = new NioSocketConnector();
    bh = new BotHandler(username, password, roomId);
    connector.setHandler(bh);

    DefaultIoFilterChainBuilder chain = connector.getFilterChain();

    log.debug("connecing to the server...");
    ConnectFuture connFuture =
        connector.connect(
            new InetSocketAddress(ServerConfig.gameServerAddress, ServerConfig.gameServerPort));
    connFuture.awaitUninterruptibly();
  }
 /**
  * Cleans-up any resources after a connection has terminated. Should be called when the connection
  * is disconnected and reconnect is not desired.
  */
 void finishConnection() {
   NioSocketConnector conn = this.connector;
   if (conn != null) {
     this.connector = null;
     conn.dispose();
     for (ConnectionListener listener : this.connectionListeners) {
       listener.connectionEnded(this);
     }
   }
   ExecutorFilter execs = this.executors;
   if (execs != null) {
     this.executors = null;
     execs.destroy();
   }
 }
 /** 注销当前连接 */
 public void dispose() {
   if (connector != null) {
     connector.dispose();
   }
   if (healthDaemon != null) {
     healthDaemon.stopHeartBeat();
   }
 }
  /** 初始化连接类 */
  public synchronized void initConnector(IoHandler handler) {
    if (connector == null) {
      connector = new NioSocketConnector();
      // 设置缓存大小
      connector.getSessionConfig().setMaxReadBufferSize(2048);
      // 添加过滤器
      connector
          .getFilterChain()
          .addLast(
              "codec", new ProtocolCodecFilter(new ExpressCodecFactory(Charset.forName("UTF-8"))));

      // 设置日志过滤器
      LoggingFilter loggingFilter = new LoggingFilter();
      loggingFilter.setMessageReceivedLogLevel(LogLevel.DEBUG);
      loggingFilter.setMessageSentLogLevel(LogLevel.DEBUG);
      connector.getFilterChain().addLast("logger", loggingFilter);
      // 添加登录过滤器
      connector.getFilterChain().addLast("loginFilter", new TCPLoginFilter());
      // 添加登出过滤器
      connector.getFilterChain().addLast("logoutFilter", new TCPLogoutFilter());
      // 防回流过滤器
      connector.getFilterChain().addLast("backFlowFilter", new BackFlowFilter());

      // 添加业务逻辑处理器类
      connector.setHandler(handler);
    }
  }
  /**
   * 根据host和port新建一个IoSession连接
   *
   * @param host 连接主机IP
   * @param port 连接端口
   * @param timeout 未收到数据超时时间/秒
   */
  @Override
  public void connect(String host, int port, int timeout) throws Exception {
    connector.getSessionConfig().setIdleTime(IdleStatus.READER_IDLE, timeout);
    log.debug("超时时间:" + timeout + "秒");
    // 设置连接超时时间
    connector.setConnectTimeoutMillis(ExpressConstant.CONNECT_TIMEOUT);

    // 创建连接
    ConnectFuture future = connector.connect(new InetSocketAddress(host, port));

    // 等待连接创建完成
    future.awaitUninterruptibly();

    // 得到连接Session
    session = future.getSession();
    // 设置Session同步锁对象
    session.setAttribute(ExpressConstant.SESSION_LOCK, new LockExpress());
  }
 @Override
 public void run() {
   running = true;
   finished = false;
   NioSocketConnector connector = setupConnector(clientHandler);
   IoSession session = createSession(connector, socketAddress);
   while (running) {
     String processedObservation = null;
     try {
       processedObservation = queue.poll(500, TimeUnit.MILLISECONDS);
     } catch (InterruptedException e) {
       logger.error("Interrupted while polling the processed observation queue");
     }
     if (processedObservation != null) session.write(processedObservation);
   }
   session.getCloseFuture().awaitUninterruptibly(); // closed when idle in handler
   connector.dispose();
   finished = true;
 }
Example #11
0
 /**
  * Title:
  *
  * <p>Desc:初始化客户端信息
  *
  * @param message
  * @throws UnsupportedEncodingException
  */
 public TongbuClient(Object message, String url, int port) {
   chain.addLast("logging", new LoggingFilter()); // 添加日志过滤器
   chain.addLast("myChin", new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
   if (message instanceof String) {
     connector.setHandler(new ClientHandler((String) message));
   } else if (message instanceof CommEntity) {
     connector.setHandler(new ClientHandler((CommEntity) message));
   }
   connector.setConnectTimeoutMillis(10000);
   SocketSessionConfig cfg = connector.getSessionConfig();
   cfg.setUseReadOperation(true);
   IoSession session =
       connector.connect(new InetSocketAddress(url, port)).awaitUninterruptibly().getSession();
   ReadFuture readFuture = session.read();
   readFuture.awaitUninterruptibly();
   this.info = (CommResultInfo) readFuture.getMessage();
   session.close(true);
   session.getService().dispose();
 }
Example #12
0
  private CommandMinaClient() throws java.net.ConnectException {
    NioSocketConnector connector = new NioSocketConnector();
    // 创建接收数据的过滤器
    DefaultIoFilterChainBuilder chain = connector.getFilterChain();
    // 设定这个过滤器将以对象为单位读取数据
    ProtocolCodecFilter filter = new ProtocolCodecFilter(new ObjectSerializationCodecFactory());
    // 设定服务器端的消息处理器:一个SamplMinaServerHandler对象,
    chain.addLast("objectFilter", filter);

    // 设定服务器端的消息处理器:一个 SamplMinaServerHandler 对象,
    connector.setHandler(new CommandMinaClientHanlder());
    // Set connect timeout.
    connector.setConnectTimeoutCheckInterval(30);
    // 连结到服务器:
    ConnectFuture cf = connector.connect(new InetSocketAddress("159.226.95.156", 9900));
    // Wait for the connection attempt to be finished.
    cf.awaitUninterruptibly();

    session = cf.getSession();
  }
Example #13
0
  public void connect(InetAddress ia, int port) {
    connector = new NioSocketConnector();
    connector
        .getFilterChain()
        .addLast("codec", new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
    if (logger.isDebugEnabled()) {
      LoggingFilter logFilter = new LoggingFilter();
      logFilter.setMessageSentLogLevel(LogLevel.DEBUG);
      logFilter.setMessageReceivedLogLevel(LogLevel.DEBUG);
      connector.getFilterChain().addLast("logger", logFilter);
    }
    connector.setHandler(this);

    ConnectFuture future = connector.connect(new InetSocketAddress(ia, port));
    future.awaitUninterruptibly();
    if (!future.isConnected()) {
      logger.error("Connection failed");
    }
    session = future.getSession();
  }
Example #14
0
  public void socketServer() {
    // 创建一个socket连接
    NioSocketConnector connector = new NioSocketConnector();
    // 消息核心处理器
    connector.setHandler(new MinaClientHanlder());
    // 设置链接超时时间
    connector.setConnectTimeoutCheckInterval(30);
    // 获取过滤器链
    DefaultIoFilterChainBuilder chain = connector.getFilterChain();
    ProtocolCodecFilter filter =
        new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8")));
    // 添加编码过滤器 处理乱码、编码问题
    chain.addLast("objectFilter", filter);

    // 连接服务器,知道端口、地址
    ConnectFuture cf = connector.connect(new InetSocketAddress(App.address, App.bindPort));
    // 等待连接创建完成
    cf.awaitUninterruptibly();
    if (cf.isConnected()) {
      App.isConnected = true;
      System.out.println("等待连接断开");
      // 等待连接断开
      cf.getSession().getCloseFuture().awaitUninterruptibly();
    } else {
      System.out.println("连接断开");
      App.isConnected = false;
    }
    System.out.println("----dispose");
    connector.dispose();
    System.out.println("dispose----");
  }
  @Test
  public void testWriteUsingSocketTransport() throws Exception {
    NioSocketAcceptor acceptor = new NioSocketAcceptor();
    acceptor.setReuseAddress(true);
    SocketAddress address =
        new InetSocketAddress("localhost", AvailablePortFinder.getNextAvailable());

    NioSocketConnector connector = new NioSocketConnector();

    // Generate 4MB of random data
    byte[] data = new byte[4 * 1024 * 1024];
    new Random().nextBytes(data);

    byte[] expectedMd5 = MessageDigest.getInstance("MD5").digest(data);

    M message = createMessage(data);

    SenderHandler sender = new SenderHandler(message);
    ReceiverHandler receiver = new ReceiverHandler(data.length);

    acceptor.setHandler(sender);
    connector.setHandler(receiver);

    acceptor.bind(address);
    connector.connect(address);
    sender.latch.await();
    receiver.latch.await();

    acceptor.dispose();

    assertEquals(data.length, receiver.bytesRead);
    byte[] actualMd5 = receiver.digest.digest();
    assertEquals(expectedMd5.length, actualMd5.length);
    for (int i = 0; i < expectedMd5.length; i++) {
      assertEquals(expectedMd5[i], actualMd5[i]);
    }
  }
  public void init() {

    // Create TCP/IP connector.
    connector = new NioSocketConnector();
    // 创建接收数据的过滤器
    DefaultIoFilterChainBuilder chain = connector.getFilterChain();
    // 自动重连
    chain.addLast(
        "reConnect",
        new IoFilterAdapter() {
          public void sessionClosed(NextFilter nextFilter, IoSession session) throws Exception {
            logger.error("连接被关闭:" + getServerInfo());
            scheduleConnect();
          }
        });
    // 设定这个过滤器将一行一行(/r/n)的读取数据
    chain.addLast("protocolCodecFilter", new ProtocolCodecFilter(new TextLineCodecFactory()));
    // 设定服务器端的消息处理器:一个MinaClientHandler对象,
    connector.setHandler(ioHandler);
    // Set connect timeout.
    connector.setConnectTimeoutMillis(30 * 1000);

    doConnnect();
  }
 public void doConnnect() {
   // 连结到服务器:
   ConnectFuture cf = connector.connect(new InetSocketAddress(remoteServerHost, remoteServerPort));
   cf.addListener(
       new IoFutureListener<ConnectFuture>() {
         public void operationComplete(ConnectFuture future) {
           if (future.isConnected()) {
             logger.info("连接成功:" + getServerInfo());
           } else {
             logger.error("连接失败:" + ",原因:" + future.getException());
             // 启动连接失败时定时重连
             scheduleConnect();
           }
         }
       });
 }
 private IoSession createSession(NioSocketConnector connector, InetSocketAddress socketAddress) {
   IoSession session;
   for (; ; ) {
     try {
       ConnectFuture future = connector.connect(socketAddress);
       future.awaitUninterruptibly();
       session = future.getSession();
       break;
     } catch (RuntimeIoException e) {
       logger.error("Error while obtaining sensor server session", e);
       try {
         Thread.sleep(5000);
       } catch (InterruptedException e1) {
         logger.error("Error while sleeping", e);
       }
     }
   }
   return session;
 }
Example #19
0
/**
 * @ClassName: TongbuClient @Description: mina客户端=====同步
 *
 * @author xubin
 * @date 2012-9-10 下午6:33:53
 */
public class TongbuClient {
  NioSocketConnector connector = new NioSocketConnector();
  DefaultIoFilterChainBuilder chain = connector.getFilterChain();
  CommResultInfo info;

  /**
   * Title:
   *
   * <p>Desc:初始化客户端信息
   *
   * @param message
   * @throws UnsupportedEncodingException
   */
  public TongbuClient(Object message, String url, int port) {
    chain.addLast("logging", new LoggingFilter()); // 添加日志过滤器
    chain.addLast("myChin", new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
    if (message instanceof String) {
      connector.setHandler(new ClientHandler((String) message));
    } else if (message instanceof CommEntity) {
      connector.setHandler(new ClientHandler((CommEntity) message));
    }
    connector.setConnectTimeoutMillis(10000);
    SocketSessionConfig cfg = connector.getSessionConfig();
    cfg.setUseReadOperation(true);
    IoSession session =
        connector.connect(new InetSocketAddress(url, port)).awaitUninterruptibly().getSession();
    ReadFuture readFuture = session.read();
    readFuture.awaitUninterruptibly();
    this.info = (CommResultInfo) readFuture.getMessage();
    session.close(true);
    session.getService().dispose();
  }

  public CommResultInfo getResult() {
    return info;
  }
}
Example #20
0
 public void connect(String host, int port, CmdListener cmdListener) {
   final CmdListener fCmdListener = cmdListener;
   // --start
   // IoBuffer.setUseDirectBuffer(false);
   // IoBuffer.setAllocator(new QSIoBufferAllocater());
   // --end
   ConnectFuture connectFuture = connector.connect(new InetSocketAddress(host, port));
   connectFuture.addListener(
       new IoFutureListener<ConnectFuture>() {
         public void operationComplete(ConnectFuture future) {
           if (!future.isConnected()) {
             fCmdListener.onException(new Exception("连接超时"));
           } else {
             future.getSession().setAttribute("CmdListener", fCmdListener);
             future
                 .getSession()
                 .getConfig()
                 .setIdleTime(IdleStatus.WRITER_IDLE, fCmdListener.getWriteTimeout());
             future.getSession().getConfig().setReadBufferSize(3000);
             future.getSession().write(fCmdListener.getCmdResuest());
           }
         }
       });
 }
 public void close() {
   connector.dispose();
 }