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/ldom_resolver.cc DELETED

@@ -1,60 +0,0 @@
-#include <internal/facts/resolvers/ldom_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 {
-    ldom_resolver::ldom_resolver() :
-        resolver(
-            "ldom",
-            {
-                fact::ldom,
-            },
-            {
-                string("^ldom_"),
-            })
-    {
-    }
-    void ldom_resolver::resolve(collection& facts)
-    {
-        auto data = collect_data(facts);
-        if (!data.ldom.empty()) {
-            auto ldom = make_value<map_value>();
-            for (auto& sub_key : data.ldom) {
-                if (sub_key.values.size() == 0) {
-                    continue;
-                } else if (sub_key.values.size() == 1) {
-                    string key = sub_key.values.begin()->first;
-                    string value = sub_key.values.begin()->second;
-                    ldom->add(key, make_value<string_value>(value));
-                    facts.add("ldom_" + key, make_value<string_value>(move(value), true));
-                } else {
-                    // If we have multiple sub key values, insert a map into the structured fact to contain them.
-                    auto sub_value = make_value<map_value>();
-                    for (auto& kv : sub_key.values) {
-                        sub_value->add(kv.first, make_value<string_value>(kv.second));
-                        facts.add("ldom_" + sub_key.key + "_" + move(kv.first), make_value<string_value>(move(kv.second), true));
-                    }
-                    ldom->add(sub_key.key, move(sub_value));
-                }
-            }
-            facts.add(fact::ldom, move(ldom));
-        }
-    }
-}}}  // namespace facter::facts

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

@@ -1,36 +0,0 @@
-#include <internal/facts/resolvers/load_average_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;
-namespace facter { namespace facts { namespace resolvers {
-    load_average_resolver::load_average_resolver() :
-        resolver(
-            "load_average",
-            {
-                fact::load_averages,
-            }
-        )
-    {
-    }
-    void load_average_resolver::resolve(collection& facts)
-    {
-        /* Get the load averages */
-        auto averages = get_load_averages();
-        if (!averages) {
-            return;
-        }
-        auto value = make_value<map_value>();
-        value->add("1m",  make_value<double_value>(get<0>(*averages)));
-        value->add("5m",  make_value<double_value>(get<1>(*averages)));
-        value->add("15m", make_value<double_value>(get<2>(*averages)));
-        facts.add(fact::load_averages, move(value));
-    }
-}}}  // namespace facter::facts::resolvers

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

@@ -1,88 +0,0 @@
-#include <internal/facts/resolvers/memory_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 <facter/util/string.hpp>
-using namespace std;
-using namespace facter::util;
-namespace facter { namespace facts { namespace resolvers {
-    memory_resolver::memory_resolver() :
-        resolver(
-            "memory",
-            {
-                fact::memory,
-                fact::memoryfree,
-                fact::memoryfree_mb,
-                fact::memorysize,
-                fact::memorysize_mb,
-                fact::swapfree,
-                fact::swapfree_mb,
-                fact::swapsize,
-                fact::swapsize_mb,
-                fact::swapencrypted
-            })
-    {
-    }
-    void memory_resolver::resolve(collection& facts)
-    {
-        data result = collect_data(facts);
-        auto value = make_value<map_value>();
-        if (result.mem_total > 0) {
-            uint64_t mem_used = result.mem_total - result.mem_free;
-            auto stats = make_value<map_value>();
-            stats->add("total", make_value<string_value>(si_string(result.mem_total)));
-            stats->add("total_bytes", make_value<integer_value>(result.mem_total));
-            stats->add("used", make_value<string_value>(si_string(mem_used)));
-            stats->add("used_bytes", make_value<integer_value>(mem_used));
-            stats->add("available", make_value<string_value>(si_string(result.mem_free)));
-            stats->add("available_bytes", make_value<integer_value>(result.mem_free));
-            stats->add("capacity", make_value<string_value>(percentage(mem_used, result.mem_total)));
-            value->add("system", move(stats));
-            // Add hidden facts
-            facts.add(fact::memoryfree, make_value<string_value>(si_string(result.mem_free), true));
-            facts.add(fact::memoryfree_mb, make_value<double_value>(result.mem_free / (1024.0 * 1024.0), true));
-            facts.add(fact::memorysize, make_value<string_value>(si_string(result.mem_total), true));
-            facts.add(fact::memorysize_mb, make_value<double_value>(result.mem_total / (1024.0 * 1024.0), true));
-        }
-        if (result.swap_total > 0) {
-            uint64_t swap_used = result.swap_total - result.swap_free;
-            auto stats = make_value<map_value>();
-            stats->add("total", make_value<string_value>(si_string(result.swap_total)));
-            stats->add("total_bytes", make_value<integer_value>(result.swap_total));
-            stats->add("used", make_value<string_value>(si_string(swap_used)));
-            stats->add("used_bytes", make_value<integer_value>(swap_used));
-            stats->add("available", make_value<string_value>(si_string(result.swap_free)));
-            stats->add("available_bytes", make_value<integer_value>(result.swap_free));
-            stats->add("capacity", make_value<string_value>(percentage(swap_used, result.swap_total)));
-            if (result.swap_encryption != encryption_status::unknown) {
-                stats->add("encrypted", make_value<boolean_value>(result.swap_encryption == encryption_status::encrypted));
-            }
-            value->add("swap", move(stats));
-            // Add hidden facts
-            facts.add(fact::swapfree, make_value<string_value>(si_string(result.swap_free), true));
-            facts.add(fact::swapfree_mb, make_value<double_value>(result.swap_free / (1024.0 * 1024.0), true));
-            facts.add(fact::swapsize, make_value<string_value>(si_string(result.swap_total), true));
-            facts.add(fact::swapsize_mb, make_value<double_value>(result.swap_total / (1024.0 * 1024.0), true));
-            if (result.swap_encryption != encryption_status::unknown) {
-                facts.add(fact::swapencrypted, make_value<boolean_value>(result.swap_encryption == encryption_status::encrypted, true));
-            }
-        }
-        if (!value->empty()) {
-            facts.add(fact::memory, move(value));
-        }
-    }
-}}}  // namespace facter::facts::resolvers

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

@@ -1,296 +0,0 @@
-#include <internal/facts/resolvers/networking_resolver.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/map_value.hpp>
-#include <facter/facts/array_value.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <boost/format.hpp>
-#include <boost/algorithm/string.hpp>
-#include <sstream>
-using namespace std;
-namespace facter { namespace facts { namespace resolvers {
-    networking_resolver::networking_resolver() :
-        resolver(
-            "networking",
-            {
-                fact::networking,
-                fact::hostname,
-                fact::ipaddress,
-                fact::ipaddress6,
-                fact::netmask,
-                fact::netmask6,
-                fact::network,
-                fact::network6,
-                fact::macaddress,
-                fact::interfaces,
-                fact::domain,
-                fact::fqdn,
-                fact::dhcp_servers,
-            },
-            {
-                string("^") + fact::ipaddress + "_",
-                string("^") + fact::ipaddress6 + "_",
-                string("^") + fact::mtu + "_",
-                string("^") + fact::netmask + "_",
-                string("^") + fact::netmask6 + "_",
-                string("^") + fact::network + "_",
-                string("^") + fact::network6 + "_",
-                string("^") + fact::macaddress + "_",
-            })
-    {
-    }
-    void networking_resolver::resolve(collection& facts)
-    {
-        auto data = collect_data(facts);
-        // Some queries, such as /etc/resolv.conf, can return domains with a trailing dot (.).
-        // We want to strip the trailing dot, as it is not useful as a valid domain or fqdn.
-        boost::trim_right_if(data.domain, boost::is_any_of("."));
-        // If no FQDN, set it to the hostname + domain
-        if (!data.hostname.empty() && data.fqdn.empty()) {
-            data.fqdn = data.hostname + (data.domain.empty() ? "" : ".") + data.domain;
-        }
-        // If no primary interface was found, default to the first interface with a valid address
-        if (data.primary_interface.empty()) {
-            LOG_DEBUG("no primary interface found: using the first interface with an assigned address as the primary interface.");
-            auto primary = find_primary_interface(data.interfaces);
-            if (primary) {
-                data.primary_interface = primary->name;
-            }
-        }
-        auto networking = make_value<map_value>();
-        // Add the interface data
-        ostringstream interface_names;
-        auto dhcp_servers = make_value<map_value>(true);
-        auto interfaces = make_value<map_value>();
-        for (auto& interface : data.interfaces) {
-            bool primary = interface.name == data.primary_interface;
-            auto value = make_value<map_value>();
-            // Add the ipv4 bindings
-            add_bindings(interface, primary, true, facts, *networking, *value);
-            // Add the ipv6 bindings
-            add_bindings(interface, primary, false, facts, *networking, *value);
-            // Add the MAC address
-            if (!interface.macaddress.empty()) {
-                facts.add(string(fact::macaddress) + "_" + interface.name, make_value<string_value>(interface.macaddress, true));
-                if (primary) {
-                    facts.add(fact::macaddress, make_value<string_value>(interface.macaddress, true));
-                    networking->add("mac", make_value<string_value>(interface.macaddress));
-                }
-                value->add("mac", make_value<string_value>(move(interface.macaddress)));
-            }
-            // Add the DHCP server
-            if (!interface.dhcp_server.empty()) {
-                if (primary) {
-                    dhcp_servers->add("system", make_value<string_value>(interface.dhcp_server));
-                    networking->add("dhcp", make_value<string_value>(interface.dhcp_server));
-                }
-                dhcp_servers->add(string(interface.name), make_value<string_value>(interface.dhcp_server));
-                value->add("dhcp", make_value<string_value>(move(interface.dhcp_server)));
-            }
-            // Add the interface MTU
-            if (interface.mtu) {
-                facts.add(string(fact::mtu) + "_" + interface.name, make_value<integer_value>(*interface.mtu, true));
-                if (primary) {
-                    networking->add("mtu", make_value<integer_value>(*interface.mtu));
-                }
-                value->add("mtu", make_value<integer_value>(*interface.mtu));
-            }
-            // Add the interface to the list of names
-            if (interface_names.tellp() != 0) {
-                interface_names << ",";
-            }
-            interface_names << interface.name;
-            interfaces->add(move(interface.name), move(value));
-        }
-        // Add top-level network data
-        if (!data.hostname.empty()) {
-            facts.add(fact::hostname, make_value<string_value>(data.hostname, true));
-            networking->add("hostname", make_value<string_value>(move(data.hostname)));
-        }
-        if (!data.domain.empty()) {
-            facts.add(fact::domain, make_value<string_value>(data.domain, true));
-            networking->add("domain", make_value<string_value>(move(data.domain)));
-        }
-        if (!data.fqdn.empty()) {
-            facts.add(fact::fqdn, make_value<string_value>(data.fqdn, true));
-            networking->add("fqdn", make_value<string_value>(move(data.fqdn)));
-        }
-        if (!data.primary_interface.empty()) {
-            networking->add("primary", make_value<string_value>(move(data.primary_interface)));
-        }
-        if (interface_names.tellp() != 0) {
-            facts.add(fact::interfaces, make_value<string_value>(interface_names.str(), true));
-        }
-        if (!dhcp_servers->empty()) {
-            facts.add(fact::dhcp_servers, move(dhcp_servers));
-        }
-        if (!interfaces->empty()) {
-            networking->add("interfaces", move(interfaces));
-        }
-        if (!networking->empty()) {
-            facts.add(fact::networking, move(networking));
-        }
-    }
-    string networking_resolver::macaddress_to_string(uint8_t const* bytes, uint8_t byte_count)
-    {
-        if (!bytes || (byte_count != 6 && byte_count != 20)) {
-            return {};
-        }
-        // Ignore MAC address "0"
-        bool nonzero = false;
-        for (size_t i = 0; i < byte_count; ++i) {
-            if (bytes[i] != 0) {
-                nonzero = true;
-                break;
-            }
-        }
-        if (!nonzero) {
-            return {};
-        }
-        if (byte_count == 6) {
-            return (boost::format("%02x:%02x:%02x:%02x:%02x:%02x") %
-                    static_cast<int>(bytes[0]) % static_cast<int>(bytes[1]) %
-                    static_cast<int>(bytes[2]) % static_cast<int>(bytes[3]) %
-                    static_cast<int>(bytes[4]) % static_cast<int>(bytes[5])).str();
-        } else if (byte_count == 20) {
-            return (boost::format("%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x") %
-                    static_cast<int>(bytes[0]) % static_cast<int>(bytes[1]) %
-                    static_cast<int>(bytes[2]) % static_cast<int>(bytes[3]) %
-                    static_cast<int>(bytes[4]) % static_cast<int>(bytes[5]) %
-                    static_cast<int>(bytes[6]) % static_cast<int>(bytes[7]) %
-                    static_cast<int>(bytes[8]) % static_cast<int>(bytes[9]) %
-                    static_cast<int>(bytes[10]) % static_cast<int>(bytes[11]) %
-                    static_cast<int>(bytes[12]) % static_cast<int>(bytes[13]) %
-                    static_cast<int>(bytes[14]) % static_cast<int>(bytes[15]) %
-                    static_cast<int>(bytes[16]) % static_cast<int>(bytes[17]) %
-                    static_cast<int>(bytes[18]) % static_cast<int>(bytes[19])).str();
-        } else {
-            return {};
-        }
-    }
-    bool networking_resolver::ignored_ipv4_address(string const& addr)
-    {
-        // Excluding localhost and 169.254.x.x in Windows - this is the DHCP APIPA, meaning that if the node cannot
-        // get an ip address from the dhcp server, it auto-assigns a private ip address
-        return addr.empty() ||  boost::starts_with(addr, "127.") || boost::starts_with(addr, "169.254.");
-    }
-    bool networking_resolver::ignored_ipv6_address(string const& addr)
-    {
-        return addr.empty() || addr == "::1" || boost::starts_with(addr, "fe80");
-    }
-    networking_resolver::binding const* networking_resolver::find_default_binding(vector<binding> const& bindings, function<bool(string const&)> const& ignored)
-    {
-        for (auto& binding : bindings) {
-            if (!ignored(binding.address)) {
-                return &binding;
-            }
-        }
-        return bindings.empty() ? nullptr : &bindings.front();
-    }
-    void networking_resolver::add_bindings(interface& iface, bool primary, bool ipv4, collection& facts, map_value& networking, map_value& iface_value)
-    {
-        auto ip_fact = ipv4 ? fact::ipaddress : fact::ipaddress6;
-        auto ip_name = ipv4 ? "ip" : "ip6";
-        auto netmask_fact = ipv4 ? fact::netmask : fact::netmask6;
-        auto netmask_name = ipv4 ? "netmask" : "netmask6";
-        auto network_fact = ipv4 ? fact::network : fact::network6;
-        auto network_name = ipv4 ? "network" : "network6";
-        auto& bindings = ipv4 ? iface.ipv4_bindings : iface.ipv6_bindings;
-        auto bindings_name = ipv4 ? "bindings" : "bindings6";
-        auto ignored = ipv4 ? &ignored_ipv4_address : &ignored_ipv6_address;
-        // Add the default binding to the collection and interface
-        auto binding = find_default_binding(bindings, ignored);
-        if (binding) {
-            if (!binding->address.empty()) {
-                facts.add(string(ip_fact) + "_" + iface.name, make_value<string_value>(binding->address, true));
-                if (primary) {
-                    facts.add(ip_fact, make_value<string_value>(binding->address, true));
-                    networking.add(ip_name, make_value<string_value>(binding->address));
-                }
-                iface_value.add(ip_name, make_value<string_value>(binding->address));
-            }
-            if (!binding->netmask.empty()) {
-                facts.add(string(netmask_fact) + "_" + iface.name, make_value<string_value>(binding->netmask, true));
-                if (primary) {
-                    facts.add(netmask_fact, make_value<string_value>(binding->netmask, true));
-                    networking.add(netmask_name, make_value<string_value>(binding->netmask));
-                }
-                iface_value.add(netmask_name, make_value<string_value>(binding->netmask));
-            }
-            if (!binding->network.empty()) {
-                facts.add(string(network_fact) + "_" + iface.name, make_value<string_value>(binding->network, true));
-                if (primary) {
-                    facts.add(network_fact, make_value<string_value>(binding->network, true));
-                    networking.add(network_name, make_value<string_value>(binding->network));
-                }
-                iface_value.add(network_name, make_value<string_value>(binding->network));
-            }
-        }
-        // Set the bindings in the interface
-        if (!bindings.empty()) {
-            auto bindings_value = make_value<array_value>();
-            for (auto& binding : bindings) {
-                auto binding_value = make_value<map_value>();
-                if (!binding.address.empty()) {
-                    binding_value->add("address", make_value<string_value>(move(binding.address)));
-                }
-                if (!binding.netmask.empty()) {
-                    binding_value->add("netmask", make_value<string_value>(move(binding.netmask)));
-                }
-                if (!binding.network.empty()) {
-                    binding_value->add("network", make_value<string_value>(move(binding.network)));
-                }
-                if (!binding_value->empty()) {
-                    bindings_value->add(move(binding_value));
-                }
-            }
-            iface_value.add(bindings_name, move(bindings_value));
-        }
-    }
-    networking_resolver::interface const* networking_resolver::find_primary_interface(vector<interface> const& interfaces)
-    {
-        for (auto const& interface : interfaces) {
-            for (auto const& binding : interface.ipv4_bindings) {
-                if (!ignored_ipv4_address(binding.address)) {
-                    return &interface;
-                }
-            }
-            for (auto const& binding : interface.ipv6_bindings) {
-                if (!ignored_ipv6_address(binding.address)) {
-                    return &interface;
-                }
-            }
-        }
-        return nullptr;
-    }
-}}}  // namespace facter::facts::posix