cfacter 3.11.0.rc.20180314

data/ext/facter/facter/lib/src/facts/posix/operatingsystem_resolver.cc

@@ -0,0 +1,29 @@
+#include <internal/facts/posix/operating_system_resolver.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <leatherman/execution/execution.hpp>
+#include <sys/utsname.h>
+
+using namespace std;
+using namespace leatherman::execution;
+
+namespace facter { namespace facts { namespace posix {
+
+    operating_system_resolver::data operating_system_resolver::collect_data(collection& facts)
+    {
+        // Default to the base implementation
+        data result = resolvers::operating_system_resolver::collect_data(facts);
+
+        struct utsname name;
+        memset(&name, 0, sizeof(name));
+        if (uname(&name) == -1) {
+            LOG_DEBUG("uname failed: {1} ({2}): OS hardware is unavailable.", strerror(errno), errno);
+        } else {
+            result.hardware = name.machine;
+        }
+
+        // By default, the architecture is the same as the hardware model
+        result.architecture = result.hardware;
+        return result;
+    }
+
+}}}  // namespace facter::facts::posix

data/ext/facter/facter/lib/src/facts/posix/processor_resolver.cc

@@ -0,0 +1,22 @@
+#include <internal/facts/posix/processor_resolver.hpp>
+#include <leatherman/execution/execution.hpp>
+#include <leatherman/logging/logging.hpp>
+
+using namespace std;
+using namespace leatherman::execution;
+
+namespace facter { namespace facts { namespace posix {
+
+    processor_resolver::data processor_resolver::collect_data(collection& facts)
+    {
+        data result;
+
+        // Unfortunately there's no corresponding member in utsname for "processor", so we need to spawn
+        auto exec = execute("uname", { "-p" });
+        if (exec.success) {
+            result.isa = exec.output;
+        }
+        return result;
+    }
+
+}}}  // namespace facter::facts::posix

data/ext/facter/facter/lib/src/facts/posix/ssh_resolver.cc

@@ -0,0 +1,116 @@
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#include <internal/facts/posix/ssh_resolver.hpp>
+#include <leatherman/file_util/file.hpp>
+#include <facter/util/string.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/format.hpp>
+#include <tuple>
+#include <vector>
+
+#ifdef USE_OPENSSL
+#include <internal/util/posix/scoped_bio.hpp>
+#include <openssl/sha.h>
+#include <openssl/evp.h>
+using namespace facter::util::posix;
+#endif  // USE_OPENSSL
+
+using namespace std;
+using namespace facter::util;
+using namespace boost::filesystem;
+
+namespace bs = boost::system;
+namespace lth_file = leatherman::file_util;
+
+namespace facter { namespace facts { namespace posix {
+
+    ssh_resolver::data ssh_resolver::collect_data(collection& facts)
+    {
+        data result;
+        populate_key("ssh_host_rsa_key.pub", 1, result.rsa);
+        populate_key("ssh_host_dsa_key.pub", 2, result.dsa);
+        populate_key("ssh_host_ecdsa_key.pub", 3, result.ecdsa);
+        populate_key("ssh_host_ed25519_key.pub", 4, result.ed25519);
+        return result;
+    }
+
+    void ssh_resolver::populate_key(std::string const& filename, int type, ssh_key& key)
+    {
+        static vector<string> const search_directories = {
+            "/etc/ssh",
+            "/usr/local/etc/ssh",
+            "/etc",
+            "/usr/local/etc",
+            "/etc/opt/ssh"
+        };
+
+        // Search the directories for the fact's key file
+        path key_file;
+        for (auto const& directory : search_directories) {
+            key_file = directory;
+            key_file /= filename;
+
+            bs::error_code ec;
+            if (!is_regular_file(key_file, ec)) {
+                key_file.clear();
+                continue;
+            }
+            break;
+        }
+
+        // Log if we didn't find the file
+        if (key_file.empty()) {
+            LOG_DEBUG("{1} could not be located.", filename);
+            return;
+        }
+
+        // Read the file's contents
+        string contents = lth_file::read(key_file.string());
+        if (contents.empty()) {
+            LOG_DEBUG("{1} could not be read.", key_file);
+            return;
+        }
+
+        // The SSH public key file format is <algo> <key> <comment>
+        vector<boost::iterator_range<string::iterator>> parts;
+        boost::split(parts, contents, boost::is_any_of(" "), boost::token_compress_on);
+        if (parts.size() < 2) {
+            LOG_DEBUG("unexpected contents for {1}.", key_file);
+            return;
+        }
+
+        // Assign the key and its type
+        key.type.assign(parts[0].begin(), parts[0].end());
+        key.key.assign(parts[1].begin(), parts[1].end());
+
+        // Only fingerprint if we are using OpenSSL
+#ifdef USE_OPENSSL
+        // Decode the key which is expected to be base64 encoded
+        vector<uint8_t> key_bytes(key.key.size());
+        scoped_bio b64((BIO_f_base64()));
+        BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
+
+        // Despite the const_cast here, we're only reading from the string; BIO_new_mem_buf is not const-correct
+        scoped_bio mem(BIO_new_mem_buf(const_cast<char*>(key.key.c_str()), key.key.size()));
+        BIO* stream = BIO_push(b64, mem);
+        int length = BIO_read(stream, key_bytes.data(), key_bytes.size());
+        if (length < 1) {
+            LOG_DEBUG("failed to decode SSH key \"{1}\".", key.key);
+            return;
+        }
+
+        // Do a SHA1 and a SHA-256 hash for the fingerprints
+        uint8_t hash[SHA_DIGEST_LENGTH];
+        SHA1(key_bytes.data(), length, hash);
+        uint8_t hash256[SHA256_DIGEST_LENGTH];
+        SHA256(key_bytes.data(), length, hash256);
+
+        key.digest.sha1 = (boost::format("SSHFP %1% 1 %2%") % type % to_hex(hash, sizeof(hash))).str();
+        key.digest.sha256 = (boost::format("SSHFP %1% 2 %2%") % type % to_hex(hash256, sizeof(hash256))).str();
+#else
+        LOG_INFO("facter was built without OpenSSL support: SSH fingerprint information is unavailable.");
+#endif  // USE_OPENSSL
+    }
+
+}}}  // namespace facter::facts::posix

data/ext/facter/facter/lib/src/facts/posix/timezone_resolver.cc

@@ -0,0 +1,26 @@
+#include <internal/facts/posix/timezone_resolver.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <time.h>
+
+using namespace std;
+
+namespace facter { namespace facts { namespace posix {
+
+    string timezone_resolver::get_timezone()
+    {
+        time_t since_epoch = time(NULL);
+        tm localtime;
+        char buffer[16];
+
+        if (!::localtime_r(&since_epoch, &localtime)) {
+            LOG_WARNING("localtime_r failed: timezone is unavailable.");
+            return {};
+        }
+        if (::strftime(buffer, sizeof(buffer), "%Z", &localtime) == 0) {
+            LOG_WARNING("strftime failed: timezone is unavailable.");
+            return {};
+        }
+        return buffer;
+    }
+
+}}}  // facter::facts::posix

data/ext/facter/facter/lib/src/facts/posix/uptime_resolver.cc

@@ -0,0 +1,53 @@
+#include <internal/facts/posix/uptime_resolver.hpp>
+#include <leatherman/util/regex.hpp>
+#include <leatherman/execution/execution.hpp>
+
+using namespace std;
+using namespace leatherman::util;
+using namespace leatherman::execution;
+
+namespace facter { namespace facts { namespace posix {
+
+    int64_t uptime_resolver::parse_uptime(string const& output)
+    {
+        // This regex parsing is directly ported from facter:
+        // https://github.com/puppetlabs/facter/blob/2.0.1/lib/facter/util/uptime.rb#L42-L60
+
+        static boost::regex days_hours_mins_pattern("(\\d+) day(?:s|\\(s\\))?,?\\s+(\\d+):-?(\\d+)");
+        static boost::regex days_hours_pattern("(\\d+) day(?:s|\\(s\\))?,\\s+(\\d+) hr(?:s|\\(s\\))?,");
+        static boost::regex days_mins_pattern("(\\d+) day(?:s|\\(s\\))?,\\s+(\\d+) min(?:s|\\(s\\))?,");
+        static boost::regex days_pattern("(\\d+) day(?:s|\\(s\\))?,");
+        static boost::regex hours_mins_pattern("up\\s+(\\d+):-?(\\d+),");
+        static boost::regex hours_pattern("(\\d+) hr(?:s|\\(s\\))?,");
+        static boost::regex mins_pattern("(\\d+) min(?:s|\\(s\\))?,");
+
+        int days, hours, minutes;
+
+        if (re_search(output, days_hours_mins_pattern, &days, &hours, &minutes)) {
+            return 86400ll * days + 3600ll * hours + 60ll * minutes;
+        } else if (re_search(output, days_hours_pattern, &days, &hours)) {
+            return 86400ll * days + 3600ll * hours;
+        } else if (re_search(output, days_mins_pattern, &days, &minutes)) {
+            return 86400ll * days + 60ll * minutes;
+        } else if (re_search(output, days_pattern, &days)) {
+            return 86400ll * days;
+        } else if (re_search(output, hours_mins_pattern, &hours, &minutes)) {
+            return 3600ll * hours + 60ll * minutes;
+        } else if (re_search(output, hours_pattern, &hours)) {
+            return 3600ll * hours;
+        } else if (re_search(output, mins_pattern, &minutes)) {
+            return 60ll * minutes;
+        }
+        return -1;
+    }
+
+    int64_t uptime_resolver::get_uptime()
+    {
+        auto exec = execute("uptime");
+        if (!exec.success) {
+            return -1;
+        }
+        return parse_uptime(exec.output);
+    }
+
+}}}  // namespace facter::facts::posix

data/ext/facter/facter/lib/src/facts/posix/xen_resolver.cc

@@ -0,0 +1,43 @@
+#include <internal/facts/posix/xen_resolver.hpp>
+#include <leatherman/execution/execution.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <boost/filesystem.hpp>
+
+using namespace std;
+using namespace facter::facts;
+using namespace leatherman::execution;
+using namespace boost::filesystem;
+namespace bs = boost::system;
+
+namespace facter { namespace facts { namespace posix {
+
+    string xen_resolver::xen_command()
+    {
+        constexpr char const* xen_toolstack = "/usr/lib/xen-common/bin/xen-toolstack";
+
+        bs::error_code ec;
+        if (exists(xen_toolstack, ec) && !ec) {
+            auto exec = execute(xen_toolstack);
+            if (exec.success) {
+                return exec.output;
+            } else {
+                LOG_DEBUG("failure executing {1}: {2}", xen_toolstack, exec.error);
+                return {};
+            }
+        } else {
+            LOG_TRACE("xen toolstack command not found: {1}", ec.message());
+
+            static vector<string> xen_commands{"/usr/sbin/xl", "/usr/sbin/xm"};
+            for (auto const& cmd : xen_commands) {
+                auto cmd_path = which(cmd);
+                if (!cmd_path.empty()) {
+                    return cmd_path;
+                }
+            }
+
+            LOG_TRACE("no xen commands found");
+            return {};
+        }
+    }
+
+}}}  // namespace facter::facts::posix

data/ext/facter/facter/lib/src/facts/resolver.cc

@@ -0,0 +1,105 @@
+#include <facter/facts/resolver.hpp>
+#include <facter/facts/collection.hpp>
+#include <leatherman/util/regex.hpp>
+#include <leatherman/util/environment.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <boost/locale/info.hpp>
+
+using namespace std;
+using namespace leatherman::util;
+
+namespace facter { namespace facts {
+
+    invalid_name_pattern_exception::invalid_name_pattern_exception(string const& message) :
+        runtime_error(message)
+    {
+    }
+
+    resolver::resolver(string name, vector<string> names, vector<string> const& patterns) :
+        _name(move(name)),
+        _names(move(names))
+    {
+        for (auto const& pattern : patterns) {
+            try {
+                _regexes.push_back(boost::regex(pattern));
+            } catch (boost::regex_error const& ex) {
+                throw invalid_name_pattern_exception(ex.what());
+            }
+        }
+    }
+
+    resolver::~resolver()
+    {
+        // This needs to be defined here since we use incomplete types in the header
+    }
+
+    resolver::resolver(resolver&& other)
+    {
+        *this = std::move(other);
+    }
+
+    resolver& resolver::operator=(resolver&& other)
+    {
+        if (this != &other) {
+            _name = std::move(other._name);
+            _names = std::move(other._names);
+            _regexes = std::move(other._regexes);
+            _http_langs = std::move(other._http_langs);
+        }
+        return *this;
+    }
+
+    string const& resolver::name() const
+    {
+        return _name;
+    }
+
+    vector<string> const& resolver::names() const
+    {
+        return _names;
+    }
+
+    bool resolver::has_patterns() const
+    {
+        return _regexes.size() > 0;
+    }
+
+    bool resolver::is_match(string const& name) const
+    {
+        // Check to see if any of our regexes match
+        for (auto const& regex : _regexes) {
+            if (re_search(name, regex)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    string const& resolver::http_langs()
+    {
+#ifdef LEATHERMAN_USE_LOCALES
+        if (_http_langs.empty()) {
+            // build Accept-Language list for HTTP-based resolvers
+            const auto& loc = leatherman::locale::get_locale();
+            if (std::has_facet<boost::locale::info>(loc)) {
+                const auto& info = std::use_facet<boost::locale::info>(loc);
+                string lang = info.language();
+                // use country code when available; add fallback to base lang
+                if (!info.country().empty())
+                    lang += "-" + info.country() + ", " + info.language();
+                // always include English (en) as a fallback
+                if (info.language() != "en")
+                    lang += ", en";
+                std::transform(lang.begin(), lang.end(), lang.begin(), ::tolower);
+                _http_langs = lang;
+            }
+        }
+#endif
+        return _http_langs;
+    }
+
+    bool resolver::is_blockable() const
+    {
+        return false;
+    }
+}}  // namespace facter::facts

data/ext/facter/facter/lib/src/facts/resolvers/augeas_resolver.cc

@@ -0,0 +1,56 @@
+#include <internal/facts/resolvers/augeas_resolver.hpp>
+#include <internal/util/agent.hpp>
+#include <facter/facts/collection.hpp>
+#include <facter/facts/fact.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <facter/facts/map_value.hpp>
+#include <leatherman/execution/execution.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <leatherman/util/regex.hpp>
+
+using namespace std;
+using namespace facter::util;
+using namespace leatherman::util;
+using namespace leatherman::execution;
+
+namespace facter { namespace facts { namespace resolvers {
+
+    augeas_resolver::augeas_resolver() :
+        resolver(
+            "augeas",
+            {
+                fact::augeas,
+                fact::augeasversion,
+            })
+    {
+    }
+
+    string augeas_resolver::get_version()
+    {
+        string augparse = agent::which("augparse");
+        string value;
+        boost::regex regexp("^augparse (\\d+\\.\\d+\\.\\d+)");
+        // Version info goes on stderr.
+        each_line(augparse, {"--version"}, nullptr, [&](string& line) {
+            if (re_search(line, regexp, &value)) {
+                return false;
+            }
+            return true;
+        });
+        return value;
+    }
+
+    void augeas_resolver::resolve(collection& facts)
+    {
+        auto version = get_version();
+        if (version.empty()) {
+            return;
+        }
+
+        auto augeas = make_value<map_value>();
+        augeas->add("version", make_value<string_value>(version));
+        facts.add(fact::augeasversion, make_value<string_value>(move(version), true));
+        facts.add(fact::augeas, move(augeas));
+    }
+
+}}}  // namespace facter::facts::resolvers