dazeus.cpp

Go to the documentation of this file.

#include "dazeus.h"
#include "database.h"
#include "network.h"
#include "config.h"
#include "plugincomm.h"
#include "pluginmonitor.h"
#include <cassert>
#include <sstream>
#include <iostream>

// #define DEBUG
#define VERBOSE

dazeus::DaZeus::DaZeus( std::string configFileName )
: config_( 0 )
, configFileName_( configFileName )
, plugins_( 0 )
, plugin_monitor_( 0 )
, database_( 0 )
, networks_()
, running_(false)
{
}


dazeus::DaZeus::~DaZeus()
{
  std::vector<Network*>::iterator it;
  for(it = networks_.begin(); it != networks_.end(); ++it)
  {
    (*it)->disconnectFromNetwork( Network::ShutdownReason );
    delete *it;
  }
  networks_.clear();

  delete plugin_monitor_;
  delete plugins_;
  delete config_;
  delete database_;
}


void dazeus::DaZeus::autoConnect()
{
#ifdef DEBUG
  fprintf(stderr, "dazeus::DaZeus::autoConnect() called: looking for networks to connect to\n");
#endif
  std::vector<Network*>::iterator it;
  for(it = networks_.begin(); it != networks_.end(); ++it)
  {
    Network *n = *it;
    if( n->autoConnectEnabled() )
    {
#ifdef DEBUG
      fprintf(stderr, "Connecting to %s (autoconnect is enabled)\n", Network::toString(n).c_str());
#endif
      n->connectToNetwork();
    }
#ifdef DEBUG
    else
    {
      fprintf(stderr, "Not connecting to %s, autoconnect is disabled.\n", Network::toString(n).c_str());
    }
#endif
  }
}


std::string dazeus::DaZeus::configFileName() const {
        return configFileName_;
}

bool dazeus::DaZeus::configLoaded() const
{
  return config_->isRead();
}


bool dazeus::DaZeus::connectDatabase()
{
  const DatabaseConfig *dbc = config_->getDatabaseConfig();
  if(dbc == 0) {
    fprintf(stderr, "Database configuration is absent, cannot continue.\n");
    return false;
  }
  database_ = new Database(dbc->hostname, dbc->port, dbc->database, dbc->username, dbc->password);

  if( !database_->open() )
  {
    fprintf(stderr, "Could not connect to database: %s\n", database_->lastError().c_str());
    return false;
  }

  return true;
}

dazeus::Database *dazeus::DaZeus::database() const
{
  return database_;
}



bool dazeus::DaZeus::initPlugins()
{
  assert(plugins_ != 0);
  plugins_->init();

  return true;
}


bool dazeus::DaZeus::loadConfig()
{
  assert( configFileName_.length() != 0 );

  if( config_ != 0 ) {
    delete config_;
  }

  config_ = new ConfigReader(configFileName_);

  if( !config_ )
    return false;

  try {
    config_->read();
  } catch(ConfigReader::exception &e) {
    std::cerr << "Failed to read configuration: " << e.what() << std::endl;
    return false;
  }

  const std::vector<NetworkConfig*> &networks = config_->getNetworks();

  if(!connectDatabase()) {
    delete config_;
    config_ = 0;
    return false;
  }

  if(plugins_)
    delete plugins_;
  plugins_ = new PluginComm( database_, config_, this );
  plugin_monitor_ = new PluginMonitor(config_->getPluginSocket(),
    config_->getGlobalConfig()->plugindirectory,
    config_->getPlugins(),
    config_->getNetworks());

  std::vector<NetworkConfig*>::const_iterator it;
  for(it = networks.begin(); it != networks.end(); ++it)
  {
    Network *net = new Network( *it );
    net->addListener(plugins_);
    if( net == 0 ) {
      delete config_;
      config_ = 0;
      return false;
    }

    networks_.push_back( net );
  }

  // Pretty number of initialisations viewer -- and also an immediate database
  // check.
  std::stringstream numInitsStr;
  numInitsStr << database_->property("dazeus.numinits");
  int numInits;
  numInitsStr >> numInits;
  if(!numInitsStr)
    numInits = 0;
  ++numInits;
  numInitsStr.str(""); numInitsStr.clear();
  numInitsStr << numInits;
  database_->setProperty("dazeus.numinits", numInitsStr.str());
  const char *suffix = "th";
  if(numInits%100 == 11 ) ;
  else if(numInits%100 == 12) ;
  else if(numInits%100 == 13) ;
  else if(numInits%10 == 1) suffix = "st";
  else if(numInits%10 == 2) suffix = "nd";
  else if(numInits%10 == 3) suffix = "rd";
  printf("Initialising DaZeus for the %d%s time!\n", numInits, suffix);
  return true;
}

void dazeus::DaZeus::sigchild()
{
        plugin_monitor_->sigchild();
}

void dazeus::DaZeus::stop()
{
        running_ = false;
}

void dazeus::DaZeus::run()
{
        running_ = true;
        while(running_) {
                plugin_monitor_->runOnce();
                // The only non-socket processing in DaZeus is done by the
                // plugin monitor. It works using signals (primarily SIGCHLD),
                // which already interrupt select(). However, its timing in
                // re-starting plugins has a granularity of 5 seconds, so if it
                // is waiting to restart a plugin, we will decrease our timeout
                // length to once every second. If it is in a normal state, we
                // can use any granularity we want.
                plugins_->run(plugin_monitor_->shouldRun() ? 1 : 30);
        }
}

void dazeus::DaZeus::setConfigFileName(std::string filename) {
        configFileName_ = filename;
}