[client] move some generic functions to client_utils library

Author: loganek

CMakeLists.txt

@@ -63,6 +63,7 @@ add_subdirectory(lib)
 
 if(ENABLE_CLIENT)
     add_subdirectory(parser)
+    add_subdirectory(client_utils)
     add_subdirectory(client)
 endif(ENABLE_CLIENT)
 

client/CMakeLists.txt

@@ -4,14 +4,13 @@ add_library(hawktracer_client
     callgrind_converter.cpp
     chrome_trace_converter.cpp
     converter.cpp
-    tcp_client_stream.cpp
     tracepoint_map.cpp)
 
 target_include_directories(hawktracer_client PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/..)
 
 add_executable(hawktracer-converter main.cpp)
 
-target_link_libraries(hawktracer_client hawktracer_parser)
+target_link_libraries(hawktracer_client hawktracer_parser client_utils)
 target_link_libraries(hawktracer-converter hawktracer_client)
 
 install(TARGETS hawktracer-converter

client/main.cpp

@@ -1,35 +1,17 @@
 #include "callgrind_converter.hpp" 
 #include "chrome_trace_converter.hpp" 
-#include "tcp_client_stream.hpp" 
-#include <hawktracer/parser/file_stream.hpp>
+
 #include <hawktracer/parser/protocol_reader.hpp>
 #include <hawktracer/parser/make_unique.hpp>
 
+#include "client_utils/command_line_parser.hpp"
+#include "client_utils/stream_factory.hpp"
+
 #include <iostream>
-#include <cstring>
 #include <map>
 
 using namespace HawkTracer;
-
-bool file_exists(const char* name)
-{
-    std::ifstream f(name);
-    return f.good();
-}
-
-bool scan_ip_address(const std::string& address, std::string& out_ip, uint16_t& out_port, uint16_t default_port)
-{
-    unsigned n1, n2, n3, n4, port;
-    int num = sscanf(address.c_str(), "%u.%u.%u.%u:%u", &n1, &n2, &n3, &n4, &port);
-
-    if (num >= 4)
-    {
-        out_ip = address.substr(0, address.find(':'));
-        out_port = (num == 5) ? (uint16_t)port : default_port;
-        return true;
-    }
-    return false;
-}
+using ClientUtils::CommandLineParser;
 
 std::string create_output_path(const char* path)
 {
@@ -52,16 +34,6 @@ std::string supported_formats(std::map<std::string, std::unique_ptr<client::Conv
     return supported_formats;
 }
 
-void print_help(const char* app_name, std::map<std::string, std::unique_ptr<client::Converter>>& formats)
-{
-    std::cout << "usage: " << app_name << " [OPTION]..." << std::endl
-              << "  --format    supported formats are: " << supported_formats(formats) << "(default is chrome-tracing)" << std::endl
-              << "  --source    data source description (either filename, or server address)" << std::endl
-              << "  --output    an output Chrome Tracing Json file" << std::endl
-              << "  --map       comma-separated list of map files" << std::endl
-              << "  --help      print this text" << std::endl;
-}
-
 void init_supported_formats(std::map<std::string, std::unique_ptr<client::Converter>>& formats)
 {
     formats["chrome-tracing"] = parser::make_unique<client::ChromeTraceConverter>();
@@ -70,68 +42,31 @@ void init_supported_formats(std::map<std::string, std::unique_ptr<client::Conver
 
 int main(int argc, char** argv)
 {
-    std::string format = "chrome-tracing";
-    std::string output_path = "hawktracer-trace-%d-%m-%Y-%H_%M_%S.httrace";
-    std::string source;
-    std::string map_files;
     std::map<std::string, std::unique_ptr<client::Converter>> formats;
 
     init_supported_formats(formats);
 
-    for (int i = 1; i < argc; i++)
+    CommandLineParser parser("--", argv[0]);
+    parser.register_option("format", CommandLineParser::OptionInfo(false, false, "Output format. Supported formats: " + supported_formats(formats)));
+    parser.register_option("output", CommandLineParser::OptionInfo(false, false, "Output file"));
+    parser.register_option("source", CommandLineParser::OptionInfo(false, true, "Data source description (either filename, or server address)"));
+    parser.register_option("map", CommandLineParser::OptionInfo(false, false, "Comma-separated list of map files"));
+    parser.register_option("help", CommandLineParser::OptionInfo(true, false, "Print this help"));
+
+    if (!parser.parse(argc, argv) || parser.has_value("help"))
     {
-        if (strcmp(argv[i], "--format") == 0 && i < argc - 1)
-        {
-            format = argv[++i];
-        }
-        else if (strcmp(argv[i], "--output") == 0 && i < argc - 1)
-        {
-            output_path = argv[++i];
-        }
-        else if (strcmp(argv[i], "--source") == 0 && i < argc - 1)
-        {
-            source = argv[++i];
-        }
-        else if (strcmp(argv[i], "--map") == 0 && i < argc - 1)
-        {
-            map_files = argv[++i];
-        }
-        else
-        {
-            int ret = 0;
-            if (strcmp(argv[i], "--help") != 0)
-            {
-                std::cerr << "unrecognized option '" << argv[i] << "'" << std::endl;
-                ret = 1;
-            }
-            print_help(argv[0], formats);
-            return ret;
-        }
-    }
-
-    if (source.empty())
-    {
-        std::cerr << "--source parameter is mandatory" << std::endl;
-        print_help(argv[0], formats);
+        parser.print_help(std::cerr);
         return 1;
     }
 
-    std::unique_ptr<parser::Stream> stream;
-    std::string ip;
-    uint16_t port;
-    bool is_network = false;
-    if (file_exists(source.c_str()))
-    {
-        stream = parser::make_unique<parser::FileStream>(source);
-    }
-    else if (scan_ip_address(source, ip, port, 8765))
-    {
-        stream = parser::make_unique<client::TCPClientStream>(ip, port);
-        is_network = true;
-    }
-    else
+    std::string format = parser.get_value("format", "chrome-tracing");
+    std::string output_path = parser.get_value("output", "hawktracer-trace-%d-%m-%Y-%H_%M_%S.httrace");
+    std::string source = parser.get_value("source", "");
+    std::string map_files = parser.get_value("map", "");
+
+    std::unique_ptr<parser::Stream> stream = ClientUtils::make_stream_from_string(source);
+    if (!stream)
     {
-        std::cerr << "Invalid stream: " << source << std::endl;
         return 1;
     }
 
@@ -176,7 +111,7 @@ int main(int argc, char** argv)
         return 1;
     }
 
-    if (is_network)
+    if (stream->is_continuous())
     {
         std::cout << "Hit [Enter] to finish the trace..." << std::endl;
         getchar();

client_utils/CMakeLists.txt

@@ -0,0 +1,7 @@
+add_library(client_utils
+    STATIC
+    command_line_parser.cpp
+    stream_factory.cpp
+    tcp_client_stream.cpp)
+
+target_link_libraries(client_utils hawktracer_parser)

client_utils/command_line_parser.cpp

@@ -0,0 +1,143 @@
+#include "command_line_parser.hpp"
+
+#include <iostream>
+#include <iomanip>
+#include <cstring>
+#include <cassert>
+
+namespace HawkTracer
+{
+namespace ClientUtils
+{
+
+CommandLineParser::CommandLineParser(std::string prefix, std::string app_name) :
+    _prefix(std::move(prefix)),
+    _app_name(std::move(app_name))
+{
+    assert(_prefix.length() > 0);
+}
+
+void CommandLineParser::register_option(std::string name, OptionInfo option_info)
+{
+    if (option_info.is_flag && option_info.is_mandatory)
+    {
+        std::cerr << "Unable to register option " << name
+                  << ": option can't be flag and mandatory at the same time" << std::endl;
+    }
+    else
+    {
+        _registered_options.insert(std::make_pair(std::move(name), std::move(option_info)));
+    }
+}
+
+size_t CommandLineParser::_get_max_option_length(size_t value_help_length) const
+{
+    size_t max_option_length = 0;
+    for (const auto& option : _registered_options)
+    {
+        size_t length = option.first.length();
+        if (!option.second.is_flag)
+        {
+            length += value_help_length;
+        }
+        if (length > max_option_length)
+        {
+            max_option_length = length;
+        }
+    }
+
+    return max_option_length;
+}
+
+void CommandLineParser::print_help(std::ostream& stream) const
+{
+    std::string value_help = " <VALUE>";
+    size_t max_option_length = _get_max_option_length(value_help.length());
+
+    stream << "usage: " << _app_name << " [OPTION]..." << std::endl;
+    for (const auto& option : _registered_options)
+    {
+        stream << "  " << _prefix << std::left << std::setw(max_option_length)
+               << option.first + (option.second.is_flag ? "" : value_help) << " ";
+
+        if (option.second.is_mandatory)
+        {
+            stream << "[MANDATORY] ";
+        }
+        stream << option.second.help_msg << std::endl << std::setw(0);
+    }
+}
+
+std::string CommandLineParser::get_value(const std::string& option, std::string default_value) const
+{
+    auto it = _actual_options.find(option);
+    return (it != _actual_options.end()) ? it->second : default_value;
+}
+
+bool CommandLineParser::has_value(const std::string& option) const
+{
+    return _actual_options.find(option) != _actual_options.end();
+}
+
+bool CommandLineParser::_is_option_valid(const char* option) const
+{
+    return strlen(option) > _prefix.length() && !strncmp(option, _prefix.c_str(), _prefix.length());
+}
+
+bool CommandLineParser::_validate_user_options() const
+{
+    for (const auto& option : _registered_options)
+    {
+        if (option.second.is_mandatory && _actual_options.find(option.first) == _actual_options.end())
+        {
+            std::cerr << "Option " << _prefix << option.first << " must be specified" << std::endl;
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool CommandLineParser::parse(int argc, char** argv)
+{
+    for (int i = 1; i < argc; i++)
+    {
+        if (!_is_option_valid(argv[i]))
+        {
+            std::cerr << "Invalid option: " << argv[i] << std::endl;
+            return false;
+        }
+
+        std::string option = argv[i] + _prefix.length();
+
+        auto it = _registered_options.find(option);
+        if (it == _registered_options.end())
+        {
+            std::cerr << "Unknown option: " << argv[i] << std::endl;
+            return false;
+        }
+
+        OptionInfo& info = it->second;
+        std::string value;
+        if (info.is_flag)
+        {
+            // leave the value empty
+        }
+        else if (i == argc - 1)
+        {
+            std::cerr << argv[i] << " requires a value" << std::endl;
+            return false;
+        }
+        else
+        {
+            value = argv[++i];
+        }
+
+        _actual_options.insert(std::make_pair(std::move(option), std::move(value)));
+    }
+
+    return _validate_user_options();
+}
+
+} // namespace ClientUtils
+} // namespace HawkTracer

client_utils/command_line_parser.hpp

@@ -0,0 +1,49 @@
+#ifndef HAWKTRACER_CLIENT_UTILS_COMMAND_LINE_PARSER_HPP
+#define HAWKTRACER_CLIENT_UTILS_COMMAND_LINE_PARSER_HPP
+
+#include <unordered_map>
+#include <string>
+
+namespace HawkTracer
+{
+namespace ClientUtils
+{
+
+class CommandLineParser
+{
+public:
+    struct OptionInfo
+    {
+        OptionInfo(bool is_flag, bool is_mandatory, std::string help_msg) :
+            help_msg(std::move(help_msg)), is_flag(is_flag), is_mandatory(is_mandatory) {}
+
+        std::string help_msg;
+        bool is_flag;
+        bool is_mandatory;
+    };
+
+    CommandLineParser(std::string prefix, std::string app_name);
+
+    void register_option(std::string name, OptionInfo option_info);
+    bool parse(int argc, char** argv);
+
+    void print_help(std::ostream& stream) const;
+
+    std::string get_value(const std::string& option, std::string default_value) const;
+    bool has_value(const std::string& option) const;
+
+private:
+    size_t _get_max_option_length(size_t value_help_length) const;
+    bool _is_option_valid(const char* option) const;
+    bool _validate_user_options() const;
+
+    std::unordered_map<std::string, OptionInfo> _registered_options;
+    std::unordered_map<std::string, std::string> _actual_options;
+    const std::string _prefix;
+    const std::string _app_name;
+};
+
+} // namespace ClientUtils
+} // namespace HawkTracer
+
+#endif // HAWKTRACER_CLIENT_UTILS_COMMAND_LINE_PARSER_HPP