MSContext.cpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ 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.
 *
 *  AiBO+ 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., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#include "MSContext.hpp"

#include <signal.h>

#ifdef AP_CPU_PROFILER
#include <gperftools/profiler.h>
#endif

#include <qapplication.h>
#include <qdir.h>
#include <qfont.h>
#include <QMap>
#include <QTime>

#include <MCDefs.hpp>
#include <MCLog.hpp>

#include "MSDefs.hpp"
#include "MSElement.hpp"
#include "MSHeart.hpp"
#include "MSSessionStorage.hpp"

typedef struct
{
  QTime Timer;
  QString Description;
  int Time;
} TimerData;

// Singleton instance
static MSContext* Singleton = nullptr;
// Singleton instance of the session storage
static MSSessionStorage* SessionStorageSingleton = nullptr;
// Singleton instance of the heart beat
static MSHeart* HeartSingleton = nullptr;
// QCoreApplication/QApplication instance
static QCoreApplication* App = nullptr;
// Hash of timers
static QMap<QString, TimerData> Timers;
// Pause timer
static QTime* PauseTimer = nullptr;
// Malfunction status
static bool MalfunctionStatus = false;

extern "C" {
static void MSSignalHandler(int signal_id)
{
  bool LastHeartBeat = false;

  MC_BPRINT(MCLog::White, "\nSignal caught: ");
  switch (signal_id)
  {
    case SIGFPE:
      MC_BPRINT(MCLog::White, "Floating point exception...D'oh!\n\n");
#if defined(__unix__) && !defined(__ANDROID__)
      MCGenerateBacktrace();
#endif
      break;
    case SIGSEGV:
      MC_BPRINT(MCLog::White, "Segmentation fault...D'oh!\n\n");
#if defined(__unix__) && !defined(__ANDROID__)
      MCGenerateBacktrace();
#endif
      break;
    case SIGILL:
      MC_BPRINT(MCLog::White, "Illegal instruction...D'oh!\n\n");
#if defined(__unix__) && !defined(__ANDROID__)
      MCGenerateBacktrace();
#endif
      break;
    case SIGINT:
      MC_BPRINT(MCLog::White, "Ctrl+C pressed?!...D'oh!\n\n");
#if defined(__unix__) && !defined(__ANDROID__)
      MCGenerateBacktrace();
#endif
      LastHeartBeat = true;
      break;
    case SIGTERM:
      MC_BPRINT(MCLog::White, "Kill signal received...D'oh!\n\n");
#if defined(__unix__) && !defined(__ANDROID__)
      MCGenerateBacktrace();
#endif
      LastHeartBeat = true;
      break;
#if defined(__MINGW32__) || defined(__MINGW64__)
    case SIGBREAK:
      MC_BPRINT(MCLog::White, "Ctrl+Break pressed...D'oh!\n\n");
      LastHeartBeat = true;
      break;
#endif
    case SIGABRT:
      MC_BPRINT(MCLog::White, "Abnormal termination...D'oh!\n\n");
#if defined(__unix__) && !defined(__ANDROID__)
      MCGenerateBacktrace();
#endif
      break;
    default:
      MC_BPRINT(MCLog::White, "Unsupported signal?...D'oh!\n\n");
      break;
  }

  // Deinstall the signal handlers
  signal(SIGFPE, SIG_DFL);
  signal(SIGSEGV, SIG_DFL);
  signal(SIGILL, SIG_DFL);
  signal(SIGINT, SIG_DFL);
  signal(SIGTERM, SIG_DFL);
#if defined(__MINGW32__) || defined(__MINGW64__)
  signal(SIGBREAK, SIG_DFL);
#endif
  signal(SIGABRT, SIG_DFL);

  MalfunctionStatus = true;
  // Request the last heart beat
  if (LastHeartBeat && HeartSingleton && HeartSingleton->IsBeatingActive())
  {
    MC_NPRINT("Request to stop the heart beating...\n");
    HeartSingleton->StopBeating();
    return;
  }

  // Close the recorded session
  if (SessionStorageSingleton && !SessionStorageSingleton->GetRecordPath().isEmpty())
  {
    MC_NPRINT("Try to close the streams in the recorded sessions...\n");
    SessionStorageSingleton->Finalize();
  }

  // Exit if we do not have to wait for the heart beating
  if (!HeartSingleton || !HeartSingleton->IsBeatingActive())
  {
    exit(1);
  }
}
}

QStringList MSContext::CmdArgumentMsgs = QStringList() <<
  "ca_ArgumentNotFound" <<
  "ca_ArgumentFound" <<
  "ca_ArgumentFoundWithParameter";

MSContext::MSContext(int& argc, char** argv, bool graphical_context) : CPUProfiling(false),
  DefaultDebugItems(""), SessionPrepared(false), SessionRuntimeTimerName("SessionRuntime")
{
  if (Singleton)
  {
    MC_ERROR("Only one MSContext instance can be created!");
  }
  // Set a new number as random seed
  MCRandomSeed::SetNewSeed();
  qsrand(QDateTime::currentDateTimeUtc().toTime_t());
  srand(QDateTime::currentDateTimeUtc().toTime_t());

  if (graphical_context)
  {
    QApplication* QtContext = new QApplication(argc, argv);
    // Set the font to something standard and readable
    boost::scoped_ptr<QFont> AppFont(new QFont("Courier New", 10));

    QtContext->setFont(*AppFont);
    App = QtContext;
  } else {
    App = new QCoreApplication(argc, argv);
  }
#if defined(__MINGW32__) || defined(__MINGW64__)
  // Add the current path to search Qt plug-ins (e.g sqlite backend)
  App->addLibraryPath(QDir::currentPath());
  App->addLibraryPath(QString(AIBOPLUS_SOURCE_ROOT)+MC_DIR_SEPARATOR+"libs"+MC_DIR_SEPARATOR+"Qt"+
                      MC_DIR_SEPARATOR+"plugins");
#endif
  // Singleton pattern
  Singleton = this;
  // Heartbeat singleton
  HeartSingleton = new MSHeart();
  connect(HeartSingleton, SIGNAL(BeatBegin(int)), this, SIGNAL(NewHeartBeat(int)), Qt::QueuedConnection);
  connect(HeartSingleton, SIGNAL(Finished()), this, SLOT(HeartFinished()), Qt::QueuedConnection);
  connect(this, SIGNAL(Stop()), HeartSingleton, SLOT(StopBeating()), Qt::QueuedConnection);

  // Session storage singleton
  SessionStorageSingleton = MSSessionStorage::GetInstance();
  SessionStorageSingleton->connect(SessionStorageSingleton, SIGNAL(EndOfDatabase()),
                                   this, SIGNAL(PlayedSessionFinished()));
  SessionStorageSingleton->connect(HeartSingleton, SIGNAL(StorageForCurrentBeat(int)),
                                   SessionStorageSingleton, SLOT(BeatEnd(int)));

  // Store the program arguments
  ProgramArguments = App->arguments();
  FindMindSessionArgs();
  // Clear vector of registered elements
  RegElements.clear();
  // Install signal handlers
  signal(SIGFPE, MSSignalHandler);
  signal(SIGSEGV, MSSignalHandler);
  signal(SIGILL, MSSignalHandler);
  signal(SIGINT, MSSignalHandler);
  signal(SIGTERM, MSSignalHandler);
#if defined(__MINGW32__) || defined(__MINGW64__)
  signal(SIGBREAK, MSSignalHandler);
#endif
  signal(SIGABRT, MSSignalHandler);
  // Register the run time timer
  RegisterTimer(SessionRuntimeTimerName, "Session runtime");
}


MSContext::~MSContext()
{
  // Clear vector of registered elements
  RegElements.clear();
  Singleton = nullptr;

  // Disconnect Stop signal
  disconnect();
  // Delete session storage singleton
  if (SessionStorageSingleton)
  {
    SessionStorageSingleton->disconnect();
    delete SessionStorageSingleton;
    SessionStorageSingleton = nullptr;
  }
  // Delete heart singleton
  if (HeartSingleton)
  {
    HeartSingleton->disconnect();
    delete HeartSingleton;
    HeartSingleton = nullptr;
  }
  // Stop the CPU profiler
  if (CPUProfiling)
  {
#ifdef AP_CPU_PROFILER
    ProfilerStop();
#endif
    CPUProfiling = false;
  }
  // Clear timer hash
  Timers.clear();
  // Destroy the application instance
  if (App)
  {
    delete App;
    App = nullptr;
  }
}


MSContext* MSContext::GetInstance()
{
  if (!Singleton)
  {
    MC_ERROR("MSContext instance can not be created by MSContext::GetInstance()");
  }
  return Singleton;
}


QString MSContext::GetDefaultDebugItems() const
{
  return DefaultDebugItems;
}


void MSContext::SetDefaultDebugItems(const QString& items)
{
  DefaultDebugItems = items;
}


QString MSContext::GetPlaybackPath() const
{
  return SessionStorageSingleton->GetPlaybackPath();
}


void MSContext::SetPlaybackPath(const QString& play_path)
{
  SessionStorageSingleton->SetPlaybackPath(play_path);
}


QString MSContext::GetRecordPath() const
{
  return SessionStorageSingleton->GetRecordPath();
}


void MSContext::SetRecordPath(const QString& record_path)
{
  if (HeartSingleton->IsBeatingActive())
    return;
  SessionStorageSingleton->SetRecordPath(record_path);
}


QString MSContext::GenerateRecordPath()
{
  QDateTime CurrentDate = QDateTime::currentDateTime();
  QString TempStr = MSGetBasePath();

  TempStr += "/sessions/";
  TempStr += CurrentDate.toString("yyyy-MM-dd_hh.mm.ss");
  TempStr += '_'+QString::number(MCRandComplex(0, 1000));
  return TempStr;
}


int MSContext::GetMaxBeats() const
{
  return HeartSingleton->GetMaxBeats();
}


void MSContext::SetMaxBeats(int max_beats)
{
  HeartSingleton->SetMaxBeats(max_beats);
}


int MSContext::GetPlayedBeats() const
{
  return SessionStorageSingleton->GetPlayedHeartBeats();
}


int MSContext::GetCurrentBeat() const
{
  return HeartSingleton->GetCurrentBeat();
}


bool MSContext::HasRegisteredElements() const
{
  return !RegElements.isEmpty();
}


bool MSContext::IsPaused() const
{
  return PauseTimer;
}


bool MSContext::IsBeatingFinished() const
{
  return HeartSingleton->IsBeatFinished();
}


bool MSContext::IsMalfunctionHappened() const
{
  return MalfunctionStatus;
}


MSContext::ArgSearchResult MSContext::FindArgument(const QString& arg, const QString& long_arg)
{
  int Index = -1;
  ArgSearchResult Result;

  Result.Parameter = nullptr;
  Index = ProgramArguments.indexOf(arg);
  Index = Index == -1 ? ProgramArguments.indexOf(long_arg) : Index;

  if (Index == -1)
  {
    Result.SearchResult = ca_ArgumentNotFound;
    return Result;
  }
  if (Index > -1 && (Index+1 == ProgramArguments.size() ||
                     ProgramArguments[Index+1].toAscii().data()[0] == '-'))
  {
    Result.SearchResult = ca_ArgumentFound;
    return Result;
  }
  Result.SearchResult = ca_ArgumentFoundWithParameter;
  Result.Parameter = &ProgramArguments[Index+1];
  return Result;
}


void MindCoreUsage()
{
  MC_NPRINT("\nCommon options for libmindsession applications:\n"
            "\n"
            "  -c, --colordebug STRING   Colorized debug mode, for the specified\n"
            "                            classes/functions.\n"
            "  -d, --debug [STRING]      Debug mode, optional argument: Only the specified\n"
            "                            classes/functions are debugged, separated by commas.\n"
#ifdef AP_CPU_PROFILER
            "  -P, --profiling           Run with processor profiler\n"
#endif
            "  -b, --beatlimit INT       The beat limit for the heart\n"
            "  -h, --help                Print this text\n\n");
}


void MSContext::FindMindSessionArgs()
{
  ArgSearchResult Result;

  // Scan for -h or --help argument
  Result = FindArgument("-h", "--help");
  if (Result.SearchResult != ca_ArgumentNotFound)
  {
    MindCoreUsage();
    return;
  }
  // Scan for -d or --debug argument
  Result = FindArgument("-d", "--debug");
  if (Result.SearchResult != ca_ArgumentNotFound)
  {
    MCLog::SetDebugStatus(true);
    if (Result.SearchResult == ca_ArgumentFoundWithParameter)
    {
      MCLog::SetDebugFilter(Result.Parameter->toStdString());
    }
  }
  // Scan for -P or --profiling argument
  Result = FindArgument("-P", "--profiling");
  if (Result.SearchResult != ca_ArgumentNotFound)
  {
    CPUProfiling = true;
#ifdef AP_CPU_PROFILER
    ProfilerStart("./cpu_profiler.perf");
#endif
  }
  // Scan for -c or --colordebug argument
  Result = FindArgument("-c", "--colordebug");
  if (Result.SearchResult == ca_ArgumentFoundWithParameter)
  {
    MCLog::SetDebugColorFilters(Result.Parameter->toStdString());
  }
}


void MSContext::HeartFinished()
{
  MC_BPRINT(MCLog::Blue, "The heart beating has been stopped...\n");

  if (GetTimerElapsedTime(SessionRuntimeTimerName) > 0)
  {
    int RunTime = GetTimerElapsedTime(SessionRuntimeTimerName);

    MC_NPRINT("Session run-time: %d ms (heart beats: %d, %.2f ms/beat)\n", RunTime,
              HeartSingleton->GetCurrentBeat(), (float)RunTime / HeartSingleton->GetCurrentBeat());

    for (auto iter = Timers.begin(); iter != Timers.end(); ++iter)
    {
      if (iter.key() != SessionRuntimeTimerName && iter.value().Time > 0)
      {
        MC_NPRINT("%s: %d ms (%.2f %%)\n", iter.value().Description.toAscii().data(),
                  iter.value().Time, (float)iter.value().Time*100 / RunTime);
      }
    }
  }
  if (SessionPrepared)
  {
    FinishSession();
  }
  Q_EMIT(HeartStopped());
}


void MSContext::RegisterSessionStorage(MSSessionStorageInterface& storage)
{
  SessionStorageSingleton->RegisterStorage(storage);
}


void MSContext::RegisterElement(MSElement& element)
{
  MC_LOG("Register element (id: %d) to the context", element.GetElementID());
  if (element.GetType() != MS::Sink && element.GetType() != MS::SinkGui && SessionPrepared)
  {
    MC_WARNING("A session has been prepared. Only sink elements can be registered.");
    return;
  }
  if (element.GetType() != MS::Sink && element.GetType() != MS::SinkGui && HeartSingleton->IsBeatingActive())
  {
    MC_WARNING("The heart beating is active. Only sink elements can be registered.");
    return;
  }
  if (RegElements.contains(&element))
  {
    MC_WARNING("Element is registered already!");
    return;
  }
  connect(this, SIGNAL(Stop()), &element, SLOT(Stop()));
  RegElements.append(&element);
  // Manual registration is needed for sink elements if the heart beating is already active
  if (HeartSingleton->IsBeatingActive())
  {
    HeartSingleton->RequestElementRegistration(element);
  }
}


void MSContext::UnregisterElement(MSElement& element)
{
  MC_LOG("Unregister element (id: %d) from the context", element.GetElementID());
  if (element.GetType() != MS::Sink && element.GetType() != MS::SinkGui && SessionPrepared)
  {
    MC_WARNING("A session has been prepared. Only sink elements can be unregistered.");
    return;
  }
  if (element.GetType() != MS::Sink && element.GetType() != MS::SinkGui && HeartSingleton->IsBeatingActive())
  {
    MC_WARNING("The heart beating is active. Only sink elements can be unregistered.");
    return;
  }
  if (!RegElements.contains(&element))
  {
//    MC_WARNING("Element %s (id: %d) is not registered!", qPrintable(element.GetClass()),
//               element.GetElementID());
    return;
  }
  if (HeartSingleton->IsElementRegistered(element))
  {
    HeartSingleton->UnregisterElement(element);
  }
  disconnect(this, SIGNAL(Stop()), &element, SLOT(Stop()));
  RegElements.removeAt(RegElements.indexOf(&element));
}


void MSContext::SetBeatDurationLimit(int new_limit)
{
  HeartSingleton->SetBeatDurationLimit(new_limit);
}


bool MSContext::PrepareSession()
{
  if (SessionPrepared)
  {
    MC_LOG("A session has been prepared already!");
    return false;
  }
  // Prepare to record a session if needed
  if (!SessionStorageSingleton->GetRecordPath().isEmpty())
  {
    SessionStorageSingleton->PrepareRecord();
  }
  // Prepare to play a session if needed
  if (!SessionStorageSingleton->GetPlaybackPath().isEmpty())
  {
    SessionStorageSingleton->PreparePlay();
  }
  // Register the elements to the storage
  for (int i = 0; i < RegElements.size(); ++i)
  {
    if (RegElements[i]->GetType() == MS::Source &&
        (!SessionStorageSingleton->GetRecordPath().isEmpty() || !SessionStorageSingleton->GetPlaybackPath().isEmpty()))
    {
      SessionStorageSingleton->RegisterElement(*RegElements[i]);
    }
  }
  SessionPrepared = true;
  return true;
}


void MSContext::FinishSession()
{
  if (!SessionPrepared)
  {
    MC_WARNING("There is no ongoing session to stop!");
    return;
  }
  // Finalize the storage operations
  SessionStorageSingleton->Finalize();
  SessionPrepared = false;
}


void MSContext::StartHeartBeating()
{
  // Start the first heart beat
  MC_BPRINT(MCLog::Blue, "Start the heart beating...\n");
  // Prepare the beating if it has not been yet
  if (!SessionPrepared)
  {
    PrepareSession();
  }
  // Register the elements to the heart
  for (int i = 0; i < RegElements.size(); ++i)
  {
    HeartSingleton->RegisterElement(*RegElements[i]);
  }
  HeartSingleton->StartBeating();
  StartTimer(SessionRuntimeTimerName);
  // Reset the timers
  for (auto iter = Timers.begin(); iter != Timers.end(); ++iter)
  {
    iter.value().Time = 0;
    iter.value().Timer.restart();
  }
  SessionStorageSingleton->ResetTimers();
}


void MSContext::StopHeartBeating()
{
  // Stop the heart
  HeartSingleton->StopBeating();
}


void MSContext::Pause()
{
  HeartSingleton->PauseBeating();
  PauseTimers();
}


void MSContext::Resume()
{
  HeartSingleton->ResumeBeating();
  ResumeTimers();
}


void MSContext::RegisterTimer(const QString& id, const QString& description)
{
  if (id.isEmpty())
  {
    MC_WARNING("Empty timer ID.");
    return;
  }
  if (description.isEmpty())
  {
    MC_WARNING("Empty timer description.");
    return;
  }
  if (Timers.contains(id))
  {
    MC_WARNING("A timer is already registered with the id %s.", id.toAscii().data());
    return;
  }
  TimerData NewTimer;

  NewTimer.Description = description;
  NewTimer.Time = 0;
  Timers[id] = NewTimer;
}


void MSContext::StartTimer(const QString& id)
{
  if (id.isEmpty())
  {
    MC_WARNING("Empty timer ID.");
    return;
  }
  if (!Timers.contains(id))
  {
    MC_WARNING("No timer is registered with this id %s.", id.toAscii().data());
    return;
  }
  if (PauseTimer)
  {
    MC_WARNING("Timers are paused. Can't start a new timer.");
    return;
  }
  Timers[id].Timer.restart();
}


void MSContext::StopTimer(const QString& id)
{
  if (id.isEmpty())
  {
    MC_WARNING("Empty timer ID.");
    return;
  }
  if (!Timers.contains(id))
  {
    MC_WARNING("No timer is registered with this id %s.", id.toAscii().data());
    return;
  }
  if (PauseTimer)
  {
    MC_WARNING("Timers are paused. Can't stop a timer.");
    return;
  }
  Timers[id].Time += Timers[id].Timer.elapsed();
  Timers[id].Timer = QTime();
}


void MSContext::ResetTimer(const QString& id)
{
  if (id.isEmpty())
  {
    MC_WARNING("Empty timer ID.");
    return;
  }
  if (!Timers.contains(id))
  {
    MC_WARNING("No timer is registered with this id %s.", id.toAscii().data());
    return;
  }
  if (PauseTimer)
  {
    MC_WARNING("Timers are paused. Can't restart a new timer.");
    return;
  }
  Timers[id].Time = 0;
  Timers[id].Timer = QTime();
}


int MSContext::GetTimerElapsedTime(const QString& id)
{
  if (id.isEmpty())
  {
    MC_WARNING("Empty timer ID.");
    return 0;
  }
  if (!Timers.contains(id))
  {
    MC_WARNING("No timer is registered with this id %s.", id.toAscii().data());
    return 0;
  }
  if (PauseTimer)
  {
    return Timers[id].Time;
  }
  if (Timers[id].Timer.isValid())
  {
    Timers[id].Time += Timers[id].Timer.elapsed();
    Timers[id].Timer = QTime();
    Timers[id].Timer.start();
  }
  return Timers[id].Time;
}


void MSContext::PauseTimers()
{
  if (PauseTimer)
  {
    MC_WARNING("Timers are already paused.");
    return;
  }
  PauseTimer = new QTime();
  PauseTimer->start();
}


void MSContext::ResumeTimers()
{
  if (!PauseTimer)
  {
    MC_WARNING("Timers have not been paused yet.");
    return;
  }
  int PauseTime = PauseTimer->elapsed();

  delete PauseTimer;
  PauseTimer = nullptr;
  for (auto iter = Timers.begin(); iter != Timers.end(); ++iter)
  {
    if (iter.value().Timer.isValid())
    {
      iter.value().Time += iter.value().Timer.elapsed()-PauseTime;
      iter.value().Timer = QTime();
      iter.value().Timer.start();
    }
  }
}