source: src/Actions/ActionQueue.cpp@ 6bbdfb

/*
 * Project: MoleCuilder
 * Description: creates and alters molecular systems
 * Copyright (C)  2013 Frederik Heber. All rights reserved.
 * 
 *
 *   This file is part of MoleCuilder.
 *
 *    MoleCuilder 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.
 *
 *    MoleCuilder 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 MoleCuilder.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * ActionQueue.cpp
 *
 *  Created on: Aug 16, 2013
 *      Author: heber
 */

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "CodePatterns/MemDebug.hpp"

#include "Actions/ActionQueue.hpp"

#include "CodePatterns/Assert.hpp"
#include "CodePatterns/IteratorAdaptors.hpp"
#include "CodePatterns/Log.hpp"
#include "CodePatterns/Singleton_impl.hpp"

#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/version.hpp>
#include <iterator>
#include <string>
#include <sstream>
#include <vector>

#include "Actions/ActionExceptions.hpp"
#include "Actions/ActionHistory.hpp"
#include "Actions/ActionRegistry.hpp"
#include "World.hpp"

using namespace MoleCuilder;

const Action* ActionQueue::_lastchangedaction = NULL;

ActionQueue::ActionQueue() :
    Observable("ActionQueue"),
    AR(new ActionRegistry()),
    history(new ActionHistory),
#ifndef HAVE_ACTION_THREAD
    lastActionOk(true)
#else
    lastActionOk(true),
    CurrentAction(0),
    run_thread_isIdle(true)
#endif
{
  // channels of observable
  Channels *OurChannel = new Channels;
  NotificationChannels.insert( std::make_pair(static_cast<Observable *>(this), OurChannel) );
  // add instance for each notification type
  for (size_t type = 0; type < NotificationType_MAX; ++type)
    OurChannel->addChannel(type);
}

ActionQueue::~ActionQueue()
{
#ifdef HAVE_ACTION_THREAD
  stop();

  clearTempQueue();
#endif

  clearQueue();

  delete history;
  delete AR;
}

void ActionQueue::queueAction(const std::string &name, enum Action::QueryOptions state)
{
  const Action * const registryaction = AR->getActionByName(name);
  queueAction(registryaction, state);
}

void ActionQueue::queueAction(const Action * const _action, enum Action::QueryOptions state)
{
  Action *newaction = _action->clone(state);
  newaction->prepare(state);
#ifdef HAVE_ACTION_THREAD
  {
    boost::mutex::scoped_lock trylock(mtx_run_thread_running, boost::try_to_lock);
    if (trylock) {
      trylock.unlock();
      run_thread = boost::thread(&ActionQueue::run, this);
    }
  }

  mtx_actionqueue.lock();
#endif
  actionqueue.push_back( newaction );
#ifndef HAVE_ACTION_THREAD
  try {
    newaction->call();
    lastActionOk = true;
  } catch(ActionFailureException &e) {
    std::cerr << "Action " << *boost::get_error_info<ActionNameString>(e) << " has failed." << std::endl;
    World::getInstance().setExitFlag(5);
//    clearQueue(actionqueue.size()-1);
    lastActionOk = false;
//    std::cerr << "Remaining Actions cleared from queue." << std::endl;
  } catch (std::exception &e) {
    pushStatus("FAIL: General exception caught, aborting.");
    World::getInstance().setExitFlag(134);
//    clearQueue(actionqueue.size()-1);
    lastActionOk = false;
//    std::cerr << "Remaining Actions cleared from queue." << std::endl;
  }
  if (lastActionOk) {
    OBSERVE;
    NOTIFY(ActionQueued);
    _lastchangedaction = newaction;
  }
#else
  mtx_actionqueue.unlock();
  const bool new_run_thread_isIdle = isActionQueueDone();
  setrun_thread_isIdle(new_run_thread_isIdle);
#endif
}

#ifdef HAVE_ACTION_THREAD
bool ActionQueue::isActionQueueDone() const
{
  boost::lock_guard<boost::mutex> lock(mtx_actionqueue);
  return (CurrentAction == actionqueue.size());
}

void ActionQueue::setActionQueueDone()
{
  boost::lock_guard<boost::mutex> lock(mtx_actionqueue);
  CurrentAction = actionqueue.size();
}

bool ActionQueue::isTempQueueDone() const
{
  boost::lock_guard<boost::mutex> lock(mtx_tempqueue);
  return tempqueue.empty();
}
#endif

void ActionQueue::insertAction(Action *_action, enum Action::QueryOptions state)
{
#ifndef HAVE_ACTION_THREAD
  queueAction(_action, state);
#else
  Action *newaction = _action->clone(state);
  newaction->prepare(state);
  {
    boost::lock_guard<boost::mutex> lock(mtx_tempqueue);
    tempqueue.push_back( newaction );
  }
  {
    bool new_run_thread_isIdle = getrun_thread_isIdle();
    new_run_thread_isIdle &= isTempQueueDone();
    setrun_thread_isIdle(new_run_thread_isIdle);
  }
#endif
}

#ifdef HAVE_ACTION_THREAD
void ActionQueue::run()
{
  // only a single thread may run this
  boost::mutex::scoped_lock trylock(mtx_run_thread_running, boost::try_to_lock);
  if (trylock) {
  bool Interrupted = false;
  do {
    // sleep for some time and wait for queue to fill up again
    try {
#if BOOST_VERSION < 105000
      boost::this_thread::sleep(boost::get_system_time() + boost::posix_time::milliseconds(100));
#else
      boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
#endif
    } catch(boost::thread_interrupted &e) {
      LOG(2, "INFO: ActionQueue has received stop signal.");
      Interrupted = true;
    }
//    LOG(1, "DEBUG: Start of ActionQueue's run() loop.");
    // call all currently present Actions
    insertTempQueue();
    while ((!Interrupted) && (!isActionQueueDone())) {
      //      boost::this_thread::disable_interruption di;
      // access actionqueue, hence using mutex
      mtx_actionqueue.lock();
      LOG(0, "Calling Action " << actionqueue[CurrentAction]->getName() << " ... ");
      try {
        actionqueue[CurrentAction]->call();
        pushStatus("SUCCESS: Action "+actionqueue[CurrentAction]->getName()+" successful.");
        lastActionOk = true;
      } catch(ActionFailureException &e) {
        pushStatus("FAIL: Action "+*boost::get_error_info<ActionNameString>(e)+" has failed.");
        World::getInstance().setExitFlag(5);
        lastActionOk = false;
        std::cerr << "Remaining Actions cleared from queue." << std::endl;
      } /* catch (std::exception &e) {
        pushStatus("FAIL: General exception caught, aborting.");
        World::getInstance().setExitFlag(134);
        lastActionOk = false;
        std::cerr << "Remaining Actions cleared from queue." << std::endl;
      }*/
      // remember action we just executed
      const Action *lastaction = actionqueue[CurrentAction];
      // step on to next action if last ok
      if (lastActionOk)
        CurrentAction++;

      mtx_actionqueue.unlock();

      // remove following Actions outside mutex if current failed
      if (!lastActionOk) {
        clearQueue(CurrentAction);  // was not incremented
        clearTempQueue();
        setActionQueueDone();
     }

      // insert new actions (before [CurrentAction]) if they have been spawned
      // we must have an extra vector for this, as we cannot change actionqueue
      // while an action instance is "in-use"

      insertTempQueue();

      // set last action when all is done for this Action call
      if (lastActionOk) {
        OBSERVE;
        NOTIFY(ActionQueued);
        _lastchangedaction = lastaction;
      }
    }
    {
      bool new_run_thread_isIdle = isActionQueueDone();
      new_run_thread_isIdle &= isTempQueueDone();
      setrun_thread_isIdle(new_run_thread_isIdle);
    }
    cond_idle.notify_one();
//    LOG(1, "DEBUG: End of ActionQueue's run() loop.");
  } while ((!Interrupted) && (!isActionQueueDone()));
  trylock.unlock();
  }
}

void ActionQueue::insertTempQueue()
{
  boost::lock_guard<boost::mutex> lock(mtx_tempqueue);
  if (!tempqueue.empty()) {
    boost::lock_guard<boost::mutex> lock(mtx_actionqueue);
    ActionQueue_t::iterator InsertionIter = actionqueue.begin();
    std::advance(InsertionIter, CurrentAction);
    actionqueue.insert( InsertionIter, tempqueue.begin(), tempqueue.end() );
    tempqueue.clear();
  }
}

void ActionQueue::setrun_thread_isIdle(
    const bool _run_thread_isIdle)
{
  boost::unique_lock<boost::mutex> lock(mtx_run_thread_isIdle);
  run_thread_isIdle = _run_thread_isIdle;
}

bool ActionQueue::getrun_thread_isIdle() const
{
  boost::unique_lock<boost::mutex> lock(mtx_run_thread_isIdle);
  return run_thread_isIdle;
}

void ActionQueue::wait()
{
  boost::mutex::scoped_lock trylock(mtx_run_thread_running, boost::try_to_lock);
  if (!trylock) {
    boost::unique_lock<boost::mutex> lock(mtx_run_thread_isIdle);
    while(!run_thread_isIdle)
    {
        cond_idle.wait(lock);
    }
  }
}

void ActionQueue::stop()
{
  // notify actionqueue thread that we wish to terminate
  run_thread.interrupt();
  // wait till it ends
  run_thread.join();
}
#endif

Action* ActionQueue::getActionByName(const std::string &name)
{
  return AR->getActionByName(name);
}

bool ActionQueue::isActionKnownByName(const std::string &name) const
{
  return AR->isActionPresentByName(name);
}

void ActionQueue::registerAction(Action *_action)
{
  AR->registerInstance(_action);
}

void ActionQueue::outputAsCLI(std::ostream &output) const
{
  for (ActionQueue_t::const_iterator iter = actionqueue.begin();
      iter != actionqueue.end();
      ++iter) {
    // skip store-session in printed list
    if ( ((*iter)->getName() != std::string("store-session"))
        && ((*iter)->getName() != std::string("load-session"))) {
      if (iter != actionqueue.begin())
        output << " ";
      (*iter)->outputAsCLI(output);
    }
  }
  output << std::endl;
}

void ActionQueue::outputAsPython(std::ostream &output) const
{
  const std::string prefix("pyMoleCuilder");
  output << "import " << prefix << std::endl;
  output << "# ========================== Stored Session BEGIN ==========================" << std::endl;
  for (ActionQueue_t::const_iterator iter = actionqueue.begin();
      iter != actionqueue.end();
      ++iter) {
    // skip store-session in printed list
    if ( ((*iter)->getName() != std::string("store-session"))
        && ((*iter)->getName() != std::string("load-session")))
      (*iter)->outputAsPython(output, prefix);
  }
  output << "# =========================== Stored Session END ===========================" << std::endl;
}

const ActionTrait& ActionQueue::getActionsTrait(const std::string &name) const
{
  // this const_cast is just required as long as we have a non-const getActionByName
  const Action * const action = const_cast<ActionQueue *>(this)->getActionByName(name);
  return action->Traits;
}

void ActionQueue::addElement(Action* _Action,ActionState::ptr _state)
{
  history->addElement(_Action, _state);
}

void ActionQueue::clear()
{
  history->clear();
}

void ActionQueue::clearQueue(const size_t _fromAction)
{
  // free all actions contained in actionqueue
  {
#ifdef HAVE_ACTION_THREAD
    boost::lock_guard<boost::mutex> lock(mtx_actionqueue);
#endif
    LOG(1, "Removing all Actions from position " << _fromAction << " onward.");
    // free all actions still to be called contained in actionqueue
    ActionQueue_t::iterator inititer = actionqueue.begin();
    std::advance(inititer, _fromAction);
    for (ActionQueue_t::iterator iter = inititer; iter != actionqueue.end(); ++iter)
      delete *iter;
    actionqueue.erase(inititer, actionqueue.end());
    LOG(1, "There are " << actionqueue.size() << " remaining Actions.");
  }
}

#ifdef HAVE_ACTION_THREAD
void ActionQueue::clearTempQueue()
{
  // free all actions contained in tempqueue
  {
    boost::lock_guard<boost::mutex> lock(mtx_tempqueue);
    for (ActionQueue_t::iterator iter = tempqueue.begin();
        !tempqueue.empty(); iter = tempqueue.begin()) {
      delete *iter;
      tempqueue.erase(iter);
    }
  }
}
#endif

const ActionQueue::ActionTokens_t ActionQueue::getListOfActions() const
{
  ActionTokens_t returnlist;

  returnlist.insert(
      returnlist.end(),
      MapKeyConstIterator<ActionRegistry::const_iterator>(AR->getBeginIter()),
      MapKeyConstIterator<ActionRegistry::const_iterator>(AR->getEndIter()));

  return returnlist;
}

void ActionQueue::undoLast()
{
        history->undoLast();
}

bool ActionQueue::canUndo() const
{
  return history->hasUndo();
}

void ActionQueue::redoLast()
{
        history->redoLast();
}

bool ActionQueue::canRedo() const
{
  return history->hasRedo();
}


CONSTRUCT_SINGLETON(ActionQueue)