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()
