SNIPClient.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_SNIPCLIENT_HXX_
#define _OPENLCB_SNIPCLIENT_HXX_
 
#include "executor/CallableFlow.hxx"
#include "openlcb/Defs.hxx"
#include "openlcb/If.hxx"
#include "os/sleep.h"
 
namespace openlcb
{
 
struct SNIPClientRequest : public CallableFlowRequestBase
{
    void reset(Node *src, NodeHandle dst)
    {
        reset_base();
        resultCode = OPERATION_PENDING;
        src_ = src;
        dst_ = dst;
    }
 
    enum
    {
        OPERATION_PENDING = 0x20000, //< cleared when done is called.
        ERROR_REJECTED = 0x200000,   //< Target node has rejected the request.
        OPENMRN_TIMEOUT = 0x80000,   //< Timeout waiting for ack/nack.
    };
 
    Node *src_;
    NodeHandle dst_;
    Payload response;
};
 
#if !defined(GTEST) || !defined(SNIP_CLIENT_TIMEOUT_NSEC)
static constexpr long long SNIP_CLIENT_TIMEOUT_NSEC = MSEC_TO_NSEC(2000);
#endif
 
class SNIPClient : public CallableFlow<SNIPClientRequest>
{
public:
    SNIPClient(Service *s)
        : CallableFlow<SNIPClientRequest>(s)
    {
    }
 
    void shutdown()
    {
        while (!is_waiting())
        {
            service()->executor()->sync_run(
                [this]() { timer_.ensure_triggered(); });
            microsleep(500);
        }
    }
 
    Action entry() override
    {
        request()->resultCode = SNIPClientRequest::OPERATION_PENDING;
        return allocate_and_call(
            iface()->addressed_message_write_flow(), STATE(write_request));
    }
 
private:
    enum
    {
        MTI_1a = Defs::MTI_TERMINATE_DUE_TO_ERROR,
        MTI_1b = Defs::MTI_OPTIONAL_INTERACTION_REJECTED,
        MASK_1 = ~(MTI_1a ^ MTI_1b),
        MTI_1 = MTI_1a,
 
        MTI_2 = Defs::MTI_IDENT_INFO_REPLY,
        MASK_2 = Defs::MTI_EXACT,
    };
 
    Action write_request()
    {
        auto *b =
            get_allocation_result(iface()->addressed_message_write_flow());
        b->data()->reset(Defs::MTI_IDENT_INFO_REQUEST,
            request()->src_->node_id(), request()->dst_, EMPTY_PAYLOAD);
 
        iface()->dispatcher()->register_handler(
            &responseHandler_, MTI_1, MASK_1);
        iface()->dispatcher()->register_handler(
            &responseHandler_, MTI_2, MASK_2);
 
        iface()->addressed_message_write_flow()->send(b);
 
        return sleep_and_call(
            &timer_, SNIP_CLIENT_TIMEOUT_NSEC, STATE(response_came));
    }
 
    void handle_response(Buffer<GenMessage> *message)
    {
        auto rb = get_buffer_deleter(message);
        if (request()->src_ != message->data()->dstNode ||
            !iface()->matching_node(request()->dst_, message->data()->src))
        {
            // Not from the right place.
            return;
        }
        if (message->data()->mti == Defs::MTI_OPTIONAL_INTERACTION_REJECTED ||
            message->data()->mti == Defs::MTI_TERMINATE_DUE_TO_ERROR)
        {
            uint16_t mti, error_code;
            buffer_to_error(
                message->data()->payload, &error_code, &mti, nullptr);
            LOG(INFO, "rejection err %04x mti %04x", error_code, mti);
            if (mti && mti != Defs::MTI_IDENT_INFO_REQUEST)
            {
                // Got error response for a different interaction. Ignore.
                return;
            }
            request()->resultCode =
                error_code | SNIPClientRequest::ERROR_REJECTED;
        }
        else if (message->data()->mti == Defs::MTI_IDENT_INFO_REPLY)
        {
            request()->response = std::move(message->data()->payload);
            request()->resultCode = 0;
        }
        else
        {
            // Dunno what this MTI is. Ignore.
            LOG(INFO, "Unexpected MTI for SNIP response handler: %04x",
                message->data()->mti);
            return;
        }
        // Wakes up parent flow.
        request()->resultCode &= ~SNIPClientRequest::OPERATION_PENDING;
        timer_.trigger();
    }
 
    Action response_came()
    {
        iface()->dispatcher()->unregister_handler_all(&responseHandler_);
        if (request()->resultCode & SNIPClientRequest::OPERATION_PENDING)
        {
            return return_with_error(SNIPClientRequest::OPENMRN_TIMEOUT);
        }
        return return_with_error(request()->resultCode);
    }
 
    If *iface()
    {
        return request()->src_->iface();
    }
 
    StateFlowTimer timer_ {this};
    IncomingMessageStateFlow::GenericHandler responseHandler_ {
        this, &SNIPClient::handle_response};
};
 
} // namespace openlcb
 
#endif // _OPENLCB_SNIPCLIENT_HXX_