tec_grpc_server.hpp

Go to the documentation of this file.

// Time-stamp: <Last changed 2026-02-20 16:19:27 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_signal.hpp"
#include "tec/tec_utils.hpp" // IWYU pragma: keep
#include "tec/tec_trace.hpp"
#include "tec/tec_actor.hpp" // IWYU pragma: keep
#include "tec/grpc/tec_grpc.hpp" // IWYU pragma: keep
 
 
namespace tec {
 
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*
*                     gRPC Server traits
*
*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
template <
    typename TService,
    typename TGrpcServer,
    typename TGrpcServerBuilder,
    typename TGrpcServerCredentials,
    typename TGrpcCompressionAlgorithm,
    typename TGrpcCompressionLevel
    >
struct grpc_server_traits {
    typedef TService                  Service;               
    typedef TGrpcServer               RpcServer;             
    typedef TGrpcServerBuilder        Builder;               
    typedef TGrpcServerCredentials    Credentials;           
    typedef TGrpcCompressionAlgorithm CompressionAlgorithm;  
    typedef TGrpcCompressionLevel     CompressionLevel;      
};
 
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*
*                     Generic gRPC Server
*
*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
template <typename TParams, typename Traits>
class GrpcServer : public Actor {
public:
    typedef TParams  Params;               
    typedef typename Traits::Service                Service;               
    typedef typename Traits::RpcServer              RpcServer;             
    typedef typename Traits::Builder                Builder;               
    typedef typename Traits::Credentials            Credentials;           
    typedef typename Traits::CompressionAlgorithm   CompressionAlgorithm;  
    typedef typename Traits::CompressionLevel       CompressionLevel;      
 
protected:
    // ── Configuration & state ───────────────────────────────────────────────
 
    Params params_;
 
    std::unique_ptr<RpcServer> server_;
 
    std::shared_ptr<Credentials> credentials_;
 
protected:
    virtual void set_plugins() {
        TEC_ENTER("GrpcServer::set_plugins");
 
        if (params_.health_check_builder.fptr) {
            params_.health_check_builder.fptr(true);
            TEC_TRACE("Health checking enabled.");
        }
        if (params_.reflection_builder.fptr) {
            params_.reflection_builder.fptr();
            TEC_TRACE("Reflection enabled.");
        }
    }
 
    virtual void set_builder_options(Builder& builder) {
        TEC_ENTER("GrpcServer::set_builder_options");
 
        // Set max message size (both send and receive)
        if (params_.max_message_size > 0) {
            const int max_size = params_.max_message_size * 1024 * 1024;
            builder.SetMaxReceiveMessageSize(max_size);
            builder.SetMaxSendMessageSize(max_size);
        }
        TEC_TRACE("MaxMessageSize is set to {} Mb.", params_.max_message_size);
 
        // Set default compression algorithm
        // Note: this overrides any compression level set by SetDefaultCompressionLevel
        if (params_.compression_algorithm > 0) {
            builder.SetDefaultCompressionAlgorithm(static_cast<CompressionAlgorithm>(params_.compression_algorithm));
        }
        TEC_TRACE("CompressionAlgorithm is set to {}.", params_.compression_algorithm);
 
        // Set default compression level
        if (params_.compression_level > 0) {
            builder.SetDefaultCompressionLevel(static_cast<CompressionLevel>(params_.compression_level));
        }
        TEC_TRACE("CompressionLevel is set to {}.", params_.compression_level);
    }
 
public:
    GrpcServer(const Params& params, const std::shared_ptr<Credentials>& credentials)
        : Actor()
        , params_{params}
        , credentials_{credentials}
    {
        static_assert(
            std::is_base_of<GrpcServerParams, Params>::value,
            "Must derive from tec::GrpcServerParams class");
    }
 
    virtual ~GrpcServer() = default;
 
    Status process_request(Request, Reply) override {
        return {tec::Error::Kind::NotImplemented};
    }
 
    void start(Signal* sig_started, Status* status) override {
        TEC_ENTER("GrpcServer::start");
 
        // Create service instance (usually synchronous)
        Service service;
 
        // Enable optional plugins
        set_plugins();
 
        Builder builder;
 
        // Bind to address with authentication
        builder.AddListeningPort(params_.addr_uri, credentials_);
 
        // Apply message size / compression settings
        set_builder_options(builder);
 
        // Register service implementation
        builder.RegisterService(&service);
 
        // Start the server
        TEC_TRACE("starting gRPC server on {} ...", params_.addr_uri);
        server_ = builder.BuildAndStart();
        if (!server_) {
            auto errmsg = format("gRPC Server cannot start on \"{}\"", params_.addr_uri);
            TEC_TRACE("!!! Error: {}.", errmsg);
            *status = {errmsg, Error::Kind::NetErr};
            sig_started->set();
            return;
        }
        TEC_TRACE("server listening on \"{}\".", params_.addr_uri);
 
        // Notify caller that server is up
        sig_started->set();
 
        // Block until shutdown is requested from another thread
        server_->Wait();
    }
 
    void shutdown(Signal* sig_stopped) override {
        TEC_ENTER("GrpcServer::shutdown");
        Signal::OnExit on_exit(sig_stopped);
        if (server_) {
            TEC_TRACE("terminating gRPC server ...");
            server_->Shutdown();
        }
    }
 
}; // GrpcServer
 
} // ::tec