facter 3.12.2.cfacter.20181217 → 4.0.7.pre

data/ext/facter/facter/lib/src/facts/solaris/filesystem_resolver.cc

@@ -1,92 +0,0 @@
-#include <internal/facts/solaris/filesystem_resolver.hpp>
-#include <internal/util/solaris/k_stat.hpp>
-#include <internal/util/scoped_file.hpp>
-#include <leatherman/file_util/file.hpp>
-#include <facter/util/string.hpp>
-#include <leatherman/util/regex.hpp>
-#include <leatherman/execution/execution.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <boost/algorithm/string.hpp>
-#include <boost/filesystem.hpp>
-#include <sys/mnttab.h>
-#include <fcntl.h>
-#include <sys/vfs.h>
-#include <sys/statvfs.h>
-#include <unordered_set>
-
-using namespace std;
-using namespace facter::facts;
-using namespace facter::util;
-using namespace facter::util::solaris;
-using namespace leatherman::util;
-using namespace boost::filesystem;
-
-namespace facter { namespace facts { namespace solaris {
-
-    filesystem_resolver::data filesystem_resolver::collect_data(collection& facts)
-    {
-        data result;
-        collect_mountpoint_data(result);
-        collect_filesystem_data(result);
-        return result;
-    }
-
-    void filesystem_resolver::collect_mountpoint_data(data& result)
-    {
-        scoped_file file(fopen("/etc/mnttab", "r"));
-        if (!static_cast<FILE*>(file)) {
-            LOG_ERROR("fopen of /etc/mnttab failed: {1} ({2}): mountpoint data is unavailable.", strerror(errno), errno);
-            return;
-        }
-
-        mnttab entry;
-        unordered_set<string> auto_home_paths;
-        vector<mountpoint> mountpoints;
-        while (getmntent(file, &entry) == 0) {
-            mountpoint point;
-
-            struct statvfs64 stats;
-            if (statvfs64(entry.mnt_mountp, &stats) != -1) {
-                point.size = stats.f_frsize * stats.f_blocks;
-                point.available = stats.f_frsize * stats.f_bfree;
-            }
-
-            if (entry.mnt_special == string("auto_home")) {
-                auto_home_paths.emplace(entry.mnt_mountp);
-                continue;
-            } else if (entry.mnt_fstype == string("autofs")) {
-                continue;
-            }
-
-            point.name = entry.mnt_mountp;
-            point.device = entry.mnt_special;
-            point.filesystem = entry.mnt_fstype;
-            boost::split(point.options, entry.mnt_mntopts, boost::is_any_of(","), boost::token_compress_on);
-
-            mountpoints.emplace_back(move(point));
-        }
-
-        for (auto& point : mountpoints) {
-            auto mount_parent = point.name.substr(0, point.name.find_last_of('/'));
-
-            // Only add entries that are not mounted from an auto_home setup
-            if (auto_home_paths.count(mount_parent) == 0) {
-                result.mountpoints.emplace_back(move(point));
-            }
-        }
-    }
-
-    void filesystem_resolver::collect_filesystem_data(data& result)
-    {
-        // Build a list of mounted filesystems
-        static boost::regex fs_re("^fs/.*/(.*)$");
-        leatherman::execution::each_line("/usr/sbin/sysdef", [&](string& line) {
-            string fs;
-            if (re_search(line, fs_re, &fs)) {
-                result.filesystems.insert(move(fs));
-            }
-            return true;
-        });
-    }
-
-}}}  // namespace facter::facts::solaris

data/ext/facter/facter/lib/src/facts/solaris/kernel_resolver.cc

@@ -1,24 +0,0 @@
-#include <internal/facts/solaris/kernel_resolver.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <sys/utsname.h>
-
-using namespace std;
-
-namespace facter { namespace facts { namespace solaris {
-
-    kernel_resolver::data kernel_resolver::collect_data(collection& facts)
-    {
-        data result;
-        struct utsname name;
-        if (uname(&name) == -1) {
-            LOG_WARNING("uname failed: {1} ({2}): kernel facts are unavailable.", strerror(errno), errno);
-            return result;
-        }
-
-        result.name = name.sysname;
-        result.release = name.release;
-        result.version = name.version;
-        return result;
-    }
-
-}}}  // namespace facter::facts::solaris

data/ext/facter/facter/lib/src/facts/solaris/ldom_resolver.cc

@@ -1,87 +0,0 @@
-#include <internal/facts/solaris/ldom_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <leatherman/execution/execution.hpp>
-#include <leatherman/util/regex.hpp>
-#include <facter/facts/map_value.hpp>
-#include <boost/algorithm/string.hpp>
-#include <string>
-#include <vector>
-
-using namespace std;
-using namespace facter::facts;
-using namespace leatherman::execution;
-using namespace leatherman::util;
-
-namespace facter { namespace facts { namespace solaris {
-
-    ldom_resolver::data ldom_resolver::collect_data(collection& facts)
-    {
-        /*
-           Convert virtinfo parseable output format to array of arrays.
-           DOMAINROLE|impl=LDoms|control=true|io=true|service=true|root=true
-           DOMAINNAME|name=primary
-           DOMAINUUID|uuid=8e0d6ec5-cd55-e57f-ae9f-b4cc050999a4
-           DOMAINCONTROL|name=san-t2k-6
-           DOMAINCHASSIS|serialno=0704RB0280
-
-           For keys containing multiple value such as domain role:
-           ldom_{key}_{subkey} = value
-           Otherwise the fact will simply be:
-           ldom_{key} = value
-        */
-        data result;
-
-        auto isa = facts.get<string_value>(fact::hardware_isa);
-        if (isa && isa->value() != "sparc") {
-            return result;
-        }
-
-        each_line("/usr/sbin/virtinfo", { "-a", "-p" }, [&] (string& line) {
-            if (!re_search(line, boost::regex("^DOMAIN"))) {
-                return true;
-            }
-
-            vector<string> items;
-            boost::split(items, line, boost::is_any_of("|"));
-
-            // The first element is the key, i.e, "domainrole." Subsequent entries are values.
-            if (items.empty()) {
-                return true;
-            } else if (items.size() == 2) {
-                ldom_info ldom_data;
-                string key = items[0];
-                string value = items[1].substr(items[1].find("=") + 1);
-
-                transform(key.begin(), key.end(), key.begin(), ::tolower);
-
-                ldom_data.key = key;
-                ldom_data.values.insert({ key, value });
-                result.ldom.emplace_back(ldom_data);
-            } else {
-                // When there are multiple values to a line, we insert them all in a single sub-map.
-                ldom_info ldom_data;
-                string base_key = items[0];  // Base key is used as top level sub-key in the structured fact
-                transform(base_key.begin(), base_key.end(), base_key.begin(), ::tolower);
-                ldom_data.key = base_key;
-
-                items.erase(items.begin());
-
-                for (string val : items) {
-                    auto pos = val.find("=");
-                    string sub_key = val.substr(0, pos);
-                    string value = val.substr(pos + 1);
-
-                    ldom_data.values.insert({ sub_key, value });
-                }
-
-                result.ldom.emplace_back(ldom_data);
-            }
-            return true;
-        });
-
-        return result;
-    }
-
-}}}  // namespace facter::facts::solaris

data/ext/facter/facter/lib/src/facts/solaris/memory_resolver.cc

@@ -1,91 +0,0 @@
-#include <internal/facts/solaris/memory_resolver.hpp>
-#include <internal/util/solaris/k_stat.hpp>
-#include <leatherman/execution/execution.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <leatherman/util/regex.hpp>
-#include <boost/algorithm/string.hpp>
-#include <sys/sysinfo.h>
-#include <sys/sysconfig.h>
-#include <sys/stat.h>
-#include <sys/swap.h>
-
-using namespace std;
-using namespace facter::util::solaris;
-using namespace leatherman::execution;
-using namespace leatherman::util;
-
-namespace facter { namespace facts { namespace solaris {
-
-    memory_resolver::data memory_resolver::collect_data(collection& facts)
-    {
-        data result;
-
-        const uint64_t page_size = sysconf(_SC_PAGESIZE);
-        const auto max_dev_size = PATH_MAX;
-
-        try {
-            k_stat ks;
-            auto ke = ks[make_pair("unix", "system_pages")][0];
-            result.mem_total = ke.value<ulong_t>("physmem") * page_size;
-            result.mem_free = ke.value<ulong_t>("pagesfree") * page_size;
-        } catch (kstat_exception &ex) {
-            LOG_DEBUG("failed to read memory facts from kstat api: {1}.", ex.what());
-
-            uint64_t physmem, pagesfree;
-
-            static boost::regex physmem_rx("^\\s*physmem\\s+(.+)$");
-            static boost::regex pagesfree_rx("^\\s*pagesfree\\s+(\\d+)$");
-
-            each_line("/usr/bin/kstat", {"-m", "unix", "-n", "system_pages"}, [&] (string& line) {
-                if (re_search(line, physmem_rx, &physmem)) {
-                    result.mem_total = physmem * page_size;
-                } else if (re_search(line, pagesfree_rx, &pagesfree)) {
-                    result.mem_free = pagesfree * page_size;
-                }
-                return result.mem_total == 0 || result.mem_free == 0;
-            });
-        }
-
-        // Swap requires a little more effort. See
-        // https://community.oracle.com/thread/1951228?start=0&tstart=0
-        // http://www.brendangregg.com/K9Toolkit/swapinfo
-        int num = 0;
-        if ((num = swapctl(SC_GETNSWP,  0)) == -1) {
-            LOG_DEBUG("swapctl failed: {1} ({2}): swap information is unavailable", strerror(errno), errno);
-            return result;
-        }
-        if (num == 0) {
-            // no swap devices configured
-            return result;
-        }
-
-        // swap devices can be added online. So add one extra.
-        num++;
-
-        vector<char> buffer(num * sizeof(swapent_t) + sizeof(swaptbl_t));
-        vector<vector<char>> str_table(num);
-
-        swaptbl_t* swaps = reinterpret_cast<swaptbl_t*>(buffer.data());
-        swaps->swt_n = num;
-
-        for (int i = 0; i < num; i++) {
-            str_table[i].resize(max_dev_size);
-            swaps->swt_ent[i].ste_path = str_table[i].data();
-        }
-
-        if (swapctl(SC_LIST, swaps) == -1) {
-            LOG_DEBUG("swapctl with SC_LIST failed: {1} ({2}): swap information is unavailable", strerror(errno), errno);
-            return result;
-        }
-
-        for (int i = 0; i < num; i++) {
-            result.swap_free += swaps->swt_ent[i].ste_free;
-            result.swap_total += swaps->swt_ent[i].ste_pages;
-        }
-
-        result.swap_free *= page_size;
-        result.swap_total *= page_size;
-
-        return result;
-    }
-}}}  // namespace facter::facts::solaris

data/ext/facter/facter/lib/src/facts/solaris/networking_resolver.cc

@@ -1,188 +0,0 @@
-#include <internal/facts/solaris/networking_resolver.hpp>
-#include <internal/util/posix/scoped_descriptor.hpp>
-#include <facter/util/string.hpp>
-#include <leatherman/execution/execution.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <boost/algorithm/string.hpp>
-#include <sys/sockio.h>
-#include <net/if_arp.h>
-
-using namespace std;
-using namespace facter::util::posix;
-using namespace facter::util;
-using namespace leatherman::execution;
-
-namespace facter { namespace facts { namespace solaris {
-
-    networking_resolver::data networking_resolver::collect_data(collection& facts)
-    {
-        auto data = posix::networking_resolver::collect_data(facts);
-
-        scoped_descriptor ctl(socket(AF_INET, SOCK_DGRAM, 0));
-        if (static_cast<int>(ctl) == -1) {
-            LOG_DEBUG("socket failed {1} ({2}): interface information is unavailable.", strerror(errno), errno);
-            return data;
-        }
-
-        // (patterned on bsd impl)
-        lifnum ifnr{AF_UNSPEC, 0, 0};
-        if (ioctl(ctl, SIOCGLIFNUM, &ifnr) == -1) {
-            LOG_DEBUG("ioctl with SIOCGLIFNUM failed: {1} ({2}): interface information is unavailable.", strerror(errno), errno);
-            return data;
-        }
-
-        vector<lifreq> buffer(ifnr.lifn_count);
-        lifconf lifc = {AF_UNSPEC, 0, static_cast<int>(buffer.size() * sizeof(lifreq)), reinterpret_cast<caddr_t>(buffer.data())};
-        if (ioctl(ctl, SIOCGLIFCONF, &lifc) == -1) {
-            LOG_DEBUG("ioctl with SIOCGLIFCONF failed: {1} ({2}): interface information is unavailable.", strerror(errno), errno);
-            return data;
-        }
-
-        // put them in a multimap so that similar address can be
-        // grouped together.
-        multimap<string, const lifreq*> interface_map;
-        for (lifreq const& lreq : buffer) {
-            interface_map.insert({lreq.lifr_name, &lreq});
-        }
-
-        data.primary_interface = get_primary_interface();
-
-        // Walk the interfaces
-        decltype(interface_map.begin()) it = interface_map.begin();
-        while (it != interface_map.end()) {
-            string const& name = it->first;
-
-            interface iface;
-            iface.name = name;
-
-            // Populate the MAC address and MTU once per interface
-            populate_macaddress(iface, it->second);
-            populate_mtu(iface, it->second);
-
-            // Walk the addresses for this interface
-            do {
-                populate_binding(iface, it->second);
-                ++it;
-            } while (it != interface_map.end() && it->first == name);
-
-            // Find the DCHP server for the interface
-            iface.dhcp_server = find_dhcp_server(name);
-
-            data.interfaces.emplace_back(move(iface));
-        }
-        return data;
-    }
-
-    void networking_resolver::populate_binding(interface& iface, lifreq const* addr) const
-    {
-        // Populate the correct bindings list
-        vector<binding>* bindings = nullptr;
-        if (addr->lifr_addr.ss_family == AF_INET) {
-            bindings = &iface.ipv4_bindings;
-        } else if (addr->lifr_addr.ss_family == AF_INET) {
-            bindings = &iface.ipv6_bindings;
-        }
-
-        if (!bindings) {
-            return;
-        }
-
-        // Create a binding
-        binding b;
-        b.address = address_to_string(reinterpret_cast<sockaddr const*>(&addr->lifr_addr));
-
-        // Get the netmask
-        scoped_descriptor ctl(socket(addr->lifr_addr.ss_family, SOCK_DGRAM, 0));
-        if (static_cast<int>(ctl) == -1) {
-            LOG_DEBUG("socket failed: {1} ({2}): netmask and network for interface {3} are unavailable.", strerror(errno), errno, addr->lifr_name);
-        } else {
-            lifreq netmask_addr = *addr;
-            if (ioctl(ctl, SIOCGLIFNETMASK, &netmask_addr) == -1) {
-                LOG_DEBUG("ioctl with SIOCGLIFNETMASK failed: {1} ({2}): netmask and network for interface {3} are unavailable.", strerror(errno), errno, addr->lifr_name);
-            } else {
-                b.netmask = address_to_string(reinterpret_cast<sockaddr const*>(&netmask_addr.lifr_addr));
-                b.network = address_to_string(reinterpret_cast<sockaddr const*>(&addr->lifr_addr), reinterpret_cast<sockaddr const*>(&netmask_addr.lifr_addr));
-            }
-        }
-
-        bindings->emplace_back(std::move(b));
-    }
-
-    void networking_resolver::populate_macaddress(interface& iface, lifreq const* addr) const
-    {
-        scoped_descriptor ctl(socket(addr->lifr_addr.ss_family, SOCK_DGRAM, 0));
-        if (static_cast<int>(ctl) == -1) {
-            LOG_DEBUG("socket failed: {1} ({2}): link level address for interface {3} is unavailable.", strerror(errno), errno, addr->lifr_name);
-            return;
-        }
-
-        arpreq arp;
-        sockaddr_in* arp_addr = reinterpret_cast<sockaddr_in*>(&arp.arp_pa);
-        arp_addr->sin_addr.s_addr = reinterpret_cast<sockaddr_in const*>(&addr->lifr_addr)->sin_addr.s_addr;
-        if (ioctl(ctl, SIOCGARP, &arp) == -1) {
-            LOG_DEBUG("ioctl with SIOCGARP failed: {1} ({2}): link level address for {3} is unavailable.", strerror(errno), errno, addr->lifr_name);
-            return;
-        }
-
-        iface.macaddress = macaddress_to_string(reinterpret_cast<uint8_t const*>(arp.arp_ha.sa_data));
-    }
-
-    void networking_resolver::populate_mtu(interface& iface, lifreq const* addr) const
-    {
-        scoped_descriptor ctl(socket(addr->lifr_addr.ss_family, SOCK_DGRAM, 0));
-        if (static_cast<int>(ctl) == -1) {
-            LOG_DEBUG("socket failed: {1} ({2}): MTU for interface {3} is unavailable.", strerror(errno), errno, addr->lifr_name);
-            return;
-        }
-
-        lifreq mtu = *addr;
-        if (ioctl(ctl, SIOCGLIFMTU, &mtu) == -1) {
-            LOG_DEBUG("ioctl with SIOCGLIFMTU failed: {1} ({2}): MTU for interface {3} is unavailable.", strerror(errno), errno, addr->lifr_name);
-            return;
-        }
-
-        iface.mtu = mtu.lifr_metric;
-    }
-
-    string networking_resolver::get_primary_interface() const
-    {
-        string value;
-        each_line("netstat", { "-rn"}, [&value](string& line) {
-            boost::trim(line);
-            if (boost::starts_with(line, "default")) {
-                vector<string> fields;
-                boost::split(fields, line, boost::is_space(), boost::token_compress_on);
-                value = fields.size() < 6 ? "" : fields[5];
-                return false;
-            }
-            return true;
-        });
-        return value;
-    }
-
-    bool networking_resolver::is_link_address(const sockaddr* addr) const
-    {
-        // We explicitly populate the MAC address; we don't need address_to_string to support link layer addresses
-        return false;
-    }
-
-    uint8_t const* networking_resolver::get_link_address_bytes(const sockaddr * addr) const
-    {
-        return nullptr;
-    }
-
-    uint8_t networking_resolver::get_link_address_length(const sockaddr * addr) const
-    {
-        return 0;
-    }
-
-    string networking_resolver::find_dhcp_server(string const& interface) const
-    {
-        auto exec = execute("dhcpinfo", { "-i", interface, "ServerID" });
-        if (!exec.success) {
-            return {};
-        }
-        return exec.output;
-    }
-
-}}}  // namespace facter::facts::solaris