mirror of https://github.com/grpc/grpc.git
The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#)
https://grpc.io/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
167 lines
5.7 KiB
167 lines
5.7 KiB
/* |
|
* |
|
* Copyright 2015 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 <memory> |
|
#include <iostream> |
|
#include <string> |
|
#include <thread> |
|
|
|
#include <grpc++/grpc++.h> |
|
#include <grpc/support/log.h> |
|
|
|
#include "helloworld.grpc.pb.h" |
|
|
|
using grpc::Server; |
|
using grpc::ServerAsyncResponseWriter; |
|
using grpc::ServerBuilder; |
|
using grpc::ServerContext; |
|
using grpc::ServerCompletionQueue; |
|
using grpc::Status; |
|
using helloworld::HelloRequest; |
|
using helloworld::HelloReply; |
|
using helloworld::Greeter; |
|
|
|
class ServerImpl final { |
|
public: |
|
~ServerImpl() { |
|
server_->Shutdown(); |
|
// Always shutdown the completion queue after the server. |
|
cq_->Shutdown(); |
|
} |
|
|
|
// There is no shutdown handling in this code. |
|
void Run() { |
|
std::string server_address("0.0.0.0:50051"); |
|
|
|
ServerBuilder builder; |
|
// Listen on the given address without any authentication mechanism. |
|
builder.AddListeningPort(server_address, grpc::InsecureServerCredentials()); |
|
// Register "service_" as the instance through which we'll communicate with |
|
// clients. In this case it corresponds to an *asynchronous* service. |
|
builder.RegisterService(&service_); |
|
// Get hold of the completion queue used for the asynchronous communication |
|
// with the gRPC runtime. |
|
cq_ = builder.AddCompletionQueue(); |
|
// Finally assemble the server. |
|
server_ = builder.BuildAndStart(); |
|
std::cout << "Server listening on " << server_address << std::endl; |
|
|
|
// Proceed to the server's main loop. |
|
HandleRpcs(); |
|
} |
|
|
|
private: |
|
// Class encompasing the state and logic needed to serve a request. |
|
class CallData { |
|
public: |
|
// Take in the "service" instance (in this case representing an asynchronous |
|
// server) and the completion queue "cq" used for asynchronous communication |
|
// with the gRPC runtime. |
|
CallData(Greeter::AsyncService* service, ServerCompletionQueue* cq) |
|
: service_(service), cq_(cq), responder_(&ctx_), status_(CREATE) { |
|
// Invoke the serving logic right away. |
|
Proceed(); |
|
} |
|
|
|
void Proceed() { |
|
if (status_ == CREATE) { |
|
// Make this instance progress to the PROCESS state. |
|
status_ = PROCESS; |
|
|
|
// As part of the initial CREATE state, we *request* that the system |
|
// start processing SayHello requests. In this request, "this" acts are |
|
// the tag uniquely identifying the request (so that different CallData |
|
// instances can serve different requests concurrently), in this case |
|
// the memory address of this CallData instance. |
|
service_->RequestSayHello(&ctx_, &request_, &responder_, cq_, cq_, |
|
this); |
|
} else if (status_ == PROCESS) { |
|
// Spawn a new CallData instance to serve new clients while we process |
|
// the one for this CallData. The instance will deallocate itself as |
|
// part of its FINISH state. |
|
new CallData(service_, cq_); |
|
|
|
// The actual processing. |
|
std::string prefix("Hello "); |
|
reply_.set_message(prefix + request_.name()); |
|
|
|
// And we are done! Let the gRPC runtime know we've finished, using the |
|
// memory address of this instance as the uniquely identifying tag for |
|
// the event. |
|
status_ = FINISH; |
|
responder_.Finish(reply_, Status::OK, this); |
|
} else { |
|
GPR_ASSERT(status_ == FINISH); |
|
// Once in the FINISH state, deallocate ourselves (CallData). |
|
delete this; |
|
} |
|
} |
|
|
|
private: |
|
// The means of communication with the gRPC runtime for an asynchronous |
|
// server. |
|
Greeter::AsyncService* service_; |
|
// The producer-consumer queue where for asynchronous server notifications. |
|
ServerCompletionQueue* cq_; |
|
// Context for the rpc, allowing to tweak aspects of it such as the use |
|
// of compression, authentication, as well as to send metadata back to the |
|
// client. |
|
ServerContext ctx_; |
|
|
|
// What we get from the client. |
|
HelloRequest request_; |
|
// What we send back to the client. |
|
HelloReply reply_; |
|
|
|
// The means to get back to the client. |
|
ServerAsyncResponseWriter<HelloReply> responder_; |
|
|
|
// Let's implement a tiny state machine with the following states. |
|
enum CallStatus { CREATE, PROCESS, FINISH }; |
|
CallStatus status_; // The current serving state. |
|
}; |
|
|
|
// This can be run in multiple threads if needed. |
|
void HandleRpcs() { |
|
// Spawn a new CallData instance to serve new clients. |
|
new CallData(&service_, cq_.get()); |
|
void* tag; // uniquely identifies a request. |
|
bool ok; |
|
while (true) { |
|
// Block waiting to read the next event from the completion queue. The |
|
// event is uniquely identified by its tag, which in this case is the |
|
// memory address of a CallData instance. |
|
// The return value of Next should always be checked. This return value |
|
// tells us whether there is any kind of event or cq_ is shutting down. |
|
GPR_ASSERT(cq_->Next(&tag, &ok)); |
|
GPR_ASSERT(ok); |
|
static_cast<CallData*>(tag)->Proceed(); |
|
} |
|
} |
|
|
|
std::unique_ptr<ServerCompletionQueue> cq_; |
|
Greeter::AsyncService service_; |
|
std::unique_ptr<Server> server_; |
|
}; |
|
|
|
int main(int argc, char** argv) { |
|
ServerImpl server; |
|
server.Run(); |
|
|
|
return 0; |
|
}
|
|
|