IfCan.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_IFCAN_HXX_
#define _OPENLCB_IFCAN_HXX_
 
#include <memory>
 
#include "executor/StateFlow.hxx"
#include "openlcb/If.hxx"
#include "openlcb/AliasCache.hxx"
#include "openlcb/Defs.hxx"
#include "utils/CanIf.hxx"
 
namespace openlcb
{
 
class IfCan;
 
extern size_t g_alias_use_conflicts;
 
class AliasAllocator;
class IfCan;
 
class IfCan : public If, public CanIf
{
public:
    IfCan(ExecutorBase *executor, CanHubFlow *device,
        int local_alias_cache_size, int remote_alias_cache_size,
        int local_nodes_count);
 
    ~IfCan();
 
    void add_addressed_message_support();
 
    AliasCache *local_aliases()
    {
        executor()->assert_current();
        return &localAliases_;
    }
 
    AliasCache *remote_aliases()
    {
        executor()->assert_current();
        return &remoteAliases_;
    }
 
    AliasAllocator *alias_allocator()
    {
        return aliasAllocator_.get();
    }
 
    void set_alias_allocator(AliasAllocator *a);
 
    void send_global_alias_enquiry(Node *source);
 
    void add_owned_flow(Executable *e) override;
 
    bool matching_node(NodeHandle expected, NodeHandle actual) override;
 
    void delete_local_node(Node *node) override;
 
    Node *lookup_local_node_handle(NodeHandle handle) override;
 
    NodeID get_default_node_id() override;
 
private:
    void canonicalize_handle(NodeHandle *h) override;
 
    friend class CanFrameWriteFlow; // accesses the device and the hubport.
 
    AliasCache localAliases_;
    AliasCache remoteAliases_;
 
    std::vector<std::unique_ptr<Executable>> ownedFlows_;
 
    std::unique_ptr<AliasAllocator> aliasAllocator_;
 
    DISALLOW_COPY_AND_ASSIGN(IfCan);
};
 
class CanFrameStateFlow : public StateFlow<Buffer<CanMessageData>, QList<1>>
{
public:
    CanFrameStateFlow(IfCan *service)
        : StateFlow<Buffer<CanMessageData>, QList<1>>(service)
    {
    }
 
    IfCan *if_can()
    {
        return static_cast<IfCan *>(service());
    }
};
 
struct NodeCanonicalizeRequest
{
    void reset(Node *node, NodeHandle handle)
    {
        srcNode = node;
        this->handle = handle;
        resultCode = 0;
    }
 
    Node *srcNode;
    NodeHandle handle;
 
    BarrierNotifiable done;
    int resultCode;
};
 
class NodeIdLookupFlow
    : public StateFlow<Buffer<NodeCanonicalizeRequest>, QList<1>>
{
public:
    NodeIdLookupFlow(IfCan *iface)
        : StateFlow<Buffer<NodeCanonicalizeRequest>, QList<1>>(iface)
    {
    }
 
    Action entry() override
    {
        if (input()->handle.id != 0)
        {
            return return_ok();
        }
        if (input()->handle.alias == 0)
        {
            // This is an empty handle, say that's OK.
            return return_ok();
        }
        NodeID id = iface()->remote_aliases()->lookup(input()->handle.alias);
        if (!id)
        {
            id = iface()->local_aliases()->lookup(input()->handle.alias);
        }
        if (id)
        {
            input()->handle.id = id;
            return return_ok();
        }
        return allocate_and_call(
            iface()->addressed_message_write_flow(), STATE(send_request));
    }
 
private:
    Action send_request()
    {
        auto *b =
            get_allocation_result(iface()->addressed_message_write_flow());
        b->data()->reset(Defs::MTI_VERIFY_NODE_ID_ADDRESSED,
            input()->srcNode->node_id(), input()->handle, EMPTY_PAYLOAD);
        replyHandler_.set_alias_waiting(input()->handle.alias);
        iface()->addressed_message_write_flow()->send(b);
 
        return sleep_and_call(&timer_, MSEC_TO_NSEC(700), STATE(reply_timeout));
    }
 
    Action reply_timeout()
    {
        replyHandler_.set_alias_waiting(0);
        if (!timer_.is_triggered())
        {
            return return_with_error(Defs::ERROR_OPENLCB_TIMEOUT);
        }
        if (!input()->handle.id)
        {
            return return_with_error(Defs::ERROR_OPENMRN_NOT_FOUND);
        }
        return return_ok();
    }
 
    class ReplyHandler : public MessageHandler
    {
    public:
        ReplyHandler(NodeIdLookupFlow *parent)
            : parent_(parent)
        {
            parent_->iface()->dispatcher()->register_handler(
                this, Defs::MTI_VERIFIED_NODE_ID_NUMBER, Defs::MTI_EXACT);
        }
 
        ~ReplyHandler()
        {
            parent_->iface()->dispatcher()->unregister_handler(
                this, Defs::MTI_VERIFIED_NODE_ID_NUMBER, Defs::MTI_EXACT);
        }
 
        void send(Buffer<GenMessage> *message, unsigned priority) OVERRIDE
        {
            AutoReleaseBuffer<GenMessage> ab(message);
            if (aliasWaiting_ == 0)
                return;
 
            GenMessage *msg = message->data();
            if (msg->src.alias != aliasWaiting_)
                return;
 
            if (msg->src.id != 0)
            {
                parent_->input()->handle.id = msg->src.id;
            }
            else if (msg->payload.size() == 6)
            {
                parent_->input()->handle.id =
                    data_to_node_id(msg->payload.data());
            }
            else
            {
                // Node ID verified with no source data. Problem.
            }
            set_alias_waiting(0);
            parent_->timer_.trigger();
        }
 
        void set_alias_waiting(NodeAlias a)
        {
            aliasWaiting_ = a;
        }
 
    private:
        NodeAlias aliasWaiting_{0};
        NodeIdLookupFlow *parent_;
    } replyHandler_{this};
 
    friend class ReplyHandler;
 
    Action return_ok()
    {
        return return_with_error(0);
    }
 
    Action return_with_error(int error)
    {
        input()->resultCode = error;
        return_buffer();
        return exit();
    }
 
    NodeCanonicalizeRequest *input()
    {
        return message()->data();
    }
 
    IfCan *iface()
    {
        return static_cast<IfCan *>(service());
    }
 
    BarrierNotifiable bn_;
    StateFlowTimer timer_{this};
};
 
} // namespace openlcb
 
#endif // _OPENLCB_IFCAN_HXX_