private void nonBlockMode() { AskerHandler handler = new AskerHandler(); Asker.Processor processor = new Asker.Processor(handler); try { TNonblockingServerTransport transport = new TNonblockingServerSocket(port); THsHaServer.Args arg = new THsHaServer.Args(transport); arg.protocolFactory(new TCompactProtocol.Factory()); // arg.transportFactory(new TFramedTransport.Factory()); // arg.processorFactory(new TProcessorFactory(processor)); arg.processor(processor); server = new THsHaServer(arg); start.countDown(); System.out.println("Starting the nonBlock server..."); server.serve(); } catch (Exception e) { e.printStackTrace(); } }
public ThriftTestingSource(String handlerName, int port, String protocol) throws Exception { TNonblockingServerTransport serverTransport = new TNonblockingServerSocket(new InetSocketAddress("0.0.0.0", port)); ThriftSourceProtocol.Iface handler = getHandler(handlerName); TProtocolFactory transportProtocolFactory = null; if (protocol != null && protocol == ThriftRpcClient.BINARY_PROTOCOL) { transportProtocolFactory = new TBinaryProtocol.Factory(); } else { transportProtocolFactory = new TCompactProtocol.Factory(); } server = new THsHaServer(new THsHaServer.Args(serverTransport).processor( new ThriftSourceProtocol.Processor(handler)).protocolFactory( transportProtocolFactory)); Executors.newSingleThreadExecutor().submit(new Runnable() { @Override public void run() { server.serve(); } }); }
public void run() { try { Scribe.Processor processor = new Scribe.Processor(new Receiver()); TNonblockingServerTransport transport = new TNonblockingServerSocket(port); THsHaServer.Args args = new THsHaServer.Args(transport); args.workerThreads(workers); args.processor(processor); args.transportFactory(new TFramedTransport.Factory(maxReadBufferBytes)); args.protocolFactory(new TBinaryProtocol.Factory(false, false)); args.maxReadBufferBytes = maxReadBufferBytes; server = new THsHaServer(args); LOG.info("Starting Scribe Source on port " + port); server.serve(); } catch (Exception e) { LOG.warn("Scribe failed", e); } }
/** * The function to create a thrift Half-Sync and Half-Async Server. * @param processor */ public static void hshaServer(PacketStreamer.Processor<PacketStreamerHandler> processor) { try { TNonblockingServerTransport serverTransport = new TNonblockingServerSocket(port); THsHaServer.Args args = new THsHaServer.Args(serverTransport); args.processor(processor); args.transportFactory(new TFramedTransport.Factory()); args.protocolFactory(new TBinaryProtocol.Factory(true, true)); TServer server = new THsHaServer(args); log.info("Starting the packetstreamer hsha server on port {} ...", port); server.serve(); } catch (Exception e) { e.printStackTrace(); } }
@VisibleForTesting public static TServer startHshaServer(TProcessor processor, int portNumber) throws Exception { final TNonblockingServerSocket socket = new TNonblockingServerSocket(portNumber); final THsHaServer.Args serverArgs = new THsHaServer.Args(socket); serverArgs.processor(processor); serverArgs.inputProtocolFactory(new TCompactProtocol.Factory()); serverArgs.outputProtocolFactory(new TCompactProtocol.Factory()); final TServer server = new THsHaServer(serverArgs); final Thread t = new Thread(new Runnable() { @Override public void run() { server.serve(); } }); t.start(); return server; }
private THsHaServer initHandlerServer(Map conf, final Drpc service) throws Exception { int port = JStormUtils.parseInt(conf.get(Config.DRPC_PORT)); int workerThreadNum = JStormUtils.parseInt(conf.get(Config.DRPC_WORKER_THREADS)); int queueSize = JStormUtils.parseInt(conf.get(Config.DRPC_QUEUE_SIZE)); TNonblockingServerSocket socket = new TNonblockingServerSocket(port); THsHaServer.Args targs = new THsHaServer.Args(socket); targs.workerThreads(64); targs.protocolFactory(new TBinaryProtocol.Factory()); targs.processor(new DistributedRPC.Processor<DistributedRPC.Iface>(service)); ThreadPoolExecutor executor = new ThreadPoolExecutor(workerThreadNum, workerThreadNum, 60, TimeUnit.SECONDS, new ArrayBlockingQueue(queueSize)); targs.executorService(executor); THsHaServer handlerServer = new THsHaServer(targs); LOG.info("Successfully init Handler Server " + port); return handlerServer; }
@SuppressWarnings("rawtypes") private void initThrift(Map conf) throws TTransportException { Integer thrift_port = JStormUtils.parseInt(conf.get(Config.NIMBUS_THRIFT_PORT)); TNonblockingServerSocket socket = new TNonblockingServerSocket(thrift_port); Integer maxReadBufSize = JStormUtils.parseInt(conf.get(Config.NIMBUS_THRIFT_MAX_BUFFER_SIZE)); THsHaServer.Args args = new THsHaServer.Args(socket); args.workerThreads(ServiceHandler.THREAD_NUM); args.protocolFactory(new TBinaryProtocol.Factory(false, true, maxReadBufSize, -1)); args.processor(new Nimbus.Processor<Iface>(serviceHandler)); args.maxReadBufferBytes = maxReadBufSize; thriftServer = new THsHaServer(args); LOG.info("Successfully started nimbus: started Thrift server..."); thriftServer.serve(); }
@Override public TServer getServer(TProcessor processor) throws IOException, TTransportException { int port = type.getPort(storm_conf); TNonblockingServerSocket serverTransport = new TNonblockingServerSocket(port); int numWorkerThreads = type.getNumThreads(storm_conf); int maxBufferSize = type.getMaxBufferSize(storm_conf); Integer queueSize = type.getQueueSize(storm_conf); THsHaServer.Args server_args = new THsHaServer.Args(serverTransport).processor(new SimpleWrapProcessor(processor)).workerThreads(numWorkerThreads) .protocolFactory(new TBinaryProtocol.Factory(false, true, maxBufferSize, -1)); if (queueSize != null) { server_args.executorService(new ThreadPoolExecutor(numWorkerThreads, numWorkerThreads, 60, TimeUnit.SECONDS, new ArrayBlockingQueue(queueSize))); } // construct THsHaServer return new THsHaServer(server_args); }
private static TServer getTHsHaServer(TProtocolFactory protocolFactory, TProcessor processor, TTransportFactory transportFactory, int workerThreads, int maxCallQueueSize, InetSocketAddress inetSocketAddress, ThriftMetrics metrics) throws TTransportException { TNonblockingServerTransport serverTransport = new TNonblockingServerSocket(inetSocketAddress); log.info("starting HBase HsHA Thrift server on " + inetSocketAddress.toString()); THsHaServer.Args serverArgs = new THsHaServer.Args(serverTransport); if (workerThreads > 0) { // Could support the min & max threads, avoiding to preserve existing functionality. serverArgs.minWorkerThreads(workerThreads).maxWorkerThreads(workerThreads); } ExecutorService executorService = createExecutor( workerThreads, maxCallQueueSize, metrics); serverArgs.executorService(executorService); serverArgs.processor(processor); serverArgs.transportFactory(transportFactory); serverArgs.protocolFactory(protocolFactory); return new THsHaServer(serverArgs); }
public static void main(String[] args) throws TTransportException, IOException, InterruptedException { FloorBroker floor = new FloorBroker(); (new Thread(floor)).start(); TProcessor proc = new TradeReporting.TradeHistory.AsyncProcessor( new AsyncTradeHistoryHandler(floor.getQ())); TNonblockingServerSocket trans_svr = new TNonblockingServerSocket(9090); TServer server = new THsHaServer(new THsHaServer.Args(trans_svr) .processor(proc) .protocolFactory(new TBinaryProtocol.Factory()) .minWorkerThreads(4) .maxWorkerThreads(4)); System.out.println("[Server] listening of port 9090"); server.serve(); }
public static AsyncEchoTestServer<THsHaServer> halfSyncHalfAsyncServer(final TestEnvironment environment) throws TTransportException { THsHaServer server = new THsHaServer(new THsHaServer.Args(new TNonblockingServerSocket( environment.getPort())).processor(getAsyncProcessor()) .inputProtocolFactory(environment.getProtocolFactory()) .outputProtocolFactory(environment.getProtocolFactory())); return new AsyncEchoTestServer<THsHaServer>(server, environment) { @Override public SyncEchoTestClient getSynchronousClient() throws TTransportException { return new SyncEchoTestClient.ClientForNonblockingServer(environment); } @Override public AsyncEchoTestClient getAsynchronousClient() throws IOException { return new AsyncEchoTestClient.Client(environment); } }; }
public static SyncEchoTestServer<THsHaServer> halfSyncHalfAsyncServer(final TestEnvironment environment) throws TTransportException { THsHaServer server = new THsHaServer(new THsHaServer.Args(new TNonblockingServerSocket( environment.getPort())).processor(getProcessor()) .inputProtocolFactory(environment.getProtocolFactory()) .outputProtocolFactory(environment.getProtocolFactory())); return new SyncEchoTestServer<THsHaServer>(server, environment) { @Override public SyncEchoTestClient getSynchronousClient() throws TTransportException { return new SyncEchoTestClient.ClientForNonblockingServer(environment); } @Override public AsyncEchoTestClient getAsynchronousClient() throws IOException { return new AsyncEchoTestClient.Client(environment); } }; }
public void start() throws Exception { transport = new TNonblockingServerSocket(port); processor = new SuroServer.Processor(this); THsHaServer.Args serverArgs = new THsHaServer.Args(transport); serverArgs.processor(processor); serverArgs.workerThreads(2); server = new THsHaServer(serverArgs); System.out.println("Server started on port:" + port); Thread t = new Thread() { @Override public void run() { server.serve(); } }; t.start(); Field serverSocketField = TNonblockingServerSocket.class.getDeclaredField("serverSocket_"); serverSocketField.setAccessible(true); ServerSocket serverSocket = (ServerSocket) serverSocketField.get(transport); port = serverSocket.getLocalPort(); }
/** * Test that bogus input into the oracle server doesn't cause an OOM exception. This essentially * tests for THRIFT-602 */ @Test public void bogusDataTest() throws Exception { // we are expecting an error at this point Level curLevel = Logger.getLogger(THsHaServer.class).getLevel(); Logger.getLogger(THsHaServer.class).setLevel(Level.FATAL); Socket socket = new Socket(); socket.connect(new InetSocketAddress(HostUtil.getHostName(), oserver.getPort())); OutputStream outstream = socket.getOutputStream(); try (PrintWriter out = new PrintWriter(outstream)) { out.print("abcd"); out.flush(); } socket.close(); OracleClient client = env.getSharedResources().getOracleClient(); assertEquals(2, client.getStamp().getTxTimestamp()); Logger.getLogger(THsHaServer.class).setLevel(curLevel); }
/** * 启动thrift的server端的服务 */ public void startTHsHaServer() { try { TNonblockingServerSocket tnbSocketTransport = new TNonblockingServerSocket( SERVER_PORT); THsHaServer.Args thhsArgs = new THsHaServer.Args(tnbSocketTransport); // 设置处理逻辑 thhsArgs.processor(tprocessor); // 传输方式 thhsArgs.transportFactory(new TFramedTransport.Factory()); // 数据协议 thhsArgs.protocolFactory(new TCompactProtocol.Factory()); // 半同步半异步的服务模型 server = new THsHaServer(thhsArgs); server.serve(); } catch (Exception e) { System.out.println("Server start error!!!"); e.printStackTrace(); } }
private THsHaServer initHandlerServer(Map conf, final Drpc service) throws Exception { int port = JStormUtils.parseInt(conf.get(Config.DRPC_PORT)); int workerThreadNum = JStormUtils.parseInt(conf.get(Config.DRPC_WORKER_THREADS)); int queueSize = JStormUtils.parseInt(conf.get(Config.DRPC_QUEUE_SIZE)); LOG.info("Begin to init DRPC handler server at port: " + port); TNonblockingServerSocket socket = new TNonblockingServerSocket(port); THsHaServer.Args targs = new THsHaServer.Args(socket); targs.workerThreads(64); targs.protocolFactory(new TBinaryProtocol.Factory()); targs.processor(new DistributedRPC.Processor<DistributedRPC.Iface>(service)); ThreadPoolExecutor executor = new ThreadPoolExecutor( workerThreadNum, workerThreadNum, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(queueSize)); targs.executorService(executor); THsHaServer handlerServer = new THsHaServer(targs); LOG.info("Successfully inited DRPC handler server at port: " + port); return handlerServer; }
private THsHaServer initInvokeServer(Map conf, final Drpc service) throws Exception { int port = JStormUtils.parseInt(conf.get(Config.DRPC_INVOCATIONS_PORT)); LOG.info("Begin to init DRPC invoke server at port: " + port); TNonblockingServerSocket socket = new TNonblockingServerSocket(port); THsHaServer.Args targsInvoke = new THsHaServer.Args(socket); targsInvoke.workerThreads(64); targsInvoke.protocolFactory(new TBinaryProtocol.Factory()); targsInvoke.processor(new DistributedRPCInvocations.Processor<DistributedRPCInvocations.Iface>(service)); THsHaServer invokeServer = new THsHaServer(targsInvoke); LOG.info("Successfully inited DRPC invoke server at port: " + port); return invokeServer; }