|
|
|
@ -54,42 +54,49 @@ class GreeterClient { |
|
|
|
|
explicit GreeterClient(std::shared_ptr<Channel> channel) |
|
|
|
|
: stub_(Greeter::NewStub(channel)) {} |
|
|
|
|
|
|
|
|
|
// Assambles the client's payload, sends it and presents the response back
|
|
|
|
|
// from the server.
|
|
|
|
|
// Assembles the client's payload and sends it to the server.
|
|
|
|
|
void SayHello(const std::string& user) { |
|
|
|
|
// Data we are sending to the server.
|
|
|
|
|
HelloRequest request; |
|
|
|
|
request.set_name(user); |
|
|
|
|
|
|
|
|
|
// Call object to store rpc data
|
|
|
|
|
AsyncClientCall* call = new AsyncClientCall; |
|
|
|
|
|
|
|
|
|
// stub_->AsyncSayHello() perform the RPC call, returning an instance we
|
|
|
|
|
// store in "rpc". Because we are using the asynchronous API, we need the
|
|
|
|
|
// hold on to the "rpc" instance in order to get updates on the ongoing RPC.
|
|
|
|
|
// stub_->AsyncSayHello() performs the RPC call, returning an instance to
|
|
|
|
|
// store in "call". Because we are using the asynchronous API, we need to
|
|
|
|
|
// hold on to the "call" instance in order to get updates on the ongoing RPC.
|
|
|
|
|
call->response_reader = stub_->AsyncSayHello(&call->context, request, &cq_); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Request that, upon completion of the RPC, "reply" be updated with the
|
|
|
|
|
// server's response; "status" with the indication of whether the operation
|
|
|
|
|
// was successful. Tag the request with the memory address of call object.
|
|
|
|
|
// was successful. Tag the request with the memory address of the call object.
|
|
|
|
|
call->response_reader->Finish(&call->reply, &call->status, (void*)call); |
|
|
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Loop while listening for completed responses
|
|
|
|
|
void AsyncCompleteRpc() |
|
|
|
|
{ |
|
|
|
|
// Loop while listening for completed responses.
|
|
|
|
|
// Prints out the response from the server.
|
|
|
|
|
void AsyncCompleteRpc() { |
|
|
|
|
void* got_tag; |
|
|
|
|
bool ok = false; |
|
|
|
|
|
|
|
|
|
// Block until the next result is available in the completion queue "cq".
|
|
|
|
|
while (cq_.Next(&got_tag, &ok)) |
|
|
|
|
{ |
|
|
|
|
while (cq_.Next(&got_tag, &ok)) { |
|
|
|
|
// The tag in this example is the memory location of the call object
|
|
|
|
|
AsyncClientCall* call = static_cast<AsyncClientCall*>(got_tag); |
|
|
|
|
if (ok) |
|
|
|
|
|
|
|
|
|
// Verify that the request was completed successfully. Note that "ok"
|
|
|
|
|
// corresponds solely to the request for updates introduced by Finish().
|
|
|
|
|
GPR_ASSERT(ok); |
|
|
|
|
|
|
|
|
|
if (call->status.ok()) |
|
|
|
|
std::cout << "Greeter received: " << call->reply.message() << std::endl; |
|
|
|
|
else |
|
|
|
|
std::cout << "RPC failed" << std::endl; |
|
|
|
|
|
|
|
|
|
// Once we're complete, deallocate the call object.
|
|
|
|
|
delete call; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
@ -97,8 +104,7 @@ class GreeterClient { |
|
|
|
|
private: |
|
|
|
|
|
|
|
|
|
// struct for keeping state and data information
|
|
|
|
|
struct AsyncClientCall |
|
|
|
|
{ |
|
|
|
|
struct AsyncClientCall { |
|
|
|
|
// Container for the data we expect from the server.
|
|
|
|
|
HelloReply reply; |
|
|
|
|
|
|
|
|
@ -135,8 +141,7 @@ int main(int argc, char** argv) { |
|
|
|
|
// Spawn reader thread that loops indefinitely
|
|
|
|
|
std::thread thread_ = std::thread(&GreeterClient::AsyncCompleteRpc, &greeter); |
|
|
|
|
|
|
|
|
|
for (int i = 0; i < 100; i++) |
|
|
|
|
{ |
|
|
|
|
for (int i = 0; i < 100; i++) { |
|
|
|
|
std::string user("world " + std::to_string(i)); |
|
|
|
|
greeter.SayHello(user); // The actual RPC call!
|
|
|
|
|
} |
|
|
|
|