Refine search
/** * Creates the server. * * @param serverTransport the server transport * @param processor the processor * @return the t server */ public TServer createServer(TServerTransport serverTransport, TMultiplexedProcessor processor) { TThreadPoolServer.Args args = new Args(serverTransport).processor(processor); args.stopTimeoutVal = 3; args.stopTimeoutUnit = TimeUnit.SECONDS; SynchronousQueue<Runnable> executorQueue = // NOSONAR new SynchronousQueue<Runnable>(); executorService = new ThreadPoolExecutor(args.minWorkerThreads, args.maxWorkerThreads, 60, TimeUnit.SECONDS, executorQueue); args.executorService = executorService; return new TThreadPoolServer(args); }
server.serve();
@Override public void afterPropertiesSet() throws Exception { if (null == tServerTransport) { throw new IllegalClassFormatException("tServerTransport is null"); } if (null == tProtocolFactory) { throw new IllegalClassFormatException("tProtocolFactory is null"); } if (null == processorMap || processorMap.isEmpty()) { throw new IllegalClassFormatException("processorMap is null"); } for (String processorName : processorMap.keySet()) { processor.registerProcessor(processorName, processorMap.get(processorName)); logger.debug("Register a Processor {}", processorName); } TThreadPoolServer.Args args = new TThreadPoolServer.Args(tServerTransport); args.processor(processor); args.protocolFactory(tProtocolFactory); server = new TThreadPoolServer(args); logger.debug("Thrift Server 正在启动............"); server.serve(); logger.error("Thrift Server 停止............"); }
@Override public void destroy() throws Exception { server.stop(); server = null; logger.warn("Thrift Server stop"); } }
/** * To stop the server */ public void stop() { stormManagerServer.stop(); executorService.shutdown(); if (stateChecker != null){ stateChecker.cancel(false); } }
public void simple(JstormAM.Processor processor) { try { TServerTransport serverTransport = new TServerSocket(port); TServer server = new TThreadPoolServer(new TThreadPoolServer.Args(serverTransport).processor(processor)); LOG.info("Starting the simple server..."); server.serve(); } catch (Exception e) { e.printStackTrace(); } }
/** * Runs the block worker. The thread calling this will be blocked until the thrift server shuts * down. */ public void process() { mWorkerMetricsSystem.start(); // Add the metrics servlet to the web server, this must be done after the metrics system starts mWebServer.addHandler(mWorkerMetricsSystem.getServletHandler()); mSyncExecutorService.submit(mBlockMasterSync); // Start the pinlist syncer to perform the periodical fetching mSyncExecutorService.submit(mPinListSync); // Start the session cleanup checker to perform the periodical checking mSyncExecutorService.submit(mSessionCleanerThread); // Start the lineage worker if (LineageUtils.isLineageEnabled(WorkerContext.getConf())) { mLineageWorker.start(); } // Start the space reserver if (mSpaceReserver != null) { mSyncExecutorService.submit(mSpaceReserver); } mWebServer.startWebServer(); mThriftServer.serve(); }
logger.info("Launching ThriftServer at " + this.host + ":" + this.port); server = new TThreadPoolServer( new TThreadPoolServer.Args(serverTransport).processor(processor)); remoteWorksResponsePool = Collections.synchronizedMap(new HashMap<String, Object>());
@SuppressWarnings("deprecation") @Override public void start() { try { InetSocketAddress bindAddr = new InetSocketAddress(host, port); serverTransport = new TServerSocket(bindAddr); ThriftFlumeEventServer.Processor processor = new ThriftFlumeEventServer.Processor(new ThriftFlumeEventServerImpl()); server = new TThreadPoolServer( new TThreadPoolServer.Args(serverTransport).processor(processor)); } catch (TTransportException e) { throw new FlumeException("Failed starting source", e); } ThriftHandler thriftHandler = new ThriftHandler(server); thriftHandlerThread = new Thread(thriftHandler); thriftHandlerThread.start(); super.start(); }
private TServer getTThreadPoolServer() { TServerTransport serverTransport; if (isSslEnabled()) { serverTransport = getSSLServerTransport(); } else { serverTransport = getTServerTransport(); } TThreadPoolServer.Args serverArgs = new TThreadPoolServer.Args(serverTransport); serverArgs.maxWorkerThreads(maxThreads); populateServerParams(serverArgs); return new TThreadPoolServer(serverArgs); }
@Override public TServer getServer(TProcessor processor) throws IOException, TTransportException { int port = type.getPort(storm_conf); TTransportFactory serverTransportFactory = getServerTransportFactory(); TServerSocket serverTransport = new TServerSocket(port); int numWorkerThreads = type.getNumThreads(storm_conf); Integer queueSize = type.getQueueSize(storm_conf); TThreadPoolServer.Args server_args = new TThreadPoolServer.Args(serverTransport).processor(new TUGIWrapProcessor(processor)).minWorkerThreads(numWorkerThreads) .maxWorkerThreads(numWorkerThreads).protocolFactory(new TBinaryProtocol.Factory(false, true)); if (serverTransportFactory != null) { server_args.transportFactory(serverTransportFactory); } BlockingQueue workQueue = new SynchronousQueue(); if (queueSize != null) { workQueue = new ArrayBlockingQueue(queueSize); } ThreadPoolExecutor executorService = new ExtendedThreadPoolExecutor(numWorkerThreads, numWorkerThreads, 60, TimeUnit.SECONDS, workQueue); server_args.executorService(executorService); return new TThreadPoolServer(server_args); }
int beBackoffSlotLength = (int) hiveConf .getTimeVar(HiveConf.ConfVars.HIVE_SERVER2_THRIFT_LOGIN_BEBACKOFF_SLOT_LENGTH, TimeUnit.MILLISECONDS); TThreadPoolServer.Args sargs = new TThreadPoolServer.Args(serverSocket).processorFactory(processorFactory) .transportFactory(transportFactory).protocolFactory(new TBinaryProtocol.Factory()) .inputProtocolFactory(new TBinaryProtocol.Factory(true, true, maxMessageSize, maxMessageSize)) .requestTimeout(requestTimeout).requestTimeoutUnit(TimeUnit.SECONDS).beBackoffSlotLength(beBackoffSlotLength) server = new TThreadPoolServer(sargs); server.setServerEventHandler(new TServerEventHandler() { @Override
TThreadPoolServer.Args args = new TThreadPoolServer.Args(serverSocket) .processor(processor) .transportFactory(transFactory) .protocolFactory(protocolFactory) .inputProtocolFactory(inputProtoFactory) .maxWorkerThreads(maxWorkerThreads); TServer tServer = new TThreadPoolServer(args); TServerEventHandler tServerEventHandler = new TServerEventHandler() { @Override
public void run() { try { TServerSocket serverTransport = new TServerSocket(port); Factory protFactory = new TBinaryProtocol.Factory(true, true); TServer server = new TThreadPoolServer(processor, serverTransport, protFactory); System.out.println("Starting " + name + " server on port " + port + " ..."); server.serve(); } catch( TTransportException tte ){ tte.printStackTrace(); } } };
TThreadPoolServer.Args options = new TThreadPoolServer.Args(transport); options.processor(new Processor<Iface>(new Receiver())); server = new TThreadPoolServer(options); registerInZooKeeper(sock.getInetAddress().getHostAddress() + ":" + sock.getLocalPort(), conf.get(Property.TRACE_ZK_PATH));
public void run() { try { TServerSocket serverTransport = new TServerSocket(SearcherServer.this.port); Searcher.Processor processor = new Searcher.Processor(new SearcherImpl(SearcherServer.this.searcher)); Factory protFactory = new TBinaryProtocol.Factory(true, true); TServer server = new TThreadPoolServer(processor, serverTransport, protFactory); System.out.println("Starting searcher server on port " + SearcherServer.this.port + " ..."); server.serve(); } catch( TTransportException tte ){ tte.printStackTrace(); } } };
public void run() { try { TServerSocket serverTransport = new TServerSocket(SuggestorServer.this.port); Suggestor.Processor processor = new Suggestor.Processor(new SuggestorImpl(SuggestorServer.this.suggestor)); Factory protFactory = new TBinaryProtocol.Factory(true, true); TServer server = new TThreadPoolServer(processor, serverTransport, protFactory); System.out.println("Starting suggestor server on port " + SuggestorServer.this.port + " ..."); server.serve(); } catch( TTransportException tte ){ tte.printStackTrace(); } } };
public void run() { try { TServerSocket serverTransport = new TServerSocket(IndexerServer.this.port); Indexer.Processor processor = new Indexer.Processor(new IndexerImpl(ie, IndexerServer.this.indexer)); Factory protFactory = new TBinaryProtocol.Factory(true, true); TServer server = new TThreadPoolServer(processor, serverTransport, protFactory); System.out.println("Starting indexer server on port " + IndexerServer.this.port + " ..."); server.serve(); } catch( TTransportException tte ){ tte.printStackTrace(); } } } ;