Line data    Source code

       1             : /**
       2             :  * Copyright Soramitsu Co., Ltd. All Rights Reserved.
       3             :  * SPDX-License-Identifier: Apache-2.0
       4             :  */
       5             : 
       6             : #include "main/server_runner.hpp"
       7             : 
       8             : #include <boost/format.hpp>
       9             : #include "logger/logger.hpp"
      10             : 
      11             : const auto kPortBindError = "Cannot bind server to address %s";
      12             : 
      13             : ServerRunner::ServerRunner(const std::string &address,
      14             :                            logger::LoggerPtr log,
      15             :                            bool reuse)
      16         512 :     : log_(std::move(log)), serverAddress_(address), reuse_(reuse) {}
      17             : 
      18             : ServerRunner &ServerRunner::append(std::shared_ptr<grpc::Service> service) {
      19        1261 :   services_.push_back(service);
      20        1261 :   return *this;
      21             : }
      22             : 
      23             : iroha::expected::Result<int, std::string> ServerRunner::run() {
      24         512 :   grpc::ServerBuilder builder;
      25         512 :   int selected_port = 0;
      26             : 
      27         512 :   if (not reuse_) {
      28         495 :     builder.AddChannelArgument(GRPC_ARG_ALLOW_REUSEPORT, 0);
      29         495 :   }
      30             : 
      31         512 :   builder.AddListeningPort(
      32         512 :       serverAddress_, grpc::InsecureServerCredentials(), &selected_port);
      33             : 
      34        1773 :   for (auto &service : services_) {
      35        1261 :     builder.RegisterService(service.get());
      36             :   }
      37             : 
      38             :   // in order to bypass built-it limitation of gRPC message size
      39         512 :   builder.SetMaxReceiveMessageSize(INT_MAX);
      40         512 :   builder.SetMaxSendMessageSize(INT_MAX);
      41             : 
      42         512 :   serverInstance_ = builder.BuildAndStart();
      43         512 :   serverInstanceCV_.notify_one();
      44             : 
      45         512 :   if (selected_port == 0) {
      46           1 :     return iroha::expected::makeError(
      47           1 :         (boost::format(kPortBindError) % serverAddress_).str());
      48             :   }
      49             : 
      50         511 :   return iroha::expected::makeValue(selected_port);
      51         512 : }
      52             : 
      53             : void ServerRunner::waitForServersReady() {
      54          13 :   std::unique_lock<std::mutex> lock(waitForServer_);
      55          13 :   while (not serverInstance_) {
      56           0 :     serverInstanceCV_.wait(lock);
      57             :   }
      58          13 : }
      59             : 
      60             : void ServerRunner::shutdown() {
      61           0 :   if (serverInstance_) {
      62           0 :     serverInstance_->Shutdown();
      63           0 :   } else {
      64           0 :     log_->warn("Tried to shutdown without a server instance");
      65             :   }
      66           0 : }
      67             : 
      68             : void ServerRunner::shutdown(
      69             :     const std::chrono::system_clock::time_point &deadline) {
      70         247 :   if (serverInstance_) {
      71         247 :     serverInstance_->Shutdown(deadline);
      72         247 :   } else {
      73           0 :     log_->warn("Tried to shutdown without a server instance");
      74             :   }
      75         247 : }