NodeInitializeFlow.hxx

 
#ifndef _OPENLCB_NODEINITIALIZEFLOW_HXX_
#define _OPENLCB_NODEINITIALIZEFLOW_HXX_
 
#include "openlcb/DefaultNode.hxx"
#include "openlcb/If.hxx"
#include "nmranet_config.h"
#include "utils/Singleton.hxx"
 
namespace openlcb
{
 
struct InitializeRequest
{
    InitializeRequest()
        : node(nullptr)
    {
    }
    Node *node;
};
 
typedef StateFlow<Buffer<InitializeRequest>, QList<1>> InitializeFlowBase;
 
class InitializeFlow : public InitializeFlowBase,
                       public Singleton<InitializeFlow>
{
public:
    InitializeFlow(Service *service)
        : InitializeFlowBase(service)
    {
    }
 
    ~InitializeFlow();
 
private:
    Node *node()
    {
        return message()->data()->node;
    }
 
    Action entry() OVERRIDE
    {
        if (!node())
        {
            return release_and_exit();
        }
        HASSERT(message()->data()->node);
        return allocate_and_call(
            node()->iface()->global_message_write_flow(),
            STATE(send_initialized));
    }
 
    Action send_initialized()
    {
        auto *b = get_allocation_result(
            node()->iface()->global_message_write_flow());
        done_.reset(this);
        NodeID id = node()->node_id();
        b->data()->reset(
            Defs::MTI_INITIALIZATION_COMPLETE, id, node_id_to_buffer(id));
        b->data()->set_flag_dst(GenMessage::WAIT_FOR_LOCAL_LOOPBACK);
        b->set_done(&done_);
        node()->iface()->global_message_write_flow()->send(
            b, b->data()->priority());
        return wait_and_call(STATE(initialization_complete));
    }
 
    Action initialization_complete()
    {
        node()->set_initialized();
        return call_immediately(STATE(identify_events));
    }
 
    Action identify_events()
    {
        if (config_node_init_identify() != CONSTANT_TRUE)
        {
            return release_and_exit();
        }
        // Get the dispatch flow.
        return allocate_and_call(
            node()->iface()->dispatcher(), STATE(initiate_local_identify));
    }
 
    Action initiate_local_identify()
    {
        auto *b = get_allocation_result(node()->iface()->dispatcher());
        b->set_done(done_.reset(this));
        GenMessage *m = b->data();
        m->mti = Defs::MTI_EVENTS_IDENTIFY_ADDRESSED;
        m->payload.clear();
        m->dst.id = node()->node_id();
        m->dstNode = node();
        m->src.alias = 0;
        m->src.id = node()->node_id();
        node()->iface()->dispatcher()->send(b, b->data()->priority());
        return wait_and_call(STATE(wait_for_local_identify));
    }
 
    Action wait_for_local_identify()
    {
        return release_and_exit();
    }
 
    BarrierNotifiable done_;
};
 
void StartInitializationFlow(Node *node);
 
class ReinitAllNodes : public StateFlowBase {
public:
    ReinitAllNodes(If* iface) : StateFlowBase(iface) {
        nextNode_ = iface->first_local_node();
        start_flow(STATE(allocate_entry));
    }
 
private:
    Action allocate_entry() {
        if (!nextNode_) {
            return delete_this();
        }
        return allocate_and_call(tgt(), STATE(send_init_request));
    }
 
    Action send_init_request() {
        auto* b = get_allocation_result(tgt());
        b->data()->node = nextNode_;
        b->set_done(bn_.reset(this));
        tgt()->send(b);
        return wait_and_call(STATE(init_done));
    }
 
    Action init_done() {
        nextNode_ = iface()->next_local_node(nextNode_->node_id());
        return call_immediately(STATE(allocate_entry));
    }
 
    InitializeFlow* tgt() {
        return Singleton<InitializeFlow>::instance();
    }
 
    If* iface() {
        return static_cast<If*>(service());
    }
 
    Node* nextNode_;
    BarrierNotifiable bn_;
};
 
} // namespace openlcb
 
#endif // _OPENLCB_NODEINITIALIZEFLOW_HXX_