Scale Stack 0.3 Developer Documentation

scalestack/kernel/module.cc

Go to the documentation of this file.

/*
 * Scale Stack
 *
 * Copyright 2010 Eric Day
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "config.h"

#include <algorithm>
#include <cctype>
#include <cerrno>
#include <cstdio>
#include <cstring>
#include <dlfcn.h>
#include <functional>
#include <iostream>
#include <memory>
#include <strings.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#include <scalestack/kernel/core.h>
#include <scalestack/kernel/delete_pointer.h>
#include <scalestack/kernel/exception.h>
#include <scalestack/kernel/module.h>
#include <scalestack/kernel/option.h>

using namespace std;

namespace scalestack
{
namespace kernel
{

/*
 * Public methods.
 */

module::~module()
{
  log_info(_("Destructing"));
  _unload();
  for_each(_options.begin(), _options.end(), delete_pointer());
  _close_object();
  log_info(_("Destructed"));
}

core& module::get_core(void) const
{
  return _core;
}

const string& module::get_name(void) const
{
  return _name;
}

string module::get_normalized_name(void) const
{
  return normalize_name(_name);
}

const string& module::get_pathname(void) const
{
  return _pathname;
}

const string& module::get_version(void) const
{
  return _version;
}

const string& module::get_author(void) const
{
  return _author;
}

const string& module::get_title(void) const
{
  return _title;
}

const string& module::get_license(void) const
{
  return _license;
}

const string& module::get_dependencies(void) const
{
  return _dependencies;
}

size_t module::get_parent_count(void) const
{
  return _parents.size();
}

module* module::begin_parent(void)
{
  _parent_iterator = _parents.begin();
  return next_parent();
}

module* module::next_parent(void)
{
  if (_parent_iterator == _parents.end())
    return NULL;

  return *(_parent_iterator++);
}

size_t module::get_child_count(void) const
{
  return _children.size();
}

module* module::begin_child(void)
{
  _child_iterator = _children.begin();
  return next_child();
}

module* module::next_child(void)
{
  if (_child_iterator == _children.end())
    return NULL;

  return *(_child_iterator++);
}

bool module::is_loaded(void) const
{
  return _is_loaded;
}

option& module::add_option(const std::string& name,
                           const std::string& help,
                           const std::string& value_name,
                           const std::string& default_value)
{
  option& option = _get_or_add_option(name);
  if (option.is_valid())
    log_fatal(_("Duplicate option added: %s"), name.c_str());

  option._set_help(help);
  option._set_value_name(value_name);
  option._set_default_value(default_value);
  option._set_value(default_value, false);
  option._set_valid(true);
  return option;
}

option& module::get_option(const std::string& name) const
{
  option* option = _get_option(name);
  if (option == NULL)
    log_fatal(_("Could not find option: %s"), name.c_str());

  return *option;
}

size_t module::get_option_count(void) const
{
  return _options.size();
}

option* module::begin_option(void)
{
  _option_iterator = _options.begin();
  return next_option();
}

option* module::next_option(void)
{
  if (_option_iterator == _options.end())
    return NULL;

  return *(_option_iterator++);
}

void module::run(void)
{
  if (!_is_started)
    return;

  _need_run = true;
  _core._notify();
}

string module::normalize_name(const std::string& name)
{
  string filename;

  for (string::const_iterator c = name.begin(); c != name.end(); ++c)
  {
    if (*c == ':')
    {
      ++c;
      filename.push_back('_');
    }
    else
      filename.push_back(static_cast<char>(tolower(*c)));
  }

  return filename;
}

/*
 * Private methods.
 */

module::module(core& core, const std::string& name, size_t threshold):
  logger(threshold),
  _is_loading(),
  _is_loaded(),
  _is_started(),
  _need_run(true),
  _need_reconfigure(true),
  _core(core),
  _handle(),
  _definition(),
  _name(name),
  _pathname(),
  _version(),
  _author(),
  _title(),
  _license(),
  _dependencies(),
  _parents(),
  _parent_iterator(_parents.begin()),
  _children(),
  _child_iterator(_children.begin()),
  _options(),
  _option_iterator(_options.begin())
{
  log_info(_("Constructed"));
}

void module::_load(void)
{
  if (is_loaded())
    return;

  if (_is_loading)
    log_fatal(_("Module dependency loop detected"));

  _load_dependencies();

  _is_loading = true;

  if (_dependencies.size() > 0)
  {
    size_t comma;
    size_t start = 0;

    do
    {
      comma = _dependencies.find(",", start);
      string module_name(_dependencies, start, comma - start);

      if (module_name.size() > 0)
      {
        module& parent = _core.get_or_add_module(module_name);
        _parents.push_back(&parent);
        parent._children.push_back(this);
        parent._load();
      }

      start = comma + 1;
    }
    while (comma != string::npos);
  }

  _open_object(RTLD_NOW | RTLD_GLOBAL);

  _name = _definition->name;
  _version = _definition->version;
  _author = _definition->author;
  _title = _definition->title;
  _license = _definition->license;

  _is_loading = false;
  _is_loaded = true;

  if (_definition->options != NULL)
    _definition->options(*this);

  log_notice(_("Loaded"));
  log_debug(_("Version: %s"), _version.c_str());
  log_debug(_("Author: %s"), _author.c_str());
  log_debug(_("Title: %s"), _title.c_str());
  log_debug(_("License: %s"), _license.c_str());
}

void module::_load_dependencies(void)
{
  string filename(normalize_name(_name));
  core::paths::const_iterator path;
  for (path = _core._paths.begin(); path != _core._paths.end(); ++path)
  {
    _pathname = *(path) + "/lib" + filename + "_module." +
                SCALESTACK_MODULE_EXTENSION;
    log_debug(_("Checking pathname: %s"), _pathname.c_str());

    struct stat stat_buffer;
    int stat_return = stat(_pathname.c_str(), &stat_buffer);
    if (stat_return == 0)
      break;
    else if (stat_return == -1 && errno != ENOENT)
    {
      log_fatal(_("Could not stat() pathname: %s (%s:%d)"),
                _pathname.c_str(), strerror(errno), errno);
    }
  }

  if (path == _core._paths.end())
    log_fatal(_("Could not find this module"));

  log_info(_("Loading from: %s"), _pathname.c_str());

  _open_object(RTLD_LAZY);

  _dependencies = _definition->dependencies;

  log_debug(_("Dependencies: %s"), _dependencies.c_str());

  _close_object();
}

void module::_unload(void)
{
  if (!is_loaded())
    return;

  log_info(_("Unloading"));

  for_each(_children.begin(), _children.end(), mem_fun(&module::_unload));

  log_info(_("Stopping"));

  if (_is_started && _definition->stop != NULL)
    _definition->stop(*this);

  _is_started = false;

  log_notice(_("Unloaded"));

  _is_loaded = false;
}

void module::_start(void)
{
  if (_is_started)
    return;

  for_each(_parents.begin(), _parents.end(), mem_fun(&module::_start));

  log_info(_("Starting"));

  if (_definition->start != NULL)
    _definition->start(*this);

  _is_started = true;
}

void module::_run(void)
{
  if (!_need_run || _definition->run == NULL)
    return;

  log_debug(_("Running"));
  _need_run = false;
  _definition->run(*this);
}

void module::_reconfigure(void)
{
  if (!_need_reconfigure || _definition->reconfigure == NULL)
    return;

  log_debug(_("Reconfiguring"));
  _need_reconfigure = false;
  _definition->reconfigure(*this);
}

void module::_open_object(int flags)
{
  _handle = dlopen(_pathname.c_str(), flags);
  if (_handle == NULL)
    log_fatal(_("Could not open shared object file: %s"), dlerror());

  _definition = static_cast<module::definition*>(dlsym(
    _handle, "_scalestack_kernel_module_definition"));
  if (_definition == NULL)
  {
    /* Copy dlerror() into buffer because the dlclose() may clear the error. */
    char error[SCALESTACK_MAX_MESSAGE_SIZE];
    snprintf(error, SCALESTACK_MAX_MESSAGE_SIZE, "%s", dlerror());
    (void) dlclose(_handle);
    _handle = NULL;
    log_fatal(_("Could not find definition symbol in shared object: %s"),
              error);
  }
}

void module::_close_object(void)
{
  if (_handle == NULL)
    return;

  if (dlclose(_handle) != 0)
    log_fatal(_("Could not close shared object file: %s"), dlerror());

  _definition = NULL;
  _handle = NULL;
}

option* module::_get_option(const std::string& name) const
{
  /*
   * The find_if algorithm cannot be used here because this would require
   * bind2nd, and that has the reference-to-reference problem with some
   * implementations when used with methods that take a reference.
   */
  for (options::const_iterator option = _options.begin();
       option != _options.end();
       ++option)
  {
    if (!strcasecmp((*option)->get_name().c_str(), name.c_str()))
      return *option;
  }

  return NULL;
}

option& module::_get_or_add_option(const std::string& name)
{
  option* option = _get_option(name);
  if (option != NULL)
    return *option;

  auto_ptr<kernel::option> new_option(new kernel::option(*this, name));
  _options.push_back(new_option.get());
  return *(new_option.release());
}

void module::_set_option_value(const std::string& name,
                               const std::string& value)
{
  /* Check for verbose options. */
  if (value == "" && name.find_first_not_of("v") == string::npos)
  {
    set_threshold(name.size());
    return;
  }

  if (name == "v")
  {
    set_threshold(atoi(value.c_str()));
    return;
  }

  option& option = _get_or_add_option(name);
  option._set_value(value, true);

  if (_is_started)
  {
    _need_reconfigure = true;
    _core._notify();
  }
}

void module::_check_options(void) const
{
  options::const_iterator option = find_if(_options.begin(),
                                           _options.end(),
                                           not1(mem_fun(&option::is_valid)));
  if (option != _options.end())
    log_fatal(_("Invalid option: %s"), (*option)->get_name().c_str());
}

void module::_set_fatal_message(const char* format,
                                std::va_list arguments) const
{
  char message[SCALESTACK_MAX_MESSAGE_SIZE];
  vsnprintf(message, SCALESTACK_MAX_MESSAGE_SIZE, format, arguments);
  throw kernel::exception(_name.c_str(), message);
}

void module::_log_message(log::level log_level,
                          const char* format,
                          std::va_list arguments) const
{
  _core._log(log_level, _name.c_str(), format, arguments);
}

void module::_print_help(void)
{
  if (_options.empty())
    return;

  cout << _name << endl;
  for_each(_options.begin(), _options.end(), mem_fun(&option::_print_help));
  cout << endl;
}

void module::_print_config(void)
{
  for_each(_options.begin(), _options.end(), mem_fun(&option::_print_config));
}

} /* namespace kernel */
} /* namespace scalestack */

---