facter 3.12.2.cfacter.20181217 → 4.0.7.pre

data/ext/facter/facter/lib/src/facts/linux/os_linux.cc

@@ -1,399 +0,0 @@
-#include <internal/facts/linux/os_linux.hpp>
-#include <internal/facts/resolvers/operating_system_resolver.hpp>
-#include <facter/facts/os.hpp>
-#include <facter/facts/os_family.hpp>
-#include <leatherman/execution/execution.hpp>
-#include <leatherman/file_util/file.hpp>
-#include <leatherman/util/regex.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/algorithm/string.hpp>
-#include <vector>
-
-using namespace std;
-using namespace leatherman::execution;
-using namespace boost::filesystem;
-using namespace leatherman::util;
-
-namespace bs = boost::system;
-namespace lth_file = leatherman::file_util;
-
-namespace facter { namespace facts { namespace linux {
-
-    // Return contents of the os-release file
-    // http://www.freedesktop.org/software/systemd/man/os-release.html
-    map<string, string> os_linux::key_value_file(string file, set<string> const& items)
-    {
-        map<string, string> values;
-        bs::error_code ec;
-        if (!items.empty() && is_regular_file(file, ec)) {
-            string key, value;
-            lth_file::each_line(file, [&](string& line) {
-                if (re_search(line, boost::regex("(?m)^(\\w+)=[\"']?(.+?)[\"']?$"), &key, &value)) {
-                    if (items.count(key)) {
-                        values.insert(make_pair(key, value));
-                    }
-                }
-                return items.size() != values.size();
-            });
-        }
-        return values;
-    }
-
-    os_linux::os_linux(std::set<std::string> items, std::string file) :
-            _release_info(key_value_file(file, items)) {}
-
-    static string check_debian_linux(string const& distro_id)
-    {
-        // Check for Debian variants
-        bs::error_code ec;
-        if (is_regular_file(release_file::huawei, ec)) {
-          return os::huawei;
-        }
-
-        if (is_regular_file(release_file::devuan, ec)) {
-          return os::devuan;
-        }
-
-        if (is_regular_file(release_file::debian, ec)) {
-            if (distro_id == os::ubuntu || distro_id == os::linux_mint) {
-                return distro_id;
-            }
-            return os::debian;
-        }
-        return {};
-    }
-
-    static string check_oracle_linux()
-    {
-        bs::error_code ec;
-        if (is_regular_file(release_file::oracle_enterprise_linux, ec)) {
-            if (is_regular_file(release_file::oracle_vm_linux, ec)) {
-                return os::oracle_vm_linux;
-            }
-            return os::oracle_enterprise_linux;
-        }
-        return {};
-    }
-
-    static string check_redhat_linux()
-    {
-        bs::error_code ec;
-        if (is_regular_file(release_file::redhat, ec)) {
-            static vector<tuple<boost::regex, string>> const regexs {
-                make_tuple(boost::regex("(?i)centos"),                        string(os::centos)),
-                make_tuple(boost::regex("(?i)scientific linux CERN"),         string(os::scientific_cern)),
-                make_tuple(boost::regex("(?i)scientific linux release"),      string(os::scientific)),
-                make_tuple(boost::regex("(?im)^cloudlinux"),                  string(os::cloud_linux)),
-                make_tuple(boost::regex("(?im)^virtuozzo linux"),             string(os::virtuozzo_linux)),
-                make_tuple(boost::regex("(?i)Ascendos"),                      string(os::ascendos)),
-                make_tuple(boost::regex("(?im)^XenServer"),                   string(os::xen_server)),
-                make_tuple(boost::regex("(?im)^XCP-ng"),                      string(os::xcp_ng)),
-                make_tuple(boost::regex("XCP"),                               string(os::zen_cloud_platform)),
-                make_tuple(boost::regex("(?im)^Parallels Server Bare Metal"), string(os::psbm)),
-                make_tuple(boost::regex("(?m)^Fedora release"),               string(os::fedora)),
-            };
-
-            string contents = lth_file::read(release_file::redhat);
-            boost::trim(contents);
-            for (auto const& regex : regexs) {
-                if (re_search(contents, get<0>(regex))) {
-                    return get<1>(regex);
-                }
-            }
-            return os::redhat;
-        }
-        return {};
-    }
-
-    static string check_photon_linux()
-    {
-        string contents = lth_file::read(release_file::lsb);
-        boost::trim(contents);
-        if (re_search(contents, boost::regex("VMware Photon"))) {
-            return string(os::photon_os);
-        }
-        return {};
-    }
-
-    static string check_suse_linux()
-    {
-        bs::error_code ec;
-        if (is_regular_file(release_file::suse, ec)) {
-            static vector<tuple<boost::regex, string>> const regexs {
-                make_tuple(boost::regex("(?im)^SUSE LINUX Enterprise Server"),  string(os::suse_enterprise_server)),
-                make_tuple(boost::regex("(?im)^SUSE LINUX Enterprise Desktop"), string(os::suse_enterprise_desktop)),
-                make_tuple(boost::regex("(?im)^openSUSE"),                      string(os::open_suse)),
-            };
-
-            string contents = lth_file::read(release_file::suse);
-            boost::trim(contents);
-            for (auto const& regex : regexs) {
-                if (re_search(contents, get<0>(regex))) {
-                    return get<1>(regex);
-                }
-            }
-            return os::suse;
-        }
-        return {};
-    }
-
-    static string check_other_linux()
-    {
-        static vector<tuple<string, string>> const files {
-            make_tuple(string(release_file::arista_eos),     string(os::arista_eos)),
-            make_tuple(string(release_file::gentoo),         string(os::gentoo)),
-            make_tuple(string(release_file::mageia),         string(os::mageia)),
-            make_tuple(string(release_file::mandriva),       string(os::mandriva)),
-            make_tuple(string(release_file::mandrake),       string(os::mandrake)),
-            make_tuple(string(release_file::meego),          string(os::meego)),
-            make_tuple(string(release_file::archlinux),      string(os::archlinux)),
-            make_tuple(string(release_file::manjarolinux),   string(os::manjarolinux)),
-            make_tuple(string(release_file::oracle_linux),   string(os::oracle_linux)),
-            make_tuple(string(release_file::openwrt),        string(os::openwrt)),
-            make_tuple(string(release_file::alpine),         string(os::alpine)),
-            make_tuple(string(release_file::vmware_esx),     string(os::vmware_esx)),
-            make_tuple(string(release_file::slackware),      string(os::slackware)),
-        };
-
-        for (auto const& file : files) {
-            bs::error_code ec;
-            if (is_regular_file(get<0>(file), ec)) {
-                return get<1>(file);
-            }
-        }
-        return {};
-    }
-
-    static string check_amazon()
-    {
-        bs::error_code ec;
-        if (is_regular_file(release_file::amazon, ec)) {
-            return os::amazon;
-        }
-        return {};
-    }
-
-    string os_linux::get_name(string const& distro_id) const
-    {
-        // Check for Debian first; this happens after AristaEOS in Facter 2.x
-        // but that platform is not a Debian so shouldn't matter.
-        auto value = check_debian_linux(distro_id);
-        if (!value.empty()) {
-            return value;
-        }
-
-        // Check for specialized distributions next
-        value = check_other_linux();
-        if (!value.empty()) {
-            return value;
-        }
-
-        // Check for Oracle Enterprise Linux next
-        value = check_oracle_linux();
-        if (!value.empty()) {
-            return value;
-        }
-
-        // Check for RedHat next
-        value = check_redhat_linux();
-        if (!value.empty()) {
-            return value;
-        }
-
-        // Check for SuSE next
-        value = check_suse_linux();
-        if (!value.empty()) {
-            return value;
-        }
-
-        value = check_photon_linux();
-        if (!value.empty()) {
-            return value;
-        }
-        // This should happen after everything else because it's a relatively broad match
-        return check_amazon();
-    }
-
-    string os_linux::get_family(string const& name) const
-    {
-        static map<string, string> const systems = {
-            { string(os::redhat),                   string(os_family::redhat) },
-            { string(os::fedora),                   string(os_family::redhat) },
-            { string(os::centos),                   string(os_family::redhat) },
-            { string(os::scientific),               string(os_family::redhat) },
-            { string(os::scientific_cern),          string(os_family::redhat) },
-            { string(os::ascendos),                 string(os_family::redhat) },
-            { string(os::cloud_linux),              string(os_family::redhat) },
-            { string(os::psbm),                     string(os_family::redhat) },
-            { string(os::oracle_linux),             string(os_family::redhat) },
-            { string(os::oracle_vm_linux),          string(os_family::redhat) },
-            { string(os::oracle_enterprise_linux),  string(os_family::redhat) },
-            { string(os::amazon),                   string(os_family::redhat) },
-            { string(os::xen_server),               string(os_family::redhat) },
-            { string(os::xcp_ng),                   string(os_family::redhat) },
-            { string(os::photon_os),                string(os_family::redhat) },
-            { string(os::huawei),                   string(os_family::debian) },
-            { string(os::linux_mint),               string(os_family::debian) },
-            { string(os::ubuntu),                   string(os_family::debian) },
-            { string(os::debian),                   string(os_family::debian) },
-            { string(os::devuan),                   string(os_family::debian) },
-            { string(os::suse_enterprise_server),   string(os_family::suse) },
-            { string(os::suse_enterprise_desktop),  string(os_family::suse) },
-            { string(os::open_suse),                string(os_family::suse) },
-            { string(os::suse),                     string(os_family::suse) },
-            { string(os::gentoo),                   string(os_family::gentoo) },
-            { string(os::archlinux),                string(os_family::archlinux) },
-            { string(os::manjarolinux),             string(os_family::archlinux) },
-            { string(os::mandrake),                 string(os_family::mandrake) },
-            { string(os::mandriva),                 string(os_family::mandrake) },
-            { string(os::mageia),                   string(os_family::mandrake) },
-        };
-        auto const& it = systems.find(name);
-        if (it != systems.end()) {
-            return it->second;
-        }
-        return {};
-    }
-
-    string os_linux::get_release(string const& name, string const& distro_release) const
-    {
-        // Map of release files that contain a "release X.X.X" on the first line
-        static map<string, string> const release_files = {
-                { string(os::amazon),                   string(release_file::amazon) },
-                { string(os::centos),                   string(release_file::redhat) },
-                { string(os::redhat),                   string(release_file::redhat) },
-                { string(os::scientific),               string(release_file::redhat) },
-                { string(os::scientific_cern),          string(release_file::redhat) },
-                { string(os::ascendos),                 string(release_file::redhat) },
-                { string(os::cloud_linux),              string(release_file::redhat) },
-                { string(os::psbm),                     string(release_file::redhat) },
-                { string(os::xen_server),               string(release_file::redhat) },
-                { string(os::xcp_ng),                   string(release_file::redhat) },
-                { string(os::fedora),                   string(release_file::fedora) },
-                { string(os::meego),                    string(release_file::meego) },
-                { string(os::oracle_linux),             string(release_file::oracle_linux) },
-                { string(os::oracle_enterprise_linux),  string(release_file::oracle_enterprise_linux) },
-                { string(os::oracle_vm_linux),          string(release_file::oracle_vm_linux) },
-                { string(os::arista_eos),               string(release_file::arista_eos) },
-                { string(os::gentoo),                   string(release_file::gentoo) },
-        };
-
-        string value;
-        auto it = release_files.find(name);
-        if (it != release_files.end()) {
-            string contents;
-            if (lth_file::each_line(it->second, [&](string& line) {
-                // We only need the first line
-                contents = move(line);
-                return false;
-            })) {
-                if (boost::ends_with(contents, "(Rawhide)")) {
-                    value = "Rawhide";
-                } else if (contents.find("release") != string::npos) {
-                    re_search(contents, boost::regex("release (\\d[\\d.]*)"), &value);
-                } else {
-                    re_search(contents, boost::regex("Amazon Linux (\\d+)"), &value);
-                }
-            }
-        }
-
-        // Debian uses the entire contents of the release file as the version
-        if (value.empty() && name == os::debian) {
-            value = lth_file::read(release_file::debian);
-            boost::trim_right(value);
-        }
-
-        // Devuan uses the entire contents of the release file as the version
-        if (value.empty() && name == os::devuan) {
-            value = lth_file::read(release_file::devuan);
-            boost::trim_right(value);
-        }
-
-        // Alpine uses the entire contents of the release file as the version
-        if (value.empty() && name == os::alpine) {
-            value = lth_file::read(release_file::alpine);
-            boost::trim_right(value);
-        }
-
-        // HuaweiOS uses the entire contents of the release file as the version
-        if (value.empty() && name == os::huawei) {
-            value = lth_file::read(release_file::huawei);
-            boost::trim_right(value);
-        }
-
-        // Check for SuSE related distros, read the release file
-        if (value.empty() && (
-                name == os::suse ||
-                name == os::suse_enterprise_server ||
-                name == os::suse_enterprise_desktop ||
-                name == os::open_suse)) {
-            string contents = lth_file::read(release_file::suse);
-            string major;
-            string minor;
-            if (re_search(contents, boost::regex("(?m)^VERSION\\s*=\\s*(\\d+)\\.?(\\d+)?"), &major, &minor)) {
-                // Check that we have a minor version; if not, use the patch level
-                if (minor.empty()) {
-                    if (!re_search(contents, boost::regex("(?m)^PATCHLEVEL\\s*=\\s*(\\d+)"), &minor)) {
-                        minor = "0";
-                    }
-                }
-                value = major + "." + minor;
-            } else {
-                value = "unknown";
-            }
-        }
-        if (value.empty() && name == os::photon_os) {
-            string major, minor;
-            string contents = lth_file::read(release_file::lsb);
-            string pattern = "DISTRIB_RELEASE=\"(\\d+)\\.(\\d+)( ([a-zA-Z]+\\d+))?\"";
-            if (re_search(contents, boost::regex(pattern), &major, &minor)) {
-                value = major + "." + minor;
-            }
-        }
-
-        // Read version files of particular operating systems
-        if (value.empty()) {
-            const char* file = nullptr;
-            boost::regex pattern;
-            if (name == os::ubuntu) {
-                file = release_file::lsb;
-                pattern = "(?m)^DISTRIB_RELEASE=(\\d+\\.\\d+)(?:\\.\\d+)*";
-            } else if (name == os::slackware) {
-                file = release_file::slackware;
-                pattern = "Slackware ([0-9.]+)";
-            } else if (name == os::mageia) {
-                file = release_file::mageia;
-                pattern = "Mageia release ([0-9.]+)";
-            } else if (name == os::linux_mint) {
-                file = release_file::linux_mint_info;
-                pattern = "(?m)^RELEASE=(\\d+)";
-            } else if (name == os::openwrt) {
-                file = release_file::openwrt_version;
-                pattern = "(?m)^(\\d+\\.\\d+.*)";
-            } else if (name == os::arista_eos) {
-                file = release_file::arista_eos;
-                pattern = "Arista Networks EOS (\\d+\\.\\d+\\.\\d+[A-M]?)";
-            }
-            if (file) {
-                string contents = lth_file::read(file);
-                re_search(contents, pattern, &value);
-            }
-        }
-
-        // For VMware ESX, execute the vmware tool
-        if (value.empty() && name == os::vmware_esx) {
-            auto exec = execute("vmware", { "-v" });
-            if (exec.success) {
-                re_search(exec.output, boost::regex("VMware ESX .*?(\\d.*)"), &value);
-            }
-        }
-
-        return value;
-    }
-
-    tuple<string, string> os_linux::parse_release(string const& name, string const& release) const
-    {
-        return facter::facts::resolvers::operating_system_resolver::parse_distro(name, release);
-    }
-
-}}}  // namespace facter::facts::linux

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

@@ -1,200 +0,0 @@
-#include <internal/facts/linux/processor_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/os.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <facter/util/string.hpp>
-#include <leatherman/file_util/file.hpp>
-#include <leatherman/file_util/directory.hpp>
-#include <leatherman/util/regex.hpp>
-#include <boost/algorithm/string.hpp>
-#include <boost/filesystem.hpp>
-#include <unordered_set>
-
-using namespace std;
-using namespace boost::filesystem;
-using facter::util::maybe_stoi;
-
-namespace lth_file = leatherman::file_util;
-namespace lth_util = leatherman::util;
-
-namespace facter { namespace facts { namespace linux {
-    static bool split_line(string const& line, string& key, string& value)
-    {
-        // Split the line on colon
-        auto pos = line.find(":");
-        if (pos == string::npos) {
-            return false;
-        }
-        key = line.substr(0, pos);
-        boost::trim(key);
-        value = line.substr(pos + 1);
-        boost::trim(value);
-
-        return true;
-    }
-
-    processor_resolver::ArchitectureType processor_resolver::architecture_type(data const& data, std::string const& root)
-    {
-        if (!data.isa.empty()) {
-            return (boost::starts_with(data.isa, "ppc64")) ? ArchitectureType::POWER : ArchitectureType::X86;
-        }
-
-        // use /proc/cpuinfo
-        unordered_set<string> to_be_seen;
-        bool seen_all = false;
-        lth_file::each_line(root + "/proc/cpuinfo", [&](string& line) {
-            // if we already know that we're on a Power machine, we can just skip
-            // the remaining lines
-            if (seen_all) {
-                return false;
-            }
-
-            string key, value;
-            if (!split_line(line, key, value)) {
-                return true;
-            }
-
-            if (key == "processor") {
-                to_be_seen = unordered_set<string>{{"cpu", "clock", "revision"}};
-            } else if (find(to_be_seen.begin(), to_be_seen.end(), key) != to_be_seen.end()) {
-                to_be_seen.erase(key);
-                seen_all = to_be_seen.empty();
-            }
-            return true;
-        });
-
-        return seen_all ? ArchitectureType::POWER : ArchitectureType::X86;
-    }
-
-    // returns true if the first cpu is a valid, physical cpu to use when computing the processor
-    // speed
-    bool processor_resolver::compute_cpu_counts(data& data, std::string const& root, std::function<bool(std::string const&)> is_valid_id) {
-        unordered_set<string> cpus;
-        bool cpu0_valid = false;
-
-        lth_file::each_subdirectory(root + "/sys/devices/system/cpu", [&](string const& cpu_directory) {
-            bool at_cpu0 = data.logical_count == 0;
-            data.logical_count++;
-            string id = lth_file::read((path(cpu_directory) / "/topology/physical_package_id").string());
-            boost::trim(id);
-            if (id.empty() || (is_valid_id(id) && cpus.emplace(move(id)).second)) {
-                // Haven't seen this processor before
-                ++data.physical_count;
-                if (at_cpu0) {
-                    cpu0_valid = true;
-                }
-            }
-
-            return true;
-        }, "^cpu\\d+$");
-
-        return cpu0_valid;
-    }
-
-    void processor_resolver::maybe_add_speed(data& data, std::string const& speed)
-    {
-        auto maybe_speed = maybe_stoi(speed);
-        if (maybe_speed && maybe_speed.get() > 0) {
-            data.speed = maybe_speed.get() * static_cast<int64_t>(1000);
-        }
-    }
-
-    bool processor_resolver::add_x86_cpu_data(data& data, std::string const& root)
-    {
-        bool cpu0_valid = compute_cpu_counts(data, root, [](string const& id) {
-            // any id is fine for x86 cpus
-            return true;
-        });
-        bool have_counts = data.logical_count > 0;
-
-        unordered_set<string> cpus;
-        string id;
-        lth_file::each_line(root + "/proc/cpuinfo", [&](string& line) {
-            string key, value;
-            if (!split_line(line, key, value)) {
-                return true;
-            }
-
-            if (key == "processor") {
-                // Start of a logical processor
-                id = move(value);
-                if (!have_counts) {
-                    ++data.logical_count;
-                }
-            } else if (!id.empty() && key == "model name") {
-                // Add the model for this logical processor
-                data.models.emplace_back(move(value));
-            } else if (!have_counts && key == "physical id" && cpus.emplace(move(value)).second) {
-                // Couldn't determine physical count from sysfs, but CPU topology is present, so use it
-                ++data.physical_count;
-            }
-            return true;
-        });
-
-        return cpu0_valid;
-    }
-
-    bool processor_resolver::add_power_cpu_data(data& data, std::string const& root)
-    {
-        bool cpu0_valid = compute_cpu_counts(data, root, [](string const& id) {
-            // only non-negative ids are allowed for power cpus
-            auto maybe_id = maybe_stoi(id);
-            return !maybe_id || maybe_id.get() >= 0;
-        });
-
-        // per ticket specs, logical count is computed below
-        data.logical_count = 0;
-
-        unordered_set<string> cpus;
-        string id;
-        lth_file::each_line(root + "/proc/cpuinfo", [&](string& line) {
-            string key, value;
-            if (!split_line(line, key, value)) {
-                return true;
-            }
-
-            if (key == "processor") {
-                // Start of a logical processor
-                id = move(value);
-                ++data.logical_count;
-            } else if (!id.empty() && key == "cpu") {
-                // Add the model for this logical processor
-                data.models.emplace_back(move(value));
-            } else if (key == "clock" && data.speed == 0) {
-                // Parse out the processor speed (in MHz)
-                string speed;
-                if (lth_util::re_search(value, boost::regex("^(\\d+).*MHz"), &speed)) {
-                    maybe_add_speed(data, speed);
-                }
-            }
-            return true;
-        });
-
-        return cpu0_valid;
-    }
-
-    void processor_resolver::add_cpu_data(data& data, std::string const& root)
-    {
-        bool cpu0_valid = (architecture_type(data, root) == ArchitectureType::X86) ?
-            add_x86_cpu_data(data, root)
-          : add_power_cpu_data(data, root);
-
-        if (data.speed != 0 || !cpu0_valid) {
-            return;
-        }
-
-        // Read in the max speed from the first cpu
-        // The speed is in kHz
-        string speed = lth_file::read(root + "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq");
-        maybe_add_speed(data, speed);
-    }
-
-    processor_resolver::data processor_resolver::collect_data(collection& facts)
-    {
-        auto result = posix::processor_resolver::collect_data(facts);
-        add_cpu_data(result);
-        return result;
-    }
-
-}}}  // namespace facter::facts::linux