cfacter 3.11.0.rc.20180314

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

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

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

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

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

@@ -0,0 +1,183 @@
+#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;
+    }
+
+    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