RubyGems - facter - Versions diffs - 3.12.2.cfacter.20181217 → 4.0.7.pre - Mend

facter 3.12.2.cfacter.20181217 → 4.0.7.pre

Files changed (1564) hide show

data/ext/facter/facter/lib/src/facts/resolvers/ssh_resolver.cc DELETED

@@ -1,77 +0,0 @@
-#include <internal/facts/resolvers/ssh_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/scalar_value.hpp>
-using namespace std;
-namespace facter { namespace facts { namespace resolvers {
-    ssh_resolver::ssh_resolver() :
-        resolver(
-            "ssh",
-            {
-                fact::ssh,
-                fact::ssh_dsa_key,
-                fact::ssh_rsa_key,
-                fact::ssh_ecdsa_key,
-                fact::ssh_ed25519_key,
-                fact::sshfp_dsa,
-                fact::sshfp_rsa,
-                fact::sshfp_ecdsa,
-                fact::sshfp_ed25519,
-            })
-    {
-    }
-    void ssh_resolver::resolve(collection& facts)
-    {
-        auto data = collect_data(facts);
-        auto ssh = make_value<map_value>();
-        add_key(facts, *ssh, data.dsa, "dsa", fact::ssh_dsa_key, fact::sshfp_dsa);
-        add_key(facts, *ssh, data.rsa, "rsa", fact::ssh_rsa_key, fact::sshfp_rsa);
-        add_key(facts, *ssh, data.ecdsa, "ecdsa", fact::ssh_ecdsa_key, fact::sshfp_ecdsa);
-        add_key(facts, *ssh, data.ed25519, "ed25519", fact::ssh_ed25519_key, fact::sshfp_ed25519);
-        if (!ssh->empty()) {
-            facts.add(fact::ssh, move(ssh));
-        }
-    }
-    void ssh_resolver::add_key(collection& facts, map_value& value, ssh_key& key, string const& name, string const& key_fact_name, string const& fingerprint_fact_name)
-    {
-        if (key.key.empty()) {
-            return;
-        }
-        auto key_value = make_value<map_value>();
-        auto fingerprint_value = make_value<map_value>();
-        facts.add(string(key_fact_name), make_value<string_value>(key.key, true));
-        key_value->add("key", make_value<string_value>(move(key.key)));
-        key_value->add("type", make_value<string_value>(move(key.type)));
-        string fingerprint;
-        if (!key.digest.sha1.empty()) {
-            fingerprint = key.digest.sha1;
-            fingerprint_value->add("sha1", make_value<string_value>(move(key.digest.sha1)));
-        }
-        if (!key.digest.sha256.empty()) {
-            if (!fingerprint.empty()) {
-                fingerprint += "\n";
-            }
-            fingerprint += key.digest.sha256;
-            fingerprint_value->add("sha256", make_value<string_value>(move(key.digest.sha256)));
-        }
-        if (!fingerprint.empty()) {
-            facts.add(string(fingerprint_fact_name), make_value<string_value>(move(fingerprint), true));
-        }
-        if (!fingerprint_value->empty()) {
-            key_value->add("fingerprints", move(fingerprint_value));
-        }
-        value.add(string(name), move(key_value));
-    }
-}}}  // namespace facter::facts::resolvers

data/ext/facter/facter/lib/src/facts/resolvers/system_profiler_resolver.cc DELETED

@@ -1,137 +0,0 @@
-#include <internal/facts/resolvers/system_profiler_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <facter/facts/map_value.hpp>
-using namespace std;
-using namespace facter::facts;
-namespace facter { namespace facts { namespace resolvers {
-    system_profiler_resolver::system_profiler_resolver() :
-        resolver(
-            "system profiler",
-            {
-                fact::system_profiler,
-                fact::sp_boot_mode,
-                fact::sp_boot_rom_version,
-                fact::sp_boot_volume,
-                fact::sp_cpu_type,
-                fact::sp_current_processor_speed,
-                fact::sp_kernel_version,
-                fact::sp_l2_cache_core,
-                fact::sp_l3_cache,
-                fact::sp_local_host_name,
-                fact::sp_machine_model,
-                fact::sp_machine_name,
-                fact::sp_number_processors,
-                fact::sp_os_version,
-                fact::sp_packages,
-                fact::sp_physical_memory,
-                fact::sp_platform_uuid,
-                fact::sp_secure_vm,
-                fact::sp_serial_number,
-                fact::sp_smc_version_system,
-                fact::sp_uptime,
-                fact::sp_user_name,
-            })
-    {
-    }
-    void system_profiler_resolver::resolve(collection& facts)
-    {
-        auto data = collect_data(facts);
-        auto system_profiler = make_value<map_value>();
-        if (!data.boot_mode.empty()) {
-            facts.add(fact::sp_boot_mode, make_value<string_value>(data.boot_mode, true));
-            system_profiler->add("boot_mode", make_value<string_value>(move(data.boot_mode)));
-        }
-        if (!data.boot_rom_version.empty()) {
-            facts.add(fact::sp_boot_rom_version, make_value<string_value>(data.boot_rom_version, true));
-            system_profiler->add("boot_rom_version", make_value<string_value>(move(data.boot_rom_version)));
-        }
-        if (!data.boot_volume.empty()) {
-            facts.add(fact::sp_boot_volume, make_value<string_value>(data.boot_volume, true));
-            system_profiler->add("boot_volume", make_value<string_value>(move(data.boot_volume)));
-        }
-        if (!data.processor_name.empty()) {
-            facts.add(fact::sp_cpu_type, make_value<string_value>(data.processor_name, true));
-            system_profiler->add("processor_name", make_value<string_value>(move(data.processor_name)));
-        }
-        if (!data.processor_speed.empty()) {
-            facts.add(fact::sp_current_processor_speed, make_value<string_value>(data.processor_speed, true));
-            system_profiler->add("processor_speed", make_value<string_value>(move(data.processor_speed)));
-        }
-        if (!data.kernel_version.empty()) {
-            facts.add(fact::sp_kernel_version, make_value<string_value>(data.kernel_version, true));
-            system_profiler->add("kernel_version", make_value<string_value>(move(data.kernel_version)));
-        }
-        if (!data.l2_cache_per_core.empty()) {
-            facts.add(fact::sp_l2_cache_core, make_value<string_value>(data.l2_cache_per_core, true));
-            system_profiler->add("l2_cache_per_core", make_value<string_value>(move(data.l2_cache_per_core)));
-        }
-        if (!data.l3_cache.empty()) {
-            facts.add(fact::sp_l3_cache, make_value<string_value>(data.l3_cache, true));
-            system_profiler->add("l3_cache", make_value<string_value>(move(data.l3_cache)));
-        }
-        if (!data.computer_name.empty()) {
-            facts.add(fact::sp_local_host_name, make_value<string_value>(data.computer_name, true));
-            system_profiler->add("computer_name", make_value<string_value>(move(data.computer_name)));
-        }
-        if (!data.model_identifier.empty()) {
-            facts.add(fact::sp_machine_model, make_value<string_value>(data.model_identifier, true));
-            system_profiler->add("model_identifier", make_value<string_value>(move(data.model_identifier)));
-        }
-        if (!data.model_name.empty()) {
-            facts.add(fact::sp_machine_name, make_value<string_value>(data.model_name, true));
-            system_profiler->add("model_name", make_value<string_value>(move(data.model_name)));
-        }
-        if (!data.cores.empty()) {
-            facts.add(fact::sp_number_processors, make_value<string_value>(data.cores, true));
-            system_profiler->add("cores", make_value<string_value>(move(data.cores)));
-        }
-        if (!data.system_version.empty()) {
-            facts.add(fact::sp_os_version, make_value<string_value>(data.system_version, true));
-            system_profiler->add("system_version", make_value<string_value>(move(data.system_version)));
-        }
-        if (!data.processors.empty()) {
-            facts.add(fact::sp_packages, make_value<string_value>(data.processors, true));
-            system_profiler->add("processors", make_value<string_value>(move(data.processors)));
-        }
-        if (!data.memory.empty()) {
-            facts.add(fact::sp_physical_memory, make_value<string_value>(data.memory, true));
-            system_profiler->add("memory", make_value<string_value>(move(data.memory)));
-        }
-        if (!data.hardware_uuid.empty()) {
-            facts.add(fact::sp_platform_uuid, make_value<string_value>(data.hardware_uuid, true));
-            system_profiler->add("hardware_uuid", make_value<string_value>(move(data.hardware_uuid)));
-        }
-        if (!data.secure_virtual_memory.empty()) {
-            facts.add(fact::sp_secure_vm, make_value<string_value>(data.secure_virtual_memory, true));
-            system_profiler->add("secure_virtual_memory", make_value<string_value>(move(data.secure_virtual_memory)));
-        }
-        if (!data.serial_number.empty()) {
-            facts.add(fact::sp_serial_number, make_value<string_value>(data.serial_number, true));
-            system_profiler->add("serial_number", make_value<string_value>(move(data.serial_number)));
-        }
-        if (!data.smc_version.empty()) {
-            facts.add(fact::sp_smc_version_system, make_value<string_value>(data.smc_version, true));
-            system_profiler->add("smc_version", make_value<string_value>(move(data.smc_version)));
-        }
-        if (!data.uptime.empty()) {
-            facts.add(fact::sp_uptime, make_value<string_value>(data.uptime, true));
-            system_profiler->add("uptime", make_value<string_value>(move(data.uptime)));
-        }
-        if (!data.username.empty()) {
-            facts.add(fact::sp_user_name, make_value<string_value>(data.username, true));
-            system_profiler->add("username", make_value<string_value>(move(data.username)));
-        }
-        if (!system_profiler->empty()) {
-            facts.add(fact::system_profiler, move(system_profiler));
-        }
-    }
-}}}  // namespace facter::facts::resolvers

data/ext/facter/facter/lib/src/facts/resolvers/timezone_resolver.cc DELETED

@@ -1,27 +0,0 @@
-#include <internal/facts/resolvers/timezone_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/scalar_value.hpp>
-namespace facter { namespace facts { namespace resolvers {
-    timezone_resolver::timezone_resolver() :
-        resolver(
-            "timezone",
-            {
-                fact::timezone,
-            })
-    {
-    }
-    void timezone_resolver::resolve(collection& facts)
-    {
-        auto timezone = get_timezone();
-        if (timezone.empty()) {
-            return;
-        }
-        facts.add(fact::timezone, make_value<string_value>(move(timezone)));
-    }
-}}}  // facter::facts::resolvers

data/ext/facter/facter/lib/src/facts/resolvers/uptime_resolver.cc DELETED

@@ -1,63 +0,0 @@
-#include <internal/facts/resolvers/uptime_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <facter/facts/map_value.hpp>
-#include <boost/format.hpp>
-using namespace std;
-namespace facter { namespace facts { namespace resolvers {
-    uptime_resolver::uptime_resolver() :
-        resolver(
-            "uptime",
-            {
-                fact::system_uptime,
-                fact::uptime,
-                fact::uptime_days,
-                fact::uptime_hours,
-                fact::uptime_seconds
-            })
-    {
-    }
-    void uptime_resolver::resolve(collection& facts)
-    {
-        auto seconds = get_uptime();
-        if (seconds < 0) {
-            return;
-        }
-        auto minutes = (seconds / 60) % 60;
-        auto hours = seconds / (60 * 60);
-        auto days = seconds / (60 * 60 * 24);
-        string uptime;
-        switch (days) {
-            case 0:
-                uptime = (boost::format("%d:%02d hours") % hours % minutes).str();
-                break;
-            case 1:
-                uptime = "1 day";
-                break;
-            default:
-                uptime = (boost::format("%d days") % days).str();
-                break;
-        }
-        // Add hidden facts
-        facts.add(fact::uptime_seconds, make_value<integer_value>(seconds, true));
-        facts.add(fact::uptime_hours, make_value<integer_value>(hours, true));
-        facts.add(fact::uptime_days, make_value<integer_value>(days, true));
-        facts.add(fact::uptime, make_value<string_value>(uptime, true));
-        auto value = make_value<map_value>();
-        value->add("seconds", make_value<integer_value>(seconds));
-        value->add("hours", make_value<integer_value>(hours));
-        value->add("days", make_value<integer_value>(days));
-        value->add("uptime", make_value<string_value>(move(uptime)));
-        facts.add(fact::system_uptime, move(value));
-    }
-}}}  // namespace facter::facts::resolvers

data/ext/facter/facter/lib/src/facts/resolvers/virtualization_resolver.cc DELETED

@@ -1,119 +0,0 @@
-#include <internal/facts/resolvers/virtualization_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/map_value.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <facter/facts/vm.hpp>
-#include <set>
-using namespace std;
-using namespace facter::facts;
-namespace facter { namespace facts { namespace resolvers {
-    virtualization_resolver::virtualization_resolver() :
-        resolver(
-            "virtualization",
-            {
-                fact::virtualization,
-                fact::is_virtual,
-                fact::cloud
-            })
-    {
-    }
-    void virtualization_resolver::resolve(collection& facts)
-    {
-        auto data = collect_data(facts);
-        facts.add(fact::is_virtual, make_value<boolean_value>(data.is_virtual));
-        facts.add(fact::virtualization, make_value<string_value>(data.hypervisor));
-        if (!data.cloud.provider.empty()) {
-            auto cloud = make_value<map_value>();
-            cloud->add("provider", make_value<string_value>(data.cloud.provider));
-            facts.add(fact::cloud, move(cloud));
-        }
-    }
-    data virtualization_resolver::collect_data(collection& facts)
-    {
-        data data;
-        auto hypervisor = get_hypervisor(facts);
-        if (hypervisor.empty()) {
-            hypervisor = "physical";
-        }
-        auto cloud_provider = get_cloud_provider(facts);
-        data.is_virtual = is_virtual(hypervisor);
-        data.hypervisor = hypervisor;
-        data.cloud.provider = cloud_provider;
-        return data;
-    }
-    string virtualization_resolver::get_cloud_provider(collection& facts)
-    {
-        // Default implementation for other resolvers.
-        return "";
-    }
-    bool virtualization_resolver::is_virtual(string const& hypervisor)
-    {
-        // Set of hypervisor values we consider to not be virtual
-        static set<string> hypervisors = {
-            "physical",
-            string(vm::xen_privileged),
-            string(vm::vmware_server),
-            string(vm::vmware_workstation),
-            string(vm::openvz_hn),
-            string(vm::vserver_host),
-        };
-        return hypervisors.count(hypervisor) == 0;
-    }
-    string virtualization_resolver::get_fact_vm(collection& facts)
-    {
-        // First, attempt to match on the SMBIOS reported product name
-        static vector<tuple<string, string>> product_names = {
-            make_tuple("VMware",            string(vm::vmware)),
-            make_tuple("VirtualBox",        string(vm::virtualbox)),
-            make_tuple("Parallels",         string(vm::parallels)),
-            make_tuple("KVM",               string(vm::kvm)),
-            make_tuple("Virtual Machine",   string(vm::hyperv)),
-            make_tuple("RHEV Hypervisor",   string(vm::redhat_ev)),
-            make_tuple("oVirt Node",        string(vm::ovirt)),
-            make_tuple("HVM domU",          string(vm::xen_hardware)),
-            make_tuple("Bochs",             string(vm::bochs)),
-            make_tuple("OpenBSD",           string(vm::vmm)),
-            make_tuple("BHYVE",             string(vm::bhyve)),
-        };
-        auto product_name = facts.get<string_value>(fact::product_name);
-        if (product_name) {
-            for (auto const& vm : product_names) {
-                if (product_name->value().find(get<0>(vm)) != string::npos) {
-                    return get<1>(vm);
-                }
-            }
-        }
-        // Next, try the reported BIOS vendor
-        static vector<tuple<string, string>> vendor_names = {
-            make_tuple("Amazon EC2",        string(vm::kvm)),
-        };
-        auto vendor_name = facts.get<string_value>(fact::bios_vendor);
-        if (vendor_name) {
-            for (auto const& vm : vendor_names) {
-                if (vendor_name->value().find(get<0>(vm)) != string::npos) {
-                    return get<1>(vm);
-                }
-            }
-        }
-        return {};
-    }
-}}}  // namespace facter::facts::resolvers

data/ext/facter/facter/lib/src/facts/resolvers/xen_resolver.cc DELETED

@@ -1,80 +0,0 @@
-#include <internal/facts/resolvers/xen_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/vm.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <facter/facts/array_value.hpp>
-#include <facter/facts/map_value.hpp>
-#include <leatherman/execution/execution.hpp>
-#include <leatherman/util/regex.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <boost/algorithm/string.hpp>
-using namespace std;
-using namespace facter::facts;
-using namespace leatherman::execution;
-using namespace leatherman::util;
-namespace facter { namespace facts { namespace resolvers {
-    xen_resolver::xen_resolver() :
-        resolver(
-            "Xen",
-            {
-                fact::xen,
-                fact::xendomains
-            })
-    {
-    }
-    void xen_resolver::resolve(collection& facts)
-    {
-        // Confine to fact virtual == xen0
-        auto virt = facts.get<string_value>(fact::virtualization);
-        if (!virt || virt->value() != vm::xen_privileged) {
-            return;
-        }
-        auto data = collect_data(facts);
-        if (!data.domains.empty()) {
-            auto xendomains = boost::algorithm::join(data.domains, ",");
-            facts.add(fact::xendomains, make_value<string_value>(move(xendomains), true));
-        }
-        auto domains = make_value<array_value>();
-        for (auto& domain : data.domains) {
-            domains->add(make_value<string_value>(move(domain)));
-        }
-        auto xen = make_value<map_value>();
-        if (!domains->empty()) {
-            xen->add("domains", move(domains));
-        }
-        if (!xen->empty()) {
-            facts.add(fact::xen, move(xen));
-        }
-    }
-    xen_resolver::data xen_resolver::collect_data(collection& facts)
-    {
-        data result;
-        auto command = xen_command();
-        if (!command.empty()) {
-            static boost::regex domain_header("^(Name|Domain-0)");
-            static boost::regex domain_entry("^([^\\s]*)\\s");
-            each_line(command, {"list"}, [&](string& line) {
-                string domain;
-                if (!boost::regex_match(line, domain_header) && re_search(line, domain_entry, &domain)) {
-                    result.domains.emplace_back(move(domain));
-                }
-                return true;
-            });
-        }
-        return result;
-    }
-}}}  // namespace facter::facts::resolvers