X-Git-Url: https://git.stg.codes/stg.git/blobdiff_plain/64b687f8ec36a103865044613cb0f42f98aeda3a..920fdb96809e7caae6a7cecc0ac8e5f7e26411c5:/projects/sgconf/main.cpp diff --git a/projects/sgconf/main.cpp b/projects/sgconf/main.cpp index c0debdc1..2d39cb2c 100644 --- a/projects/sgconf/main.cpp +++ b/projects/sgconf/main.cpp @@ -16,18 +16,18 @@ /* * Author : Boris Mikhailenko - */ - - /* - $Author: faust $ - $Revision: 1.25 $ - $Date: 2010/03/25 14:37:43 $ + * Author : Maxim Mamontov */ #include "request.h" #include "common_sg.h" #include "sg_error_codes.h" +#include "xml.h" +#include "options.h" +#include "actions.h" +#include "config.h" + #include "stg/user_conf.h" #include "stg/user_stat.h" #include "stg/common.h" @@ -66,6 +66,65 @@ struct ARRAY_TYPE typedef T type; }; +template +struct nullary_function +{ +typedef T result_type; +}; + +template +class binder0 : public nullary_function +{ + public: + binder0(const F & func, const typename F::argument_type & arg) + : m_func(func), m_arg(arg) {} + typename F::result_type operator()() const { return m_func(m_arg); } + private: + F m_func; + typename F::argument_type m_arg; +}; + +template +inline +binder0 bind0(const F & func, const typename F::argument_type & arg) +{ +return binder0(func, arg); +} + +template +class METHOD1_ADAPTER : public std::unary_function +{ + public: + METHOD1_ADAPTER(R (C::* func)(A), C & obj) : m_func(func), m_obj(obj) {} + R operator()(A arg) { return (m_obj.*m_func)(arg); } + private: + R (C::* m_func)(A); + C & m_obj; +}; + +template +class CONST_METHOD1_ADAPTER : public std::unary_function +{ + public: + CONST_METHOD1_ADAPTER(R (C::* func)(A) const, C & obj) : m_func(func), m_obj(obj) {} + R operator()(A arg) const { return (m_obj.*m_func)(arg); } + private: + R (C::* m_func)(A) const; + C & m_obj; +}; + +template +METHOD1_ADAPTER Method1Adapt(R (C::* func)(A), C & obj) +{ +return METHOD1_ADAPTER(func, obj); +} + +template +CONST_METHOD1_ADAPTER Method1Adapt(R (C::* func)(A) const, C & obj) +{ +return CONST_METHOD1_ADAPTER(func, obj); +} + template bool SetArrayItem(T & array, const char * index, const typename ARRAY_TYPE::type & value) { @@ -76,7 +135,19 @@ array[pos] = value; return true; } -void Usage(bool full); +void RawXMLCallback(bool result, const std::string & reason, const std::string & response, void * data) +{ +if (!result) + { + std::cerr << "Failed to get raw XML response. Reason: '" << reason << "'." << std::endl; + return; + } +PrintXML(response); +} + +void Usage(); +void UsageAll(); +void UsageImpl(bool full); void UsageConnection(); void UsageAdmins(bool full); void UsageTariffs(bool full); @@ -84,8 +155,119 @@ void UsageUsers(bool full); void UsageServices(bool full); void UsageCorporations(bool full); +void Version(); + +void ReadUserConfigFile(SGCONF::OPTION_BLOCK & block) +{ +std::vector paths; +const char * configHome = getenv("XDG_CONFIG_HOME"); +if (configHome == NULL) + { + const char * home = getenv("HOME"); + if (home == NULL) + return; + paths.push_back(std::string(home) + "/.config/sgconf/sgconf.conf"); + paths.push_back(std::string(home) + "/.sgconf/sgconf.conf"); + } +else + paths.push_back(std::string(configHome) + "/sgconf/sgconf.conf"); +for (std::vector::const_iterator it = paths.begin(); it != paths.end(); ++it) + if (access(it->c_str(), R_OK) == 0) + { + block.ParseFile(*it); + return; + } +} + } // namespace anonymous +namespace SGCONF +{ + +class CONFIG_ACTION : public ACTION +{ + public: + CONFIG_ACTION(CONFIG & config, + const std::string & paramDescription) + : m_config(config), + m_description(paramDescription) + {} + + virtual ACTION * Clone() const { return new CONFIG_ACTION(*this); } + + virtual std::string ParamDescription() const { return m_description; } + virtual std::string DefaultDescription() const { return ""; } + virtual OPTION_BLOCK & Suboptions() { return m_suboptions; } + virtual PARSER_STATE Parse(int argc, char ** argv); + + private: + CONFIG & m_config; + std::string m_description; + OPTION_BLOCK m_suboptions; + + void ParseCredentials(const std::string & credentials); + void ParseHostAndPort(const std::string & hostAndPort); +}; + +PARSER_STATE CONFIG_ACTION::Parse(int argc, char ** argv) +{ +if (argc == 0 || + argv == NULL || + *argv == NULL) + throw ERROR("Missing argument."); +char * pos = strchr(*argv, '@'); +if (pos != NULL) + { + ParseCredentials(std::string(*argv, pos)); + ParseHostAndPort(std::string(pos + 1)); + } +else + { + ParseHostAndPort(std::string(*argv)); + } +return PARSER_STATE(false, --argc, ++argv); +} + +void CONFIG_ACTION::ParseCredentials(const std::string & credentials) +{ +std::string::size_type pos = credentials.find_first_of(':'); +if (pos != std::string::npos) + { + m_config.userName = credentials.substr(0, pos); + m_config.userPass = credentials.substr(pos + 1); + } +else + { + m_config.userName = credentials; + } +} + +void CONFIG_ACTION::ParseHostAndPort(const std::string & hostAndPort) +{ +std::string::size_type pos = hostAndPort.find_first_of(':'); +if (pos != std::string::npos) + { + m_config.server = hostAndPort.substr(0, pos); + uint16_t port = 0; + if (str2x(hostAndPort.substr(pos + 1), port)) + throw ERROR("Invalid port value: '" + hostAndPort.substr(pos + 1) + "'"); + m_config.port = port; + } +else + { + m_config.server = hostAndPort; + } +} + +inline +CONFIG_ACTION * MakeParamAction(CONFIG & config, + const std::string & paramDescription) +{ +return new CONFIG_ACTION(config, paramDescription); +} + +} // namespace SGCONF + time_t stgTime; struct option long_options_get[] = { @@ -1052,66 +1234,84 @@ if (isMessage) return ProcessSetUser(req.server.data(), req.port.data(), req.admLogin.data(), req.admPasswd.data(), req.login.data(), conf, stat); } //----------------------------------------------------------------------------- -PARSER_STATE TryParse(const PARSERS& parsers, char ** argv, int argc) +int main(int argc, char **argv) { -PARSERS::const_iterator it = parsers.find(*argv); -if (it != parsers.end()) - return it->second(++argv, --argc); -PARSER_STATE state; -state.argc = argc; -state.argv = argv; -state.result = false; -return state; +SGCONF::CONFIG config; + +SGCONF::OPTION_BLOCKS blocks; +blocks.Add("General options") + .Add("c", "config", SGCONF::MakeParamAction(config.configFile, std::string("~/.config/stg/sgconf.conf"), ""), "override default config file") + .Add("h", "help", SGCONF::MakeFunc0Action(bind0(Method1Adapt(&SGCONF::OPTION_BLOCKS::Help, blocks), 0)), "\t\tshow this help and exit") + .Add("help-all", SGCONF::MakeFunc0Action(UsageAll), "\t\tshow full help and exit") + .Add("v", "version", SGCONF::MakeFunc0Action(Version), "\t\tshow version information and exit"); +SGCONF::OPTION_BLOCK & block = blocks.Add("Connection options") + .Add("s", "server", SGCONF::MakeParamAction(config.server, std::string("localhost"), "
"), "\t\thost to connect") + .Add("p", "port", SGCONF::MakeParamAction(config.port, uint16_t(5555), ""), "\t\tport to connect") + .Add("u", "username", SGCONF::MakeParamAction(config.userName, std::string("admin"), ""), "\tadministrative login") + .Add("w", "userpass", SGCONF::MakeParamAction(config.userPass, ""), "\tpassword for the administrative login") + .Add("a", "address", SGCONF::MakeParamAction(config, ""), "connection params as a single string in format: :@:"); +blocks.Add("Raw XML") + .Add("r", "raw", SGCONF::MakeFunc1Action(), "\t\tmake raw XML request") +/*blocks.Add("Admins management options") + .Add("get-admins", SGCONF::MakeConfAction()) + .Add("get-admin", SGCONF::MakeConfAction()) + .Add("add-admin", SGCONF::MakeConfAction()) + .Add("del-admin", SGCONF::MakeConfAction()) + .Add("chg-admin", SGCONF::MakeConfAction());*/ + + +SGCONF::PARSER_STATE state(false, argc, argv); + +try +{ +state = blocks.Parse(--argc, ++argv); // Skipping self name } -//----------------------------------------------------------------------------- -PARSER_STATE ParseCommon(int argc, char ** argv, CONFIG& config) +catch (const SGCONF::OPTION::ERROR& ex) { -if (pos == 0) - ++pos; +std::cerr << ex.what() << "\n"; +return -1; +} -PARSERS parsers; -parsers.add("-c", "--config", config.configFile); -parsers.add("-h", "--help", Usage, false); -parsers.add("--help-all", Usage, true); -parsers.add("-v", "--version", Version); +if (state.stop) + return 0; -while (true) +if (state.argc > 0) { - PARSER_STATE state(TryParse(parsers, argv, argc, config)); - if (state.argv == argv) - return state; // No-op - if (state.argc == 0) - return state; // EOF - if (state.result) - return state; // Done - argv = state.argv; - argc = state.argc; + std::cerr << "Unknown option: '" << *state.argv << "'\n"; + return -1; } -assert(0 && "Can't be here."); -return PARSER_STATE(); -} -//----------------------------------------------------------------------------- -int main(int argc, char **argv) +try { -Usage(true); -exit(0); +SGCONF::CONFIG configOverride(config); -// Ok - succesfully parsed -// Done - don't continue, return 0 -// Error - don't continue, return -1 -// No-op - nothing changed +if (config.configFile.empty()) + { + const char * mainConfigFile = "/etc/sgconf/sgconf.conf"; + if (access(mainConfigFile, R_OK) == 0) + block.ParseFile(mainConfigFile); + ReadUserConfigFile(block); + } +else + { + block.ParseFile(config.configFile.data()); + } -return COMPOSER(argv).compose(ParseCommon) - .compose(ReadConfig) - .compose(ParseCommand) - .exec(); +config = configOverride; +} +catch (const std::exception& ex) +{ +std::cerr << ex.what() << "\n"; +return -1; +} + +std::cerr << "Config: " << config.Serialize() << std::endl; +return 0; if (argc < 2) { - // TODO: no arguments - Usage(false); + Usage(); return 1; } @@ -1145,7 +1345,17 @@ return UNKNOWN_ERR_CODE; namespace { -void Usage(bool full) +void Usage() +{ +UsageImpl(false); +} + +void UsageAll() +{ +UsageImpl(true); +} + +void UsageImpl(bool full) { std::cout << "sgconf is the Stargazer management utility.\n\n" << "Usage:\n" @@ -1336,4 +1546,9 @@ if (full) << "\t\t--set-cash [:]\tnew corporation's cash and optional comment message\n\n"; } +void Version() +{ +std::cout << "sgconf, version: 2.0.0-alpha.\n"; +} + } // namespace anonymous