cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,393 @@
+#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("(?i)Ascendos"),                      string(os::ascendos)),
+                make_tuple(boost::regex("(?im)^XenServer"),                   string(os::xen_server)),
+                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::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::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 {
+                    re_search(contents, boost::regex("release (\\d[\\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

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