Example usage for org.apache.thrift.server TThreadedSelectorServer TThreadedSelectorServer

Introduction

In this page you can find the example usage for org.apache.thrift.server TThreadedSelectorServer TThreadedSelectorServer.

Prototype

public TThreadedSelectorServer(Args args) 

Source Link

Document

Create the server with the specified Args configuration

Usage

From source file:StubServer.java

License:Apache License

public static void main(String argv[]) {
    try {//from  www . j a va2 s .co  m
        int port = 9090;
        int numThreads = 32;
        if (argv.length != 1) {
            usage();
        }
        System.out.println(argv[0]);
        StubServer mapkeeper = new StubServer();
        TServer server = null;
        if (argv[0].equals("hsha")) {
            TNonblockingServerTransport trans = new TNonblockingServerSocket(port);
            THsHaServer.Args args = new THsHaServer.Args(trans);
            args.transportFactory(new TFramedTransport.Factory());
            args.protocolFactory(new TBinaryProtocol.Factory());
            args.processor(new MapKeeper.Processor(mapkeeper));
            args.workerThreads(numThreads);
            server = new THsHaServer(args);
        } else if (argv[0].equals("nonblocking")) {
            TNonblockingServerTransport trans = new TNonblockingServerSocket(port);
            TNonblockingServer.Args args = new TNonblockingServer.Args(trans);
            args.transportFactory(new TFramedTransport.Factory());
            args.protocolFactory(new TBinaryProtocol.Factory());
            args.processor(new MapKeeper.Processor(mapkeeper));
            server = new TNonblockingServer(args);
        } else if (argv[0].equals("threadpool")) {
            TServerTransport trans = new TServerSocket(port);
            TThreadPoolServer.Args args = new TThreadPoolServer.Args(trans);
            args.transportFactory(new TFramedTransport.Factory());
            args.protocolFactory(new TBinaryProtocol.Factory());
            args.processor(new MapKeeper.Processor(mapkeeper));
            server = new TThreadPoolServer(args);
        } else if (argv[0].equals("selector")) {
            TNonblockingServerTransport trans = new TNonblockingServerSocket(port);
            TThreadedSelectorServer.Args args = new TThreadedSelectorServer.Args(trans);
            args.transportFactory(new TFramedTransport.Factory());
            args.protocolFactory(new TBinaryProtocol.Factory());
            args.processor(new MapKeeper.Processor(mapkeeper));
            args.selectorThreads(4);
            args.workerThreads(numThreads);
            server = new TThreadedSelectorServer(args);
        } else {
            usage();
        }
        server.serve();
    } catch (Exception x) {
        System.out.println(x.toString() + " " + x.getMessage());
    }
}

---

From source file:ch.epfl.eagle.daemon.util.TServers.java

License:Apache License

/**
 * Launch a multi-threaded Thrift server with the given {@code processor}. Note that
 * internally this creates an expanding thread pool of at most {@code threads} threads,
 * and requests are queued whenever that thread pool is saturated.
 *//*  w  w w.j  av  a2s.  c  om*/
public static void launchThreadedThriftServer(int port, int threads, TProcessor processor) throws IOException {
    LOG.info("Staring async thrift server of type: " + processor.getClass().toString() + " on port " + port);
    TNonblockingServerTransport serverTransport;
    try {
        serverTransport = new TNonblockingServerSocket(port);
    } catch (TTransportException e) {
        throw new IOException(e);
    }
    TThreadedSelectorServer.Args serverArgs = new TThreadedSelectorServer.Args(serverTransport);
    serverArgs.transportFactory(new TFramedTransport.Factory());
    serverArgs.protocolFactory(new TBinaryProtocol.Factory());
    serverArgs.processor(processor);
    serverArgs.selectorThreads(SELECTOR_THREADS);
    serverArgs.workerThreads(threads);
    TServer server = new TThreadedSelectorServer(serverArgs);
    new Thread(new TServerRunnable(server)).start();
}

---

From source file:com.facebook.buck.distributed.build_slave.ThriftCoordinatorServer.java

License:Apache License

public ThriftCoordinatorServer start() throws IOException {
    LOG.info("Starting ThriftCoordinatorServer.");
    synchronized (lock) {
        TNonblockingServerSocket transport;
        try {/*  w  w  w .  j  av a  2s .  c om*/
            transport = new TNonblockingServerSocket(this.port.orElse(0));
            // If we initially specified port zero, we would now have the correct value.
            this.port = OptionalInt.of(transport.getPort());
        } catch (TTransportException e) {
            throw new ThriftException(e);
        }

        TThreadedSelectorServer.Args serverArgs = new TThreadedSelectorServer.Args(transport);
        serverArgs.processor(processor);
        server = new TThreadedSelectorServer(serverArgs);
        serverThread = new Thread(() -> Preconditions.checkNotNull(server).serve());
        serverThread.start();
    }

    // Note: this call will initialize MinionCountProvider (same Object as eventListener)
    eventListener.onThriftServerStarted(InetAddress.getLocalHost().getHostName(), port.getAsInt());
    return this;
}

---

From source file:com.facebook.buck.distributed.ThriftCoordinatorServer.java

License:Apache License

public ThriftCoordinatorServer start() throws IOException {
    synchronized (lock) {
        try {/*from   w w w  .java  2 s . co m*/
            transport = new TNonblockingServerSocket(this.port);
        } catch (TTransportException e) {
            throw new ThriftException(e);
        }

        TThreadedSelectorServer.Args serverArgs = new TThreadedSelectorServer.Args(transport);
        serverArgs.processor(processor);
        server = new TThreadedSelectorServer(serverArgs);
        serverThread = new Thread(() -> Preconditions.checkNotNull(server).serve());
        serverThread.start();
    }

    return this;
}

---

From source file:com.liveramp.hank.partition_server.PartitionServer.java

License:Apache License

protected void startThriftServer() throws TTransportException, IOException, InterruptedException {
    IfaceWithShutdown handler = null;/*from  w  w  w  .j  av  a 2s  . c  om*/
    try {
        // Set up the service handler
        handler = getHandler();
        // Launch the thrift server
        TNonblockingServerSocket serverSocket = new TNonblockingServerSocket(configurator.getServicePort());
        TThreadedSelectorServer.Args options = new TThreadedSelectorServer.Args(serverSocket);
        options.processor(new com.liveramp.hank.generated.PartitionServer.Processor(handler));
        options.workerThreads(configurator.getNumConcurrentQueries());
        options.selectorThreads(4);
        options.protocolFactory(new TCompactProtocol.Factory());
        options.maxReadBufferBytes = MAX_BUFFER_SIZE;
        dataServer = new TThreadedSelectorServer(options);
        LOG.info("Launching Thrift server.");
        dataServer.serve();
        LOG.info("Thrift server exited.");
        // The Thrift server does not clean up selectors after stopping, which leads to a file descriptor leak.
        // See https://issues.apache.org/jira/browse/THRIFT-2274
        // TODO: when the bug is fixed in Thrift, remove this ugly hack which takes care of the issue
        List<Selector> selectors = getServerSelectors(dataServer);
        closeServerSelectors(selectors);
        // Close the socket
        serverSocket.close();
    } finally {
        // Always shut down the handler
        if (handler != null) {
            LOG.debug("Shutting down Partition Server handler.");
            handler.shutDown();
        }
    }
}

---

From source file:com.zhentao.thrift.example.CalculatorServer.java

License:Apache License

private static void startServer(Calculator.Processor<CalculatorHandler> processor) throws TTransportException {
    // TServerTransport serverTransport = new TServerSocket(9090);
    // TServer server = new TSimpleServer(new Args(serverTransport).processor(processor));

    // Use this for a multithreaded server
    // TServer server = new TThreadPoolServer(new TThreadPoolServer.Args(serverTransport).processor(processor));

    TNonblockingServerTransport serverTransport = new TNonblockingServerSocket(9090);
    //TServer server = new THsHaServer(new THsHaServer.Args(serverTransport).workerThreads(20).processor(processor));
    TServer server = new TThreadedSelectorServer(new TThreadedSelectorServer.Args(serverTransport)
            .workerThreads(20).selectorThreads(4).acceptQueueSizePerThread(8).processor(processor));
    System.out.println("Starting the simple server...");
    server.serve();// w  w  w . j a  va2  s . co  m
    System.out.println("started");
}

---

From source file:de.hzi.helmholtz.ThriftService.ThriftServer.java

public void init(String portNo) throws InterruptedException, TTransportException {
    try {//from   w  ww  .java2s . c o  m
        if (portNo.equals("")) {
            System.out.println("Port number is empty");
            return;
        }
        System.out.println("Starting server on port " + portNo + " ...");

        //TSSLTransportFactory.TSSLTransportParameters params = new TSSLTransportFactory.TSSLTransportParameters();
        //params.setKeyStore(Properties.THIFT_SSC_PATH, Properties.THRIFT_SSC_PW);

        ThriftServiceHandler handler = new ThriftServiceHandler();
        BiosynThriftService.Processor<ThriftServiceHandler> processor = new BiosynThriftService.Processor<ThriftServiceHandler>(
                handler);
        //TServerSocket serverTransport = TSSLTransportFactory.getServerSocket( Integer.valueOf(portNo),1000000000, InetAddress.getByName(Properties.MXBASE_SERVER), params);
        //TServerTransport serverTransport = new TServerSocket(Integer.valueOf(portNo));
        TNonblockingServerTransport trans = new TNonblockingServerSocket(Integer.valueOf(portNo));
        //TNonblockingServerTransport serverTransport = new TNonblockingServerSocket(Integer.valueOf(portNo));
        TThreadedSelectorServer.Args args = new TThreadedSelectorServer.Args(trans);

        args.transportFactory(new TFramedTransport.Factory());
        args.protocolFactory(new TCompactProtocol.Factory());// TBinaryProtocol.Factory());
        args.processor(processor);
        args.selectorThreads(4);
        args.workerThreads(32);
        server = new TThreadedSelectorServer(args);
        //server = new TNonblockingServer(new TNonblockingServer.Args(serverTransport).processor(processor));
        //server = new TThreadPoolServer(new TThreadPoolServer.Args(serverTransport).processor(processor));
        server.serve();
        //new Thread(this).start();

        //while (!server.isServing()) {
        //    Thread.sleep(1);
        //};
    } catch (Exception ex) {
        System.out.println(ex.toString());
        Logger.getLogger(ThriftServer.class.getName()).log(Level.SEVERE, null, ex);
    }
}

---

From source file:galen.api.server.GalenApiServer.java

License:Apache License

public static void runService(GalenApiRemoteService.Processor processor, int serverPort) {
    try {/*from  ww  w.  j a va2 s. c  o m*/
        TNonblockingServerTransport serverTransport = new TNonblockingServerSocket(serverPort);
        TThreadedSelectorServer.Args args = new TThreadedSelectorServer.Args(serverTransport);
        TServer server = new TThreadedSelectorServer(args.processor(processor));
        server.serve();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

---

From source file:org.apache.dubbo.rpc.protocol.nativethrift.ThriftProtocol.java

License:Apache License

private <T> Runnable exportThreadedSelectorServer(T impl, Class<T> type, URL url) throws RpcException {

    TThreadedSelectorServer.Args tArgs = null;
    String typeName = type.getName();

    TServer tserver = null;//  w  w w. j  ava2  s  . c  o m
    if (typeName.endsWith(THRIFT_IFACE)) {
        String processorClsName = typeName.substring(0, typeName.indexOf(THRIFT_IFACE)) + THRIFT_PROCESSOR;
        try {
            Class<?> clazz = Class.forName(processorClsName);
            Constructor constructor = clazz.getConstructor(type);
            try {
                TProcessor tprocessor = (TProcessor) constructor.newInstance(impl);
                processor.registerProcessor(typeName, tprocessor);

                tserver = serverMap.get(url.getAddress());
                if (tserver == null) {

                    /**Solve the problem of only 50 of the default number of concurrent connections*/
                    TNonblockingServerSocket.NonblockingAbstractServerSocketArgs args = new TNonblockingServerSocket.NonblockingAbstractServerSocketArgs();
                    /**1000 connections*/
                    args.backlog(1000);
                    args.bindAddr(new InetSocketAddress(url.getHost(), url.getPort()));
                    /**timeout: 10s */
                    args.clientTimeout(10000);

                    TNonblockingServerSocket transport = new TNonblockingServerSocket(args);

                    tArgs = new TThreadedSelectorServer.Args(transport);
                    tArgs.workerThreads(200);
                    tArgs.selectorThreads(4);
                    tArgs.acceptQueueSizePerThread(256);
                    tArgs.processor(processor);
                    tArgs.transportFactory(new TFramedTransport.Factory());
                    tArgs.protocolFactory(new TCompactProtocol.Factory());
                } else {
                    return null; // if server is starting, return and do nothing here
                }
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
                throw new RpcException("Fail to create nativethrift server(" + url + ") : " + e.getMessage(),
                        e);
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            throw new RpcException("Fail to create nativethrift server(" + url + ") : " + e.getMessage(), e);
        }
    }

    if (tserver == null && tArgs == null) {
        logger.error("Fail to create nativethrift server(" + url + ") due to null args");
        throw new RpcException("Fail to create nativethrift server(" + url + ") due to null args");
    }
    final TServer thriftServer = new TThreadedSelectorServer(tArgs);
    serverMap.put(url.getAddress(), thriftServer);

    new Thread(() -> {
        logger.info("Start Thrift ThreadedSelectorServer");
        thriftServer.serve();
        logger.info("Thrift ThreadedSelectorServer started.");
    }).start();

    return () -> {
        try {
            logger.info("Close Thrift NonblockingServer");
            thriftServer.stop();
        } catch (Throwable e) {
            logger.warn(e.getMessage(), e);
        }
    };
}

---

From source file:org.apache.hadoop.hbase.thrift.ThriftServerRunner.java

License:Apache License

/**
 * Setting up the thrift TServer/*from  w ww.  j ava 2s.  co m*/
 */
private void setupServer() throws Exception {
    // Construct correct ProtocolFactory
    TProtocolFactory protocolFactory;
    if (conf.getBoolean(COMPACT_CONF_KEY, false)) {
        LOG.debug("Using compact protocol");
        protocolFactory = new TCompactProtocol.Factory();
    } else {
        LOG.debug("Using binary protocol");
        protocolFactory = new TBinaryProtocol.Factory();
    }

    final TProcessor p = new Hbase.Processor<Hbase.Iface>(handler);
    ImplType implType = ImplType.getServerImpl(conf);
    TProcessor processor = p;

    // Construct correct TransportFactory
    TTransportFactory transportFactory;
    if (conf.getBoolean(FRAMED_CONF_KEY, false) || implType.isAlwaysFramed) {
        if (qop != null) {
            throw new RuntimeException(
                    "Thrift server authentication" + " doesn't work with framed transport yet");
        }
        transportFactory = new TFramedTransport.Factory(conf.getInt(MAX_FRAME_SIZE_CONF_KEY, 2) * 1024 * 1024);
        LOG.debug("Using framed transport");
    } else if (qop == null) {
        transportFactory = new TTransportFactory();
    } else {
        // Extract the name from the principal
        String name = SecurityUtil.getUserFromPrincipal(conf.get("hbase.thrift.kerberos.principal"));
        Map<String, String> saslProperties = new HashMap<String, String>();
        saslProperties.put(Sasl.QOP, qop);
        TSaslServerTransport.Factory saslFactory = new TSaslServerTransport.Factory();
        saslFactory.addServerDefinition("GSSAPI", name, host, saslProperties, new SaslGssCallbackHandler() {
            @Override
            public void handle(Callback[] callbacks) throws UnsupportedCallbackException {
                AuthorizeCallback ac = null;
                for (Callback callback : callbacks) {
                    if (callback instanceof AuthorizeCallback) {
                        ac = (AuthorizeCallback) callback;
                    } else {
                        throw new UnsupportedCallbackException(callback, "Unrecognized SASL GSSAPI Callback");
                    }
                }
                if (ac != null) {
                    String authid = ac.getAuthenticationID();
                    String authzid = ac.getAuthorizationID();
                    if (!authid.equals(authzid)) {
                        ac.setAuthorized(false);
                    } else {
                        ac.setAuthorized(true);
                        String userName = SecurityUtil.getUserFromPrincipal(authzid);
                        LOG.info("Effective user: " + userName);
                        ac.setAuthorizedID(userName);
                    }
                }
            }
        });
        transportFactory = saslFactory;

        // Create a processor wrapper, to get the caller
        processor = new TProcessor() {
            @Override
            public boolean process(TProtocol inProt, TProtocol outProt) throws TException {
                TSaslServerTransport saslServerTransport = (TSaslServerTransport) inProt.getTransport();
                SaslServer saslServer = saslServerTransport.getSaslServer();
                String principal = saslServer.getAuthorizationID();
                hbaseHandler.setEffectiveUser(principal);
                return p.process(inProt, outProt);
            }
        };
    }

    if (conf.get(BIND_CONF_KEY) != null && !implType.canSpecifyBindIP) {
        LOG.error("Server types " + Joiner.on(", ").join(ImplType.serversThatCannotSpecifyBindIP())
                + " don't support IP " + "address binding at the moment. See "
                + "https://issues.apache.org/jira/browse/HBASE-2155 for details.");
        throw new RuntimeException("-" + BIND_CONF_KEY + " not supported with " + implType);
    }

    if (implType == ImplType.HS_HA || implType == ImplType.NONBLOCKING
            || implType == ImplType.THREADED_SELECTOR) {

        InetAddress listenAddress = getBindAddress(conf);
        TNonblockingServerTransport serverTransport = new TNonblockingServerSocket(
                new InetSocketAddress(listenAddress, listenPort));

        if (implType == ImplType.NONBLOCKING) {
            TNonblockingServer.Args serverArgs = new TNonblockingServer.Args(serverTransport);
            serverArgs.processor(processor).transportFactory(transportFactory).protocolFactory(protocolFactory);
            tserver = new TNonblockingServer(serverArgs);
        } else if (implType == ImplType.HS_HA) {
            THsHaServer.Args serverArgs = new THsHaServer.Args(serverTransport);
            CallQueue callQueue = new CallQueue(new LinkedBlockingQueue<Call>(), metrics);
            ExecutorService executorService = createExecutor(callQueue, serverArgs.getWorkerThreads());
            serverArgs.executorService(executorService).processor(processor).transportFactory(transportFactory)
                    .protocolFactory(protocolFactory);
            tserver = new THsHaServer(serverArgs);
        } else { // THREADED_SELECTOR
            TThreadedSelectorServer.Args serverArgs = new HThreadedSelectorServerArgs(serverTransport, conf);
            CallQueue callQueue = new CallQueue(new LinkedBlockingQueue<Call>(), metrics);
            ExecutorService executorService = createExecutor(callQueue, serverArgs.getWorkerThreads());
            serverArgs.executorService(executorService).processor(processor).transportFactory(transportFactory)
                    .protocolFactory(protocolFactory);
            tserver = new TThreadedSelectorServer(serverArgs);
        }
        LOG.info("starting HBase " + implType.simpleClassName() + " server on " + Integer.toString(listenPort));
    } else if (implType == ImplType.THREAD_POOL) {
        // Thread pool server. Get the IP address to bind to.
        InetAddress listenAddress = getBindAddress(conf);

        TServerTransport serverTransport = new TServerSocket(new InetSocketAddress(listenAddress, listenPort));

        TBoundedThreadPoolServer.Args serverArgs = new TBoundedThreadPoolServer.Args(serverTransport, conf);
        serverArgs.processor(processor).transportFactory(transportFactory).protocolFactory(protocolFactory);
        LOG.info("starting " + ImplType.THREAD_POOL.simpleClassName() + " on " + listenAddress + ":"
                + Integer.toString(listenPort) + "; " + serverArgs);
        TBoundedThreadPoolServer tserver = new TBoundedThreadPoolServer(serverArgs, metrics);
        this.tserver = tserver;
    } else {
        throw new AssertionError("Unsupported Thrift server implementation: " + implType.simpleClassName());
    }

    // A sanity check that we instantiated the right type of server.
    if (tserver.getClass() != implType.serverClass) {
        throw new AssertionError("Expected to create Thrift server class " + implType.serverClass.getName()
                + " but got " + tserver.getClass().getName());
    }

    registerFilters(conf);
}

---

• «
• 1
• 2
• »