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);
}
