def setUp(self): if self.ssl: self.socket = TSSLSocket.TSSLSocket("localhost", self._port) else: self.socket = TSocket.TSocket("localhost", self._port) self.transport = TTransport.TBufferedTransport(self.socket) self.protocol = self.protocol_factory.getProtocol(self.transport) if isinstance(self, HeaderAcceleratedCompactTest): self.protocol.trans.set_protocol_id( THeaderProtocol.THeaderProtocol.T_COMPACT_PROTOCOL ) self.protocol.reset_protocol() self.transport.open() self.client = ThriftTest.Client(self.protocol) if self.multiple: p = TMultiplexedProtocol.TMultiplexedProtocol(self.protocol, "ThriftTest") self.client = ThriftTest.Client(p) p = TMultiplexedProtocol.TMultiplexedProtocol( self.protocol, "SecondService" ) self.client2 = SecondService.Client(p) else: self.client = ThriftTest.Client(self.protocol) self.client2 = None
def getFileMetaData(self, deviceId): print "device ID -> " + str(deviceId) query = ('Select DeviceIp From Devices Where DeviceId=%s' % (deviceId)) try: self.cur.execute(query) except Exception as e: print e devIp = self.cur.fetchone()[0] query = ('Select DevicePort From Devices Where DeviceId=%s' % (deviceId)) try: self.cur.execute(query) except Exception as e: print e devPort = self.cur.fetchone()[0] print devIp print devPort clientSocket = TSSLSocket.TSSLSocket(host=devIp, port=devPort, ca_certs=str(deviceId) + '.crt') clientTransport = TTransport.TFramedTransport(clientSocket) clientProtocol = TBinaryProtocol.TBinaryProtocol(clientTransport) client = clientService.Client(clientProtocol) clientTransport.open() result = client.getFileMetaData() clientTransport.close() print result return result
def setUp(self): if self.ssl: self.socket = TSSLSocket.TSSLSocket("localhost", self._port) else: self.socket = TSocket.TSocket("localhost", self._port) if self.server_type in FRAMED_TYPES \ and not isinstance(self, HeaderTest): self.transport = TTransport.TFramedTransport(self.socket) else: self.transport = TTransport.TBufferedTransport(self.socket) self.protocol = self.protocol_factory.getProtocol(self.transport) self.transport.open() self.client = ThriftTest.Client(self.protocol) if self.multiple: p = TMultiplexedProtocol.TMultiplexedProtocol( self.protocol, "ThriftTest") self.client = ThriftTest.Client(p) p = TMultiplexedProtocol.TMultiplexedProtocol( self.protocol, "SecondService") self.client2 = SecondService.Client(p) else: self.client = ThriftTest.Client(self.protocol) self.client2 = None
def setUp(self): if options.http_path: self.transport = THttpClient.THttpClient(options.host, port=options.port, path=options.http_path) else: if options.ssl: from thrift.transport import TSSLSocket socket = TSSLSocket.TSSLSocket(options.host, options.port, validate=False) else: socket = TSocket.TSocket(options.host, options.port) # frame or buffer depending upon args if options.framed: self.transport = TTransport.TFramedTransport(socket) else: self.transport = TTransport.TBufferedTransport(socket) if options.zlib: self.transport = TZlibTransport.TZlibTransport( self.transport, 9) self.transport.open() protocol = self.protocol_factory.getProtocol(self.transport) if options.multiple: p = TMultiplexedProtocol.TMultiplexedProtocol( protocol, "ThriftTest") self.client = ThriftTest.Client(p) p = TMultiplexedProtocol.TMultiplexedProtocol( protocol, "SecondService") self.client2 = SecondService.Client(p) else: self.client = ThriftTest.Client(protocol) self.client2 = None
def setUp(self): if options.http_path: self.transport = THttpClient.THttpClient(options.host, port=options.port, path=options.http_path) else: if options.ssl: from thrift.transport import TSSLSocket socket = TSSLSocket.TSSLSocket(options.host, options.port, validate=False) else: socket = TSocket.TSocket(options.host, options.port) # frame or buffer depending upon args self.transport = TTransport.TBufferedTransport(socket) if options.trans == 'framed': self.transport = TTransport.TFramedTransport(socket) elif options.trans == 'buffered': self.transport = TTransport.TBufferedTransport(socket) elif options.trans == '': raise AssertionError('Unknown --transport option: %s' % options.trans) if options.zlib: self.transport = TZlibTransport.TZlibTransport( self.transport, 9) self.transport.open() protocol = self.get_protocol(self.transport) self.client = ThriftTest.Client(protocol)
def _get_transport(self): """Create a Transport. A non-kerberized impalad just needs a simple buffered transport. For the kerberized version, a sasl transport is created. If SSL is enabled, a TSSLSocket underlies the transport stack; otherwise a TSocket is used. """ if self.use_ssl: # TSSLSocket needs the ssl module, which may not be standard on all Operating # Systems. Only attempt to import TSSLSocket if the user wants an SSL connection. from thrift.transport import TSSLSocket # sasl does not accept unicode strings, explicitly encode the string into ascii. host, port = self.impalad[0].encode('ascii', 'ignore'), int(self.impalad[1]) if self.use_ssl: if self.ca_cert is None: # No CA cert means don't try to verify the certificate sock = TSSLSocket.TSSLSocket(host, port, validate=False) else: sock = TSSLSocket.TSSLSocket(host, port, validate=True, ca_certs=self.ca_cert) else: sock = TSocket(host, port) if not (self.use_ldap or self.use_kerberos): return TBufferedTransport(sock) # Initializes a sasl client def sasl_factory(): sasl_client = sasl.Client() sasl_client.setAttr("host", host) if self.use_ldap: sasl_client.setAttr("username", self.user) sasl_client.setAttr("password", self.ldap_password) else: sasl_client.setAttr("service", self.kerberos_service_name) sasl_client.init() return sasl_client # GSSASPI is the underlying mechanism used by kerberos to authenticate. if self.use_kerberos: return TSaslClientTransport(sasl_factory, "GSSAPI", sock) else: return TSaslClientTransport(sasl_factory, "PLAIN", sock)
def __init__(self): try: self.socket = TSSLSocket.TSSLSocket('192.168.99.105', 9930, validate=False) except Thrift.TException as tx: print('%s' % (tx.message))
def ssl_socket_factory(host, port): """ Returns a :class:`TSSLSocket` instance. """ return TSSLSocket.TSSLSocket(host, port, ca_certs=ca_certs, validate=validate)
def setup_client(self): socket = TSSLSocket.TSSLSocket(host=self.test_host, port=self.test_port, validate=False) self.client_transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocol(self.client_transport) self.client = DemoService.Client(protocol) self.client_transport.open()
def get_transport(hostname, port): # Create a socket to the Airavata Server # TODO: validate server certificate transport = TSSLSocket.TSSLSocket(hostname, port, validate=False) # Use Buffered Protocol to speedup over raw sockets transport = TTransport.TBufferedTransport(transport) return transport
def create_transport(host, port, service, transport_type="buffered", user=None, password=None, use_ssl=False, ssl_cert=None): """ Create a new Thrift Transport based on the requested type. Supported transport types: - buffered, returns simple buffered transport - plain_sasl, return a SASL transport with the PLAIN mechanism - kerberos, return a SASL transport with the GSSAPI mechanism If use_ssl is True, the connection will use SSL, optionally using the file at ssl_cert as the CA cert. """ port = int(port) if use_ssl: from thrift.transport import TSSLSocket if ssl_cert is None: sock = TSSLSocket.TSSLSocket(host, port, validate=False) else: sock = TSSLSocket.TSSLSocket(host, port, validate=True, ca_certs=ssl_cert) else: sock = TSocket(host, port) if transport_type.lower() == "buffered": return TBufferedTransport(sock) # Set defaults for LDAP connections if transport_type.lower() == "plain_sasl": if user is None: user = getpass.getuser() if password is None: password = "" # Initializes a sasl client from shell.thrift_sasl import TSaslClientTransport def sasl_factory(): sasl_client = sasl.Client() sasl_client.setAttr("host", host) sasl_client.setAttr("service", service) if transport_type.lower() == "plain_sasl": sasl_client.setAttr("username", user) sasl_client.setAttr("password", password) sasl_client.init() return sasl_client if transport_type.lower() == "plain_sasl": return TSaslClientTransport(sasl_factory, "PLAIN", sock) else: # GSSASPI is the underlying mechanism used by kerberos to authenticate. return TSaslClientTransport(sasl_factory, "GSSAPI", sock)
def __init__(self, ip, port): # Make SSL socket self.socket = TSSLSocket.TSSLSocket(ip, port, False) # Buffering is critical. Raw sockets are very slow self.transport = TTransport.TBufferedTransport(self.socket) # Wrap in a protocol self.protocol = TBinaryProtocol.TBinaryProtocol(self.transport) self.sessionId = None self.streamId = None
def _get_client(self, options): host, port = self._parse_host_port(options.host, self.default_port) socket = (TSSLSocket.TSSLSocket(host, port) if options.ssl else TSocket.TSocket(host, port)) if options.framed: transport = TTransport.TFramedTransport(socket) else: transport = TTransport.TBufferedTransport(socket) return self._get_client_by_transport(options, transport, socket=socket)
def __init__(self, ip, ssl_port, tcp_port): # Make SSL socket self.ssl_socket = TSSLSocket.TSSLSocket(ip, ssl_port, False) self.ssl_transport = TTransport.TBufferedTransport(self.ssl_socket) self.ssl_protocol = TBinaryProtocol.TBinaryProtocol(self.ssl_transport) # Make TCP socket self.tcp_socket = TSocket.TSocket(ip, tcp_port) self.tcp_transport = TTransport.TBufferedTransport(self.tcp_socket) self.tcp_protocol = TBinaryProtocol.TBinaryProtocol(self.tcp_transport)
def _get_client_by_host(self): config = self.config host, port = self._parse_host_port(config.host, self.default_port) socket = (TSSLSocket.TSSLSocket(host, port) if config.ssl else TSocket.TSocket(host, port)) if config.framed: transport = TTransport.TFramedTransport(socket) else: transport = TTransport.TBufferedTransport(socket) return self._get_client_by_transport(config, transport, socket=socket)
def get_transport(hostname, port): """Create a socket to the Airavata Server :param hostname: Hostname of Airavata server :param port: Port of Airavata server :return: Transport object """ # TODO: validate server certificate transport = TSSLSocket.TSSLSocket(hostname, port, validate=False) # Use Buffered Protocol to speedup over raw sockets transport = TTransport.TBufferedTransport(transport) return transport
def ssl_transport_factory(host, port, env, config_file): """ SSL Thrift transport factory function. Params: * host .........: hostname of Cassandra node. * port .........: port number to connect to. * env ..........: environment variables. SSL factory will use, if passed, SSL_CERTFILE and SSL_VALIDATE variables. * config_file ..: path to cqlsh config file (usually ~/.cqlshrc). SSL factory will use, if set, certfile and validate options in [ssl] section, as well as host to certfile mapping in [certfiles] section. [certfiles] section is optional, 'validate' setting in [ssl] section is optional too. If validation is enabled then SSL certfile must be provided either in the config file or as an environment variable. Environment variables override any options set in cqlsh config file. """ configs = ConfigParser.SafeConfigParser() configs.read(config_file) def get_option(section, option): try: return configs.get(section, option) except ConfigParser.Error: return None ssl_validate = env.get('SSL_VALIDATE') if ssl_validate is None: ssl_validate = get_option('ssl', 'validate') ssl_validate = ssl_validate is None or ssl_validate.lower() != 'false' ssl_certfile = env.get('SSL_CERTFILE') if ssl_certfile is None: ssl_certfile = get_option('certfiles', host) if ssl_certfile is None: ssl_certfile = get_option('ssl', 'certfile') if ssl_validate and ssl_certfile is None: sys.exit( "Validation is enabled; SSL transport factory requires a valid certfile " "to be specified. Please provide path to the certfile in [ssl] section " "as 'certfile' option in %s (or use [certfiles] section) or set SSL_CERTFILE " "environment variable." % (config_file, )) if not ssl_certfile is None: ssl_certfile = os.path.expanduser(ssl_certfile) tsocket = TSSLSocket.TSSLSocket(host, port, ca_certs=ssl_certfile, validate=ssl_validate) return TTransport.TFramedTransport(tsocket)
def setUp(self): if self.ssl: self.socket = TSSLSocket.TSSLSocket("localhost", self._port) else: self.socket = TSocket.TSocket("localhost", self._port) if self.server_type in FRAMED_TYPES \ and not isinstance(self, HeaderTest): self.transport = TTransport.TFramedTransport(self.socket) else: self.transport = TTransport.TBufferedTransport(self.socket) self.protocol = self.protocol_factory.getProtocol(self.transport) self.transport.open() self.client = ThriftTest.Client(self.protocol)
def setUp(self): if options.trans == 'http': uri = '{0}://{1}:{2}{3}'.format( ('https' if options.ssl else 'http'), options.host, options.port, (options.http_path if options.http_path else '/')) if options.ssl: __cafile = os.path.join(os.path.dirname(SCRIPT_DIR), "keys", "CA.pem") __certfile = os.path.join(os.path.dirname(SCRIPT_DIR), "keys", "client.crt") __keyfile = os.path.join(os.path.dirname(SCRIPT_DIR), "keys", "client.key") self.transport = THttpClient.THttpClient(uri, cafile=__cafile, cert_file=__certfile, key_file=__keyfile) else: self.transport = THttpClient.THttpClient(uri) else: if options.ssl: from thrift.transport import TSSLSocket socket = TSSLSocket.TSSLSocket(options.host, options.port, validate=False) else: socket = TSocket.TSocket(options.host, options.port, options.domain_socket) # frame or buffer depending upon args self.transport = TTransport.TBufferedTransport(socket) if options.trans == 'framed': self.transport = TTransport.TFramedTransport(socket) elif options.trans == 'buffered': self.transport = TTransport.TBufferedTransport(socket) elif options.trans == '': raise AssertionError('Unknown --transport option: %s' % options.trans) if options.zlib: self.transport = TZlibTransport.TZlibTransport( self.transport, 9) self.transport.open() protocol = self.get_protocol(self.transport) self.client = ThriftTest.Client(protocol) # for multiplexed services: protocol2 = self.get_protocol2(self.transport) self.client2 = SecondService.Client( protocol2) if protocol2 is not None else None
def get_instance(self): if self.http: self.transport = THttpClient.THttpClient(self.host, self.port, self.uri) else: socket = TSSLSocket.TSSLSocket( self.host, self.port, validate=False) if self.ssl else TSocket.TSocket( self.host, self.port) if self.framed: self.transport = TTransport.TFramedTransport(socket) else: self.transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocol(self.transport) self.client = ThriftHiveMetastore.Client(protocol) self.transport.open() return self.client
def get_thrift_client(self, use_ssl): socket = ( TSSLSocket.TSSLSocket( host=self.cli_opts.host, port=self.cli_opts.openr_ctrl_port, # verify server cert_reqs=ssl.CERT_REQUIRED, ca_certs=self.cli_opts.ca_file, certfile=self.cli_opts.cert_file, keyfile=self.cli_opts.key_file, verify_name=self.cli_opts.acceptable_peer_name, ) if use_ssl else TSocket.TSocket( host=self.cli_opts.host, port=self.cli_opts.openr_ctrl_port)) socket.setTimeout(self.cli_opts.timeout) transport = THeaderTransport.THeaderTransport(socket) protocol = THeaderProtocol.THeaderProtocol(transport) transport.open() return OpenrCtrl.Client(protocol)
def __init__( self, host: str, ca_file: str, cert_file: str, key_file: str, acceptable_peer_name: str, port: int = consts.Consts.CTRL_PORT, timeout_ms: int = 5000, ) -> None: socket = TSSLSocket.TSSLSocket( host=host, port=port, cert_reqs=ssl.CERT_REQUIRED, ca_certs=ca_file, certfile=cert_file, keyfile=key_file, verify_name=acceptable_peer_name, ) socket.setTimeout(timeout_ms) OpenrCtrlClient.__init__(self, host, THeaderTransport.THeaderTransport(socket))
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 connect(self): """Connect to the HostHandler.""" self._logger.info( "Initialize SSLSocket using certfile=%s, keyfile=%s, capath=%s, ciphers=%s" % (self._certfile, self._keyfile, self._capath, self._ciphers)) sock = TSSLSocket.TSSLSocket(host=self._host, port=self._port, validate=self._validate, certfile=self._certfile, keyfile=self._keyfile, capath=self._capath, ciphers=self._ciphers) if self._client_timeout: sock.setTimeout(self._client_timeout * 1000) self._transport = TTransport.TFramedTransport(sock) protocol = TCompactProtocol.TCompactProtocol(self._transport) mux_protocol = TMultiplexedProtocol.TMultiplexedProtocol( protocol, self._service_name) self._client = self._client_cls(mux_protocol) self._transport.open() self._logger.info("Connected to %s:%s. for service %s" % (self._host, self._port, self._service_name))
def _open_connection(self, address): """ Opens a connection with a server address. :param address: the address of the server to connect to """ (url, port) = self._parse_address_for_hostname_and_port(address) if self._tls: verifier_type = self._get_verifier_type( self.cert_verification_mode) if self._proxy: proxy_host, proxy_port = self._proxy.split(":") self._transport = TProxySSLSocket(url, port, proxy_host, proxy_port, verifier_type, ca_certs=self._tls_key_path) else: ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23) if self._tls_key_path is not None: ssl_context.load_cert_chain(self._tls_key_path, self._tls_key_path) ssl_context.verify_mode = verifier_type self._transport = TSSLSocket.TSSLSocket( url, port, ssl_context=ssl_context) else: if self._proxy: proxy_host, proxy_port = self._proxy.split(":") self._transport = TProxySocket(proxy_host, proxy_port, url, port) else: self._transport = TSocket.TSocket(url, port) self._transport = TTransport.TFramedTransport(self._transport) self._transport.open() self._protocol = TFinagleProtocol(self._transport, client_id=self._client_id)
def __init__( self, uri=None, user=None, password=None, host=None, port=6274, dbname=None, protocol='binary', sessionid=None, bin_cert_validate=None, bin_ca_certs=None, ): self.sessionid = None if sessionid is not None: if any([user, password, uri, dbname]): raise TypeError("Cannot specify sessionid with user, password," " dbname, or uri") if uri is not None: if not all([ user is None, password is None, host is None, port == 6274, dbname is None, protocol == 'binary', bin_cert_validate is None, bin_ca_certs is None ]): raise TypeError("Cannot specify both URI and other arguments") user, password, host, port, dbname, protocol, \ bin_cert_validate, bin_ca_certs = _parse_uri(uri) if host is None: raise TypeError("`host` parameter is required.") if protocol != 'binary' and not all( [bin_cert_validate is None, bin_ca_certs is None]): raise TypeError("Cannot specify bin_cert_validate or bin_ca_certs," " without binary protocol") if protocol in ("http", "https"): if not host.startswith(protocol): # the THttpClient expects http[s]://localhost host = '{0}://{1}'.format(protocol, host) transport = THttpClient.THttpClient("{}:{}".format(host, port)) proto = TJSONProtocol.TJSONProtocol(transport) socket = None elif protocol == "binary": if any([bin_cert_validate is not None, bin_ca_certs]): socket = TSSLSocket.TSSLSocket(host, port, validate=(bin_cert_validate), ca_certs=bin_ca_certs) else: socket = TSocket.TSocket(host, port) transport = TTransport.TBufferedTransport(socket) proto = TBinaryProtocol.TBinaryProtocolAccelerated(transport) else: raise ValueError("`protocol` should be one of", " ['http', 'https', 'binary'],", " got {} instead".format(protocol)) self._user = user self._password = password self._host = host self._port = port self._dbname = dbname self._transport = transport self._protocol = protocol self._socket = socket self._closed = 0 self._tdf = None try: self._transport.open() except TTransportException as e: if e.NOT_OPEN: err = OperationalError("Could not connect to database") raise err from e else: raise self._client = Client(proto) try: # If a sessionid was passed, we should validate it if sessionid: self._session = sessionid self.get_tables() self.sessionid = sessionid else: self._session = self._client.connect(user, password, dbname) except TMapDException as e: raise _translate_exception(e) from e except TTransportException: raise ValueError(f"Connection failed with port {port} and " f"protocol '{protocol}'. Try port 6274 for " "protocol == binary or 6273, 6278 or 443 for " "http[s]") # if OmniSci version <4.6, raise RuntimeError, as data import can be # incorrect for columnar date loads # Caused by https://github.com/omnisci/pymapd/pull/188 semver = self._client.get_version() if Version(semver.split("-")[0]) < Version("4.6"): raise RuntimeError(f"Version {semver} of OmniSci detected. " "Please use pymapd <0.11. See release notes " "for more details.")
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.')