appstate.cpp

Go to the documentation of this file.

/*
  AppState  -  application initialisation and behaviour
 
   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/error.hpp"
#include "common/appstate.hpp"
#include "common/subsystem-runner.hpp"
 
extern "C" {
#include "common/config-interface.h"
 
#include "common/interface.h"
#include "common/interfaceregistry.h"
#include "common/plugin.h"
}
 
#include "lib/symbol.hpp"
#include "lib/util.hpp"
 
 
using lib::Literal;
using std::unique_ptr;
 
 
 
namespace lumiera {
  
  namespace { // implementation details
  
    inline void
    log_and_clear_unexpected_errorstate ()
    {
      if (lumiera_err errorstate = lumiera_error ())
        ALERT (common, "*** Unexpected error: %s\n     Triggering emergency exit.", errorstate);
    }
  }
  
  
  
  
  AppState::AppState()
    : setup_{LUMIERA_LOCATION_OF_BOOTSTRAP_INI}
    , subsystems_{}
    , emergency_{false}
    , core_up_{false}
  { }
  
  lib::Depend<AppState> AppState::instance;
  
  
  string
  AppState::fetchSetupValue (Literal key)
  {
    return setup_.get(key).as<string>();
  }
 
  
  
  
  
  // ===== Implementation startup and shutdown sequence for main() ========
  
  
#define _MAYBE_THROW_ \
  maybeThrow<error::Fatal> ("internal failure while initialising the "\
                            "Lumiera application framework");
  
  
  
  void
  AppState::init (Option& options)
  {
    TRACE (common, "initialising application core...");
    
    lumiera_interfaceregistry_init ();
    _MAYBE_THROW_
    
    lumiera_plugin_discover (lumiera_plugin_load, lumiera_plugin_register);
    _MAYBE_THROW_
    
    lumiera_config_interface_init ();
    _MAYBE_THROW_
    
    core_up_= true;
    LifecycleHook::trigger (ON_GLOBAL_INIT);
    _MAYBE_THROW_
    
    
    subsystems_.reset (new SubsystemRunner (options));
    TRACE (common, "Lumiera core started successfully.");
  }
  
  
  
  void
  AppState::maybeStart (lumiera::Subsys& subsys)
  {
    TRACE (common, "maybe startup %s...?", cStr(subsys));
    REQUIRE (subsystems_);
    subsystems_->maybeRun (subsys);
  }
  
  
  
  typedef AppState::ExitCode ExitCode;
  
  
  ExitCode
  AppState::maybeWait()
  {
    if (subsystems_)
      {
        emergency_ |= subsystems_->wait();
        subsystems_.reset(0);
      }
    
    NOTICE (common, "Shutting down Lumiera...");
    
    if (emergency_)
      {
        ALERT (common, "Triggering emergency exit...");
        LifecycleHook::trigger (ON_EMERGENCY);
        return CLEAN_EMERGENCY_EXIT;
      }
    else
      {
        LifecycleHook::trigger (ON_GLOBAL_SHUTDOWN);
        return NORMAL_EXIT;
      }
  }
  
  
  
  ExitCode
  AppState::abort (lumiera::Error& problem)
  {
    
    ERROR (common, "Aborting Lumiera after unhandled error: %s", cStr(problem.what()));
    
    log_and_clear_unexpected_errorstate();
    
    try
      {
        if (subsystems_)
          {
            subsystems_->triggerEmergency(true);
            subsystems_->shutdownAll();
          }
        return maybeWait ();
      }
    catch (...)
      {
        return abort();
      }
  }
  
  
  
  ExitCode
  AppState::abort ()  noexcept
  {
    log_and_clear_unexpected_errorstate();
    
    if (emergency_)
      {
        LifecycleHook::trigger (ON_EMERGENCY);
        return FAILED_EMERGENCY_EXIT;
      }
    else
      {
        LifecycleHook::trigger (ON_GLOBAL_SHUTDOWN);
        return CLEAN_EXIT_AFTER_ERROR;
      }
  }
  
  
  
  
  AppState::~AppState()
    {
      if (core_up_)
        try
        {
          TRACE (common, "shutting down basic application layer...");
          lumiera_config_interface_destroy ();
          lumiera_interfaceregistry_destroy ();
        }
    catch (...)
      {
        log_and_clear_unexpected_errorstate();
    } }
  
  
  
  
} // namespace lumiera