subsystem-runner.hpp

Go to the documentation of this file.

/*
  SUBSYSTEMRUNNER.hpp  -  helper for controlling execution of several dependent subsystems 

  Copyright (C)         Lumiera.org
    2008,               Hermann Vosseler <Ichthyostega@web.de>

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of
  the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#ifndef LUMIERA_SUBSYSTEMRUNNER_H
#define LUMIERA_SUBSYSTEMRUNNER_H

#include "lib/error.hpp"
#include "lib/util.hpp"
#include "lib/util-foreach.hpp"
#include "lib/format-string.hpp"
#include "common/subsys.hpp"
#include "lib/sync.hpp"

#include <vector>
#include <string>


namespace lumiera {

  using lib::Sync;
  using lib::RecursiveLock_Waitable;
  using std::chrono_literals::operator ""s;
  using std::vector;
  using std::string;
  using util::_Fmt;
  using util::isnil;
  using util::and_all;
  using util::for_each;
  using util::removeall;
  
  namespace {
    const auto EMERGENCY_STOP = 5s;
  }
  
  
  
  /*************************************************************************/
  class SubsystemRunner
    : public Sync<RecursiveLock_Waitable>
    {
      Option& opts_;
      volatile bool emergency_;
      vector<Subsys*> running_;
      
      bool isEmergency()  { return emergency_; }
      bool allDead(){ return isnil (running_); }
      
      
    public:
      SubsystemRunner (Option& opts)
        : opts_{opts}
        , emergency_{false}
        { }
      
      void
      maybeRun (Subsys& susy)
        {
          Lock guard{this};
          
          if (!susy.isRunning() && susy.shouldStart (opts_))
            triggerStartup (&susy);
        }
      
      void
      shutdownAll()
        {
          Lock guard{this};
          for_each (running_, [](Subsys* susy){ susy->triggerShutdown(); });
        }
      
      void
      triggerEmergency (bool cond)
        {
          Lock guard{this};
          if (cond) emergency_= true;
        }
      
      bool
      wait()
        {
          Lock blocking{this, [&]{ return allDead() or isEmergency(); }};
          if (isEmergency())
            blocking.wait_for (EMERGENCY_STOP, [&]{ return allDead(); });
           // ...prevent deadlock on emergency by limiting shutdown wait
          return isEmergency();
        }
      
      
      
    private:
      void
      triggerStartup (Subsys* susy)
        {
          auto isRunning    = [](Subsys* susy){ return susy->isRunning(); };
          auto triggerStart = [this](Subsys* susy){ triggerStartup(susy); };
          auto termCallback = [this,susy]
                              (string* problem)
                                {
                                  this->sigTerm (susy, problem);
                                };
          REQUIRE (susy);
          if (isRunning(susy)) return;
          
          INFO (subsystem, "Triggering startup of subsystem \"%s\"", cStr(*susy));
          
          for_each (susy->getPrerequisites(), triggerStart );
          bool started = susy->start (opts_, termCallback);
          
          if (started)
            {
              if (isRunning(susy))
                running_.push_back (susy); // now responsible for managing the started subsystem
              else
                throw error::Logic(_Fmt{"Subsystem %s failed to start"} % *susy);
            }
          
          if (not and_all (susy->getPrerequisites(), isRunning ))
            {
              susy->triggerShutdown();
              throw error::State(_Fmt{"Unable to start all prerequisites of Subsystem %s"} % *susy);
        }   }
      
      void
      sigTerm (Subsys* susy, string* problem) 
        {
          REQUIRE (susy);
          Lock sync{this};
          triggerEmergency(not isnil (problem));
          INFO (subsystem, "Subsystem '%s' terminated.", cStr(*susy));
          WARN_IF (not isnil(problem), subsystem, "Irregular shutdown caused by: %s", cStr(*problem));
          ERROR_IF (susy->isRunning(), subsystem, "Subsystem '%s' signals termination, "
                                                  "without resetting running state", cStr(*susy));
          removeall (running_, susy);
          shutdownAll();
          sync.notify_one();
        }
    };
  
  
  
} // namespace lumiera
#endif