subsystem-runner-test.cpp

Go to the documentation of this file.

/*
  SubsystemRunner(Test)  -  validate starting and stopping of dependent subsystems

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

  **Lumiera** 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. See the file COPYING for further details.

* *****************************************************************/

#include "lib/test/run.hpp"
#include "lib/test/test-helper.hpp"
#include "common/subsys.hpp"
#include "common/subsystem-runner.hpp"
#include "common/option.hpp"

#include "lib/symbol.hpp"
#include "lib/thread.hpp"
#include "lib/sync-barrier.hpp"
#include "lib/query-util.hpp"
#include "lib/format-cout.hpp"
#include "lib/error.hpp"
#include "lib/util.hpp"
#include "lib/sync.hpp"

#include <memory>
#include <atomic>
#include <chrono>

using util::isnil;
using test::Test;
using lib::Literal;
using lib::query::extractID;
using lib::Thread;
using std::unique_ptr;
using std::atomic_bool;
using std::this_thread::sleep_for;
using std::chrono::milliseconds;


namespace lumiera {
namespace test  {
    
    namespace { // private test classes and data...
      
      using lib::query::extractID;
      
      const uint MAX_RUNNING_TIME_ms = 80;
      const uint MIN_RUNNING_TIME_ms = 20;
      
      inline int
      draw_rand_runtime()
      {
        return MIN_RUNNING_TIME_ms
             + rani (MAX_RUNNING_TIME_ms - MIN_RUNNING_TIME_ms);
      }
      
      const uint TICK_DURATION_ms = 5;
      
      const uint DELAY_FOR_FLOUNDERING_THRAD_ms = 20;
      
      lib::Cmdline dummyArgs ("");
      lumiera::Option dummyOpt (dummyArgs);
      
      LUMIERA_ERROR_DEFINE( TEST, "simulated failure.");
      
      using LERR_(LOGIC);
      using LERR_(STATE);
      
      
      
      
      class MockSys
        : public lumiera::Subsys
        {
          const string id_;
          const string spec_;
          
          atomic_bool isUp_{false};
          atomic_bool didRun_{false};
          atomic_bool started_{false};
          atomic_bool termRequest_{false};
          int running_duration_{0};
          const int TIME_GOAL{draw_rand_runtime()};
          
          lib::SyncBarrier barrier_{};
          unique_ptr<Thread> thread_{};
          
          bool
          shouldStart (lumiera::Option&)  override
            {
              string startSpec (extractID ("start",spec_));
              return "true" ==startSpec 
                  or "fail" ==startSpec
                  or "throw"==startSpec;
            }
          
          
          bool
          start (lumiera::Option&, Subsys::SigTerm termination)  override
            {
              CHECK (not (isUp_ or started_ or didRun_), "attempt to start %s twice!", cStr(*this));
              
              string startSpec (extractID ("start",spec_));
              CHECK (not isnil (startSpec));
              
              if ("true"==startSpec) //----simulate successful subsystem start
                {
                  CHECK (not started_);
                   
                  // start »Subsystem operation« in a dedicated thread....
                  thread_.reset (new Thread{id_, &MockSys::run, this, termination});
                  barrier_.sync();    //---run-status handshake
                  
                  CHECK (started_);
                }
              else
              if ("fail"==startSpec)  //---not starting, incorrectly reporting success
                return true;
              else
              if ("throw"==startSpec) //---starting flounders
                throw error::Fatal("simulated failure to start the subsystem", LUMIERA_ERROR_TEST);
              
              return started_;
            }
          
          void
          triggerShutdown ()  noexcept override
            {
              // note: *not* locking here...
              termRequest_ = true;
              
              INFO (test, "triggerShutdown() --> %s....", cStr(*this));
            }
          
          bool 
          checkRunningState ()  noexcept override
            {
              // note: *not* locking here...
              return isUp_;
            }
          
          
          void
          run (Subsys::SigTerm termination)
            {
              string runSpec (extractID ("run",spec_));
              CHECK (not isnil (runSpec));
              
              // run-status handshake
              started_ = true;
              isUp_    = ("true"==runSpec || "throw"==runSpec);
              didRun_  = ("false"!=runSpec); // includes "fail" and "throw"
              
              // coordinate startup with controlling thread
              barrier_.sync();
              
              if (isUp_) //-------------actually enter running state for some time
                {
                  running_duration_ = TIME_GOAL;    // prepared when creating instance 
                  
                  INFO (test, "thread %s now running....", cStr(*this));
                  
                  while (not shouldTerminate())
                    {
                      sleep_for (milliseconds{TICK_DURATION_ms});
                      running_duration_ -= TICK_DURATION_ms;
                    }
                  
                  INFO (test, "thread %s about to terminate...", cStr(*this));
                  isUp_ = false;
                }
              
              if ("fail" ==runSpec) return; // terminate without further notice
              if ("true" ==runSpec) termination(0); // signal regular termination
              if ("throw"==runSpec)
                {
                  Error problemIndicator("simulated Problem terminating subsystem",LUMIERA_ERROR_TEST);
                  lumiera_error();    //  reset error state....
                                     //   Note: in real life this actually
                                    //    would be an catched exception!
                  string problemReport (problemIndicator.what());
                  termination (&problemReport);
                }
              
            }
          
          
          bool
          shouldTerminate ()  
            {
              return termRequest_ || running_duration_ <= 0;
            }
          
          
          
        public:
          MockSys(Literal id, Literal spec)
            : id_(id)
            , spec_(spec)
            { }
          
         ~MockSys() { }
          
          operator string ()  const { return "MockSys(\""+id_+"\")"; }
          
          bool didRun ()  const { return didRun_; }
        };
      
      
      
    } // (End) test classes and data....
    
    
    
    
    
    
    
    
    
    
    /**********************************************************************/
    class SubsystemRunner_test : public Test
      {
        
        virtual void
        run (Arg)
          {
            seedRand();
            singleSubsys_complete_cycle();
            singleSubsys_start_failure();
            singleSubsys_emegency_exit();
            
            dependentSubsys_complete_cycle();
            dependentSubsys_start_failure();
          }
        
        
        void
        singleSubsys_complete_cycle()
          {
            cout << "-----singleSubsys_complete_cycle-----\n";
            
            MockSys unit ("one", "start(true), run(true).");
            SubsystemRunner runner(dummyOpt);
            CHECK (not unit.isRunning());
            CHECK (not unit.didRun());
            
            runner.maybeRun (unit);
            bool emergency = runner.wait();
            
            CHECK (not emergency);
            CHECK (not unit.isRunning());
            CHECK (unit.didRun());
          }
        
        
        void
        singleSubsys_start_failure()
          {
            cout << "-----singleSubsys_start_failure-----\n";
            
            MockSys unit1 ("U1", "start(false), run(false).");
            MockSys unit2 ("U2", "start(throw), run(false).");
            MockSys unit3 ("U3", "start(fail),  run(false).");  // simulates incorrect behaviour
            MockSys unit4 ("U4", "start(true),  run(fail)." );  // simulates failure immediately after start
            SubsystemRunner runner(dummyOpt);
            
            runner.maybeRun (unit1);  // this one doesn't start at all, which isn't considered an error
            CHECK (not unit1.didRun());
            
            VERIFY_ERROR (TEST,  runner.maybeRun (unit2) );
            VERIFY_ERROR (LOGIC, runner.maybeRun (unit3) );     // incorrect behaviour trapped
            VERIFY_ERROR (LOGIC, runner.maybeRun (unit4) );     // detected that the subsystem didn't come up
            
            sleep_for (milliseconds{DELAY_FOR_FLOUNDERING_THRAD_ms}); // preempt to allow unit4 to go away
            runner.wait();
            
            CHECK (not unit1.isRunning());
            CHECK (not unit2.isRunning());
            CHECK (not unit3.isRunning());
            CHECK (not unit4.isRunning());
            CHECK (not unit1.didRun());
            CHECK (not unit2.didRun());
            CHECK (not unit3.didRun());
            CHECK (unit4.didRun()); // ...but it failed immediately
          }
        
        
        void
        singleSubsys_emegency_exit()
          {
            cout << "-----singleSubsys_emegency_exit-----\n";
            
            MockSys unit ("one", "start(true), run(throw).");
            SubsystemRunner runner(dummyOpt);
            
            runner.maybeRun (unit);
            bool emergency = runner.wait();
            
            CHECK (emergency == true);  // emergency state was propagated
            CHECK (not unit.isRunning());
            CHECK (unit.didRun());
          }
        
        
        void
        dependentSubsys_complete_cycle()
          {
            cout << "-----dependentSubsys_complete_cycle-----\n";
            
            MockSys unit1 ("U1", "start(true), run(true).");
            MockSys unit2 ("U2", "start(true), run(true).");
            MockSys unit3 ("U3", "start(true), run(true).");
            MockSys unit4 ("U4", "start(true), run(true).");
            unit2.depends (unit1);
            unit4.depends (unit3);
            unit4.depends (unit1);
            unit3.depends (unit2);
            SubsystemRunner runner(dummyOpt);
            
            runner.maybeRun (unit4);
            CHECK (unit1.isRunning());
            CHECK (unit2.isRunning());
            CHECK (unit3.isRunning());
            CHECK (unit4.isRunning());
            
            bool emergency = runner.wait();
            
            CHECK (not emergency);
            CHECK (not unit1.isRunning());
            CHECK (not unit2.isRunning());
            CHECK (not unit3.isRunning());
            CHECK (not unit4.isRunning());
            CHECK (unit1.didRun());
            CHECK (unit2.didRun());
            CHECK (unit3.didRun());
            CHECK (unit4.didRun());
          }
        
        
        void
        dependentSubsys_start_failure()
          {
            cout << "-----dependentSubsys_start_failure-----\n";
            
            MockSys unit1 ("U1", "start(true), run(true).");
            MockSys unit2 ("U2", "start(true), run(true).");
            MockSys unit3 ("U3", "start(false),run(false)."); // note
            MockSys unit4 ("U4", "start(true), run(true).");
            unit2.depends (unit1);
            unit4.depends (unit3);
            unit4.depends (unit1);
            unit3.depends (unit2);
            SubsystemRunner runner(dummyOpt);
            
            VERIFY_ERROR (STATE, runner.maybeRun (unit4) );   // failure to bring up prerequisites is detected
            CHECK (    unit1.isRunning());
            CHECK (    unit2.isRunning());
            CHECK (not unit3.isRunning());
            // shutdown has been triggered for unit4, but may require some time
            
            bool emergency = runner.wait();
            
            CHECK (not emergency);     // no problems with the subsystems actually running...
            CHECK (not unit1.isRunning());
            CHECK (not unit2.isRunning());
            CHECK (not unit3.isRunning());
            CHECK (not unit4.isRunning());
            CHECK (    unit1.didRun());
            CHECK (    unit2.didRun());
            CHECK (not unit3.didRun());
            // can't say for sure if unit4 actually did run
          }
      };
    
    
    
    LAUNCHER (SubsystemRunner_test, "function common");
    
    
    
}} // namespace lumiera::test