Example usage for org.apache.mina.filter.codec ProtocolCodecFilter ProtocolCodecFilter

List of usage examples for org.apache.mina.filter.codec ProtocolCodecFilter ProtocolCodecFilter

  1. HOME
  2. Java
  3. org.apache.mina
  4. org.apache.mina.filter.codec.*
  5. ProtocolCodecFilter
  6. ProtocolCodecFilter

Introduction

In this page you can find the example usage for org.apache.mina.filter.codec ProtocolCodecFilter ProtocolCodecFilter.

Prototype

public ProtocolCodecFilter(ProtocolEncoder<MESSAGE, ENCODED, ENCODING_STATE> encoder,
        ProtocolDecoder<ENCODED, MESSAGE, DECODING_STATE> decoder)

Source Link

Document

Creates a new instance of ProtocolCodecFilter, with the specified encoder and decoder.

Usage

From source file:com.jagornet.dhcpv6.client.TestClient.java

License:Open Source License

/**
 * Start.//w  ww.  ja  v a2  s . com
 */
public void start() {
    // pre-configure the message factory instance
    DhcpMessageFactory.setType(DhcpMessageFactory.Type.STATELESS_CLIENT);

    log.debug("Creating a datagram connector");
    IoConnector connector = new NioDatagramConnector();

    log.debug("Setting the handler");
    connector.setHandler(this);

    DefaultIoFilterChainBuilder chain = connector.getFilterChain();
    chain.addLast("logger", new LoggingFilter());

    ProtocolEncoder encoder = new DhcpEncoderAdapter();
    ProtocolDecoder decoder = new DhcpDecoderAdapter();
    chain.addLast("codec", new ProtocolCodecFilter(encoder, decoder));

    log.debug("About to connect to the server...");
    ConnectFuture connFuture = connector.connect(new InetSocketAddress(serverAddr, serverPort));

    log.debug("About to wait.");
    connFuture.awaitUninterruptibly();

    log.debug("Adding a future listener.");
    connFuture.addListener(new IoFutureListener<ConnectFuture>() {
        public void operationComplete(ConnectFuture future) {
            if (future.isConnected()) {
                log.debug("...connected");
                IoSession session = future.getSession();
                List<DhcpMessage> msgs = buildRequestMessages();
                for (DhcpMessage msg : msgs) {
                    // write the message, the codec will convert it
                    // to wire format... well, hopefully it will!
                    session.write(msg);
                }
                System.exit(0);
            } else {
                log.error("Not connected...exiting");
            }
        }
    });
}

From source file:com.jagornet.dhcpv6.server.nio.NioDhcpServer.java

License:Open Source License

/**
 * Instantiates a new unicast dhcp server.
 * /*  ww w.jav a  2s.  c om*/
 * @param port the port
 * 
 * @throws Exception the exception
 */
public NioDhcpServer(List<InetAddress> addrs, int port) throws Exception {
    try {
        acceptor = new NioDatagramAcceptor();
        if ((addrs != null) && !addrs.isEmpty()) {
            List<SocketAddress> socketAddrs = new ArrayList<SocketAddress>();
            for (InetAddress addr : addrs) {
                SocketAddress sockAddr = new InetSocketAddress(addr, port);
                socketAddrs.add(sockAddr);
            }
            acceptor.setDefaultLocalAddresses(socketAddrs);
        }

        acceptor.setHandler(new DhcpHandlerAdapter());

        registerJmx(acceptor);

        DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();
        chain.addLast("logger", new LoggingFilter());

        ProtocolEncoder encoder = new DhcpEncoderAdapter();
        ProtocolDecoder decoder = new DhcpDecoderAdapter();
        /*
         * From the MINA Wiki documentation:
         * 
         *      Where should I put an ExecutorFilter in an IoFilterChain?
         * 
         *          It depends on the characteristics of your application. 
         *          For an application with a ProtocolCodecFilter implementation and 
         *          a usual IoHandler implementation with database operations, 
         *          I'd suggest you to add the ExecutorFilter after the 
         *          ProtocolCodecFilter implementation. It is because the 
         *          performance characteristic of most protocol codec implementations 
         *          is CPU-bound, which is the same with I/O processor threads.      
         */
        // Add CPU-bound job first,
        chain.addLast("codec", new ProtocolCodecFilter(encoder, decoder));

        // and then a thread pool.
        executorService = Executors.newCachedThreadPool();
        chain.addLast("threadPool", new ExecutorFilter(executorService));

        DatagramSessionConfig dcfg = acceptor.getSessionConfig();
        dcfg.setReuseAddress(true);
    } catch (Exception ex) {
        log.error("Failed to initialize server: " + ex, ex);
        throw ex;
    }
}

From source file:mx.unam.fesa.isoo.msp.network.MSClient.java

License:Open Source License

/**
 * @param hostname//from  w ww. j  a v a2  s.c  om
 * @param port
 */
public MSClient(String hostname, int port) {
    this.connector = new NioDatagramConnector();
    this.connector.getFilterChain().addLast("ms protocol codec",
            new ProtocolCodecFilter(new MSRequestEncoder(), new MSResponseDecoder()));

    StateMachine sm = StateMachineFactory.getInstance(IoHandlerTransition.class).create(MSPlayer.REGISTER,
            new MSPlayer(this));
    this.connector.setHandler(new StateMachineProxyBuilder().create(IoHandler.class, sm));
    this.connector.connect(new InetSocketAddress(hostname, port));
}

From source file:mx.unam.fesa.mss.network.MSServer.java

License:Open Source License

/**
 * @param port/*from  w w w . j a v a2s.  c o m*/
 * @throws IOException 
 */
public MSServer(int port) throws IOException {
    this.acceptor = new NioDatagramAcceptor();
    this.acceptor.getSessionConfig().setReuseAddress(true);
    this.acceptor.getFilterChain().addLast("codec",
            new ProtocolCodecFilter(new MSResponseEncoder(), new MSRequestDecoder()));
    //this.acceptor.getFilterChain().addLast("logger", new LoggingFilter());
    this.acceptor.addListener(new IoServiceListener() {

        /* (non-Javadoc)
         * @see org.apache.mina.core.service.IoServiceListener#sessionDestroyed(org.apache.mina.core.session.IoSession)
         */
        @Override
        public void sessionDestroyed(IoSession session) throws Exception {
        }

        /* (non-Javadoc)
         * @see org.apache.mina.core.service.IoServiceListener#sessionCreated(org.apache.mina.core.session.IoSession)
         */
        @Override
        public void sessionCreated(IoSession session) throws Exception {
        }

        /* (non-Javadoc)
         * @see org.apache.mina.core.service.IoServiceListener#serviceIdle(org.apache.mina.core.service.IoService, org.apache.mina.core.session.IdleStatus)
         */
        @Override
        public void serviceIdle(IoService service, IdleStatus idleStatus) throws Exception {
        }

        /* (non-Javadoc)
         * @see org.apache.mina.core.service.IoServiceListener#serviceDeactivated(org.apache.mina.core.service.IoService)
         */
        @Override
        public void serviceDeactivated(IoService service) throws Exception {
        }

        /* (non-Javadoc)
         * @see org.apache.mina.core.service.IoServiceListener#serviceActivated(org.apache.mina.core.service.IoService)
         */
        @Override
        public void serviceActivated(IoService service) throws Exception {
            LOGGER.info("Server connected to " + address);
        }
    });

    StateMachine sm = StateMachineFactory.getInstance(IoHandlerTransition.class)
            .create(MSProtocolHandler.REGISTER_PLAYER1, new MSProtocolHandler(this));
    this.acceptor.setHandler(new StateMachineProxyBuilder().create(IoHandler.class, sm));
    this.acceptor.bind(this.address = new InetSocketAddress(port));
}

From source file:org.eclipse.mihini.coap.assetfactory.CoapServer.java

License:Apache License

public void start() {

    final Map<String, IoSession> registration = new ConcurrentHashMap<String, IoSession>();

    reg = new ResourceRegistry();

    BioUdpServer server = new BioUdpServer();
    final RequestFilter<CoapMessage, CoapMessage> rq = new RequestFilter<CoapMessage, CoapMessage>();

    server.setFilters(/* new LoggingFilter(), */new ProtocolCodecFilter<CoapMessage, ByteBuffer, Void, Void>(
            new CoapEncoder(), new CoapDecoder()), rq);
    // idle in 10 minute
    server.getSessionConfig().setIdleTimeInMillis(IdleStatus.READ_IDLE, 10 * 60 * 1000);
    server.setIoHandler(new AbstractIoHandler() {

        long start = System.currentTimeMillis();
        int count = 0;

        @Override/*from  w  ww . ja v a2 s  . co m*/
        public void messageReceived(IoSession session, Object message) {
            System.err.println("rcv : " + message);

            CoapMessage resp = reg.respond((CoapMessage) message, session);
            System.err.println("resp : " + resp);
            session.write(resp);
            count++;
            if (count >= 100000) {
                System.err.println("time for 100k msg : " + (System.currentTimeMillis() - start));
                count = 0;
                start = System.currentTimeMillis();
            }
        }

        @Override
        public void messageSent(IoSession session, Object message) {
            System.err.println("sent : " + message);
        }

        @Override
        public void sessionIdle(IoSession session, IdleStatus status) {
            System.err.println("idle closing");
            session.close(false);
        }
    });

    try {
        server.bind(5683);
        new Thread() {
            @Override
            public void run() {
                for (;;) {
                    for (IoSession s : registration.values()) {
                        rq.request(s, CoapMessage.get("st", true), 15000)
                                .register(new AbstractIoFutureListener<CoapMessage>() {
                                    @Override
                                    public void completed(CoapMessage result) {
                                        System.err.println("status : " + result);
                                    }
                                });
                    }

                    try {
                        // let's poll every 10 seconds
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        break;
                    }
                }
            }
        }.start();

        for (;;) {
            Thread.sleep(1000);
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

}

From source file:org.eclipse.scada.core.net.ConnectionHelper.java

License:Open Source License

/**
 * Setup the filter chain of a NET/GMPP connection
 * //from  w  w w. j a va2s .c om
 * @param connectionInformation
 *            the connection information to use
 * @param filterChainBuilder
 *            the chain builder
 */
public static void setupFilterChain(final ConnectionInformation connectionInformation,
        final DefaultIoFilterChainBuilder filterChainBuilder, final boolean isClient) {
    // set up compression
    final CompressionFilter compressionFilter = createCompressionFilter(
            connectionInformation.getProperties().get("compress"));
    if (compressionFilter != null) {
        filterChainBuilder.addLast("compress", compressionFilter);
    }

    // set up ssl
    final String ssl = connectionInformation.getProperties().get("ssl");
    if (ssl != null) {
        initSsl(connectionInformation, filterChainBuilder, isClient);
    }

    // set up logging
    final String trace = connectionInformation.getProperties().get("trace");
    if (trace != null) {
        filterChainBuilder.addLast("logging", new LoggingFilter());
    }

    // add the main codec
    filterChainBuilder.addLast("codec",
            new ProtocolCodecFilter(new GMPPProtocolEncoder(), new GMPPProtocolDecoder()));
}

From source file:org.eclipse.scada.da.client.sfp.FilterChainBuilder.java

License:Open Source License

@Override
public void buildFilterChain(final IoFilterChain chain) {
    if (this.loggerName != null && Boolean.getBoolean("org.eclipse.scada.protocol.sfp.common.logger.raw")) {
        chain.addFirst("logger.raw", new LoggingFilter(this.loggerName));
    }/*from   ww w. j a  va 2s .co  m*/

    if (!Boolean.getBoolean("org.eclipse.scada.protocol.sfp.common.disableStats")) {
        chain.addFirst(StatisticsFilter.DEFAULT_NAME, new StatisticsFilter());
    }

    if (this.loggerName != null && Boolean.getBoolean("org.eclipse.scada.protocol.sfp.common.logger")) {
        chain.addFirst("logger", new LoggingFilter(this.loggerName));
    }

    chain.addLast("closeidle", new IoFilterAdapter() {
        @Override
        public void sessionIdle(final NextFilter nextFilter, final IoSession session, final IdleStatus status)
                throws Exception {
            session.close(true);
        }
    });
    chain.addLast("codec", new ProtocolCodecFilter(new ProtocolEncoderImpl(), new ProtocolDecoderImpl()));
}

From source file:org.eclipse.scada.da.server.exporter.modbus.ModbusExport.java

License:Open Source License

private void createAcceptor() {
    final NioSocketAcceptor acceptor = new NioSocketAcceptor(this.processor);
    try {//from  w w w. ja  va  2 s .c o  m
        acceptor.setReuseAddress(true);
        acceptor.setBacklog(
                Integer.getInteger("org.eclipse.scada.da.server.exporter.modbus.acceptor.backlog", 5)); //$NON-NLS-1$

        final ModbusTcpEncoder encoder = new ModbusTcpEncoder();
        final ModbusTcpDecoder decoder = new ModbusTcpDecoder();
        acceptor.getFilterChain().addLast("modbusPdu", new ProtocolCodecFilter(encoder, decoder)); //$NON-NLS-1$
        acceptor.getFilterChain().addLast("modbus", new ModbusSlaveProtocolFilter()); //$NON-NLS-1$

        acceptor.setHandler(new IoHandlerAdapter() {
            @Override
            public void exceptionCaught(final IoSession session, final Throwable cause) throws Exception {
                session.close(true);
            };

            @Override
            public void sessionOpened(final IoSession session) throws Exception {
                logger.info("Session opened: {}", session); //$NON-NLS-1$
                ModbusExport.this.info.incrementActiveSessions();
                handleSessionOpened(session);
            };

            @Override
            public void sessionIdle(final IoSession session, final IdleStatus status) throws Exception {
                logger.info("Session idle: {}", session); //$NON-NLS-1$
                handleSessionIdle(session);
            };

            @Override
            public void sessionClosed(final IoSession session) throws Exception {
                logger.info("Session closed: {}", session); //$NON-NLS-1$
                ModbusExport.this.info.decrementActiveSessions();
            };

            @Override
            public void messageReceived(final IoSession session, final Object message) throws Exception {
                handleMessageReceived(session, message);
            };
        });
        this.acceptor = acceptor;
        this.acceptor.bind(this.currentAddress);
    } catch (final Exception e) {
        logger.warn("Failed to create acceptor", e);
        this.acceptor.dispose();
        throw new RuntimeException(e);
    }
}

From source file:org.eclipse.scada.da.server.osgi.modbus.ModbusMaster.java

License:Open Source License

@Override
protected void configureConnector(final NioSocketConnector connector) {
    logger.debug("Configuring connector: {}", connector);

    switch (this.protocolType) {
    case TYPE_TCP:
        connector.getFilterChain().addLast("modbusPdu",
                new ProtocolCodecFilter(new ModbusTcpEncoder(), new ModbusTcpDecoder()));
        connector.getFilterChain().addLast("modbus", new ModbusMasterProtocolFilter());
        break;/*from  w w  w.j  a  v a2 s  .  co  m*/
    case TYPE_RTU:
        // convert milliseconds to microseconds to allow more accurate timing
        final ModbusRtuDecoder rtuDecoder = new ModbusRtuDecoder(getExecutor(),
                Double.valueOf(this.interFrameDelay * 1000).longValue(), TimeUnit.MICROSECONDS);
        connector.getFilterChain().addLast("modbusPdu",
                new ModbusRtuProtocolCodecFilter(new ModbusRtuEncoder(), rtuDecoder));
        connector.getFilterChain().addLast("modbus", new ModbusMasterProtocolFilter());
        break;
    default:
        throw new IllegalArgumentException(
                String.format("'%s' is not an allowed modbus device type", this.protocolType));
    }

    if (Boolean.getBoolean("org.eclipse.scada.da.server.osgi.modbus.trace")) {
        connector.getFilterChain().addFirst("logger",
                new LoggingFilter(ModbusMaster.class.getName() + ".protocol"));
    }
}

From source file:org.eclipse.scada.protocol.arduino.ArduinoDevice.java

License:Open Source License

public synchronized void start() {
    if (this.started) {
        return;/*  www  .  j a  va 2  s  .c  om*/
    }

    this.started = true;

    this.executorService = ScheduledExportedExecutorService
            .newSingleThreadExportedScheduledExecutor("ArduninoDevice/" + this.address);

    this.connector = new NioDatagramConnector();

    this.connector.setHandler(this);
    if (this.activateLogger) {
        this.connector.getFilterChain().addLast("logger", new LoggingFilter(this.getClass().getName()));
    }

    final ArduinoCodec codec = new ArduinoCodec();
    this.connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(codec, codec));

    this.connector.connect(this.address);
}