Method CallMethod

src/brpc/redis_cluster.cpp:231–289

}

void RedisClusterChannel::CallMethod(
    const google::protobuf::MethodDescriptor* /*method*/,
    google::protobuf::RpcController* controller_base,
    const google::protobuf::Message* request_base,
    google::protobuf::Message* response_base,
    google::protobuf::Closure* done) {
    Controller* cntl = static_cast<Controller*>(controller_base);
    if (cntl == NULL) {
        LOG(ERROR) << "controller is NULL";
        if (done) {
            done->Run();
        }
        return;
    }

    if (request_base == NULL ||
        request_base->GetDescriptor() != RedisRequest::descriptor()) {
        cntl->SetFailed(EREQUEST, "request must be RedisRequest");
        if (done) {
            done->Run();
        }
        return;
    }
    if (response_base == NULL ||
        response_base->GetDescriptor() != RedisResponse::descriptor()) {
        cntl->SetFailed(ERESPONSE, "response must be RedisResponse");
        if (done) {
            done->Run();
        }
        return;
    }

    const RedisRequest* request = static_cast<const RedisRequest*>(request_base);
    RedisResponse* response = static_cast<RedisResponse*>(response_base);

    if (done == NULL) {
        CallMethodImpl(cntl, *request, response);
        return;
    }

    AsyncCall* ac = new (std::nothrow) AsyncCall;
    if (ac == NULL) {
        cntl->SetFailed(ENOMEM, "Fail to allocate async context");
        done->Run();
        return;
    }
    ac->self = this;
    ac->cntl = cntl;
    ac->request = request;
    ac->response = response;
    ac->done = done;

    bthread_t tid;
    if (bthread_start_background(&tid, NULL, RedisClusterChannel::RunAsyncCall, ac) != 0) {
        delete ac;
        CallMethodImpl(cntl, *request, response);
        done->Run();
    }