def setUp(self):
self.handler = TestHandler()
self.processor = ThriftTest.Processor(self.handler)
self.pfactory = TBinaryProtocol.TBinaryProtocolFactory()
self.server = reactor.listenTCP(
0, TTwisted.ThriftServerFactory(self.processor, self.pfactory), interface="127.0.0.1")
self.portNo = self.server.getHost().port
self.txclient = yield ClientCreator(reactor,
TTwisted.ThriftClientProtocol,
ThriftTest.Client,
self.pfactory).connectTCP("127.0.0.1", self.portNo)
self.client = self.txclient.client
def create_server(server_reactor, port):
model_base.setup_db()
mux = TMultiplexedProcessor.TMultiplexedProcessor()
for service_name, service in services.handlers.iteritems():
processor = service.processor()
mux.registerProcessor(service_name, processor(service()))
server_factory = TTwisted.ThriftServerFactory(
processor=mux,
iprot_factory=TBinaryProtocol.TBinaryProtocolFactory()
)
server_endpoint = endpoints.TCP4ServerEndpoint(server_reactor, port)
server_endpoint.listen(server_factory)
server_reactor.run()
def startService(self):
if scribe.Iface.providedBy(self._handler):
handler = self._handler
else:
handler = _SimpleLogHandler(self._handler)
self._processor = scribe.Processor(handler)
thriftFactory = TTwisted.ThriftServerFactory(
processor=self._processor,
iprot_factory=TBinaryProtocol.TBinaryProtocolFactory())
d = self._endpoint.listen(thriftFactory)
def _listening(port):
self._port = port
d.addCallback(_listening)
def make_application():
ssetings = settings.get('SERVER')
port = ssetings['port']
pkg_size = settings.getint("SEED_PKG_SIZE")
seed_servie = MemoryBasedSeedsService(pkg_size)
handler = RequestHandler(seed_servie)
processor = Scheduler.Processor(handler)
factory = TTwisted.ThriftServerFactory(processor,
TBinaryProtocol.TBinaryProtocolFactory())
tcp_service = internet.TCPServer(port, factory)
application = service.Application(ssetings['name'])
logfile = DailyLogFile(settings.get('LOG_FILE'), settings.get('LOG_DIR'))
application.setComponent(ILogObserver, FileLogObserver(logfile).emit)
multiService = service.MultiService()
tcp_service.setServiceParent(multiService)
multiService.setServiceParent(application)
return application
def main():
if len(sys.argv) < 2:
print 'Usage: %s config_file' % sys.argv[0]
sys.exit()
log.startLogging(sys.stdout)
Config.init(sys.argv[1])
if Config.debug:
log.startLogging(sys.stdout)
else:
log.startLogging(DailyLogFile.fromFullPath(Config.get('log.file')))
handler = SnowflakeServiceHandler(Config.getint('worker.id'),
Config.getint('datacenter.id'))
processor = SnowflakeService.Processor(handler)
server = TTwisted.ThriftServerFactory(
processor=processor,
iprot_factory=TBinaryProtocol.TBinaryProtocolFactory())
reactor.listenTCP(Config.getint('port', default=9999),
server,
interface=Config.get('listen', default="0.0.0.0"))
reactor.run()
else:
x = InvalidOperation()
x.what = work.op
x.why = 'Invalid operation'
raise x
log = SharedStruct()
log.key = logid
log.value = '%d' % (val)
self.log[logid] = log
return val
def getStruct(self, key):
print 'getStruct(%d)' % (key)
return self.log[key]
def zip(self):
print 'zip()'
if __name__ == '__main__':
handler = CalculatorHandler()
processor = Calculator.Processor(handler)
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = reactor.listenTCP(9090,
TTwisted.ThriftServerFactory(
processor, pfactory),
interface="127.0.0.1")
reactor.run()
def FdsFactory(server):
processor = fdsapi.Processor(FdsApiHandler(server))
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
return TTwisted.ThriftServerFactory(processor, pfactory)
def OtsApiFactory(topka):
processor = otsapi.Processor(OtsApiHandler(topka))
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
return TTwisted.ThriftServerFactory(processor, pfactory)
def build_factory(self):
return TTwisted.ThriftServerFactory(
processor=self.handler,
iprot_factory=TBinaryProtocol.TBinaryProtocolFactory())