cfacter 3.11.0.rc.20180314

data/ext/facter/facter/lib/src/util/solaris/scoped_kstat.cc

@@ -0,0 +1,31 @@
+#include <internal/util/solaris/scoped_kstat.hpp>
+
+using namespace std;
+using namespace leatherman::util;
+
+namespace facter { namespace util { namespace solaris {
+
+    scoped_kstat::scoped_kstat() :
+        scoped_resource(nullptr, close)
+    {
+        _resource = kstat_open();
+    }
+
+    scoped_kstat::scoped_kstat(kstat_ctl* ctrl) :
+        scoped_resource(move(ctrl), free)
+    {
+    }
+
+    void scoped_kstat::close(kstat_ctl* ctrl)
+    {
+        if (ctrl) {
+            ::kstat_close(ctrl);
+        }
+    }
+
+    kstat_exception::kstat_exception(std::string const& message) :
+        runtime_error(message)
+    {
+    }
+
+}}}  // namespace facter::util::solaris

data/ext/facter/facter/lib/src/util/string.cc

@@ -0,0 +1,170 @@
+#include <facter/util/string.hpp>
+#include <boost/regex.hpp>
+#include <sstream>
+#include <iomanip>
+#include <algorithm>
+#include <iterator>
+#include <cmath>
+#include <limits>
+
+using namespace std;
+
+namespace facter { namespace util {
+
+    string to_hex(uint8_t const* bytes, size_t length, bool uppercase)
+    {
+        ostringstream ss;
+        if (bytes) {
+            ss << hex << (uppercase ? std::uppercase : std::nouppercase) << setfill('0');
+            for (size_t i = 0; i < length; ++i) {
+                ss << setw(2) << static_cast<int>(bytes[i]);
+            }
+        }
+        return ss.str();
+    }
+
+    void each_line(string const& s, function<bool(string&)> callback)
+    {
+        string line;
+        istringstream in(s);
+        while (getline(in, line)) {
+            // Handle Windows CR in the string.
+            if (line.size() && line.back() == '\r') {
+                line.pop_back();
+            }
+            if (!callback(line)) {
+                break;
+            }
+        }
+    }
+
+    string si_string(uint64_t size)
+    {
+        static char prefixes[] = { 'K', 'M', 'G', 'T', 'P', 'E' };
+
+        if (size < 1024) {
+            return to_string(size) + " bytes";
+        }
+        unsigned int exp = floor(log2(size) / 10.0);
+        double converted = round(100.0 * (size / pow(1024.0, exp))) / 100.0;
+
+        // Check to see if rounding up gets us to 1024; if so, move to the next unit
+        if (fabs(converted - 1024.0) < numeric_limits<double>::epsilon()) {
+            converted = 1.00;
+            ++exp;
+        }
+
+        // If we exceed the SI prefix (we shouldn't, but just in case), just return the bytes
+        if (exp - 1 >= sizeof(prefixes)) {
+            return to_string(size) + " bytes";
+        }
+
+        ostringstream ss;
+        ss  << fixed << setprecision(2) << converted << " " << prefixes[exp - 1] << "iB";
+        return ss.str();
+    }
+
+    string percentage(uint64_t used, uint64_t total)
+    {
+        if (total == 0 || used >= total) {
+            return "100%";
+        }
+        if (used == 0) {
+            return "0%";
+        }
+        double converted = round(10000.0 * (used / static_cast<double>(total))) / 100.0;
+        // Check to see if we would round up to 100%; if so, keep it at 99.99%
+        if (fabs(converted - 100.0) < numeric_limits<double>::epsilon()) {
+            converted = 99.99;
+        }
+        ostringstream ss;
+        ss << fixed << setprecision(2) << converted << "%";
+        return ss.str();
+    }
+
+    string frequency(int64_t freq)
+    {
+        static char prefixes[] = { 'k', 'M', 'G', 'T'  };
+
+        if (freq < 1000) {
+            return to_string(freq) + " Hz";
+        }
+        unsigned int exp = floor(log10(freq) / 3.0);
+        double converted = round(100.0 * (freq / pow(1000.0, exp))) / 100.0;
+
+        // Check to see if rounding up gets us to 1000; if so, move to the next unit
+        if (fabs(converted - 1000.0) < numeric_limits<double>::epsilon()) {
+            converted = 1.00;
+            ++exp;
+        }
+
+        // If we exceed the SI prefix (we shouldn't, but just in case), just return the speed in Hz
+        if (exp - 1 >= sizeof(prefixes)) {
+            return to_string(freq) + " Hz";
+        }
+
+        ostringstream ss;
+        ss  << fixed << setprecision(2) << converted << " " << prefixes[exp - 1] << "Hz";
+        return ss.str();
+    }
+
+    bool needs_quotation(string const& str)
+    {
+        // Empty strings should be quoted
+        if (str.empty()) {
+            return true;
+        }
+
+        // Taken from http://yaml.org/type/bool.html.
+        // The string would be interpreted as a boolean, so quote it.
+        static boost::regex yaml_bool("y|Y|yes|Yes|YES|n|N|no|No|NO|true|True|TRUE|false|False|FALSE|on|On|ON|off|Off|OFF");
+        if (boost::regex_match(str, yaml_bool)) {
+            return true;
+        }
+
+        // A string starting with the ':' special character interferes with parsing.
+        // Other string patterns containing ':' can be unexpectedly parsed as sexagesimal.
+        // To be safe quote all strings that contain ':' characters.
+        if (str.find(':') != string::npos) {
+            return true;
+        }
+
+        // Poor man's check for a numerical string or list of numbers
+        // May start with - or +
+        // May contain one . and one or more ,
+        // All other characters should be digits
+        // Note: Ruby YAML interprets 1,2,3 as a number, but not 1.2.3.
+        // It doesn't appear to honor locales when parsing YAML.
+        bool has_dot = false;
+        for (size_t i = 0; i < str.size(); ++i) {
+            char c = str[i];
+            if (i == 0 && (c == '+' || c == '-')) {
+                continue;
+            }
+            if (c == ',') {
+                continue;
+            }
+            if (c == '.') {
+                if (has_dot) {
+                    return false;
+                }
+                has_dot = true;
+                continue;
+            }
+            if (!isdigit(c)) {
+                return false;
+            }
+        }
+
+        // Numerical strings should be quoted
+        return true;
+    }
+
+    boost::optional<int> maybe_stoi(string const& str) {
+        try {
+            return stoi(str);
+        } catch (invalid_argument&) {
+            return boost::optional<int>();
+        }
+    }
+}}  // namespace facter::util

data/ext/facter/facter/lib/src/util/windows/wsa.cc

@@ -0,0 +1,69 @@
+#include <internal/util/windows/wsa.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <leatherman/locale/locale.hpp>
+#include <boost/format.hpp>
+#include <boost/nowide/convert.hpp>
+#include <Ws2tcpip.h>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+
+namespace facter { namespace util { namespace windows {
+
+    wsa_exception::wsa_exception(string const& message) :
+        runtime_error(message)
+    {
+    }
+
+    string format_err(string const& s, int err)
+    {
+        return str(boost::format("%1% (%2%)") % s % boost::io::group(hex, showbase, err));
+    }
+
+    wsa::wsa()
+    {
+        LOG_DEBUG("initializing Winsock");
+        WSADATA wsaData;
+        auto wVersionRequested = MAKEWORD(2, 2);
+        auto err = WSAStartup(wVersionRequested, &wsaData);
+
+        if (err != 0) {
+            throw wsa_exception(format_err(_("WSAStartup failed with error"), err));
+        }
+
+        if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
+            throw wsa_exception(_("could not find a usable version of Winsock.dll"));
+        }
+    }
+
+    wsa::~wsa()
+    {
+        WSACleanup();
+    }
+
+    string wsa::saddress_to_string(SOCKET_ADDRESS const& addr) const
+    {
+        if (!addr.lpSockaddr) {
+            return {};
+        }
+
+        DWORD size = INET6_ADDRSTRLEN+1;
+        wchar_t buffer[INET6_ADDRSTRLEN+1];
+        if (0 != WSAAddressToStringW(addr.lpSockaddr, addr.iSockaddrLength, NULL, buffer, &size)) {
+            throw wsa_exception(format_err(_("address to string translation failed"), WSAGetLastError()));
+        }
+
+        return boost::nowide::narrow(buffer);
+    }
+
+    void wsa::string_fill_sockaddr(sockaddr *sock, std::string const& addr, int size) const
+    {
+        auto addrW = boost::nowide::widen(addr);
+        if (0 != WSAStringToAddressW(&addrW[0], sock->sa_family, NULL, sock, &size)) {
+            throw wsa_exception(format_err(_("string to address translation failed"), WSAGetLastError()));
+        }
+    }
+
+}}}  // namespace facter::util::windows

data/ext/facter/facter/lib/src/util/yaml.cc

@@ -0,0 +1,72 @@
+#include <internal/util/yaml.hpp>
+
+#include <facter/facts/collection.hpp>
+#include <facter/facts/array_value.hpp>
+#include <facter/facts/map_value.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <boost/algorithm/string.hpp>
+
+#include <yaml-cpp/yaml.h>
+
+using namespace std;
+using namespace YAML;
+using namespace facter::facts;
+
+namespace facter { namespace util { namespace yaml {
+
+    void add_value(
+        string const& name,
+        Node const& node,
+        collection& facts,
+        array_value* array_parent,
+        map_value* map_parent)
+    {
+        unique_ptr<value> val;
+        // For scalars, code the value into a specific value type
+        if (node.IsScalar()) {
+            bool bool_val;
+            int64_t int_val;
+            double double_val;
+            // If the node tag is "!", it was a quoted scalar and should be treated as a string
+            if (node.Tag() != "!") {
+                if (convert<bool>::decode(node, bool_val)) {
+                    val = make_value<boolean_value>(bool_val);
+                } else if (convert<int64_t>::decode(node, int_val)) {
+                    val = make_value<integer_value>(int_val);
+                } else if (convert<double>::decode(node, double_val)) {
+                    val = make_value<double_value>(double_val);
+                }
+            }
+            if (!val) {
+                val = make_value<string_value>(node.as<string>());
+            }
+        } else if (node.IsSequence()) {
+            // For arrays, convert to a array value
+            auto array = make_value<array_value>();
+            for (auto const& child : node) {
+                add_value({}, child, facts, array.get());
+            }
+            val = move(array);
+        } else if (node.IsMap()) {
+            // For maps, convert to a map value
+            auto map = make_value<map_value>();
+            for (auto const& child : node) {
+                add_value(child.first.as<string>(), child.second, facts, nullptr, map.get());
+            }
+            val = move(map);
+        } else if (!node.IsNull()) {
+            // Ignore nodes we don't understand
+            return;
+        }
+
+        // Put the value in the array, map, or directly as a top-level fact
+        if (array_parent) {
+            array_parent->add(move(val));
+        } else if (map_parent) {
+            map_parent->add(string(name), move(val));
+        } else {
+            facts.add_external(boost::to_lower_copy(name), move(val));
+        }
+    }
+}}}
+

data/ext/facter/facter/lib/tasks/spec.rake

@@ -0,0 +1,26 @@
+['rubygems',
+'rspec',
+'rspec/core/rake_task',
+'rcov',].each do |lib|
+  begin
+    require lib
+  rescue LoadError
+  end
+end
+
+if defined?(RSpec::Core::RakeTask)
+  desc "Run all specs"
+  RSpec::Core::RakeTask.new do |t|
+    t.pattern ='spec/{unit,integration}/**/*_spec.rb'
+    t.fail_on_error = true
+  end
+
+  RSpec::Core::RakeTask.new('spec:rcov') do |t|
+    t.pattern ='spec/{unit,integration}/**/*_spec.rb'
+    t.fail_on_error = true
+    if defined?(Rcov)
+      t.rcov = true
+      t.rcov_opts = ['--exclude', 'spec/*,test/*,results/*,/usr/lib/*,/usr/local/lib/*,gems/*']
+    end
+  end
+end

data/ext/facter/facter/lib/tests/CMakeLists.txt

@@ -0,0 +1,172 @@
+cmake_minimum_required(VERSION 3.2.2)
+
+find_package(Ruby 1.9)
+
+# Set the common (platform-independent) sources
+set(LIBFACTER_TESTS_COMMON_SOURCES
+    "facts/array_value.cc"
+    "facts/boolean_value.cc"
+    "facts/double_value.cc"
+    "facts/external/json_resolver.cc"
+    "facts/external/text_resolver.cc"
+    "facts/external/yaml_resolver.cc"
+    "facts/collection.cc"
+    "facts/integer_value.cc"
+    "facts/map_value.cc"
+    "facts/resolvers/augeas_resolver.cc"
+    "facts/resolvers/disk_resolver.cc"
+    "facts/resolvers/dmi_resolver.cc"
+    "facts/resolvers/filesystem_resolver.cc"
+    "facts/resolvers/identity_resolver.cc"
+    "facts/resolvers/kernel_resolver.cc"
+    "facts/resolvers/ldom_resolver.cc"
+    "facts/resolvers/memory_resolver.cc"
+    "facts/resolvers/networking_resolver.cc"
+    "facts/resolvers/operating_system_resolver.cc"
+    "facts/resolvers/processor_resolver.cc"
+    "facts/resolvers/ruby_resolver.cc"
+    "facts/resolvers/ssh_resolver.cc"
+    "facts/resolvers/system_profiler_resolver.cc"
+    "facts/resolvers/timezone_resolver.cc"
+    "facts/resolvers/uptime_resolver.cc"
+    "facts/resolvers/virtualization_resolver.cc"
+    "facts/resolvers/xen_resolver.cc"
+    "facts/resolvers/zfs_resolver.cc"
+    "facts/resolvers/zone_resolver.cc"
+    "facts/resolvers/zpool_resolver.cc"
+    "facts/schema.cc"
+    "facts/cache.cc"
+    "facts/string_value.cc"
+    "logging/logging.cc"
+    "log_capture.cc"
+    "main.cc"
+    "util/string.cc"
+    "fixtures.cc"
+    "collection_fixture.cc"
+    "cwrapper.cc"
+)
+
+# Set compiler-specific flags
+set(CMAKE_CXX_FLAGS ${FACTER_CXX_FLAGS})
+
+# Add the ruby tests if there's a ruby installed
+if (RUBY_FOUND)
+    set(LIBFACTER_TESTS_COMMON_SOURCES
+        ${LIBFACTER_TESTS_COMMON_SOURCES}
+        "ruby/ruby.cc"
+        "ruby/ruby_dirfacts.cc"
+        "ruby/ruby_helper.cc")
+
+    if (WIN32)
+        set(LIBFACTER_TESTS_COMMON_SOURCES
+            ${LIBFACTER_TESTS_COMMON_SOURCES}
+            "ruby/windows/ruby.cc")
+    endif()
+endif()
+
+# Set the POSIX sources if on a POSIX platform
+if (UNIX)
+    set(LIBFACTER_TESTS_CATEGORY_SOURCES
+        "facts/posix/collection.cc"
+        "facts/posix/uptime_resolver.cc"
+        "facts/external/posix/execution_resolver.cc"
+        "util/posix/scoped_addrinfo.cc"
+        "util/posix/scoped_descriptor.cc"
+    )
+    if (OPENSSL_FOUND)
+        set(LIBFACTER_TESTS_CATEGORY_SOURCES ${LIBFACTER_TESTS_CATEGORY_SOURCES} "util/posix/scoped_bio.cc")
+    endif()
+
+     set(POSIX_TESTS_LIBRARIES ${POSIX_LIBRARIES})
+endif()
+
+set(LIBFACTER_TESTS_PLATFORM_LIBRARIES
+    ${LIBFACTER_PLATFORM_LIBRARIES}
+)
+
+if (WIN32)
+    list(APPEND LIBFACTER_TESTS_PLATFORM_LIBRARIES Mswsock)
+endif()
+
+if (WIN32)
+    set(LIBFACTER_TESTS_CATEGORY_SOURCES
+        "facts/windows/collection.cc"
+        "facts/windows/networking_resolver.cc"
+        "facts/external/windows/execution_resolver.cc"
+        "facts/external/windows/powershell_resolver.cc"
+    )
+endif()
+
+# Set the platform-specific sources
+if ("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")
+    set(LIBFACTER_TESTS_PLATFORM_SOURCES
+        "util/bsd/scoped_ifaddrs.cc"
+    )
+elseif ("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
+    set(LIBFACTER_TESTS_PLATFORM_SOURCES
+        "facts/linux/dmi_resolver.cc"
+        "facts/linux/filesystem_resolver.cc"
+        "facts/linux/virtualization_resolver.cc"
+        "facts/linux/processor_fixture.cc"
+        "facts/linux/processor_resolver.cc"
+        "util/bsd/scoped_ifaddrs.cc"
+    )
+endif()
+
+if (JRUBY_SUPPORT)
+    include_directories(${JNI_INCLUDE_DIRS})
+    set(LIBFACTER_TESTS_COMMON_SOURCES ${LIBFACTER_TESTS_COMMON_SOURCES} java/facter.cc)
+endif()
+
+include_directories(
+    ../inc
+    ${Boost_INCLUDE_DIRS}
+    ${OPENSSL_INCLUDE_DIRS}
+    ${YAMLCPP_INCLUDE_DIRS}
+    ${LEATHERMAN_CATCH_INCLUDE}
+    ${CPPHOCON_INCLUDE_DIRS}
+)
+
+# On EL 4, we run into a linking error when trying to create libraries or
+# executables that link in a static library with code using threads. As I
+# described in https://gcc.gnu.org/ml/gcc-help/2015-08/msg00035.html, we get
+# the error undefined reference to symbol '__tls_get_addr@@GLIBC_2.3'.
+# Build mock_server as a separate shared library to avoid this error.
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations")
+add_library(mock-server SHARED mock_server.cc)
+target_link_libraries(mock-server PRIVATE
+    ${Boost_THREAD_LIBRARY}
+    ${Boost_SYSTEM_LIBRARY}
+    ${LIBFACTER_TESTS_PLATFORM_LIBRARIES})
+
+add_executable(libfacter_test $<TARGET_OBJECTS:libfactersrc>
+    ${LIBFACTER_TESTS_COMMON_SOURCES}
+    ${LIBFACTER_TESTS_PLATFORM_SOURCES}
+    ${LIBFACTER_TESTS_CATEGORY_SOURCES})
+# On Windows, mock-server comes after Boost libraries to avoid double
+# definition of boost::system::system_category() on Windows. On Linux, it
+# comes before to avoid picking up incomplete Boost.Asio symbols included
+# by Boost.Log in Leatherman logging.
+if (WIN32)
+    target_link_libraries(libfacter_test
+        ${LIBS}
+        ${LIBFACTER_TESTS_PLATFORM_LIBRARIES}
+        mock-server)
+else()
+    target_link_libraries(libfacter_test
+        mock-server
+        ${LIBS}
+        ${LIBFACTER_TESTS_PLATFORM_LIBRARIES})
+endif()
+
+if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin" AND BOOST_STATIC AND LEATHERMAN_USE_LOCALES)
+    target_link_libraries(libfacter_test iconv)
+endif()
+
+target_compile_definitions(libfacter_test PRIVATE "-Dlibfacter_EXPORTS")
+
+# Generate a file containing the path to the fixtures
+configure_file (
+    "fixtures.hpp.in"
+    "${CMAKE_CURRENT_LIST_DIR}/fixtures.hpp"
+)