ConfigUpdateFlow.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_CONFIGUPDATEFLOW_HXX_
#define _OPENLCB_CONFIGUPDATEFLOW_HXX_
 
#include "openmrn_features.h"
#include "utils/ConfigUpdateListener.hxx"
#include "utils/ConfigUpdateService.hxx"
#include "openlcb/NodeInitializeFlow.hxx"
#include "executor/StateFlow.hxx"
 
#if OPENMRN_FEATURE_REBOOT
extern "C" {
extern void reboot();
}
#endif // OPENMRN_FEATURE_REBOOT
 
namespace openlcb
{
 
class ConfigUpdateFlow : public StateFlowBase,
                         public ConfigUpdateService,
                         private Atomic
{
public:
    ConfigUpdateFlow(If *iface)
        : StateFlowBase(iface)
        , nextRefresh_(listeners_.begin())
        , needsReboot_(0)
        , needsReInit_(0)
        , fd_(-1)
    {
    }
 
    int open_file(const char *path);
    void init_flow();
    void factory_reset();
 
    int get_fd()
    {
        return fd_;
    }
 
#ifdef GTEST
    void TEST_set_fd(int fd)
    {
        fd_ = fd;
    }
    bool TEST_is_terminated()
    {
        return is_terminated();
    }
    bool TEST_get_needs_reboot()
    {
        return needsReboot_;
    }
    bool TEST_get_needs_reinit()
    {
        return needsReInit_;
    }
#endif // GTEST
 
    void trigger_update() override
    {
        AtomicHolder h(this);
        nextRefresh_ = listeners_.begin();
        needsReboot_ = 0;
        needsReInit_ = 0;
        if (is_state(exit().next_state()))
        {
            start_flow(STATE(call_next_listener));
        }
    }
 
    void register_update_listener(ConfigUpdateListener *listener) override;
    void unregister_update_listener(ConfigUpdateListener *listener) override;
private:
    Action call_next_listener()
    {
        ConfigUpdateListener *l = nullptr;
        {
            AtomicHolder h(this);
            if (nextRefresh_ == listeners_.end())
            {
                return call_immediately(STATE(do_initial_load));
            }
            l = nextRefresh_.operator->();
            ++nextRefresh_;
        }
        return call_listener(l, false);
    }
 
    Action call_listener(ConfigUpdateListener *l, bool is_initial)
    {
        if (fd_ < 0)
        {
            DIE("CONFIG_FILENAME not specified, or init() was not called, but "
                "there are configuration listeners.");
        }
        ConfigUpdateListener::UpdateAction action =
            l->apply_configuration(fd_, is_initial, n_.reset(this));
        switch (action)
        {
            case ConfigUpdateListener::UPDATED:
            {
                break;
            }
            case ConfigUpdateListener::REINIT_NEEDED:
            {
                needsReInit_ = 1;
                break;
            }
            case ConfigUpdateListener::REBOOT_NEEDED:
            {
                needsReboot_ = 1;
                break;
            }
        }
        return wait();
    }
 
    Action do_initial_load()
    {
        ConfigUpdateListener *l = nullptr;
        {
            AtomicHolder h(this);
            if (!pendingListeners_.empty())
            {
                l = pendingListeners_.pop_front();
                listeners_.push_front(l);
            }
        }
        if (!l)
        {
            return apply_action();
        }
        return call_listener(l, true);
    }
 
    Action apply_action()
    {
        if (needsReboot_)
        {
#if OPENMRN_FEATURE_REBOOT
            reboot();
#endif
        }
        if (needsReInit_)
        {
            // Takes over ownership of itself, will delete when done.
            new ReinitAllNodes(static_cast<If *>(service()));
        }
        return exit();
    }
 
    typedef TypedQueue<ConfigUpdateListener> queue_type;
    queue_type listeners_;
    queue_type pendingListeners_;
    typename queue_type::iterator nextRefresh_;
    unsigned needsReboot_ : 1;
    unsigned needsReInit_ : 1;
    int fd_;
    BarrierNotifiable n_;
};
 
} // namespace openlcb
 
#endif // _OPENLCB_CONFIGUPDATEFLOW_HXX_