DataPackage RpcSocket::sendSynch(const DataPackage& output) throw(Exception) { ScopedLock lock(this->sendLock); this->isWaitingData=true; this->idOfWaitData=output.getId(); // TODO: deal with block(or timeout) this->send(output); unsigned int timeout = this->timeout + 100; if(this->timeout == 0) timeout = INFINITE; if(!this->sendLock.wait(timeout)) throwpe(TimeoutException(timeout)); DataPackage& result = this->recvPacket; if(result.getId() != output.getId()) { // if another thread send a request, idOfWaitData may changed // TODO: should we support multi-thread to send? if so, we should // add a map instead of idOfWaitData, like map<id, object(lock, value)> // when a response reached: // map(id).value=response; // map(id).lock.notify(); String msg = "Unexpected response received, there may be another "\ "thread sending a request? if so please use async-send instead!"; throwpe(RpcException(msg)); } this->isWaitingData=false; return std::move(result); }
const google::protobuf::MethodDescriptor* protobuf::socketrpc::RpcForwarder::getMethod( Request *rpcRequest, const google::protobuf::ServiceDescriptor *serviceDescriptor) { const google::protobuf::MethodDescriptor *descriptor = serviceDescriptor->FindMethodByName(rpcRequest->method_name()); if (descriptor == NULL) throw RpcException(ErrorReason::METHOD_NOT_FOUND, "Could not find method in the service"); return descriptor; }
QByteArray RpcTask::process(QByteArray req_msg) { const void *req_data = req_msg.constData(); Q_ASSERT(req_data); int req_size = req_msg.length(); Q_ASSERT(req_size); bool req_parsed = m_req.ParseFromArray(req_data, req_size); Q_ASSERT(req_parsed); if (m_req.name() == ".Reflector.Service.ack") { bool ack_parsed = m_ack_req.ParseFromString(m_req.data()); Q_ASSERT(ack_parsed); m_ack_res.set_timestamp(m_ack_req.timestamp()); m_res.set_data(m_ack_res.SerializeAsString()); } else if (m_req.name() == ".Calculator.Service.add") { bool add_parsed = m_add_req.ParseFromString(m_req.data()); Q_ASSERT(add_parsed); m_add_res.set_value(m_add_req.lhs() + m_add_req.rhs()); m_res.set_data(m_add_res.SerializeAsString()); } else if (m_req.name() == ".Calculator.Service.sub") { bool sub_parsed = m_sub_req.ParseFromString(m_req.data()); Q_ASSERT(sub_parsed); m_sub_res.set_value(m_sub_req.lhs() - m_sub_req.rhs()); m_res.set_data(m_sub_res.SerializeAsString()); } else if (m_req.name() == ".Calculator.Service.mul") { bool mul_parsed = m_mul_req.ParseFromString(m_req.data()); Q_ASSERT(mul_parsed); m_mul_res.set_value(m_mul_req.lhs() * m_mul_req.rhs()); m_res.set_data(m_mul_res.SerializeAsString()); } else if (m_req.name() == ".Calculator.Service.div") { bool mul_parsed = m_div_req.ParseFromString(m_req.data()); Q_ASSERT(mul_parsed); m_div_res.set_value(m_div_req.lhs() / m_div_req.rhs()); m_res.set_data(m_div_res.SerializeAsString()); } else { throw RpcException(QString(m_req.name().c_str()).append(": not supported")); } m_res.set_id(m_req.id()); Q_ASSERT(m_res.id() > 0); int res_size = m_res.ByteSize(); Q_ASSERT(res_size); QByteArray res_msg(res_size, 0); Q_ASSERT(res_msg.capacity() == res_size); m_res.SerializeToArray(res_msg.data(), res_size); Q_ASSERT(res_msg.size() == res_size); return res_msg; }
void protobuf::socketrpc::RpcForwarder::doRpc(Request *rpcRequest, Response *rpcResponse, google::protobuf::Closure *callback) { google::protobuf::Service *service = serviceMap.at(rpcRequest->service_name()); if (service == NULL) throw RpcException(ErrorReason::SERVICE_NOT_FOUND, "Can't find service " + rpcRequest->service_name()); SocketRpcController *socketController = new SocketRpcController(); google::protobuf::Message *response = forwardToService(rpcRequest, callback, service, socketController); rpcResponse->set_response_proto(response->SerializeAsString()); callback->Run(); delete response; delete socketController; }
P2pRpcConnection::P2pRpcConnection(cstring url, RpcService* dispatcher, AuthChecker* authChecker, cstring serializerType, unsigned int timeout, RpcSocket* sock) : url(url), rpcSocket(sock), timeout(timeout), RpcConnection(dispatcher, authChecker, serializerType) { this->url = this->url.trim(); parseUrl(this->url); //rpcSocket is null if this is a client, else not null(server). if (this->rpcSocket == null){ this->rpcSocket = RpcSocketFactory::getRpcSocket(protocol); if (this->rpcSocket == null) throwpe(RpcException("invalid url: protocol " + protocol)); } this->rpcSocket->setReceiveListener(this); }