Java 类com.facebook.nifty.core.NettyServerConfig 实例源码

public NettyIkasoaFactory(NettyServerConfig nettyServerConfig, ChannelGroup channelGroup) {
    this.nettyServerConfig = nettyServerConfig;
    if (channelGroup == null)
        this.channelGroup = new DefaultChannelGroup();
    else
        this.channelGroup = channelGroup;
}

@Inject
public NettyServerTransport(final ThriftServerDef def, final NettyServerConfig nettyServerConfig, final ChannelGroup allChannels, final boolean local) {
    this.def = def;
    this.nettyServerConfig = nettyServerConfig;
    this.requestedPort = def.getServerPort();
    this.allChannels = allChannels;
    this.local = local;
    // connectionLimiter must be instantiated exactly once (and thus outside
    // the pipeline factory)
    final ConnectionLimiter connectionLimiter = new ConnectionLimiter(def.getMaxConnections());

    this.channelStatistics = new ChannelStatistics(allChannels);

    this.pipelineFactory = new ChannelPipelineFactory() {
        @Override
        public ChannelPipeline getPipeline() throws Exception {
            ChannelPipeline cp = Channels.pipeline();
            TProtocolFactory inputProtocolFactory = def.getDuplexProtocolFactory().getInputProtocolFactory();
            NiftySecurityHandlers securityHandlers = def.getSecurityFactory().getSecurityHandlers(def, nettyServerConfig);
            cp.addLast("connectionContext", new ConnectionContextHandler());
            cp.addLast("connectionLimiter", connectionLimiter);
            cp.addLast(ChannelStatistics.NAME, channelStatistics);
            cp.addLast("encryptionHandler", securityHandlers.getEncryptionHandler());
            cp.addLast("frameCodec", def.getThriftFrameCodecFactory().create(def.getMaxFrameSize(), inputProtocolFactory));
            if (def.getClientIdleTimeout() != null) {
                // Add handlers to detect idle client connections and
                // disconnect them
                cp.addLast("idleTimeoutHandler", new IdleStateHandler(nettyServerConfig.getTimer(), def.getClientIdleTimeout().toMillis(),
                        NO_WRITER_IDLE_TIMEOUT, NO_ALL_IDLE_TIMEOUT, TimeUnit.MILLISECONDS));
                cp.addLast("idleDisconnectHandler", new IdleDisconnectHandler());
            }

            cp.addLast("authHandler", securityHandlers.getAuthenticationHandler());
            cp.addLast("dispatcher", new NiftyDispatcher(def, nettyServerConfig.getTimer()));
            cp.addLast("exceptionLogger", new NiftyExceptionLogger());
            return cp;
        }
    };
}

public NettyIkasoaFactory(NettyServerConfig nettyServerConfig) {
    this.nettyServerConfig = nettyServerConfig;
    this.channelGroup = new DefaultChannelGroup();
}

public NettyServerConfig getNettyServerConfig() {
    return nettyServerConfig;
}

public void setNettyServerConfig(NettyServerConfig nettyServerConfig) {
    this.nettyServerConfig = nettyServerConfig;
}

@Inject
public ThriftServer(final NiftyProcessor processor, ThriftServerConfig config, @ThriftServerTimer Timer timer,
        Map<String, ThriftFrameCodecFactory> availableFrameCodecFactories, Map<String, TDuplexProtocolFactory> availableProtocolFactories,
        @ThriftServerWorkerExecutor Map<String, ExecutorService> availableWorkerExecutors, NiftySecurityFactoryHolder securityFactoryHolder, boolean local) {
    checkNotNull(availableFrameCodecFactories, "availableFrameCodecFactories cannot be null");
    checkNotNull(availableProtocolFactories, "availableProtocolFactories cannot be null");

    NiftyProcessorFactory processorFactory = new NiftyProcessorFactory() {
        @Override
        public NiftyProcessor getProcessor(TTransport transport) {
            return processor;
        }
    };

    String transportName = config.getTransportName();
    String protocolName = config.getProtocolName();

    checkState(availableFrameCodecFactories.containsKey(transportName), "No available server transport named " + transportName);
    checkState(availableProtocolFactories.containsKey(protocolName), "No available server protocol named " + protocolName);

    workerExecutor = config.getOrBuildWorkerExecutor(availableWorkerExecutors);
    if (local) {
        log.warn("Using local server");
        configuredPort = 0;
        ioThreads = 0;
        ioExecutor = null;
        acceptorThreads = 0;
        acceptorExecutor = null;
        serverChannelFactory = new DefaultLocalServerChannelFactory();
    } else {
        configuredPort = config.getPort();

        acceptorExecutor = newCachedThreadPool(new ThreadFactoryBuilder().setNameFormat("thrift-acceptor-%s").build());
        acceptorThreads = config.getAcceptorThreadCount();
        ioExecutor = newCachedThreadPool(new ThreadFactoryBuilder().setNameFormat("thrift-io-%s").build());
        ioThreads = config.getIoThreadCount();

        serverChannelFactory = new NioServerSocketChannelFactory(new NioServerBossPool(acceptorExecutor, acceptorThreads, ThreadNameDeterminer.CURRENT),
                new NioWorkerPool(ioExecutor, ioThreads, ThreadNameDeterminer.CURRENT));
    }

    ThriftServerDef thriftServerDef = ThriftServerDef.newBuilder().name("thrift").listen(configuredPort)
            .limitFrameSizeTo((int) config.getMaxFrameSize().toBytes()).clientIdleTimeout(config.getIdleConnectionTimeout())
            .withProcessorFactory(processorFactory).limitConnectionsTo(config.getConnectionLimit())
            .limitQueuedResponsesPerConnection(config.getMaxQueuedResponsesPerConnection())
            .thriftFrameCodecFactory(availableFrameCodecFactories.get(transportName)).protocol(availableProtocolFactories.get(protocolName))
            .withSecurityFactory(securityFactoryHolder.niftySecurityFactory).using(workerExecutor).taskTimeout(config.getTaskExpirationTimeout()).build();

    NettyServerConfigBuilder nettyServerConfigBuilder = NettyServerConfig.newBuilder();

    nettyServerConfigBuilder.getServerSocketChannelConfig().setBacklog(config.getAcceptBacklog());
    nettyServerConfigBuilder.setBossThreadCount(config.getAcceptorThreadCount());
    nettyServerConfigBuilder.setWorkerThreadCount(config.getIoThreadCount());
    nettyServerConfigBuilder.setTimer(timer);

    NettyServerConfig nettyServerConfig = nettyServerConfigBuilder.build();

    transport = new NettyServerTransport(thriftServerDef, nettyServerConfig, allChannels, local);
}

private void startServer(final ThriftServerDefBuilder thriftServerDefBuilder) {
  server = new NettyServerTransport(thriftServerDefBuilder.build(), NettyServerConfig.newBuilder().build(), new DefaultChannelGroup());
  server.start();
  port = ((InetSocketAddress) server.getServerChannel().getLocalAddress()).getPort();
}