mirror of
https://github.com/php-win-ext/grpc.git
synced 2026-03-24 17:12:19 +01:00
110 lines
3.3 KiB
C++
110 lines
3.3 KiB
C++
//
|
|
//
|
|
// Copyright 2023 gRPC authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
//
|
|
|
|
#include <grpcpp/grpcpp.h>
|
|
|
|
#include <condition_variable>
|
|
#include <iostream>
|
|
#include <memory>
|
|
#include <mutex>
|
|
#include <string>
|
|
#include <thread>
|
|
|
|
#include "absl/flags/flag.h"
|
|
#include "absl/flags/parse.h"
|
|
#include "absl/log/initialize.h"
|
|
|
|
#ifdef BAZEL_BUILD
|
|
#include "examples/protos/helloworld.grpc.pb.h"
|
|
#else
|
|
#include "helloworld.grpc.pb.h"
|
|
#endif
|
|
|
|
ABSL_FLAG(std::string, target, "localhost:50051", "Server address");
|
|
|
|
using grpc::Channel;
|
|
using grpc::ClientContext;
|
|
using grpc::Status;
|
|
using helloworld::Greeter;
|
|
using helloworld::HelloReply;
|
|
using helloworld::HelloRequest;
|
|
|
|
class GreeterClient {
|
|
public:
|
|
GreeterClient(std::shared_ptr<Channel> channel)
|
|
: stub_(Greeter::NewStub(channel)) {}
|
|
|
|
// Assembles the client's payload, sends it and presents the response back
|
|
// from the server.
|
|
std::string SayHello(const std::string& user, bool wait_for_ready) {
|
|
HelloRequest request;
|
|
request.set_name(user);
|
|
HelloReply reply;
|
|
ClientContext context;
|
|
context.set_wait_for_ready(wait_for_ready);
|
|
std::mutex mu;
|
|
std::condition_variable cv;
|
|
bool done = false;
|
|
Status status;
|
|
stub_->async()->SayHello(&context, &request, &reply,
|
|
[&mu, &cv, &done, &status](Status s) {
|
|
status = std::move(s);
|
|
std::lock_guard<std::mutex> lock(mu);
|
|
done = true;
|
|
cv.notify_one();
|
|
});
|
|
|
|
std::unique_lock<std::mutex> lock(mu);
|
|
while (!done) {
|
|
cv.wait(lock);
|
|
}
|
|
if (status.ok()) {
|
|
return reply.message();
|
|
} else {
|
|
std::cout << status.error_code() << ": " << status.error_message()
|
|
<< "\n";
|
|
return "RPC failed";
|
|
}
|
|
}
|
|
|
|
private:
|
|
std::unique_ptr<Greeter::Stub> stub_;
|
|
};
|
|
|
|
int main(int argc, char** argv) {
|
|
absl::ParseCommandLine(argc, argv);
|
|
absl::InitializeLog();
|
|
std::string target_str = absl::GetFlag(FLAGS_target);
|
|
GreeterClient greeter(
|
|
grpc::CreateChannel(target_str, grpc::InsecureChannelCredentials()));
|
|
std::string user("world");
|
|
// First send an RPC without wait_for_ready. If the server is not running,
|
|
// this RPC will fail immediately.
|
|
std::cout << "Greeter received: "
|
|
<< greeter.SayHello(user, /*wait_for_ready=*/false) << "\n";
|
|
std::cout << "\nWe will now send RPCs with wait_for_ready set. If the "
|
|
"server is not running already, please start it now.\n";
|
|
// Now send RPC with wait_for_ready for set. Even if the server is not
|
|
// running, the RPC will still wait for the deadline to expire before
|
|
// failing.
|
|
std::cout << "Greeter received: "
|
|
<< greeter.SayHello(user, /*wait_for_ready=*/true) << "\n";
|
|
|
|
return 0;
|
|
}
|