// Class/Function Implementation
void
RunServer (AgentServerLog *logger, AgentSystem *sys_handle,
PathValidator *path_validator)
{
// This is NA grpc server address as configured by the user
std::string my_server_address;
if (global_config.running_mode == RUNNING_MODE_OFF_BOX) {
my_server_address = global_config.grpc_server_ip + ":" +
std::to_string(global_config.grpc_server_port);
} else {
my_server_address = "unix:" + global_config.grpc_server_unix_socket;
}
AgentServer service(logger, sys_handle, path_validator);
ServerBuilder builder;
// Listen on the given address without any authentication mechanism.
builder.AddListeningPort(my_server_address,
grpc::InsecureServerCredentials());
// Register "service" as the instance through which we'll communicate with
// clients. In this case it corresponds to an *synchronous* service.
builder.RegisterService(&service);
// Finally assemble the server.
std::unique_ptr<Server> server(builder.BuildAndStart());
std::cout << "Server listening on " << my_server_address << std::endl;
// Wait for the server to shutdown. Note that some other thread must be
// responsible for shutting down the server for this call to ever return.
server->Wait();
}
void RunServer(const std::string& db_path) {
std::string server_address("0.0.0.0:50051");
RouteGuideImpl service(db_path);
ServerBuilder builder;
builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
builder.RegisterService(&service);
std::unique_ptr<Server> server(builder.BuildAndStart());
std::cout << "Server listening on " << server_address << std::endl;
server->Wait();
}
int RunServer(const std::string& address, EnigmaPlugin& plugin, OptionsParser &options, CallBack &ecb) {
CompilerServiceImpl service(plugin, options, ecb);
ServerBuilder builder;
builder.AddListeningPort(address, grpc::InsecureServerCredentials());
builder.RegisterService(&service);
std::unique_ptr<Server> server(builder.BuildAndStart());
std::cout << "Server listening on " << address << std::endl;
server->Wait();
return 0;
}
ServerRunner::ServerRunner(const string & address, const vector<SynchronousService *> & services)
{
ServerBuilder builder;
builder.AddListeningPort(address, grpc::InsecureServerCredentials());
for (auto s : services){
builder.RegisterService(s);
}
unique_ptr<Server> server(builder.BuildAndStart());
cout << address << ": Server listening" << endl;
server->Wait();
}
ServerRunner::ServerRunner(const string & address, const vector<SynchronousService *> & services)
{
ServerBuilder builder;
builder.AddListeningPort(address, grpc::InsecureServerCredentials());
for (auto s : services){
builder.RegisterService(s);
}
m_server = builder.BuildAndStart();
LOG(INFO) << address << ": Server listening";
m_server->Wait();
}
void chordService::startRPCServer(std::string server_address) {
ServerBuilder builder;
// Listen on the given address without any authentication mechanism.
builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
// Register "rpc_service" as the instance through which we'll communicate with
// clients. In this case it corresponds to an *synchronous* rpc_service.
builder.RegisterService(rpc_service);
// Finally assemble the server.
std::unique_ptr<Server> server(builder.BuildAndStart());
std::string info = "RPC Server listening on " + server_address;
DEBUG_PRINT(info.c_str());
rpcserverInitialized = true;
// Wait for the server to shutdown. Note that some other thread must be
// responsible for shutting down the server for this call to ever return.
server->Wait();
}
void* RunServer(void* MY_IP_PORT) {//同步调用服务端
std::string server_address((char*)MY_IP_PORT);
dumpServiceImpl service;
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 *synchronous* service.
builder.RegisterService(&service);
// Finally assemble the server.
std::unique_ptr<Server> server(builder.BuildAndStart());
std::cout << "Server listening on " << server_address << std::endl;
// Wait for the server to shutdown. Note that some other thread must be
// responsible for shutting down the server for this call to ever return.
server->Wait();
}
void Run() {//构建一个服务器导出异步服务
ServerImpl* server=new ServerImpl();
std::string server_address("0.0.0.0:6000");
ServerBuilder builder;
builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
builder.RegisterAsyncService(&(server->service_));
server->cq_ = builder.AddCompletionQueue();
server->server_ = builder.BuildAndStart();
std::cout << "Server listening on " << server_address << std::endl;
pthread_t thdId[3];
pthread_create(&thdId[0], NULL, HandleRpcs,(void *)server);
//pthread_create(&thdId[1], NULL, HandleRpcs,(void *)server);
//pthread_create(&thdId[2], NULL, HandleRpcs,(void *)server);
int iRet = 0;
pthread_join(thdId[0],(void **)&iRet); //接收子线程的返回值*/
//pthread_join(thdId[1],(void **)&iRet); //接收子线程的返回值*/
//pthread_join(thdId[2],(void **)&iRet); //接收子线程的返回值*/
}
void HybridSimulationManager::Start()
{
GOOGLE_PROTOBUF_VERIFY_VERSION;
grpc_init();
///0.0.0.0 means to listen on all devices
string jupedsim_service_address("0.0.0.0:"+std::to_string(_config->GetServicePort()));
JPSserver service(this, _latches, _config);
_service = &service;
ServerBuilder builder;
builder.AddListeningPort(jupedsim_service_address, grpc::InsecureServerCredentials());
builder.RegisterService(&service);
_server = builder.BuildAndStart();
Log->Write("INFO:\tJPS server at port: "+std::to_string(_config->GetServicePort())+" is up and running.");
_server->Wait();
}
void server()
{
std::string server_address("0.0.0.0:50051");
TestServiceImpl service;
grpc::SslServerCredentialsOptions sslopt;
grpc::SslServerCredentialsOptions::PemKeyCertPair pair;
sslopt.pem_root_certs = loadFile("ca.cert.pem");
pair.private_key = loadFile("server.key.pem");
pair.cert_chain = loadFile("server.cert.pem");
sslopt.pem_key_cert_pairs.emplace_back(std::move(pair));
ServerBuilder builder;
builder.AddListeningPort(server_address, grpc::SslServerCredentials(sslopt));
builder.RegisterService(&service);
std::unique_ptr<Server> server(builder.BuildAndStart());
std::cout << "Server listening on " << server_address << std::endl;
server->Wait();
}
Try<Connection> MockCSIPlugin::startup(const Option<string>& address)
{
ServerBuilder builder;
if (address.isSome()) {
builder.AddListeningPort(address.get(), InsecureServerCredentials());
}
builder.RegisterService(static_cast<Identity::Service*>(this));
builder.RegisterService(static_cast<Controller::Service*>(this));
builder.RegisterService(static_cast<Node::Service*>(this));
server = builder.BuildAndStart();
if (!server) {
return Error("Unable to start a mock CSI plugin.");
}
return address.isSome()
? Connection(address.get())
: Connection(server->InProcessChannel(ChannelArguments()));
}
