def createService(self, path, serviceFunc, headers=None):
transport = THttpClient(f"https://gd2.line.naver.jp{path}")
if headers is None:
headers = {
"X-Line-Application": self.account.getLineApplication(),
"User-Agent": self.account.getUserAgent(),
"X-Line-Access": self.account.getAuthToken(),
}
# setting the headers for the transport
transport.setCustomHeaders(headers)
# initiating the factory for CompactProtocol
factory = TCompactProtocolFactory()
# getting the CompactProtocol
protocol = factory.getProtocol(transport)
# initiating a new client using the protocol provided
return serviceFunc.Client(protocol)
async def g(*args, **kwargs):
if conf.IS_FAILOVER:
if downgrade:
return await f(None, *args, **kwargs)
else:
return None
res = None
opened = False
re_conn = TTornado.TTornadoStreamTransport(conf.CONTENT_SVC['HOST'], conf.CONTENT_SVC['PORT'])
try:
re_conn.open()
opened = True
tclient = RecommendService.Client(re_conn, TCompactProtocolFactory())
res = await timeout(f(tclient, *args, **kwargs), TIMEOUT)
except Exception as e:
logger.error(f"{kwargs['log_id']} {e}")
# 降级到Redis中取数据
if downgrade:
res = await timeout(f(None, *args, **kwargs), 1)
finally:
if opened:
re_conn.close()
return res
def get_protocol_factory(protocol):
"""
Returns a protocol factory associated with the string protocol passed in
as a command line argument to the cross runner
:param protocol: string
:return: Protocol factory
"""
if protocol == "binary":
return FProtocolFactory(TBinaryProtocolFactory())
elif protocol == "compact":
return FProtocolFactory(TCompactProtocolFactory())
elif protocol == "json":
return FProtocolFactory(TJSONProtocolFactory())
else:
logging.error("Unknown protocol type: %s", protocol)
sys.exit(1)
async def g(*args, **kwargs):
if conf.IS_FAILOVER:
return None
res = None
opened = False
di_conn = TTornado.TTornadoStreamTransport(conf.DI_CONTENT_SVC['HOST'], conf.DI_CONTENT_SVC['PORT'])
try:
di_conn.open()
opened = True
diclient = DIService.Client(di_conn, TCompactProtocolFactory())
res = await timeout(f(diclient, *args, **kwargs), TIMEOUT)
except Exception as e:
logger.error(f"{kwargs['log_id']} {e}")
finally:
if opened:
di_conn.close()
return res
def main():
parser = argparse.ArgumentParser(description="Run a tornado python server")
parser.add_argument('--port', dest='port', default='9090')
parser.add_argument('--protocol',
dest='protocol_type',
default="binary",
choices="binary, compact, json")
parser.add_argument('--transport',
dest="transport_type",
default="stateless",
choices="stateless, http")
args = parser.parse_args()
if args.protocol_type == "binary":
protocol_factory = FProtocolFactory(TBinaryProtocolFactory())
elif args.protocol_type == "compact":
protocol_factory = FProtocolFactory(TCompactProtocolFactory())
elif args.protocol_type == "json":
protocol_factory = FProtocolFactory(TJSONProtocolFactory())
else:
logging.error("Unknown protocol type: %s", args.protocol_type)
sys.exit(1)
nats_client = NATS()
options = {"verbose": True, "servers": ["nats://127.0.0.1:4222"]}
yield nats_client.connect(**options)
global port
port = args.port
handler = FrugalTestHandler()
subject = "frugal.*.*.rpc.{}".format(args.port)
processor = Processor(handler)
if args.transport_type == "stateless":
server = FNatsServer(nats_client, [subject], processor,
protocol_factory)
# start healthcheck so the test runner knows the server is running
thread.start_new_thread(healthcheck, (port, ))
print("Starting {} server...".format(args.transport_type))
yield server.serve()
elif args.transport_type == "http":
factories = {
'processor': processor,
'protocol_factory': protocol_factory
}
server = Application([(r'/', FHttpHandler, factories)])
print("Starting {} server...".format(args.transport_type))
server.listen(port)
else:
logging.error("Unknown transport type: %s", args.transport_type)
sys.exit(1)
# Setup subscriber, send response upon receipt
pub_transport_factory = FNatsPublisherTransportFactory(nats_client)
sub_transport_factory = FNatsSubscriberTransportFactory(nats_client)
provider = FScopeProvider(pub_transport_factory, sub_transport_factory,
protocol_factory)
global publisher
publisher = EventsPublisher(provider)
yield publisher.open()
@gen.coroutine
def response_handler(context, event):
print("received {} : {}".format(context, event))
preamble = context.get_request_header(PREAMBLE_HEADER)
if preamble is None or preamble == "":
logging.error("Client did not provide preamble header")
return
ramble = context.get_request_header(RAMBLE_HEADER)
if ramble is None or ramble == "":
logging.error("Client did not provide ramble header")
return
response_event = Event(Message="Sending Response")
response_context = FContext("Call")
global publisher
global port
yield publisher.publish_EventCreated(response_context, preamble,
ramble, "response",
"{}".format(port), response_event)
print("Published event={}".format(response_event))
subscriber = EventsSubscriber(provider)
yield subscriber.subscribe_EventCreated("*", "*", "call",
"{}".format(args.port),
response_handler)
def test_TCompactProtocol(self):
factory = TCompactProtocolFactory()
self.verify(self.compact_serialized, factory)