facter 2.5.7 → 3.9.6.cfacter.20180606

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

@@ -0,0 +1,15 @@
+#include <internal/facts/linux/uptime_resolver.hpp>
+#include <sys/sysinfo.h>
+
+namespace facter { namespace facts { namespace linux {
+
+    int64_t uptime_resolver::get_uptime()
+    {
+        struct sysinfo info;
+        if (sysinfo(&info) == 0) {
+            return info.uptime;
+        }
+        return posix::uptime_resolver::get_uptime();
+    }
+
+}}}  // namespace facter::facts::linux

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

@@ -0,0 +1,282 @@
+#include <internal/facts/linux/virtualization_resolver.hpp>
+#include <internal/util/agent.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <facter/facts/collection.hpp>
+#include <facter/facts/fact.hpp>
+#include <facter/facts/vm.hpp>
+#include <leatherman/file_util/file.hpp>
+#include <leatherman/util/regex.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/algorithm/string.hpp>
+
+using namespace std;
+using namespace facter::facts;
+using namespace facter::util;
+using namespace leatherman::util;
+using namespace leatherman::execution;
+using namespace boost::filesystem;
+
+namespace bs = boost::system;
+namespace lth_file = leatherman::file_util;
+
+namespace facter { namespace facts { namespace linux {
+
+    string virtualization_resolver::get_cloud_provider(collection& facts)
+    {
+        // Check for Azure
+        std::string provider = get_azure(facts);
+
+        return provider;
+    }
+
+    string virtualization_resolver::get_azure(collection& facts, string const& leases_file)
+    {
+        std::string provider;
+        if (boost::filesystem::exists(leases_file))
+        {
+            lth_file::each_line(leases_file, [&](string& line) {
+                // Search for DHCP option 245. This is an accepted method of determining
+                // whether a machine is running inside Azure. Source:
+                // https://social.msdn.microsoft.com/Forums/azure/en-US/f7fbbee6-370a-41c2-a384-d14ab2a0ac12/what-is-the-correct-method-in-linux-on-azure-to-test-if-you-are-an-azure-vm-?forum=WAVirtualMachinesforWindows
+                if (line.find("option 245") != std::string::npos ||
+                        line.find("option unknown-245") != std::string::npos) {
+                    provider = "azure";
+                    return false;
+                }
+                return true;
+            });
+        }
+        return provider;
+    }
+
+    string virtualization_resolver::get_hypervisor(collection& facts)
+    {
+        // First check for Docker/LXC
+        string value = get_cgroup_vm();
+
+        // Next check for Google Compute Engine
+        if (value.empty()) {
+            value = get_gce_vm(facts);
+        }
+
+        // Next check based on the virt-what command
+        if (value.empty()) {
+            value = get_what_vm();
+        }
+
+        // Next check the vmware tool output
+        if (value.empty()) {
+            value = get_vmware_vm();
+        }
+
+        // Next check for OpenVZ
+        if (value.empty()) {
+            value = get_openvz_vm();
+        }
+
+        // Next check for VServer
+        if (value.empty()) {
+            value = get_vserver_vm();
+        }
+
+        // Next check for Xen
+        if (value.empty()) {
+            value = get_xen_vm();
+        }
+
+        // Next check other facts for the VM
+        if (value.empty()) {
+            value = get_fact_vm(facts);
+        }
+
+        // Lastly, resort to lspci to look for hardware related to certain VMs
+        if (value.empty()) {
+            value = get_lspci_vm();
+        }
+
+        return value;
+    }
+
+    string virtualization_resolver::get_cgroup_vm()
+    {
+        string value;
+        lth_file::each_line("/proc/1/cgroup", [&](string& line) {
+            vector<boost::iterator_range<string::iterator>> parts;
+            boost::split(parts, line, boost::is_any_of(":"), boost::token_compress_on);
+            if (parts.size() < 3) {
+                return true;
+            }
+            if (boost::contains(parts[2], boost::as_literal("/docker"))) {
+                value = vm::docker;
+                return false;
+            }
+            if (boost::contains(parts[2], boost::as_literal("/lxc"))) {
+                value = vm::lxc;
+                return false;
+            }
+            return true;
+        });
+        return value;
+    }
+
+    string virtualization_resolver::get_gce_vm(collection& facts)
+    {
+        auto vendor = facts.get<string_value>(fact::bios_vendor);
+        if (vendor && vendor->value().find("Google") != string::npos) {
+            return vm::gce;
+        }
+        return {};
+    }
+
+    string virtualization_resolver::get_what_vm()
+    {
+        string virt_what = agent::which("virt-what");
+        string value;
+        each_line(virt_what, [&](string& line) {
+            // Some versions of virt-what dump error/warning messages to stdout
+            if (boost::starts_with(line, "virt-what:")) {
+                return true;
+            }
+            // Take the first line that isn't an error/warning
+            // unless it's "xen", in which case we expect a second
+            // line with more useful information
+            if (line == "xen") {
+                return true;
+            }
+            value = move(line);
+            return false;
+        });
+
+        // Do some normalization of virt-what's output
+        if (!value.empty()) {
+            boost::to_lower(value);
+            if (value == "linux_vserver") {
+                return get_vserver_vm();
+            }
+            if (value == "xen-hvm") {
+                return vm::xen_hardware;
+            }
+            if (value == "xen-dom0") {
+                return vm::xen_privileged;
+            }
+            if (value == "xen-domu") {
+                return vm::xen_unprivileged;
+            }
+            if (value == "ibm_systemz") {
+                return vm::zlinux;
+            }
+        }
+        return value;
+    }
+
+    string virtualization_resolver::get_vserver_vm()
+    {
+        string value;
+        lth_file::each_line("/proc/self/status", [&](string& line) {
+            vector<boost::iterator_range<string::iterator>> parts;
+            boost::split(parts, line, boost::is_space(), boost::token_compress_on);
+            if (parts.size() != 2) {
+                return true;
+            }
+            if (parts[0] == boost::as_literal("s_context:") || parts[0] == boost::as_literal("VxID:")) {
+                if (parts[1] == boost::as_literal("0")) {
+                    value = vm::vserver_host;
+                } else {
+                    value = vm::vserver;
+                }
+                return false;
+            }
+            return true;
+        });
+        return value;
+    }
+
+    string virtualization_resolver::get_vmware_vm()
+    {
+        auto exec = execute("vmware", { "-v" });
+        if (!exec.success) {
+            return {};
+        }
+        vector<string> parts;
+        boost::split(parts, exec.output, boost::is_space(), boost::token_compress_on);
+        if (parts.size() < 2) {
+            return {};
+        }
+        boost::to_lower(parts[0]);
+        boost::to_lower(parts[1]);
+        return parts[0] + '_' + parts[1];
+    }
+
+    string virtualization_resolver::get_openvz_vm()
+    {
+        // Detect if it's a OpenVZ without being CloudLinux
+        bs::error_code ec;
+        if (!is_directory("/proc/vz", ec) ||
+            is_regular_file("/proc/lve/list", ec) ||
+            boost::filesystem::is_empty("/proc/vz", ec)) {
+            return {};
+        }
+        string value;
+        lth_file::each_line("/proc/self/status", [&](string& line) {
+            vector<boost::iterator_range<string::iterator>> parts;
+            boost::split(parts, line, boost::is_space(), boost::token_compress_on);
+            if (parts.size() != 2) {
+                return true;
+            }
+            if (parts[0] == boost::as_literal("envID:")) {
+                if (parts[1] == boost::as_literal("0")) {
+                    value = vm::openvz_hn;
+                } else {
+                    value = vm::openvz_ve;
+                }
+                return false;
+            }
+            return true;
+        });
+        return value;
+    }
+
+    string virtualization_resolver::get_xen_vm()
+    {
+        // Check for a required Xen file
+        bs::error_code ec;
+        if (exists("/dev/xen/evtchn", ec) && !ec) {
+            return vm::xen_privileged;
+        }
+        ec.clear();
+        if (exists("/proc/xen", ec) && !ec) {
+            return vm::xen_unprivileged;
+        }
+        ec.clear();
+        if (exists("/dev/xvda1", ec) && !ec) {
+            return vm::xen_unprivileged;
+        }
+        return {};
+    }
+
+    string virtualization_resolver::get_lspci_vm()
+    {
+        static vector<tuple<boost::regex, string>> vms = {
+            make_tuple(boost::regex("VM[wW]are"),                     string(vm::vmware)),
+            make_tuple(boost::regex("VirtualBox"),                    string(vm::virtualbox)),
+            make_tuple(boost::regex("1ab8:|[Pp]arallels"),            string(vm::parallels)),
+            make_tuple(boost::regex("XenSource"),                     string(vm::xen_hardware)),
+            make_tuple(boost::regex("Microsoft Corporation Hyper-V"), string(vm::hyperv)),
+            make_tuple(boost::regex("Class 8007: Google, Inc"),       string(vm::gce)),
+            make_tuple(boost::regex("virtio", boost::regex::icase),   string(vm::kvm)),
+        };
+
+        string value;
+        each_line("lspci", [&](string& line) {
+            for (auto const& vm : vms) {
+                if (re_search(line, get<0>(vm))) {
+                    value = get<1>(vm);
+                    return false;
+                }
+            }
+            return true;
+        });
+        return value;
+    }
+
+}}}  // namespace facter::facts::linux

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

@@ -0,0 +1,119 @@
+#include <facter/facts/map_value.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <facter/util/string.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <rapidjson/document.h>
+#include <yaml-cpp/yaml.h>
+
+using namespace std;
+using namespace facter::util;
+using namespace rapidjson;
+using namespace YAML;
+
+namespace facter { namespace facts {
+
+    map_value::map_value(map_value&& other)
+    {
+        *this = std::move(other);
+    }
+
+    map_value& map_value::operator=(map_value&& other)
+    {
+        value::operator=(static_cast<value&&>(other));
+        if (this != &other) {
+            _elements = std::move(other._elements);
+        }
+        return *this;
+    }
+
+    void map_value::add(string name, unique_ptr<value> value)
+    {
+        if (!value) {
+            LOG_DEBUG("null value cannot be added to map.");
+            return;
+        }
+
+        _elements.emplace(move(name), move(value));
+    }
+
+    bool map_value::empty() const
+    {
+        return _elements.empty();
+    }
+
+    size_t map_value::size() const
+    {
+        return _elements.size();
+    }
+
+    void map_value::each(function<bool(string const&, value const*)> func) const
+    {
+        for (auto const& kvp : _elements) {
+            if (!func(kvp.first, kvp.second.get())) {
+                break;
+            }
+        }
+    }
+
+    value const* map_value::operator[](string const& name) const
+    {
+        auto it = _elements.find(name);
+        if (it == _elements.end()) {
+            return nullptr;
+        }
+        return it->second.get();
+    }
+
+    void map_value::to_json(json_allocator& allocator, json_value& value) const
+    {
+        value.SetObject();
+
+        for (auto const& kvp : _elements) {
+            json_value child;
+            kvp.second->to_json(allocator, child);
+            value.AddMember(rapidjson::StringRef(kvp.first.c_str(), kvp.first.size()), std::move(child), allocator);
+        }
+    }
+
+    ostream& map_value::write(ostream& os, bool quoted, unsigned int level) const
+    {
+        if (_elements.empty()) {
+            os << "{}";
+            return os;
+        }
+
+        // Write out the elements in the map
+        os << "{\n";
+        bool first = true;
+        for (auto const& kvp : _elements) {
+            if (first) {
+                first = false;
+            } else {
+                os << ",\n";
+            }
+            fill_n(ostream_iterator<char>(os), level * 2, ' ');
+            os << kvp.first << " => ";
+            kvp.second->write(os, true /* always quote strings in a map */, level + 1);
+        }
+        os << "\n";
+        fill_n(ostream_iterator<char>(os), (level > 0 ? (level - 1) : 0) * 2, ' ');
+        os << "}";
+        return os;
+    }
+
+    Emitter& map_value::write(Emitter& emitter) const
+    {
+        emitter << BeginMap;
+        for (auto const& kvp : _elements) {
+            emitter << Key;
+            if (needs_quotation(kvp.first)) {
+                emitter << DoubleQuoted;
+            }
+            emitter << kvp.first << YAML::Value;
+            kvp.second->write(emitter);
+        }
+        emitter << EndMap;
+        return emitter;
+    }
+
+}}  // namespace facter::facts

data/ext/facter/facter/lib/src/facts/openbsd/collection.cc

@@ -0,0 +1,37 @@
+#include <facter/facts/collection.hpp>
+#include <internal/facts/bsd/filesystem_resolver.hpp>
+#include <internal/facts/bsd/uptime_resolver.hpp>
+#include <internal/facts/glib/load_average_resolver.hpp>
+#include <internal/facts/openbsd/dmi_resolver.hpp>
+#include <internal/facts/openbsd/memory_resolver.hpp>
+#include <internal/facts/openbsd/networking_resolver.hpp>
+#include <internal/facts/openbsd/virtualization_resolver.hpp>
+#include <internal/facts/openbsd/processor_resolver.hpp>
+#include <internal/facts/posix/identity_resolver.hpp>
+#include <internal/facts/posix/kernel_resolver.hpp>
+#include <internal/facts/posix/ssh_resolver.hpp>
+#include <internal/facts/posix/timezone_resolver.hpp>
+#include <internal/facts/posix/operating_system_resolver.hpp>
+
+using namespace std;
+
+namespace facter { namespace facts {
+
+    void collection::add_platform_facts()
+    {
+        add(make_shared<posix::kernel_resolver>());
+        add(make_shared<posix::operating_system_resolver>());
+        add(make_shared<bsd::uptime_resolver>());
+        add(make_shared<bsd::filesystem_resolver>());
+        add(make_shared<posix::ssh_resolver>());
+        add(make_shared<posix::identity_resolver>());
+        add(make_shared<posix::timezone_resolver>());
+        add(make_shared<glib::load_average_resolver>());
+        add(make_shared<openbsd::networking_resolver>());
+        add(make_shared<openbsd::dmi_resolver>());
+        add(make_shared<openbsd::memory_resolver>());
+        add(make_shared<openbsd::virtualization_resolver>());
+        add(make_shared<openbsd::processor_resolver>());
+    }
+
+}}  // namespace facter::facts