tec_grpc_client.hpp

Go to the documentation of this file.

// Time-stamp: <Last changed 2026-02-20 16:19:01 by magnolia>
/*----------------------------------------------------------------------
------------------------------------------------------------------------
Copyright (c) 2020-2026 The Emacs Cat (https://github.com/olddeuteronomy/tec).
 
   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.
------------------------------------------------------------------------
----------------------------------------------------------------------*/
#pragma once
 
#include "tec/tec_def.hpp" // IWYU pragma: keep
#include "tec/tec_status.hpp"
#include "tec/tec_trace.hpp"
#include "tec/tec_utils.hpp"
#include "tec/tec_actor.hpp"
#include "tec/grpc/tec_grpc.hpp" // IWYU pragma: keep
 
 
namespace tec {
 
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*
*                      gRPC Client traits
*
*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
template <
    typename TService,
    typename TGrpcChannel,
    typename TGrpcClientCredentials,
    typename TGrpcChannelArguments,
    typename TGrpcCompressionAlgorithm
    >
struct grpc_client_traits {
    typedef TService                Service;               
    typedef TGrpcChannel            Channel;               
    typedef TGrpcClientCredentials  Credentials;           
    typedef TGrpcChannelArguments   Arguments;             
    typedef TGrpcCompressionAlgorithm CompressionAlgorithm; 
};
 
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*
*                          gRPC client
*
*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
template <typename TParams, typename Traits>
class GrpcClient : public Actor {
public:
    typedef Traits   traits;               
    typedef TParams  Params;               
    typedef typename traits::Service                Service;               
    typedef typename traits::Channel                Channel;               
    typedef typename traits::Credentials            Credentials;           
    typedef typename traits::Arguments              Arguments;             
    typedef typename traits::CompressionAlgorithm   CompressionAlgorithm;  
 
    struct ChannelBuilder {
        std::shared_ptr<Channel> (*fptr)(const std::string&,
                                        const std::shared_ptr<Credentials>&,
                                        const Arguments&);
    };
 
protected:
    // ── Configuration & state ───────────────────────────────────────────────
 
    Params params_;
 
    std::shared_ptr<Credentials> credentials_;
 
    std::unique_ptr<typename Service::Stub> stub_;
 
    ChannelBuilder channel_builder_;
 
    std::shared_ptr<Channel> channel_;
 
    Arguments arguments_;
 
protected:
    virtual void set_channel_arguments() {
        TEC_ENTER("GrpcClient::set_channel_arguments");
 
        // Maximum message size, see tec::kGrpcMaxMessageSize
        if (params_.max_message_size > 0) {
            // Convert MB → bytes
            const int max_size = params_.max_message_size * 1024 * 1024;
            arguments_.SetMaxSendMessageSize(max_size);
            arguments_.SetMaxReceiveMessageSize(max_size);
        }
        TEC_TRACE("MaxMessageSize is set to {} Mb.", params_.max_message_size);
 
        // Compression algorithm
        // GRPC_COMPRESS_NONE = 0, GRPC_COMPRESS_DEFLATE, GRPC_COMPRESS_GZIP, ...
        if (params_.compression_algorithm > 0) {
            arguments_.SetCompressionAlgorithm(static_cast<CompressionAlgorithm>(params_.compression_algorithm));
        }
        TEC_TRACE("CompressionAlgorithm is set to {}.", params_.compression_algorithm);
    }
 
public:
    GrpcClient(const Params& params,
               const ChannelBuilder& channel_builder,
               const std::shared_ptr<Credentials>& credentials)
        : Actor()
        , params_{params}
        , channel_builder_{channel_builder}
        , credentials_{credentials}
    {
        static_assert(
            std::is_base_of<GrpcClientParams, Params>::value,
            "Must be derived from tec::GrpcClientParams class");
    }
 
    virtual ~GrpcClient() = default;
 
    void start(Signal* sig_started, Status* status) override {
        TEC_ENTER("GrpcClient::start");
        Signal::OnExit on_exit(sig_started);
 
        // Prepare channel creation arguments
        set_channel_arguments();
 
        // Create channel (may return "lame" channel on error)
        channel_ = channel_builder_.fptr(params_.addr_uri, credentials_, arguments_);
        TEC_TRACE("Connecting to {} ...", params_.addr_uri);
 
        // Wait for connection with timeout
        auto deadline = std::chrono::system_clock::now() + params_.connect_timeout;
        if (!channel_->WaitForConnected(deadline)) {
            std::string msg{format(
                    "It took too long (> {} ms) to reach out the server on \"{}\"",
                    MilliSec{params_.connect_timeout}.count(), params_.addr_uri)};
            TEC_TRACE("!!! Error: {}.", msg);
            *status = {msg, Error::Kind::NetErr};
            return;
        }
 
        // Create service stub
        stub_ = Service::NewStub(channel_);
        TEC_TRACE("connected to {} OK.", params_.addr_uri);
    }
 
    void shutdown(Signal* sig_stopped) override {
        TEC_ENTER("GrpcClient::shutdown");
        Signal::OnExit on_exit{sig_stopped};
        TEC_TRACE("closed OK.");
    }
 
    virtual Status process_request(Request request, Reply reply) override {
        // Must be implemented in derived class.
        return {Error::Kind::NotImplemented};
    }
}; // class GrpcClient
 
} // ::tec