Scale Stack 0.3 Developer Documentation

scalestack/kernel/core.h

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.
 */

#ifndef SCALESTACK_KERNEL_CORE_H
#define SCALESTACK_KERNEL_CORE_H

#include <map>
#include <string>
#include <vector>

#include <scalestack/kernel/logger.h>
#include <scalestack/kernel/macros.h>

namespace scalestack
{
namespace kernel
{

class log;
class module;
class service;

class SCALESTACK_API core: private logger
{
public:

  core(void);

  ~core();

  /* Make the base class method public. */
  using logger::get_threshold;

  /* Make the base class method public. */
  using logger::set_threshold;

  void parse_arguments(int argument_count, const char** arguments);

  void parse_file(const std::string& filename);

  void add_module_option_value(const std::string& module_name,
                               const std::string& option_name,
                               const std::string& value);

  void set_signal_handlers(void);

  void handle_signal(int signal_number);

  module& get_or_add_module(const std::string& name);

  module& get_module(const std::string& name) const;

  size_t get_module_count(void) const;

  module* begin_module(void);

  module* next_module(void);

  void add_service(const std::string& name, service* service);

  service* remove_service(const std::string& name);

  service& get_service(const std::string& name) const;

  size_t get_service_count(void) const;

  void add_log(const std::string& name, log* log);

  log* remove_log(const std::string& name);

  log& get_log(const std::string& name) const;

  size_t get_log_count(void) const;

  void run(void);

  void shutdown(void);

private:

  SCALESTACK_LOCAL
  core(const core&);

  SCALESTACK_LOCAL
  core& operator=(const core&);

  SCALESTACK_LOCAL
  void _parse_argument(std::string argument);

  SCALESTACK_LOCAL
  const std::string& _get_alias(const std::string& name) const;

  SCALESTACK_LOCAL
  module* _get_module(const std::string& name) const;

  SCALESTACK_LOCAL
  void _notify(void);

  SCALESTACK_LOCAL
  void _set_fatal_message(const char* format, std::va_list arguments) const;

  SCALESTACK_LOCAL
  void _log_message(log::level log_level,
                    const char* format,
                    std::va_list arguments) const;

  SCALESTACK_LOCAL
  void _log(log::level log_level,
            const char* context,
            const char* format,
            std::va_list arguments) const;

  SCALESTACK_LOCAL
  void _print_help(void);

  SCALESTACK_LOCAL
  void _print_config(void);

  typedef std::vector<std::string> files;
  typedef std::vector<std::string> paths;
  typedef std::vector<module*> modules;
  typedef std::map<std::string, std::string> aliases;
  typedef std::map<std::string, service*> services;
  typedef std::map<std::string, log*> logs;

  bool _need_help;
  bool _need_config;
  bool _shutdown_request;
  bool _iterator_on_modules;
  int _notify_pipe[2];
  files _open_files;
  paths _paths;
  modules _modules;
  modules _new_modules;
  modules::iterator _module_iterator;
  aliases _aliases;
  services _services;
  logs _logs;

  friend class module;
};

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

#endif /* SCALESTACK_KERNEL_CORE_H */

---