ManagerConfig.cpp

Go to the documentation of this file.

// -*- C++ -*-
#include <rtm/RTC.h>
#include <rtm/ManagerConfig.h>
#include <fstream>
#include <iostream>
#include <coil/OS.h>
#include <coil/stringutil.h>
#include <rtm/DefaultConfiguration.h>

namespace RTC
{
  
  // The list of default configuration file path.
  const char* ManagerConfig::config_file_path[] = 
    {
      "./rtc.conf",
      "/etc/rtc.conf",
      "/etc/rtc/rtc.conf",
      "/usr/local/etc/rtc.conf",
      "/usr/local/etc/rtc/rtc.conf",
      NULL
    };
  
  // Environment value to specify configuration file
  const char* ManagerConfig::config_file_env = "RTC_MANAGER_CONFIG";
  
  ManagerConfig::ManagerConfig()
    : m_isMaster(false)
  {
  }
  
  ManagerConfig::ManagerConfig(int argc, char** argv)
    : m_isMaster(false)
  {
    init(argc, argv);
  }
  
  ManagerConfig::~ManagerConfig()
  {
  }
  
  void ManagerConfig::init(int argc, char** argv)
  {
    parseArgs(argc, argv);
  }
  
  void ManagerConfig::configure(coil::Properties& prop)
  {
    prop.setDefaults(default_config);
    if (findConfigFile())
      {
        std::ifstream f(m_configFile.c_str());
        if (f.is_open())
          {
            prop.load(f);
            f.close();
          }
      }
    setSystemInformation(prop);
    if (m_isMaster) { prop["manager.is_master"] = "YES"; }

    // Properties from arguments are marged finally
    prop << m_argprop;
    prop["config_file"] = m_configFile;
  }
  
  void ManagerConfig::parseArgs(int argc, char** argv)
  {
    coil::GetOpt get_opts(argc, argv, "af:l:o:p:d", 0);
    int opt;
    
    //  if (argc == 0) return true;
    
    while ((opt = get_opts()) > 0)
      {
        switch (opt)
          {
          case 'a':
            {
              m_argprop["manager.corba_servant"] = "NO";
            }
            break;
            // Specify configuration file not default
          case 'f':
            m_configFile = get_opts.optarg;
            break;
          case 'l':
            //      m_configFile = get_opts.optarg;
            break;
          case 'o':
            {
              std::string optarg(get_opts.optarg);
              std::string::size_type pos(optarg.find(":"));
              if (pos != std::string::npos)
                {
                  m_argprop[optarg.substr(0, pos)] = optarg.substr(pos + 1);
                }
            }
            break;
          case 'p': // ORB's port number
            {
              int portnum;
              if (coil::stringTo(portnum, get_opts.optarg))
                {
                  std::string arg(":"); arg += get_opts.optarg;
                  m_argprop["corba.endpoints"]  = arg;
                }
            }
            break;
          case 'd':
            m_isMaster = true;
            break;
          default:
            ;
          }
      }
    return;
  }
  
  bool ManagerConfig::findConfigFile()
  {
    // Check existance of configuration file given command arg
    if (m_configFile != "") 
      {
        if (fileExist(m_configFile))
          {
            return true;
          }
      }
    
    // Search rtc configuration file from environment variable
    char* env = getenv(config_file_env);
    if (env != NULL)
      {
        if (fileExist(env))
          {
            m_configFile = env;
            return true;
          }
      }
    // Search rtc configuration file from default search path
    int i = 0;
    while (config_file_path[i] != NULL)
      {
        if (fileExist(config_file_path[i]))
          {
            m_configFile = config_file_path[i];
            return true;
          }
        ++i;
      }
    return false;
  }
  
  void ManagerConfig::setSystemInformation(coil::Properties& prop)
  { 
    //
    // Get system information by using ACE_OS::uname (UNIX/Windows)
    // 
    coil::utsname  sysinfo;
    if (coil::uname(&sysinfo) != 0)
      {
        return;
      }
    
    //
    // Getting current proccess pid by using ACE_OS::getpid() (UNIX/Windows)
    //
    coil::pid_t pid = coil::getpid();
    char pidc[8];
    sprintf(pidc, "%d", pid);
    
    prop.setProperty("os.name",     sysinfo.sysname);
    prop.setProperty("os.release",  sysinfo.release);
    prop.setProperty("os.version",  sysinfo.version);
    prop.setProperty("os.arch",     sysinfo.machine);
    prop.setProperty("os.hostname", sysinfo.nodename);
    prop.setProperty("manager.pid",         pidc);
    
    return;
  }
  
  bool ManagerConfig::fileExist(const std::string& filename)
  {
    std::ifstream infile;
    infile.open(filename.c_str(), std::ios::in);
    // fial() 0: ok, !0: fail
    if (infile.fail() != 0) 
      {
        infile.close();
        return false;
      }
    else
      {
        infile.close();
        return true;
      }
    return false;
  }
}