daemon/src/Configuration.h

Go to the documentation of this file.

#ifndef CONFIGURATION_H_
#define CONFIGURATION_H_

#include "ibrcommon/data/ConfigFile.h"
#include "core/Node.h"
#include "routing/StaticRoutingExtension.h"
#include "ibrcommon/Exceptions.h"
#include "ibrcommon/net/NetInterface.h"

using namespace dtn::net;
using namespace dtn::core;
using namespace dtn::data;

namespace dtn
{
        namespace daemon
        {
                class Configuration
                {
                private:
                        Configuration();
                        virtual ~Configuration();

                public:
                        class NetConfig
                        {
                        public:
                                enum NetType
                                {
                                        NETWORK_UNKNOWN = 0,
                                        NETWORK_TCP = 1,
                                        NETWORK_UDP = 2,
                                        NETWORK_HTTP = 3,
                                        NETWORK_LOWPAN = 4
                                };

                                NetConfig(std::string name, NetType type, const std::string &address, int port, bool discovery = true);
                                NetConfig(std::string name, NetType type, const ibrcommon::NetInterface &iface, int port, bool discovery = true);
                                ~NetConfig();

                                std::string name;
                                NetType type;
                                ibrcommon::NetInterface interface;
                                std::string address;
                                int port;
                                bool discovery;
                        };

                        class ParameterNotSetException : ibrcommon::Exception
                        {
                        };

                        class ParameterNotFoundException : ibrcommon::Exception
                        {
                        };

                        static Configuration &getInstance();

                        void load();
                        void load(string filename);

                        void params(int argc, char *argv[]);

                        string getNodename();

                        int getTimezone();

                        ibrcommon::File getPath(string name);

                        unsigned int getUID();

                        unsigned int getGID();

                        bool doAPI();

                        Configuration::NetConfig getAPIInterface();
                        ibrcommon::File getAPISocket();

                        std::string version();

                        std::string getNotifyCommand();

                        std::string getStorage() const;

                        enum RoutingExtension
                        {
                                DEFAULT_ROUTING = 0,
                                EPIDEMIC_ROUTING = 1,
                                FLOOD_ROUTING = 2
                        };

                        size_t getLimit(std::string);

                        class Extension
                        {
                        protected:
                                virtual void load(const ibrcommon::ConfigFile &conf) = 0;
                        };

                        class Discovery : public Configuration::Extension
                        {
                                friend class Configuration;
                        protected:
                                Discovery();
                                ~Discovery();
                                void load(const ibrcommon::ConfigFile &conf);

                                bool _enabled;
                                unsigned int _timeout;

                        public:
                                bool enabled() const;
                                bool announce() const;
                                bool shortbeacon() const;
                                char version() const;
                                std::string address() const throw (ParameterNotFoundException);
                                int port() const;
                                unsigned int timeout() const;
                        };

                        class Statistic : public Configuration::Extension
                        {
                                friend class Configuration;
                        protected:
                                Statistic();
                                ~Statistic();
                                void load(const ibrcommon::ConfigFile &conf);

                        public:
                                bool enabled() const;

                                ibrcommon::File logfile() const throw (ParameterNotSetException);

                                std::string type() const;

                                unsigned int interval() const;

                                std::string address() const;

                                unsigned int port() const;
                        };

                        class Debug : public Configuration::Extension
                        {
                                friend class Configuration;
                        protected:
                                Debug();
                                ~Debug();
                                void load(const ibrcommon::ConfigFile &conf);

                                bool _enabled;
                                bool _quiet;
                                int _level;

                        public:
                                int level() const;

                                bool enabled() const;

                                bool quiet() const;

                        };

                        class Logger : public Configuration::Extension
                        {
                                friend class Configuration;
                        protected:
                                Logger();
                                ~Logger();
                                void load(const ibrcommon::ConfigFile &conf);

                                bool _quiet;
                                unsigned int _options;

                        public:
                                bool quiet() const;

                                unsigned int options() const;

                                std::ostream &output() const;
                        };

                        class Network :  public Configuration::Extension
                        {
                                friend class Configuration;
                        protected:
                                Network();
                                ~Network();
                                void load(const ibrcommon::ConfigFile &conf);

                                std::list<dtn::routing::StaticRoutingExtension::StaticRoute> _static_routes;
                                std::list<Node> _nodes;
                                std::list<NetConfig> _interfaces;
                                std::string _routing;
                                bool _forwarding;
                                bool _tcp_nodelay;
                                size_t _tcp_chunksize;
                                ibrcommon::NetInterface _default_net;
                                bool _use_default_net;

                        public:
                                const std::list<NetConfig>& getInterfaces() const;

                                const std::list<Node>& getStaticNodes() const;

                                const list<dtn::routing::StaticRoutingExtension::StaticRoute>& getStaticRoutes() const;

                                RoutingExtension getRoutingExtension() const;

                                bool doForwarding() const;

                                bool getTCPOptionNoDelay() const;

                                size_t getTCPChunkSize() const;
                        };

                        const Configuration::Discovery& getDiscovery() const;
                        const Configuration::Statistic& getStatistic() const;
                        const Configuration::Debug& getDebug() const;
                        const Configuration::Logger& getLogger() const;
                        const Configuration::Network& getNetwork() const;

                private:
                        ibrcommon::ConfigFile _conf;
                        Configuration::Discovery _disco;
                        Configuration::Statistic _stats;
                        Configuration::Debug _debug;
                        Configuration::Logger _logger;
                        Configuration::Network _network;

                        string _filename;
                        bool _doapi;
                };
        }
}

#endif /*CONFIGURATION_H_*/