def _initialize_thrift_service(self): """ Initialize the thrift server. """ mux_processor = TMultiplexedProcessor.TMultiplexedProcessor() for plugin in thrift_services(): self._logger.info("Load thrift services %s (num_threads: %d)", plugin.name, plugin.num_threads) handler = plugin.handler processor = plugin.service.Processor(handler) mux_processor.registerProcessor(plugin.name, processor) self._logger.info( "Initialize SSLSocket using certfile=%s, keyfile=%s, capath=%s" % (SSL_CERT_FILE, SSL_KEY_FILE, CA_PATH)) transport = TSSLSocket.TSSLServerSocket(port=self._config.host_port, certfile=SSL_CERT_FILE, keyfile=SSL_KEY_FILE, capath=CA_PATH, ciphers=SSL_CIPHERS) protocol_factory = TCompactProtocol.TCompactProtocolFactory() server = TNonblockingServer.TNonblockingServer( mux_processor, transport, protocol_factory, protocol_factory, self._config.host_service_threads) self._server = server
def main(self): self.set_proctitle(self.name) self.set_exit_handler() try: handler = StateServiceHandler(self) processor = StateService.Processor(handler) if self.certfile: transport = TSSLSocket.TSSLServerSocket(self.host, self.port, certfile=self.certfile) else: transport = TSocket.TServerSocket(self.host, self.port) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() # In order to accept multiple simultaneous clients, we use TThreadedServer server = TServer.TThreadedServer(processor, transport, tfactory, pfactory) server.serve() except Exception as exp: logger.error("Error while trying to launch TSCA module %s", exp)
def startServer(config): def catch_shutdown(signal, frame): click.echo(f"Caught SIGTERM. Shutting down. Signal: {signal} Frame: {frame}") handler.keyboard_interrupt_handler_playbooks() click.echo("SIGTERM was handled. Exiting with Exitcode: -1.") sys.exit(-1) signal.signal(signal.SIGTERM, catch_shutdown) click.echo("Start Cloud-Client-Portal Server") CONFIG_FILE = config with open(CONFIG_FILE, "r") as ymlfile: cfg = yaml.load(ymlfile, Loader=yaml.SafeLoader) HOST = cfg["openstack_connection"]["host"] PORT = cfg["openstack_connection"]["port"] USE_SSL = cfg["openstack_connection"].get("use_ssl", True) if USE_SSL: CERTFILE = cfg["openstack_connection"]["certfile"] THREADS = cfg["openstack_connection"]["threads"] click.echo(f"Server is running on port {PORT}") handler = VirtualMachineHandler(CONFIG_FILE) processor = Processor(handler) if USE_SSL: click.echo("Use SSL") transport = TSSLSocket.TSSLServerSocket( host=HOST, port=PORT, certfile=CERTFILE, ssl_version=ssl.PROTOCOL_TLS_SERVER ) else: click.echo("Does not use SSL") transport = TSocket.TServerSocket(host=HOST, port=PORT) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TThreadPoolServer( processor, transport, tfactory, pfactory, daemon=True ) server.setNumThreads(THREADS) click.echo(f"Started with {THREADS} threads!") server.serve()
def main(options): # set up the protocol factory form the --protocol option prot_factories = { 'binary': TBinaryProtocol.TBinaryProtocolFactory, 'accel': TBinaryProtocol.TBinaryProtocolAcceleratedFactory, 'compact': TCompactProtocol.TCompactProtocolFactory, 'json': TJSONProtocol.TJSONProtocolFactory, } pfactory_cls = prot_factories.get(options.proto, None) if pfactory_cls is None: raise AssertionError('Unknown --protocol option: %s' % options.proto) pfactory = pfactory_cls() try: pfactory.string_length_limit = options.string_limit pfactory.container_length_limit = options.container_limit except: # Ignore errors for those protocols that does not support length limit pass # get the server type (TSimpleServer, TNonblockingServer, etc...) if len(args) > 1: raise AssertionError( 'Only one server type may be specified, not multiple types.') server_type = args[0] # Set up the handler and processor objects handler = TestHandler() processor = ThriftTest.Processor(handler) # Handle THttpServer as a special case if server_type == 'THttpServer': server = THttpServer.THttpServer(processor, ('', options.port), pfactory) server.serve() sys.exit(0) # set up server transport and transport factory abs_key_path = os.path.join(os.path.dirname(SCRIPT_DIR), 'keys', 'server.pem') host = None if options.ssl: from thrift.transport import TSSLSocket transport = TSSLSocket.TSSLServerSocket(host, options.port, certfile=abs_key_path) else: transport = TSocket.TServerSocket(host, options.port) tfactory = TTransport.TBufferedTransportFactory() if options.trans == 'buffered': tfactory = TTransport.TBufferedTransportFactory() elif options.trans == 'framed': tfactory = TTransport.TFramedTransportFactory() elif options.trans == '': raise AssertionError('Unknown --transport option: %s' % options.trans) else: tfactory = TTransport.TBufferedTransportFactory() # if --zlib, then wrap server transport, and use a different transport factory if options.zlib: transport = TZlibTransport.TZlibTransport(transport) # wrap with zlib tfactory = TZlibTransport.TZlibTransportFactory() # do server-specific setup here: if server_type == "TNonblockingServer": server = TNonblockingServer.TNonblockingServer( processor, transport, inputProtocolFactory=pfactory) elif server_type == "TProcessPoolServer": import signal from thrift.server import TProcessPoolServer server = TProcessPoolServer.TProcessPoolServer(processor, transport, tfactory, pfactory) server.setNumWorkers(5) def set_alarm(): def clean_shutdown(signum, frame): for worker in server.workers: if options.verbose > 0: logging.info('Terminating worker: %s' % worker) worker.terminate() if options.verbose > 0: logging.info('Requesting server to stop()') try: server.stop() except: pass signal.signal(signal.SIGALRM, clean_shutdown) signal.alarm(4) set_alarm() else: # look up server class dynamically to instantiate server ServerClass = getattr(TServer, server_type) server = ServerClass(processor, transport, tfactory, pfactory) # enter server main loop server.serve()
def main(options): # common header allowed client types allowed_client_types = [ THeaderTransport.THeaderClientType.HEADERS, THeaderTransport.THeaderClientType.FRAMED_BINARY, THeaderTransport.THeaderClientType.UNFRAMED_BINARY, THeaderTransport.THeaderClientType.FRAMED_COMPACT, THeaderTransport.THeaderClientType.UNFRAMED_COMPACT, ] # set up the protocol factory form the --protocol option prot_factories = { 'accel': TBinaryProtocol.TBinaryProtocolAcceleratedFactory(), 'multia': TBinaryProtocol.TBinaryProtocolAcceleratedFactory(), 'accelc': TCompactProtocol.TCompactProtocolAcceleratedFactory(), 'multiac': TCompactProtocol.TCompactProtocolAcceleratedFactory(), 'binary': TPedanticSequenceIdProtocolFactory( TBinaryProtocol.TBinaryProtocolFactory()), 'multi': TPedanticSequenceIdProtocolFactory( TBinaryProtocol.TBinaryProtocolFactory()), 'compact': TCompactProtocol.TCompactProtocolFactory(), 'multic': TCompactProtocol.TCompactProtocolFactory(), 'header': THeaderProtocol.THeaderProtocolFactory(allowed_client_types), 'multih': THeaderProtocol.THeaderProtocolFactory(allowed_client_types), 'json': TJSONProtocol.TJSONProtocolFactory(), 'multij': TJSONProtocol.TJSONProtocolFactory(), } pfactory = prot_factories.get(options.proto, None) if pfactory is None: raise AssertionError('Unknown --protocol option: %s' % options.proto) try: pfactory.string_length_limit = options.string_limit pfactory.container_length_limit = options.container_limit except Exception: # Ignore errors for those protocols that does not support length limit pass # get the server type (TSimpleServer, TNonblockingServer, etc...) if len(args) > 1: raise AssertionError( 'Only one server type may be specified, not multiple types.') server_type = args[0] if options.trans == 'http': server_type = 'THttpServer' # Set up the handler and processor objects handler = TestHandler() processor = ThriftTest.Processor(handler) if options.proto.startswith('multi'): secondHandler = SecondHandler() secondProcessor = SecondService.Processor(secondHandler) multiplexedProcessor = TMultiplexedProcessor() multiplexedProcessor.registerDefault(processor) multiplexedProcessor.registerProcessor('ThriftTest', processor) multiplexedProcessor.registerProcessor('SecondService', secondProcessor) processor = multiplexedProcessor global server # Handle THttpServer as a special case if server_type == 'THttpServer': if options.ssl: __certfile = os.path.join(os.path.dirname(SCRIPT_DIR), "keys", "server.crt") __keyfile = os.path.join(os.path.dirname(SCRIPT_DIR), "keys", "server.key") server = THttpServer.THttpServer(processor, ('', options.port), pfactory, cert_file=__certfile, key_file=__keyfile) else: server = THttpServer.THttpServer(processor, ('', options.port), pfactory) server.serve() sys.exit(0) # set up server transport and transport factory abs_key_path = os.path.join(os.path.dirname(SCRIPT_DIR), 'keys', 'server.pem') host = None if options.ssl: from thrift.transport import TSSLSocket transport = TSSLSocket.TSSLServerSocket(host, options.port, certfile=abs_key_path) else: transport = TSocket.TServerSocket(host, options.port, options.domain_socket) tfactory = TTransport.TBufferedTransportFactory() if options.trans == 'buffered': tfactory = TTransport.TBufferedTransportFactory() elif options.trans == 'framed': tfactory = TTransport.TFramedTransportFactory() elif options.trans == '': raise AssertionError('Unknown --transport option: %s' % options.trans) else: tfactory = TTransport.TBufferedTransportFactory() # if --zlib, then wrap server transport, and use a different transport factory if options.zlib: transport = TZlibTransport.TZlibTransport(transport) # wrap with zlib tfactory = TZlibTransport.TZlibTransportFactory() # do server-specific setup here: if server_type == "TNonblockingServer": server = TNonblockingServer.TNonblockingServer( processor, transport, inputProtocolFactory=pfactory) elif server_type == "TProcessPoolServer": import signal from thrift.server import TProcessPoolServer server = TProcessPoolServer.TProcessPoolServer(processor, transport, tfactory, pfactory) server.setNumWorkers(5) def set_alarm(): def clean_shutdown(signum, frame): for worker in server.workers: if options.verbose > 0: logging.info('Terminating worker: %s' % worker) worker.terminate() if options.verbose > 0: logging.info('Requesting server to stop()') try: server.stop() except Exception: pass signal.signal(signal.SIGALRM, clean_shutdown) signal.alarm(4) set_alarm() else: # look up server class dynamically to instantiate server ServerClass = getattr(TServer, server_type) server = ServerClass(processor, transport, tfactory, pfactory) # enter server main loop server.serve()
return challenge def balance_history(self, address): history_list = [] for x in range(5): balance_history = BalanceTransfer() balance_history.amount = random.randrange(100) balance_history.receiverId = uuid.uuid4().hex balance_history.senderId = uuid.uuid4().hex balance_history.timestamp = random.randrange(99999999) history_list.append(balance_history) print('balance_hisotry(%s, %s)' % (address, history_list)) return history_list if __name__ == '__main__': handler = TransactionHandler() processor = Transaction.Processor(handler) transport = TSSLSocket.TSSLServerSocket(host='127.0.0.1', port=9090, certfile='.ssh/server.crt', keyfile='.ssh/server.key') tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TSimpleServer(processor, transport, tfactory, pfactory) print('Starting the server...') server.serve() print('Done.')
book = db_get_book(isbn) return book.image def postSellItemImages(self, id, images): print("postSellItemImages(id=%s, images=...)" % id) c.execute("insert into Item values(?, ?)", id, repr(images)) conn.commit() def queryIsbn(self, isbn): print("queryIsbn(isbn=%s)" % isbn) book = db_get_book(isbn) return [book.title, book.author] handler = ImagesHandler() processor = Images.Processor(handler) transport = TSSLSocket.TSSLServerSocket("app.handytextbook.com", 9092, "/etc/letsencrypt/live/app.handytextbook.com/fullchain.pem") tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TSimpleServer(processor, transport, tfactory, pfactory) def exit_handler(): print('My application is ending!') conn.close() atexit.register(exit_handler) print("Starting thrift server in python...") server.serve() print("done!")
# Handle THttpServer as a special case if server_type == 'THttpServer': server = THttpServer.THttpServer(processor, ('', options.port), pfactory) server.serve() sys.exit(0) # set up server transport and transport factory rel_path = "../keys/server.pem" abs_key_path = os.path.join(script_dir, rel_path) host = None if options.ssl: from thrift.transport import TSSLSocket transport = TSSLSocket.TSSLServerSocket(host, options.port, certfile=abs_key_path) else: transport = TSocket.TServerSocket(host, options.port) tfactory = TTransport.TBufferedTransportFactory() if options.trans == 'buffered': tfactory = TTransport.TBufferedTransportFactory() elif options.trans == 'framed': tfactory = TTransport.TFramedTransportFactory() elif options.trans == '': raise AssertionError('Unknown --transport option: %s' % options.trans) else: tfactory = TTransport.TBufferedTransportFactory() # if --zlib, then wrap server transport, and use a different transport factory if options.zlib: transport = TZlibTransport.TZlibTransport(transport) # wrap with zlib
handler = SecondHandler() processor.registerProcessor("SecondService", SecondService.Processor(handler)) # Handle THttpServer as a special case if server_type == 'THttpServer': server = THttpServer.THttpServer(processor, ('', options.port), pfactory) server.serve() sys.exit(0) # set up server transport and transport factory host = None if options.ssl: from thrift.transport import TSSLSocket transport = TSSLSocket.TSSLServerSocket(host, options.port, certfile='../keys/server.pem') else: transport = TSocket.TServerSocket(host, options.port) tfactory = TTransport.TBufferedTransportFactory() # if --zlib, then wrap server transport, and use a different transport factory if options.zlib: transport = TZlibTransport.TZlibTransport(transport) # wrap with zlib tfactory = TZlibTransport.TZlibTransportFactory() # do server-specific setup here: if server_type == "TNonblockingServer": server = TNonblockingServer.TNonblockingServer( processor, transport, inputProtocolFactory=pfactory) elif server_type == "TProcessPoolServer":
"SecondService", SecondService.Processor(SecondHandler())) if args[0] == "THttpServer": try: server = THttpServer.THttpServer(processor, ('', options.port), pfactory) except: print("Could not load THttpServer") raise elif args[0] == "TCppServer": server = TCppServer.TCppServer(processor) server.setPort(options.port) else: if options.ssl: cert_path = 'thrift/test/py/test_cert.pem' transport = TSSLSocket.TSSLServerSocket(options.port, certfile=cert_path) else: transport = TSocket.TServerSocket(options.port) tfactory = TTransport.TBufferedTransportFactory() server_class_name = args[0] if args[0] == "TNonblockingServer": server = TNonblockingServer.TNonblockingServer( processor, transport, pfactory, readTimeout=options.timeout) elif args[0] == "TProcessPoolServer": server = TProcessPoolServer.TProcessPoolServer( processor, transport, tfactory, pfactory) else: ServerClass = getattr(TServer, server_class_name) server = ServerClass(processor, transport, tfactory, pfactory)
result = client.getFileMetaData(filePath) clientTransport.close() print result return result logging.basicConfig() x = ServerHandler() processor = myService.Processor(x) #transport = TSocket.TServerSocket(host='144.122.71.154',port=8081) try: transport = TSSLSocket.TSSLServerSocket(host='144.122.71.154', port=8080, certfile='key/server.pem') #tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() tfactory = TTransport.TFramedTransportFactory() #pfactory = TTransport.TFramedTransportFactory() #server = TServer.TSimpleServer(processor, transport, tfactory, pfactory) # You could do one of these for a multithreaded server #server = TServer.TThreadedServer(processor, transport, tfactory, pfactory) #server = TNonblockingServer.TNonblockingServer(processor, transport, pfactory, pfactory) server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory) print('Starting the server...')
# Set up the handler and processor objects handler = TestHandler() processor = ThriftTest.Processor(handler) # Handle THttpServer as a special case if server_type == 'THttpServer': server = THttpServer.THttpServer(processor, ('', options.port), pfactory) server.serve() sys.exit(0) # set up server transport and transport factory host = None if options.ssl: from thrift.transport import TSSLSocket transport = TSSLSocket.TSSLServerSocket(host, options.port, certfile='test_cert.pem') else: transport = TSocket.TServerSocket(host, options.port) tfactory = TTransport.TBufferedTransportFactory() # if --zlib, then wrap server transport, and use a different transport factory if options.zlib: transport = TZlibTransport.TZlibTransport(transport) # wrap with zlib tfactory = TZlibTransport.TZlibTransportFactory() # do server-specific setup here: if server_type == "TNonblockingServer": server = TNonblockingServer.TNonblockingServer( processor, transport, inputProtocolFactory=pfactory) elif server_type == "TProcessPoolServer":
#!/usr/bin/env python import sys import os sys.path.append('gen-py') from thrift.transport import TTransport from thrift.protocol import TBinaryProtocol from thrift.server import TServer from thrift.transport import TSSLSocket from ServerHandler import ServerHandler from ThriftSecureEventTransmissionService import ThriftSecureEventTransmissionService SERVER_ADDRESS = 'localhost' SERVER_PORT = 8988 CERTIFICATE_FILE = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'server.pem') handler = ServerHandler() processor = ThriftSecureEventTransmissionService.Processor(handler) transport = TSSLSocket.TSSLServerSocket(SERVER_ADDRESS, SERVER_PORT, certfile=CERTIFICATE_FILE) tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TSimpleServer(processor, transport, tfactory, pfactory) print 'Starting SSL Server at ' + SERVER_ADDRESS + ':' + str(SERVER_PORT) server.serve()