facter 3.12.2.cfacter.20181217 → 4.0.7.pre

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

@@ -1,29 +0,0 @@
-#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

@@ -1,22 +0,0 @@
-#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

@@ -1,116 +0,0 @@
-#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

@@ -1,26 +0,0 @@
-#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

@@ -1,72 +0,0 @@
-#include <internal/facts/posix/uptime_resolver.hpp>
-#include <internal/util/posix/utmpx_file.hpp>
-#include <leatherman/util/regex.hpp>
-#include <leatherman/execution/execution.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <leatherman/locale/locale.hpp>
-
-#include <ctime>
-
-// Mark string for translation (alias for leatherman::locale::format)
-using leatherman::locale::_;
-
-using namespace std;
-using namespace leatherman::util;
-using namespace leatherman::execution;
-using namespace facter::util::posix;
-
-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()
-    {
-        LOG_DEBUG(_("Attempting to calculate the uptime from the utmpx file"));
-        utmpx query;
-        query.ut_type = BOOT_TIME;
-        utmpx_file file;
-        auto ent = file.query(query);
-        if (ent) {
-          return time(NULL) - ent->ut_tv.tv_sec;
-        }
-        LOG_DEBUG(_("Could not calculate the uptime from the utmpx file"));
-
-        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

@@ -1,43 +0,0 @@
-#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

@@ -1,105 +0,0 @@
-#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

@@ -1,56 +0,0 @@
-#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