def string_received(self, data):
rpc = Rpc()
rpc.ParseFromString(data)
for serializedRequest in rpc.request:
service = self.server.services[serializedRequest.method.split('.')
[0]]
method = service.GetDescriptor().FindMethodByName(
serializedRequest.method.split('.')[1])
if method:
request = service.GetRequestClass(method)()
request.ParseFromString(serializedRequest.serialized_request)
controller = Controller()
class callbackClass(object):
def __init__(self):
self.response = None
def __call__(self, response):
self.response = response
callback = callbackClass()
service.CallMethod(method, controller, request, callback)
responseRpc = self.serialize_rpc(
self.serialize_response(callback.response,
serializedRequest))
self.send_string(responseRpc.SerializeToString())
def run(self):
with self._conn:
block_chan = BlockChannel(self._conn)
while True:
meta_buffer, data_buffer = block_chan.next_block()
status, meta = self._protocol.unpack(meta_buffer)
if not status:
logger.error("fail to unpack buffer for %s" % meta.reason)
continue
full_class, method = self.split_method(meta.method)
if not full_class:
logger.error("class name is None,the method is %s" %
meta.method)
continue
service = self._service_router.get(full_class, None)
if not service:
logger.error("no service for class name %s" % full_class)
continue
method_func = service.GetDescriptor().FindMethodByName(method)
if not method_func:
logger.error("no matched method %s in class %s" %
(method, full_class))
continue
req_class = service.GetRequestClass(method_func)
if not req_class:
logger.error("no matched req class ")
continue
req = req_class()
req.ParseFromString(data_buffer)
response = service.CallMethod(method_func, None, req, None)
self.do_response(response, meta.sequence_id, block_chan)
def stringReceived(self, data):
rpc = Rpc()
rpc.ParseFromString(data)
for serializedRequest in rpc.request:
service = self._services[serializedRequest.method.split('.')[0]]
if not service:
self.sendError(serializedRequest.id,
RpcErrors.SERVICE_NOT_FOUND)
return
method = service.GetDescriptor().FindMethodByName(
serializedRequest.method.split('.')[1])
if not method:
self.sendError(serializedRequest.id, RpcErrors.METHOD_NOT_FOUND)
return
request = service.GetRequestClass(method)()
request.ParseFromString(serializedRequest.serialized_request)
controller = Controller(peer=self.transport.getPeer())
d = Deferred()
d.addCallback(self.serialize_response, serializedRequest,
controller)
d.addCallback(self.serialize_rpc)
d.addCallback(lambda rpc: self.sendString(rpc.SerializeToString()))
service.CallMethod(method, controller, request, d.callback)
for serializedResponse in rpc.response:
_id = serializedResponse.id
if _id in self._pending:
self._pending[_id].callback(serializedResponse)
class UdpChannel(BaseChannel, DatagramProtocol):
def __init__(self, host=None, port=None):
self._host = host
self._port = port
self.connected = False
BaseChannel.__init__(self)
def startProtocol(self):
if self._host and self._port:
self.transport.connect(self._host, self._port)
self.connected = True
def datagramReceived(self, data, (host, port)):
rpc = Rpc()
rpc.ParseFromString(data)
for serializedRequest in rpc.request:
service = self._services[serializedRequest.method.split('.')[0]]
if not service:
self.sendError(serializedRequest.id,
RpcErrors.SERVICE_NOT_FOUND, host, port)
return
method = service.GetDescriptor().FindMethodByName(
serializedRequest.method.split('.')[1])
if not method:
self.sendError(serializedRequest.id,
RpcErrors.METHOD_NOT_FOUND, host, port)
return
request = service.GetRequestClass(method)()
request.ParseFromString(serializedRequest.serialized_request)
controller = Controller()
d = Deferred()
d.addCallback(self.serialize_response, serializedRequest)
d.addCallback(self.serialize_rpc)
d.addCallback(lambda rpc: self.send_string(rpc.SerializeToString(),
host, port))
service.CallMethod(method, controller, request, d.callback)
for serializedResponse in rpc.response:
id = serializedResponse.id
if self._pending.has_key(id):
self._pending[id].callback(serializedResponse)
async def call(self, rpc):
service = self.manager.get_service(rpc.request.service)
method = service.GetDescriptor().FindMethodByName(rpc.request.method)
request_args = service.GetRequestClass(method)()
request_args.ParseFromString(rpc.request.args)
controller = None
callback = self.ResponseCallback(rpc.sid)
# synchronously call method
co = service.CallMethod(method, controller, request_args, callback)
# await if method is a coroutine, i.e. asynchronous method
if asyncio.iscoroutine(co):
await co
# send response
if callback.response:
await self.send_response(callback.sid, callback.response)
def serveOneClient(self, service):
(clientsocket, address) = self.serversocket.accept()
print "got connection from", address
while True:
message = decode(clientsocket)
if not message:
clientsocket.close()
break
assert message.type == rpc_pb2.REQUEST
assert message.service == service.GetDescriptor().name
method = service.GetDescriptor().FindMethodByName(message.method)
request_class = service.GetRequestClass(method)
request = request_class()
request.ParseFromString(message.request)
response = service.CallMethod(method, None, request, None)
responseMessage = rpc_pb2.RpcMessage()
responseMessage.type = rpc_pb2.RESPONSE
responseMessage.id = message.id
responseMessage.response = response.SerializeToString()
wire = encode(responseMessage)
clientsocket.sendall(wire)
print "connection is down", address
