IfImpl.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_IFIMPL_HXX_
#define _OPENLCB_IFIMPL_HXX_
 
#include "openlcb/If.hxx"
 
namespace openlcb
{
 
class WriteFlowBase : public StateFlow<Buffer<GenMessage>, QList<4>>
{
public:
    WriteFlowBase(If *async_if)
        : StateFlow<Buffer<GenMessage>, QList<4>>(async_if)
    {
    }
 
protected:
    virtual Action send_to_hardware() = 0;
 
    virtual Action send_to_local_node();
 
    virtual Action send_finished()
    {
        return release_and_exit();
    }
 
    If *async_if()
    {
        return static_cast<If *>(service());
    }
 
    // void cleanup();
 
    GenMessage *nmsg()
    {
        return message()->data();
    }
 
protected:
    /*    /// Entry point for external callers.
        virtual void WriteAddressedMessage(Defs::MTI mti, NodeID src, NodeHandle
       dst,
                                           Buffer* data, Notifiable* done)
        {
            HASSERT(IsNotStarted());
            Restart(done);
            mti_ = mti;
            src_ = src;
            dst_ = dst;
            dstNode_ = nullptr;
            data_ = data;
            StartFlowAt(STATE(maybe_send_to_local_node));
        }
 
        virtual void WriteGlobalMessage(Defs::MTI mti, NodeID src, Buffer* data,
                                        Notifiable* done)
        {
            HASSERT(IsNotStarted());
            Restart(done);
            mti_ = mti;
            src_ = src;
            dst_.id = 0;
            dst_.alias = 0;
            dstNode_ = nullptr;
            data_ = data;
            StartFlowAt(STATE(send_to_local_nodes));
        }
    */
 
    Action addressed_entry();
    Action global_entry();
};
 
class VerifyNodeIdHandler : public IncomingMessageStateFlow
{
public:
    VerifyNodeIdHandler(If *service) : IncomingMessageStateFlow(service)
    {
        iface()->dispatcher()->register_handler(
            this, Defs::MTI_VERIFY_NODE_ID_GLOBAL &
                      Defs::MTI_VERIFY_NODE_ID_ADDRESSED,
            0xffff & ~(Defs::MTI_VERIFY_NODE_ID_GLOBAL ^
                       Defs::MTI_VERIFY_NODE_ID_ADDRESSED));
    }
 
    ~VerifyNodeIdHandler()
    {
        iface()->dispatcher()->unregister_handler(
            this, Defs::MTI_VERIFY_NODE_ID_GLOBAL &
                      Defs::MTI_VERIFY_NODE_ID_ADDRESSED,
            0xffff & ~(Defs::MTI_VERIFY_NODE_ID_GLOBAL ^
                       Defs::MTI_VERIFY_NODE_ID_ADDRESSED));
    }
 
    Action entry() override
    {
        GenMessage *m = message()->data();
        if (m->dst.id)
        {
            // Addressed message.
            srcNode_ = m->dstNode;
            it_ = iface()->localNodes_.end();
        }
        else if (!m->payload.empty() && m->payload.size() == 6)
        {
            // Global message with a node id included
            NodeID id = buffer_to_node_id(m->payload);
            srcNode_ = iface()->lookup_local_node(id);
            if (!srcNode_)
            {
                // Someone looking for a node that's not on this interface.
                return release_and_exit();
            }
#ifndef SIMPLE_NODE_ONLY
            it_ = iface()->localNodes_.end();
#endif
        }
        else
        {
// Global message. Everyone should respond.
#ifdef SIMPLE_NODE_ONLY
            // We assume there can be only one local node.
            If::VNodeMap::Iterator it = iface()->localNodes_.begin();
            if (it == iface()->localNodes_.end())
            {
                // No local nodes.
                return release_and_exit();
            }
            srcNode_ = it->second;
            ++it;
            HASSERT(it == iface()->localNodes_.end());
#else
            // We need to do an iteration over all local nodes.
            it_ = iface()->localNodes_.begin();
            if (it_ == iface()->localNodes_.end())
            {
                // No local nodes.
                return release_and_exit();
            }
            srcNode_ = it_->second;
            ++it_;
#endif // not simple node.
        }
        if (srcNode_)
        {
            release();
            return allocate_and_call(iface()->global_message_write_flow(),
                                     STATE(send_response));
        }
        LOG(WARNING, "node pointer not found.");
        return release_and_exit();
    }
 
#ifdef SIMPLE_NODE_ONLY
    Action send_response()
    {
        auto *b =
            get_allocation_result(iface()->global_message_write_flow());
        GenMessage *m = b->data();
        NodeID id = srcNode_->node_id();
        m->reset(Defs::MTI_VERIFIED_NODE_ID_NUMBER, id, node_id_to_buffer(id));
        iface()->global_message_write_flow()->send(b);
        return exit();
    }
#else
    Action send_response()
    {
        auto *b =
            get_allocation_result(iface()->global_message_write_flow());
        GenMessage *m = b->data();
        // This is called on the main executor of the interface, this we are
        // allowed to access the local nodes cache.
        NodeID id = srcNode_->node_id();
        LOG(VERBOSE, "Sending verified reply from node %012" PRIx64, id);
        m->reset(Defs::MTI_VERIFIED_NODE_ID_NUMBER, id, node_id_to_buffer(id));
        iface()->global_message_write_flow()->send(b);
 
        if (it_ != iface()->localNodes_.end())
        {
            srcNode_ = it_->second;
            ++it_;
            return allocate_and_call(iface()->global_message_write_flow(),
                                     STATE(send_response));
        }
        else
        {
            return exit();
        }
    }
#endif // not simple node
 
private:
    Node *srcNode_;
 
#ifndef SIMPLE_NODE_ONLY
    If::VNodeMap::Iterator it_;
#endif
};
 
class UnhandledAddressedMessageHandler : public IncomingMessageStateFlow
{
public:
    UnhandledAddressedMessageHandler(If *service)
        : IncomingMessageStateFlow(service)
    {
        iface()->dispatcher()->register_fallback_handler(this);
    }
 
    Action entry() override
    {
        if (!message()->data()->dstNode)
        {
            // Destination is not a local node.
            return release_and_exit();
        }
        auto mti = message()->data()->mti;
        if (mti == Defs::MTI_OPTIONAL_INTERACTION_REJECTED ||
            mti == Defs::MTI_TERMINATE_DUE_TO_ERROR) {
            // We don't generate an OIR for an incoming error report, as this
            // generally would cause an infinite bouncing of error reports back
            // and forth between two OpenMRN nodes.
            return release_and_exit();
        }
        return allocate_and_call(
            iface()->addressed_message_write_flow(), STATE(fill_oir));
    }
 
    Action fill_oir()
    {
        auto rb = get_buffer_deleter(
            get_allocation_result(iface()->addressed_message_write_flow()));
        GenMessage *inm = message()->data();
        GenMessage *outm = rb->data();
        outm->reset(Defs::MTI_OPTIONAL_INTERACTION_REJECTED,
            inm->dstNode->node_id(), inm->src,
            error_payload(Defs::ERROR_UNIMPLEMENTED, inm->mti));
        iface()->addressed_message_write_flow()->send(rb.release());
        return release_and_exit();
    }
};
 
} // namespace openlcb
 
#endif // _OPENLCB_IFIMPL_HXX_