cfacter 3.11.0.rc.20180314

data/ext/facter/leatherman/logging/src/logging.cc

@@ -0,0 +1,229 @@
+#include <leatherman/logging/logging.hpp>
+#include <leatherman/locale/locale.hpp>
+#include <vector>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+// boost includes are not always warning-clean. Disable warnings that
+// cause problems before including the headers, then re-enable the warnings.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wextra"
+
+#include <boost/log/utility/setup/common_attributes.hpp>
+#include <boost/log/attributes/scoped_attribute.hpp>
+#include <boost/log/sources/logger.hpp>
+#include <boost/log/sources/record_ostream.hpp>
+#include <boost/log/sinks/sync_frontend.hpp>
+#include <boost/log/sinks/basic_sink_backend.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/date_time/gregorian/gregorian.hpp>
+#include <boost/algorithm/string.hpp>
+
+#pragma GCC diagnostic pop
+
+using namespace std;
+namespace expr = boost::log::expressions;
+namespace src = boost::log::sources;
+namespace attrs = boost::log::attributes;
+namespace keywords = boost::log::keywords;
+namespace sinks = boost::log::sinks;
+
+namespace leatherman { namespace logging {
+
+    static function<bool(log_level, string const&)> g_callback;
+    static log_level g_level = log_level::none;
+    static bool g_colorize = false;
+    static bool g_error_logged = false;
+
+    namespace lth_locale = leatherman::locale;
+
+    class color_writer : public sinks::basic_sink_backend<sinks::synchronized_feeding>
+    {
+     public:
+        color_writer(ostream *dst);
+        void consume(boost::log::record_view const& rec);
+     private:
+        ostream &_dst;
+    };
+
+    color_writer::color_writer(ostream *dst) : _dst(*dst) {}
+
+    void color_writer::consume(boost::log::record_view const& rec)
+    {
+        auto level = boost::log::extract<log_level>("Severity", rec);
+
+        if (!is_enabled(*level)) {
+            return;
+        }
+
+        auto line_num = boost::log::extract<int>("LineNum", rec);
+        auto name_space = boost::log::extract<string>("Namespace", rec);
+        auto timestamp = boost::log::extract<boost::posix_time::ptime>("TimeStamp", rec);
+        auto message = rec[expr::smessage];
+
+        _dst << boost::gregorian::to_iso_extended_string(timestamp->date());
+        _dst << " " << boost::posix_time::to_simple_string(timestamp->time_of_day());
+        _dst << " " << left << setfill(' ') << setw(5) << level << " " << *name_space;
+        if (line_num) {
+            _dst << ":" << *line_num;
+        }
+        _dst << " - ";
+        colorize(_dst, *level);
+        _dst << *message;
+        colorize(_dst);
+        _dst << endl;
+    }
+
+    // cppcheck-suppress passedByValue
+    void setup_logging(ostream &dst, string locale, string domain, bool use_locale)
+    {
+        // Remove existing sinks before adding a new one
+        auto core = boost::log::core::get();
+        core->remove_all_sinks();
+
+        using sink_t = sinks::synchronous_sink<color_writer>;
+        boost::shared_ptr<sink_t> sink = boost::make_shared<sink_t>(boost::make_shared<color_writer>(&dst));
+        core->add_sink(sink);
+
+
+#ifdef LEATHERMAN_USE_LOCALES
+        // Imbue the logging sink with the requested locale.
+        // Locale in GCC is busted on Solaris, so skip it.
+        // TODO: Imbue may not be useful, as setup_logging can be called multiple times
+        // with different domains for the same ostream.
+        // Note that this creates a locale that's not usable for testing, as it
+        // only includes paths for install locations. This is intentional, to avoid leaving
+        // searching paths that have unknown permissions.
+        if (use_locale) {
+            dst.imbue(lth_locale::get_locale(locale, domain, {}));
+        }
+#endif
+
+        boost::log::add_common_attributes();
+
+        // Default to the warning level
+        set_level(log_level::warning);
+
+        // Set whether or not to use colorization depending if the destination is a tty
+        g_colorize = color_supported(dst);
+    }
+
+    // This version exists for binary compatibility only.
+    void setup_logging(ostream &dst, string locale, string domain)
+    {
+        setup_logging(dst, move(locale), move(domain), true);
+    }
+
+    void set_level(log_level level)
+    {
+        auto core = boost::log::core::get();
+        core->set_logging_enabled(level != log_level::none);
+        g_level = level;
+    }
+
+    log_level get_level()
+    {
+        return g_level;
+    }
+
+    void set_colorization(bool color)
+    {
+        g_colorize = color;
+    }
+
+    bool get_colorization()
+    {
+        return g_colorize;
+    }
+
+    bool is_enabled(log_level level)
+    {
+        return g_level != log_level::none && static_cast<int>(level) >= static_cast<int>(g_level);
+    }
+
+    bool error_has_been_logged() {
+        return g_error_logged;
+    }
+
+    void clear_error_logged_flag() {
+        g_error_logged = false;
+    }
+
+    // cppcheck-suppress passedByValue
+    void on_message(function<bool(log_level, string const&)> callback)
+    {
+        g_callback = callback;
+    }
+
+    void log_helper(const string &logger, log_level level, int line_num, string const& message)
+    {
+        if (level >= log_level::error) {
+            g_error_logged = true;
+        }
+        if (!is_enabled(level) || (g_callback && !g_callback(level, message))) {
+            return;
+        }
+
+        src::logger slg;
+        slg.add_attribute("Severity", attrs::constant<log_level>(level));
+        slg.add_attribute("Namespace", attrs::constant<string>(logger));
+        if (line_num > 0) {
+            slg.add_attribute("LineNum", attrs::constant<int>(line_num));
+        }
+
+        BOOST_LOG(slg) << message;
+    }
+
+    istream& operator>>(istream& in, log_level& level)
+    {
+        string value;
+        if (in >> value) {
+            boost::algorithm::to_lower(value);
+            if (value == "none") {
+                level = log_level::none;
+                return in;
+            }
+            if (value == "trace") {
+                level = log_level::trace;
+                return in;
+            }
+            if (value == "debug") {
+                level = log_level::debug;
+                return in;
+            }
+            if (value == "info") {
+                level = log_level::info;
+                return in;
+            }
+            if (value == "warn") {
+                level = log_level::warning;
+                return in;
+            }
+            if (value == "error") {
+                level = log_level::error;
+                return in;
+            }
+            if (value == "fatal") {
+                level = log_level::fatal;
+                return in;
+            }
+        }
+        throw runtime_error(_("invalid log level '{1}': expected none, trace, debug, info, warn, error, or fatal.", value));
+    }
+
+    ostream& operator<<(ostream& strm, log_level level)
+    {
+        static const vector<string> strings = {"TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"};
+
+        if (level != log_level::none) {
+            size_t index = static_cast<size_t>(level) - 1;
+            if (index < strings.size()) {
+                strm << strings[index];
+            }
+        }
+
+        return strm;
+    }
+
+}}  // namespace leatherman::logging

data/ext/facter/leatherman/logging/src/posix/logging.cc

@@ -0,0 +1,39 @@
+#include <leatherman/logging/logging.hpp>
+#include <boost/nowide/iostream.hpp>
+#include <unistd.h>
+
+using namespace std;
+
+namespace leatherman { namespace logging {
+
+    void colorize(ostream& dst, log_level level)
+    {
+        if (!get_colorization()) {
+            return;
+        }
+
+        static const string cyan = "\33[0;36m";
+        static const string green = "\33[0;32m";
+        static const string yellow = "\33[0;33m";
+        static const string red = "\33[0;31m";
+        static const string reset = "\33[0m";
+
+        if (level == log_level::trace || level == log_level::debug) {
+            dst << cyan;
+        } else if (level == log_level::info) {
+            dst << green;
+        } else if (level == log_level::warning) {
+            dst << yellow;
+        } else if (level == log_level::error || level == log_level::fatal) {
+            dst << red;
+        } else {
+            dst << reset;
+        }
+    }
+
+    bool color_supported(ostream& dst)
+    {
+        return (&dst == &cout && isatty(fileno(stdout))) || (&dst == &cerr && isatty(fileno(stderr)));
+    }
+
+}}  // namespace leatherman::logging

data/ext/facter/leatherman/logging/src/windows/logging.cc

@@ -0,0 +1,52 @@
+#include <leatherman/logging/logging.hpp>
+#include <boost/nowide/iostream.hpp>
+#include <windows.h>
+
+using namespace std;
+
+namespace leatherman { namespace logging {
+    static HANDLE stdHandle;
+    static WORD originalAttributes;
+
+    void colorize(ostream& dst, log_level level)
+    {
+        if (!get_colorization()) {
+            return;
+        }
+
+        // The ostream may have buffered data, and changing the console color will affect any buffered data written
+        // later. Ensure the buffer is flushed before changing the console color.
+        dst.flush();
+        if (level == log_level::trace || level == log_level::debug) {
+            SetConsoleTextAttribute(stdHandle, FOREGROUND_BLUE | FOREGROUND_GREEN);
+        } else if (level == log_level::info) {
+            SetConsoleTextAttribute(stdHandle, FOREGROUND_GREEN);
+        } else if (level == log_level::warning) {
+            SetConsoleTextAttribute(stdHandle, FOREGROUND_RED | FOREGROUND_GREEN);
+        } else if (level == log_level::error || level == log_level::fatal) {
+            SetConsoleTextAttribute(stdHandle, FOREGROUND_RED);
+        } else {
+            SetConsoleTextAttribute(stdHandle, originalAttributes);
+        }
+    }
+
+    bool color_supported(ostream& dst)
+    {
+        bool colorize = false;
+        if (&dst == &cout || &dst == &boost::nowide::cout) {
+            stdHandle = GetStdHandle(STD_OUTPUT_HANDLE);
+            colorize = true;
+        } else if (&dst == &cerr || &dst == &boost::nowide::cerr) {
+            stdHandle = GetStdHandle(STD_ERROR_HANDLE);
+            colorize = true;
+        }
+
+        if (colorize) {
+            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+            GetConsoleScreenBufferInfo(stdHandle, &csbiInfo);
+            originalAttributes = csbiInfo.wAttributes;
+        }
+        return colorize;
+    }
+
+}}  // namespace leatherman::logging

data/ext/facter/leatherman/logging/tests/logging.cc

@@ -0,0 +1,118 @@
+#include "logging.hpp"
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/nowide/iostream.hpp>
+#include <cassert>
+
+namespace leatherman { namespace test {
+
+    static bool all_spaces(string const& s)
+    {
+        return boost::algorithm::all(s, [](char c) { return c == ' '; });
+    }
+
+    std::streamsize colored_tokenizing_stringbuf::xsputn(char_type const* s, std::streamsize count)
+    {
+        auto str = string(s, count);
+        if (all_spaces(str) && !tokens.empty() && all_spaces(tokens.back())) {
+            // Lump all white space strings together.
+            tokens.back() += move(str);
+        } else {
+            tokens.emplace_back(move(str));
+        }
+
+        return stringbuf::xsputn(s, count);
+    }
+
+    logging_context::logging_context(log_level lvl)
+    {
+        set_level(lvl);
+        REQUIRE(get_level() == lvl);
+        clear_error_logged_flag();
+    }
+
+    logging_context::~logging_context()
+    {
+        set_level(log_level::none);
+        REQUIRE(get_level() == log_level::none);
+        on_message(nullptr);
+        clear_error_logged_flag();
+    }
+
+    logging_format_context::logging_format_context(log_level lvl, string ns, int line_num)
+        : logging_context(lvl)
+    {
+        _strm_buf = boost::nowide::cout.rdbuf();
+        boost::nowide::cout.rdbuf(&_buf);
+
+        setup_logging(boost::nowide::cout);
+        set_level(lvl);
+        REQUIRE(get_level() == lvl);
+        set_colorization(true);
+
+        static const boost::regex rdate("\\d{4}-\\d{2}-\\d{2}");
+        static const boost::regex rtime("[0-2]\\d:[0-5]\\d:\\d{2}\\.\\d{6}");
+
+        _expected = {rdate, " ", rtime, " ", lvl, boost::regex("[ ]+"), ns};
+
+        if (line_num > 0) {
+            _expected.emplace_back(":");
+            _expected.emplace_back(to_string(line_num));
+        }
+        _expected.emplace_back(" - ");
+
+        auto color = get_color(lvl);
+        if (!color.empty()) {
+            _expected.emplace_back(color);
+        }
+        _expected.emplace_back("testing 1 2 3");
+        if (!color.empty()) {
+            _expected.emplace_back(get_color(log_level::none));
+        }
+    }
+
+    logging_format_context::~logging_format_context()
+    {
+        boost::nowide::cout.rdbuf(_strm_buf);
+
+        auto core = boost::log::core::get();
+        core->reset_filter();
+        core->remove_all_sinks();
+    }
+
+    vector<string> const& logging_format_context::tokens() const
+    {
+        return _buf.tokens;
+    }
+
+    string logging_format_context::message() const
+    {
+        return _buf.str();
+    }
+
+    vector<matcher> const& logging_format_context::expected() const
+    {
+        return _expected;
+    }
+
+}}  // namespace leatherman::test
+
+namespace boost {
+
+    bool operator== (std::string const& lhs, leatherman::test::matcher const& rhs)
+    {
+        using leatherman::logging::log_level;
+        if (auto *expected = boost::get<boost::regex>(&rhs)) {
+            return boost::regex_match(lhs, *expected);
+        } else if (auto *expected = boost::get<log_level>(&rhs)) {
+            std::stringstream ss{lhs};
+            log_level lvl = log_level::none;
+            ss >> lvl;
+            return lvl == *expected;
+        } else if (auto *expected = boost::get<std::string>(&rhs)) {
+            return lhs == *expected;
+        } else {
+            return false;
+        }
+    }
+
+}  // namespace boost

data/ext/facter/leatherman/logging/tests/logging.hpp

@@ -0,0 +1,88 @@
+/**
+ * @file Utilities for testing logging
+ */
+#pragma once
+#include <catch.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <boost/regex.hpp>
+#include <boost/iterator/zip_iterator.hpp>
+#include <boost/range.hpp>
+#include <boost/variant.hpp>
+
+namespace leatherman { namespace test {
+    using namespace std;
+    using namespace leatherman::logging;
+
+    using matcher = boost::variant<boost::regex, string, log_level>;
+
+    /**
+     * Declare colors.
+     */
+    constexpr char cyan[] = "\33[0;36m";
+    constexpr char green[] = "\33[0;32m";
+    constexpr char yellow[] = "\33[0;33m";
+    constexpr char red[] = "\33[0;31m";
+    constexpr char reset[] = "\33[0m";
+
+    /**
+     * Zip view for iterating over multiple containers at once
+     */
+    template <typename... T>
+    auto zip_view(T const&... containers) ->
+        boost::iterator_range<boost::zip_iterator<decltype(boost::make_tuple(std::begin(containers)...))>>
+    {
+        auto zip_begin = boost::make_zip_iterator(boost::make_tuple(std::begin(containers)...));
+        auto zip_end = boost::make_zip_iterator(boost::make_tuple(std::end(containers)...));
+        return boost::make_iterator_range(zip_begin, zip_end);
+    }
+
+    /**
+     * Stringbuf for capturing tokens written to the attached stream, and insert color
+     * codes on Windows that match to the current console attributes.
+     */
+    class colored_tokenizing_stringbuf : public stringbuf
+    {
+     public:
+        vector<string> tokens;
+
+     protected:
+        virtual std::streamsize xsputn(char_type const* s, std::streamsize count);
+    };
+
+    /**
+     * Context for simple logging tests.
+     */
+    struct logging_context
+    {
+        logging_context(log_level lvl = log_level::trace);
+        virtual ~logging_context();
+    };
+
+    /**
+     * Context for capturing the format of log messages as they would appear on cout/cerr.
+     */
+    struct logging_format_context : logging_context
+    {
+        logging_format_context(log_level lvl = log_level::trace, string ns = LOG_NAMESPACE, int line_num = 0);
+        ~logging_format_context() final;
+
+        vector<string> const& tokens() const;
+        string message() const;
+
+        vector<matcher> const& expected() const;
+
+     private:
+        string get_color(log_level lvl) const;
+
+        colored_tokenizing_stringbuf _buf;
+        streambuf *_strm_buf;
+        vector<matcher> _expected;
+    };
+
+}}  // namespace leatherman::test
+
+namespace boost {
+
+    bool operator== (std::string const& lhs, leatherman::test::matcher const& rhs);
+
+}  // namespace boost