channel_factory.hpp

Go to the documentation of this file.

#ifndef IROHA_CHANNEL_FACTORY_HPP
#define IROHA_CHANNEL_FACTORY_HPP

#include "network/impl/channel_provider.hpp"

#include <memory>
#include <set>
#include <string>

#include <grpc++/grpc++.h>

#include "common/result.hpp"
#include "interfaces/common_objects/types.hpp"
#include "network/impl/grpc_channel_params.hpp"

namespace iroha {
  namespace network {
    namespace detail {
      grpc::ChannelArguments makeChannelArguments(
          const std::set<std::string> &services,
          const GrpcChannelParams &params);

      grpc::ChannelArguments makeInterPeerChannelArguments(
          const std::set<std::string> &services,
          const GrpcChannelParams &params);
    }  // namespace detail

    template <typename Service>
    grpc::ChannelArguments makeInterPeerChannelArguments(
        const GrpcChannelParams &params) {
      return detail::makeInterPeerChannelArguments(
          {Service::service_full_name()}, params);
    }

    template <typename Service>
    std::shared_ptr<grpc::Channel> createInsecureChannel(
        const shared_model::interface::types::AddressType &address,
        std::optional<std::reference_wrapper<GrpcChannelParams const>>
            maybe_params) {
      return createInsecureChannel(
          address, Service::service_full_name(), maybe_params);
    }

    std::shared_ptr<grpc::Channel> createInsecureChannel(
        const shared_model::interface::types::AddressType &address,
        const std::string &service_full_name,
        std::optional<std::reference_wrapper<GrpcChannelParams const>>
            maybe_params);

    template <typename Service>
    std::unique_ptr<typename Service::StubInterface> createInsecureClient(
        const std::string &address,
        std::optional<std::reference_wrapper<GrpcChannelParams const>> params) {
      return Service::NewStub(createInsecureChannel<Service>(address, params));
    }

    template <typename Service>
    std::unique_ptr<typename Service::StubInterface> createInsecureClient(
        const std::string &ip,
        size_t port,
        std::optional<std::reference_wrapper<GrpcChannelParams const>>
            maybe_params) {
      return createInsecureClient<Service>(ip + ":" + std::to_string(port),
                                           maybe_params);
    }

    class ChannelFactory : public ChannelProvider {
     public:
      ChannelFactory(
          std::optional<std::shared_ptr<const GrpcChannelParams>> maybe_params);

      ~ChannelFactory() override;

      iroha::expected::Result<std::shared_ptr<grpc::Channel>, std::string>
      getChannel(const std::string &service_full_name,
                 const shared_model::interface::Peer &peer) override;

     protected:
      virtual iroha::expected::Result<std::shared_ptr<grpc::ChannelCredentials>,
                                      std::string>
      getChannelCredentials(const shared_model::interface::Peer &) const;

     private:
      class ChannelArgumentsProvider;
      std::unique_ptr<ChannelArgumentsProvider> args_;
    };

  }  // namespace network
}  // namespace iroha

#endif