SystemConfig.cpp

Go to the documentation of this file.

/*
 * $Id: ConfigException.cpp 61 2008-01-14 17:38:19Z phbaer $
 *
 * Copyright 2008 Carpe Noctem, Distributed Systems Group,
 * University of Kassel. All right reserved.
 *
 * The code is licensed under the Carpe Noctem Userfriendly BSD-Based
 * License (CNUBBL). Redistribution and use in source and binary forms,
 * with or without modification, are permitted provided that the
 * conditions of the CNUBBL are met.
 *
 * You should have received a copy of the CNUBBL along with this
 * software. The license is also available on our website:
 * http://carpenoctem.das-lab.net/license.txt
 */

#include <stdlib.h>
#include <unistd.h>
#include <iostream>
#include <fstream>

#include <boost/thread.hpp>

#include "asio.hpp"

#include "SystemConfig.h"

namespace castor {

        // Initialize static variables
        bool SystemConfig::initialized = false;

        boost::mutex SystemConfig::mutex;

        SystemConfigPtr SystemConfig::instance;

        boost::filesystem::path SystemConfig::rootPath;
        boost::filesystem::path SystemConfig::libPath;
        boost::filesystem::path SystemConfig::logPath;
        boost::filesystem::path SystemConfig::configPath;
        int SystemConfig::ownRobotID;

        std::string SystemConfig::hostname;

        std::map<std::string, boost::shared_ptr<Configuration> > SystemConfig::configs;

        SystemConfigPtr SystemConfig::getInstance() {

                boost::mutex::scoped_lock lock(mutex);

                if (!initialized) {

                        instance = boost::shared_ptr<SystemConfig>(new SystemConfig());

                        char *x = ::getenv("ES_ROOT");

                        if (x == NULL) {

                                char cwd[PATH_MAX];
                                if (::getcwd(cwd, PATH_MAX) == NULL) {
                                        std::cout << "SystemConfig: Error while calling getcwd!" << std::endl;
                                }

                                rootPath = boost::filesystem::path(cwd).normalize();

                        } else {
                                rootPath = boost::filesystem::path(x).normalize();
                        }

                        x = ::getenv("ES_CONFIG_ROOT");

                        if (x == NULL) {
                                configPath = (rootPath / "etc").normalize();
                        } else {
                                configPath = boost::filesystem::path(x).normalize();
                        }

                        libPath = (rootPath / "lib").normalize();
                        logPath = (rootPath / "log").normalize();
                        char* envname = ::getenv("ROBOT");
                        if( (envname == NULL) || ((*envname)==0x0) ) {
                                hostname = asio::ip::host_name();
                        } else {
                                hostname = envname;
                        }
                        std::cout << "Root:       " << rootPath << std::endl;
                        std::cout << "ConfigRoot: " << configPath << std::endl;
                        std::cout << "LibRoot:    " << libPath << std::endl;
                        std::cout << "LogRoot:    " << logPath << std::endl;
                        std::cout << "Hostname:   " << hostname << std::endl;

                        initialized = true;
                }

                return instance;
        }

        Configuration *SystemConfig::operator[] (const std::string s) {

                {
                        boost::mutex::scoped_lock lock(mutex);

                        std::map<std::string, boost::shared_ptr<Configuration> >::iterator itr = configs.find(s);

                        if (itr != configs.end()) {
                                return itr->second.get();
                        }
                }
                                
                std::vector<boost::filesystem::path> files;

                std::string file = s + ".conf";

                // Check the local config
                files.push_back(boost::filesystem::path(file));

                boost::filesystem::path path(configPath);
                path /= hostname;
                path /= file;

                // Check the host-specific config
                files.push_back(path);

                path = boost::filesystem::path(configPath);
                path /= file;

                // Check the global config
                files.push_back(path);

                for (size_t i = 0; i < files.size(); i++) {

                        if (boost::filesystem::exists(files[i])) {

                                boost::mutex::scoped_lock lock(mutex);

                                boost::shared_ptr<Configuration> result = boost::shared_ptr<Configuration>(new Configuration(files[i].string()));
                                configs[s] = result;

                                return result.get();
                        }
                }

                std::ostringstream ss;

                ss << "Configuration file " << file << " not found in either location:" << std::endl;

                for (size_t i = 0; i < files.size(); i++) {
                        ss << "- " << files[i].string() << std::endl;
                }

                throw ConfigException(ss.str());
        }
        int SystemConfig::GetOwnRobotID() {
                if(ownRobotID!=0) return ownRobotID;
                Configuration *tmp = (*SystemConfig::getInstance())["Globals"];
                ownRobotID = tmp->get<int>("Globals","Team",SystemConfig::getHostname().c_str(),"ID", NULL);
                delete tmp;
                return ownRobotID;
        }
        std::string SystemConfig::getRootPath() {
                return rootPath.string();
        }

        std::string SystemConfig::getLibPath() {
                return libPath.string();
        }

        std::string SystemConfig::getLogPath() {
                return logPath.string();
        }

        std::string SystemConfig::getConfigPath() {
                return configPath.string();
        }

        std::string SystemConfig::getHostname(){

                return hostname;
        }

        std::string SystemConfig::robotNodeName(const std::string& nodeName) {
                return SystemConfig::getHostname() + NODE_NAME_SEPERATOR + nodeName;
        }
        /*
        void SystemConfig::splitRobotNodeName(const std::string& name, std::string* robotName, std::string* nodeName) {
                int index = name.find_last_of(NODE_NAME_SEPERATOR);
                
                robotName = new std::string(name.substr(0, index));
                nodeName = new std::string(name.substr(index + 1));
        }*/
};