cfacter 3.11.0.rc.20180314

data/ext/facter/facter/lib/src/facts/external/yaml_resolver.cc

@@ -0,0 +1,45 @@
+#include <internal/facts/external/yaml_resolver.hpp>
+#include <internal/util/yaml.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <leatherman/locale/locale.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/nowide/fstream.hpp>
+#include <yaml-cpp/yaml.h>
+#include <yaml-cpp/eventhandler.h>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+using namespace YAML;
+using namespace facter::util::yaml;
+
+namespace facter { namespace facts { namespace external {
+
+    bool yaml_resolver::can_resolve(string const& path) const
+    {
+        return boost::iends_with(path, ".yaml");
+    }
+
+    void yaml_resolver::resolve(string const& path, collection& facts) const
+    {
+        LOG_DEBUG("resolving facts from YAML file \"{1}\".", path);
+
+        boost::nowide::ifstream stream(path.c_str());
+        if (!stream) {
+            throw external_fact_exception(_("file could not be opened."));
+        }
+
+        try {
+            Node node = YAML::Load(stream);
+            for (auto const& kvp : node) {
+                add_value(kvp.first.as<string>(), kvp.second, facts);
+            }
+        } catch (Exception& ex) {
+            throw external_fact_exception(ex.msg);
+        }
+
+        LOG_DEBUG("completed resolving facts from YAML file \"{1}\".", path);
+    }
+
+}}}  // namespace facter::facts::external

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

@@ -0,0 +1,41 @@
+#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/freebsd/processor_resolver.hpp>
+#include <internal/facts/freebsd/dmi_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/freebsd/operating_system_resolver.hpp>
+#include <internal/facts/freebsd/networking_resolver.hpp>
+#include <internal/facts/freebsd/zfs_resolver.hpp>
+#include <internal/facts/freebsd/zpool_resolver.hpp>
+#include <internal/facts/freebsd/virtualization_resolver.hpp>
+#include <internal/facts/freebsd/memory_resolver.hpp>
+
+using namespace std;
+
+namespace facter { namespace facts {
+
+    void collection::add_platform_facts()
+    {
+        add(make_shared<posix::kernel_resolver>());
+        add(make_shared<freebsd::operating_system_resolver>());
+        add(make_shared<freebsd::networking_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<freebsd::processor_resolver>());
+        add(make_shared<freebsd::dmi_resolver>());
+        add(make_shared<freebsd::zfs_resolver>());
+        add(make_shared<freebsd::zpool_resolver>());
+        add(make_shared<freebsd::virtualization_resolver>());
+        add(make_shared<freebsd::memory_resolver>());
+    }
+
+}}  // namespace facter::facts

data/ext/facter/facter/lib/src/facts/freebsd/dmi_resolver.cc

@@ -0,0 +1,43 @@
+#include <internal/facts/freebsd/dmi_resolver.hpp>
+#include <leatherman/logging/logging.hpp>
+
+#include <kenv.h>
+
+using namespace std;
+
+namespace facter { namespace facts { namespace freebsd {
+
+    dmi_resolver::data dmi_resolver::collect_data(collection& facts)
+    {
+        data result;
+        result.bios_vendor = kenv_lookup("smbios.bios.vendor");
+        result.bios_version = kenv_lookup("smbios.bios.version");
+        result.bios_release_date = kenv_lookup("smbios.bios.reldate");
+        result.uuid = kenv_lookup("smbios.system.uuid");
+        result.serial_number = kenv_lookup("smbios.system.serial");
+        result.product_name = kenv_lookup("smbios.system.product");
+        if (result.product_name.length() == 0) {
+            result.product_name = result.bios_vendor;
+        }
+        result.manufacturer = kenv_lookup("smbios.system.maker");
+        // Fix for Proxmox VMs
+        if (result.manufacturer == "QEMU") {
+            result.product_name = "KVM";
+        }
+
+        return result;
+    }
+
+    string dmi_resolver::kenv_lookup(const char* file)
+    {
+        char buffer[100] = {};
+
+        LOG_DEBUG("kenv lookup for {1}", file);
+        if (kenv(KENV_GET, file, buffer, sizeof(buffer) - 1) == -1) {
+            LOG_INFO("kenv lookup for {1} failed: {2} ({3})", file, strerror(errno), errno);
+            return "";
+        }
+        return buffer;
+    }
+
+} } }  // namespace facter::facts::freebsd

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

@@ -0,0 +1,76 @@
+#include <internal/facts/freebsd/memory_resolver.hpp>
+#include <leatherman/execution/execution.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#include <vm/vm_param.h>
+#include <unistd.h>
+
+using namespace std;
+using namespace leatherman::execution;
+
+namespace facter { namespace facts { namespace freebsd {
+
+    memory_resolver::data memory_resolver::collect_data(collection& facts)
+    {
+        data result;
+
+        size_t size;
+        int pagesize = getpagesize();
+
+        // Memory usage
+
+        unsigned long physmem;
+        size = sizeof(physmem);
+        if (0 == sysctlbyname("hw.physmem", &physmem, &size, NULL, 0)) {
+            result.mem_total = physmem;
+        }
+
+        unsigned int inactive_count = 0;
+        size = sizeof(inactive_count);
+        sysctlbyname("vm.stats.vm.v_inactive_count", &inactive_count, &size, NULL, 0);
+
+        unsigned int cache_count = 0;
+        size = sizeof(cache_count);
+        sysctlbyname("vm.stats.vm.v_cache_count", &cache_count, &size, NULL, 0);
+
+        unsigned int free_count = 0;
+        size = sizeof(free_count);
+        sysctlbyname("vm.stats.vm.v_free_count", &free_count, &size, NULL, 0);
+
+        long mem_free_page_count = inactive_count + cache_count + free_count;
+        result.mem_free = mem_free_page_count * pagesize;
+
+        // Swap usage
+
+        struct xswdev xsw;
+        size = sizeof(xsw);
+
+        int mib[16];
+        size_t mibsize;
+        mibsize = sizeof mib / sizeof mib[0];
+        if (sysctlnametomib("vm.swap_info", mib, &mibsize) == -1) {
+            LOG_DEBUG("sysctlnametomib() failed");
+        } else {
+            for (int n = 0; ; ++n) {
+                mib[mibsize] = n;
+                if (-1 == sysctl(mib, mibsize + 1, &xsw, &size, NULL, 0))
+                    break;
+
+                if (xsw.xsw_version != XSWDEV_VERSION) {
+                    LOG_DEBUG("xswdev version mismatch");
+                } else {
+                    result.swap_total += xsw.xsw_nblks;
+                    result.swap_free += xsw.xsw_nblks - xsw.xsw_used;
+                }
+            }
+
+            result.swap_free *= pagesize;
+            result.swap_total *= pagesize;
+        }
+
+        return result;
+    }
+
+}}}  // namespace facter::facts::freebsd

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

@@ -0,0 +1,55 @@
+#include <internal/facts/freebsd/networking_resolver.hpp>
+#include <internal/util/bsd/scoped_ifaddrs.hpp>
+#include <leatherman/execution/execution.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <boost/algorithm/string.hpp>
+#include <sys/sockio.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <netinet/in.h>
+
+using namespace std;
+using namespace facter::util;
+using namespace facter::util::bsd;
+using namespace leatherman::execution;
+
+namespace facter { namespace facts { namespace freebsd {
+
+    bool networking_resolver::is_link_address(sockaddr const* addr) const
+    {
+        return addr && addr->sa_family == AF_LINK;
+    }
+
+    uint8_t const* networking_resolver::get_link_address_bytes(sockaddr const* addr) const
+    {
+        if (!is_link_address(addr)) {
+            return nullptr;
+        }
+        sockaddr_dl const* link_addr = reinterpret_cast<sockaddr_dl const*>(addr);
+        if (link_addr->sdl_alen != 6) {
+            return nullptr;
+        }
+        return reinterpret_cast<uint8_t const*>(LLADDR(link_addr));
+     }
+
+    boost::optional<uint64_t> networking_resolver::get_link_mtu(string const& interface, void* data) const
+    {
+        ifreq ifr;
+        memset(&ifr, 0, sizeof(ifr));
+        strncpy(ifr.ifr_name, interface.c_str(), sizeof(ifr.ifr_name));
+        int s = socket(AF_INET, SOCK_DGRAM, 0);
+        if (s < 0) {
+            LOG_WARNING("socket failed: {1} ({2}): interface MTU fact is unavailable for interface {3}.", strerror(errno), errno, interface);
+            return boost::none;
+        }
+
+        if (ioctl(s, SIOCGIFMTU, &ifr) == -1) {
+            LOG_WARNING("ioctl failed: {1} ({2}): interface MTU fact is unavailable for interface {3}.", strerror(errno), errno, interface);
+            return boost::none;
+        }
+
+        return ifr.ifr_mtu;
+    }
+
+}}}  // namespace facter::facts::freebsd

data/ext/facter/facter/lib/src/facts/freebsd/operating_system_resolver.cc

@@ -0,0 +1,17 @@
+#include <leatherman/execution/execution.hpp>
+
+#include <internal/facts/freebsd/operating_system_resolver.hpp>
+
+using namespace std;
+using namespace leatherman::execution;
+
+namespace facter { namespace facts { namespace freebsd {
+
+    void operating_system_resolver::collect_release_data(collection& facts, data& result)
+    {
+        auto exec = execute("freebsd-version");
+        if (exec.success) {
+            result.release = exec.output;
+        }
+    }
+} } }  // namespace facter::facts::freebsd

data/ext/facter/facter/lib/src/facts/freebsd/processor_resolver.cc

@@ -0,0 +1,63 @@
+#include <internal/facts/freebsd/processor_resolver.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+
+using namespace std;
+
+namespace facter { namespace facts { namespace freebsd {
+
+    processor_resolver::data processor_resolver::collect_data(collection& facts)
+    {
+        auto result = posix::processor_resolver::collect_data(facts);
+        size_t len;
+        int mib[2];
+        mib[0] = CTL_HW;
+
+        // Get the logical count of processors
+        len = sizeof(result.logical_count);
+        mib[1] = HW_NCPU;
+
+        if (sysctl(mib, 2, &result.logical_count, &len, nullptr, 0) == -1) {
+            LOG_DEBUG("sysctl hw.ncpu failed: {1} ({2}): logical processor count is unavailable.", strerror(errno), errno);
+        }
+
+        // For each logical processor, collect the model name
+        if (result.logical_count > 0) {
+            // Note: we're using the same description string for all logical processors:
+            // using different CPUs is not even likely to work.
+            vector<char> buffer(256);
+
+            while (true) {
+                size_t size = buffer.size();
+                mib[1] = HW_MODEL;
+                if (sysctl(mib, 2, buffer.data(), &size, nullptr, 0) == 0) {
+                    buffer.resize(size + 1);
+                    result.models.resize(result.logical_count, buffer.data());
+                    break;
+                }
+                if (errno != ENOMEM) {
+                    LOG_DEBUG("sysctl hw.model failed: {1} ({2}): processor models are unavailable.", strerror(errno), errno);
+                    break;
+                }
+                buffer.resize(buffer.size() * 2);
+            }
+        }
+
+        // Set the speed
+        len = sizeof(result.speed);
+
+        int cmd[2];
+        size_t two = 2;
+        sysctlnametomib("hw.clockrate", cmd, &two);
+
+        if (sysctl(cmd, 2, &result.speed, &len, nullptr, 0) == -1) {
+            LOG_DEBUG("sysctl hw.cpuspeed failed: {1} ({2}): processor speed is unavailable.", strerror(errno), errno);
+        }
+        // Scale the speed to something resolve() can correctly map
+        result.speed *= 1000 * 1000;
+
+        return result;
+    }
+
+}}}  // namespace facter::facts::freebsd

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

@@ -0,0 +1,41 @@
+#include <internal/facts/freebsd/virtualization_resolver.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <facter/facts/collection.hpp>
+#include <facter/facts/fact.hpp>
+#include <facter/facts/vm.hpp>
+#include <leatherman/execution/execution.hpp>
+#include <boost/algorithm/string.hpp>
+
+#include <sys/types.h>
+#include <sys/sysctl.h>
+
+using namespace std;
+using namespace facter::facts;
+using namespace leatherman::execution;
+
+namespace facter { namespace facts { namespace freebsd {
+
+    string virtualization_resolver::get_hypervisor(collection& facts)
+    {
+        string value = get_jail_vm();
+
+        if (value.empty()) {
+            value = get_fact_vm(facts);
+        }
+
+        return value;
+    }
+
+    string virtualization_resolver::get_jail_vm()
+    {
+        int jailed;
+        size_t size = sizeof(jailed);
+        if (sysctlbyname("security.jail.jailed", &jailed, &size, NULL, 0) == 0) {
+            if (jailed)
+                return vm::jail;
+        }
+
+        return {};
+    }
+
+} } }  // namespace facter::facts::freebsd

data/ext/facter/facter/lib/src/facts/freebsd/zfs_resolver.cc

@@ -0,0 +1,12 @@
+#include <internal/facts/freebsd/zfs_resolver.hpp>
+
+using namespace std;
+
+namespace facter { namespace facts { namespace freebsd {
+
+    string zfs_resolver::zfs_command()
+    {
+        return "/sbin/zfs";
+    }
+
+}}}  // namespace facter::facts::freebsd

data/ext/facter/facter/lib/src/facts/freebsd/zpool_resolver.cc

@@ -0,0 +1,12 @@
+#include <internal/facts/freebsd/zpool_resolver.hpp>
+
+using namespace std;
+
+namespace facter { namespace facts { namespace freebsd {
+
+    string zpool_resolver::zpool_command()
+    {
+        return "/sbin/zpool";
+    }
+
+}}}  // namespace facter::facts::freebsd

data/ext/facter/facter/lib/src/facts/glib/load_average_resolver.cc

@@ -0,0 +1,22 @@
+#include <internal/facts/glib/load_average_resolver.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <cstdlib>
+
+#ifdef __sun
+#include <sys/loadavg.h>
+#endif
+
+using namespace std;
+
+namespace facter { namespace facts { namespace glib {
+
+    boost::optional<tuple<double, double, double> > load_average_resolver::get_load_averages()
+    {
+        array<double, 3> averages;
+        if (getloadavg(averages.data(), averages.size()) == -1) {
+            LOG_DEBUG("failed to retrieve load averages: {1} ({2}).", strerror(errno), errno);
+            return boost::none;
+        }
+        return make_tuple(averages[0], averages[1], averages[2]);
+    }
+}}}  // namespace facter::facts::glib

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

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