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