tec_socket_client_nd.hpp

Go to the documentation of this file.

// Time-stamp: <Last changed 2026-02-05 02:43:24 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
 
#ifndef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200809L   // This line fixes the "storage size of ‘hints’ isn’t known" issue.
#endif
 
#include <any>
#include <cerrno>
#include <cstdlib>
 
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
 
#include "tec/tec_def.hpp"  // IWYU pragma: keep
#include "tec/tec_trace.hpp"
#include "tec/tec_status.hpp"
#include "tec/tec_message.hpp"
#include "tec/net/tec_net_data.hpp"
#include "tec/net/tec_socket_nd.hpp"
#include "tec/net/tec_socket_client.hpp"
#include "tec/net/tec_nd_compress.hpp"
 
 
namespace tec {
 
template <typename TParams>
class SocketClientNd: public SocketClient<TParams> {
public:
    using Params = TParams;
 
    explicit SocketClientNd(const Params& params)
        : SocketClient<Params>(params)
    {
    }
 
    virtual ~SocketClientNd() = default;
 
    Status process_request(Request request, Reply reply) override {
        TEC_ENTER("SocketClientNd::process_request");
        if( request.type() == typeid(const NetData::StreamIn*) &&
            reply.type() == typeid(NetData::StreamOut*)) {
            // NetData: Both request and reply are required.
            if (!request.has_value() || !reply.has_value()) {
                return {EINVAL, Error::Kind::Invalid};
            }
            const NetData::StreamIn* req = std::any_cast<const NetData::StreamIn*>(request);
            NetData::StreamOut* rep = std::any_cast<NetData::StreamOut*>(reply);
            if (req->nd == nullptr || rep->nd == nullptr) {
                return {EFAULT, Error::Kind::Invalid};
            }
            return send_recv_nd(req->nd, rep->nd);
        }
 
        // Default processing.
        return SocketClient<Params>::process_request(request, reply);
    }
 
    Status request_nd(NetData* nd_in, NetData* nd_out) {
        TEC_ENTER("SocketClientNd::request");
        auto status =  send_recv_nd(nd_in, nd_out);
        return status;
    }
 
protected:
 
    virtual Status send_nd(NetData* nd) {
        TEC_ENTER("SocketClientNd::send_nd");
        // Socket helper.
        SocketNd sock{this->sockfd_, this->params_.addr.c_str(), this->params_.port,
                      this->get_buffer(), this->get_buffer_size()};
        return SocketNd::send_nd(nd, &sock);
    }
 
    virtual Status recv_nd(NetData* nd) {
        TEC_ENTER("SocketClientNd::recv_nd");
        // Socket helper.
        SocketNd sock{this->sockfd_, this->params_.addr.c_str(), this->params_.port,
                      this->get_buffer(), this->get_buffer_size()};
        auto status = SocketNd::recv_nd(nd, &sock);
        nd->rewind();
        return status;
    }
 
    /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     *
     *                    Pre- and postprocessing
     *
     *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
    virtual Status compress(NetData* nd) {
        NdCompress cmpr(this->params_.compression,
                        this->params_.compression_level,
                        this->params_.compression_min_size);
        return cmpr.compress(*nd);
    }
 
    virtual Status uncompress(NetData* nd) {
        NdCompress cmpr(this->params_.compression,
                        this->params_.compression_level,
                        this->params_.compression_min_size);
        return cmpr.uncompress(*nd);
    }
 
    virtual Status preprocess(NetData* nd) {
        return compress(nd);
    }
 
    virtual Status postprocess(NetData* nd) {
        return uncompress(nd);
    }
 
    /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     *
     *                        Data send/receive
     *
     *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
    virtual Status send_recv_nd(NetData* nd_in, NetData* nd_out) {
        TEC_ENTER("SocketClientNd::send_recv_nd");
        //
        // Preprocess the input.
        //
        auto status = preprocess(nd_in);
        if (status) {
            //
            // Send a request.
            //
            status = send_nd(nd_in);
            if (status) {
                //
                // Receive a reply.
                //
                status = recv_nd(nd_out);
 
            }
        }
        //
        // Postprocess the output.
        //
        if (status) {
            status = postprocess(nd_out);
        }
        else {
            this->terminate();
        }
        return status;
    }
 
}; // class SocketClientNd
 
} // namespace tec