cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,49 @@
+#include <internal/facts/osx/operating_system_resolver.hpp>
+#include <leatherman/execution/execution.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/regex.hpp>
+#include <string>
+
+using namespace std;
+using namespace facter::facts;
+using namespace leatherman::execution;
+
+namespace facter { namespace facts { namespace osx {
+
+    operating_system_resolver::data operating_system_resolver::collect_data(collection& facts)
+    {
+        // Default to the base implementation
+        data result = posix::operating_system_resolver::collect_data(facts);
+
+        each_line("/usr/bin/sw_vers", [&](string& line) {
+            // Split at the first ':'
+            auto pos = line.find(':');
+            if (pos == string::npos) {
+                return true;
+            }
+            string key = line.substr(0, pos);
+            boost::trim(key);
+            string value = line.substr(pos + 1);
+            boost::trim(value);
+
+            if (key == "ProductName") {
+                result.osx.product = move(value);
+            } else if (key == "BuildVersion") {
+                result.osx.build = move(value);
+            } else if (key == "ProductVersion") {
+                result.osx.version = move(value);
+            }
+
+            // Continue only if we haven't populated the data
+            return result.osx.product.empty() || result.osx.build.empty() || result.osx.version.empty();
+        });
+
+        // If osx.build is missing the patch version, add '.0'
+        if (boost::regex_match(result.osx.version, boost::regex("^\\d+\\.\\d+$"))) {
+            result.osx.version += ".0";
+        }
+
+        return result;
+    }
+
+}}}  // namespace facter::facts::osx

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

@@ -0,0 +1,55 @@
+#include <internal/facts/osx/processor_resolver.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+
+using namespace std;
+
+namespace facter { namespace facts { namespace osx {
+
+    processor_resolver::data processor_resolver::collect_data(collection& facts)
+    {
+        auto result = posix::processor_resolver::collect_data(facts);
+
+        // Get the logical count of processors
+        size_t size = sizeof(result.logical_count);
+        if (sysctlbyname("hw.logicalcpu_max", &result.logical_count, &size, nullptr, 0) == -1) {
+            LOG_DEBUG("sysctlbyname failed: logical processor count is unavailable.", strerror(errno), errno);
+        }
+
+        // Get the physical count of processors
+        size = sizeof(result.physical_count);
+        if (sysctlbyname("hw.physicalcpu_max", &result.physical_count, &size, nullptr, 0) == -1) {
+            LOG_DEBUG("sysctlbyname failed: {1} ({2}): physical 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
+            vector<char> buffer(256);
+
+            while (true) {
+                size_t size = buffer.size();
+                if (sysctlbyname("machdep.cpu.brand_string", buffer.data(), &size, nullptr, 0) == 0) {
+                    buffer.resize(size + 1);
+                    result.models.resize(result.logical_count, buffer.data());
+                    break;
+                }
+                if (errno != ENOMEM) {
+                    LOG_DEBUG("sysctlbyname failed: {1} ({2}): processor models are unavailable.", strerror(errno), errno);
+                    break;
+                }
+                buffer.resize(buffer.size() * 2);
+            }
+        }
+
+        // Set the speed
+        size = sizeof(result.speed);
+        if (sysctlbyname("hw.cpufrequency_max", &result.speed, &size, nullptr, 0) == -1) {
+            LOG_DEBUG("sysctlbyname failed: {1} ({2}): processor speed is unavailable.", strerror(errno), errno);
+        }
+
+        return result;
+    }
+
+}}}  // namespace facter::facts::osx

data/ext/facter/facter/lib/src/facts/osx/system_profiler_resolver.cc

@@ -0,0 +1,66 @@
+#include <internal/facts/osx/system_profiler_resolver.hpp>
+#include <leatherman/execution/execution.hpp>
+#include <boost/algorithm/string.hpp>
+#include <map>
+#include <functional>
+
+using namespace std;
+using namespace facter::facts;
+using namespace leatherman::execution;
+
+namespace facter { namespace facts { namespace osx {
+
+    system_profiler_resolver::data system_profiler_resolver::collect_data(collection& facts)
+    {
+        static map<string, function<string&(data&)>> data_map = {
+            { "Boot Mode",              [](data& d) -> string& { return d.boot_mode; } },
+            { "Boot ROM Version",       [](data& d) -> string& { return d.boot_rom_version; } },
+            { "Boot Volume",            [](data& d) -> string& { return d.boot_volume; } },
+            { "Processor Name",         [](data& d) -> string& { return d.processor_name; } },
+            { "Processor Speed",        [](data& d) -> string& { return d.processor_speed; } },
+            { "Kernel Version",         [](data& d) -> string& { return d.kernel_version; } },
+            { "L2 Cache (per Core)",    [](data& d) -> string& { return d.l2_cache_per_core; } },
+            { "L3 Cache",               [](data& d) -> string& { return d.l3_cache; } },
+            { "Computer Name",          [](data& d) -> string& { return d.computer_name; } },
+            { "Model Identifier",       [](data& d) -> string& { return d.model_identifier; } },
+            { "Model Name",             [](data& d) -> string& { return d.model_name; } },
+            { "Total Number of Cores",  [](data& d) -> string& { return d.cores; } },
+            { "System Version",         [](data& d) -> string& { return d.system_version; } },
+            { "Number of Processors",   [](data& d) -> string& { return d.processors; } },
+            { "Memory",                 [](data& d) -> string& { return d.memory; } },
+            { "Hardware UUID",          [](data& d) -> string& { return d.hardware_uuid; } },
+            { "Secure Virtual Memory",  [](data& d) -> string& { return d.secure_virtual_memory; } },
+            { "Serial Number (system)", [](data& d) -> string& { return d.serial_number; } },
+            { "SMC Version (system)",   [](data& d) -> string& { return d.smc_version; } },
+            { "Time since boot",        [](data& d) -> string& { return d.uptime; } },
+            { "User Name",              [](data& d) -> string& { return d.username; } }
+        };
+
+        data result;
+        size_t count = 0;
+        each_line("/usr/sbin/system_profiler", { "SPSoftwareDataType", "SPHardwareDataType" }, [&](string& line) {
+            // Split at the first ':'
+            auto pos = line.find(':');
+            if (pos == string::npos) {
+                return true;
+            }
+            string key = line.substr(0, pos);
+            boost::trim(key);
+            string value = line.substr(pos + 1);
+            boost::trim(value);
+
+            // Lookup the data based on the "key"
+            auto it = data_map.find(key);
+            if (it == data_map.end()) {
+                return true;
+            }
+            it->second(result) = move(value);
+
+            // Continue only if we haven't collected all the data
+            return ++count < data_map.size();
+        });
+
+        return result;
+    }
+
+}}}  // namespace facter::facts::osx

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

@@ -0,0 +1,46 @@
+#include <internal/facts/osx/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>
+
+using namespace std;
+using namespace facter::facts;
+using namespace leatherman::execution;
+
+namespace facter { namespace facts { namespace osx {
+
+    string virtualization_resolver::get_hypervisor(collection& facts)
+    {
+        // Check for VMWare
+        auto machine_model = facts.get<string_value>(fact::sp_machine_model);
+        if (machine_model) {
+            if (boost::starts_with(machine_model->value(), "VMware")) {
+                return vm::vmware;
+            }
+        }
+
+        // Check for VirtualBox
+        auto boot_rom_version = facts.get<string_value>(fact::sp_boot_rom_version);
+        if (boot_rom_version) {
+            if (boot_rom_version->value() == "VirtualBox") {
+                return vm::virtualbox;
+            }
+        }
+
+        // Check for Parallels
+        string value;
+        each_line("/usr/sbin/system_profiler", { "SPEthernetDataType" }, [&](string& line) {
+            boost::trim(line);
+            if (line == "Subsystem Vendor ID: 0x1ab8") {
+                value = vm::parallels;
+                return false;
+            }
+            return true;
+        });
+        return value;
+    }
+
+}}}  // namespace facter::facts::osx

data/ext/facter/facter/lib/src/facts/posix/cache.cc

@@ -0,0 +1,9 @@
+#include <internal/facts/cache.hpp>
+
+namespace facter { namespace facts { namespace cache {
+
+    std::string fact_cache_location() {
+        return "/opt/puppetlabs/facter/cache/cached_facts/";
+    }
+
+}}}  // namespace facter::facts::cache

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

@@ -0,0 +1,48 @@
+#include <facter/facts/collection.hpp>
+#include <internal/facts/external/json_resolver.hpp>
+#include <internal/facts/external/text_resolver.hpp>
+#include <internal/facts/external/yaml_resolver.hpp>
+#include <internal/facts/external/execution_resolver.hpp>
+#include <leatherman/util/environment.hpp>
+#include <unistd.h>
+#include <vector>
+#include <string>
+#include <cstdlib>
+#include <memory>
+
+using namespace std;
+using namespace leatherman::util;
+using namespace facter::facts::external;
+
+namespace facter { namespace facts {
+
+    vector<string> collection::get_external_fact_directories() const
+    {
+        vector<string> directories;
+        if (getuid()) {
+            string home;
+            if (environment::get("HOME", home)) {
+                directories.emplace_back(home + "/.puppetlabs/opt/facter/facts.d");
+                directories.emplace_back(home + "/.facter/facts.d");
+            }
+        } else {
+            directories.emplace_back("/opt/puppetlabs/facter/facts.d");
+            directories.emplace_back("/etc/facter/facts.d");
+            directories.emplace_back("/etc/puppetlabs/facter/facts.d");
+        }
+        return directories;
+    }
+
+    vector<unique_ptr<external::resolver>> collection::get_external_resolvers()
+    {
+        vector<unique_ptr<external::resolver>> resolvers;
+        resolvers.emplace_back(new text_resolver());
+        resolvers.emplace_back(new yaml_resolver());
+        resolvers.emplace_back(new json_resolver());
+
+        // The execution resolver should go last as it doesn't check file extensions
+        resolvers.emplace_back(new execution_resolver());
+        return resolvers;
+    }
+
+}}  // namespace facter::facts

data/ext/facter/facter/lib/src/facts/posix/identity_resolver.cc

@@ -0,0 +1,79 @@
+#include <internal/facts/posix/identity_resolver.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <sys/types.h>
+#include <unistd.h>
+#include <pwd.h>
+#include <grp.h>
+
+using namespace std;
+
+namespace facter { namespace facts { namespace posix {
+
+    identity_resolver::data identity_resolver::collect_data(collection& facts)
+    {
+        data result;
+
+        vector<char> buffer;
+        long buffer_size = sysconf(_SC_GETPW_R_SIZE_MAX);
+
+        if (buffer_size == -1) {
+            buffer.resize(1024);
+        } else {
+            buffer.resize(buffer_size);
+        }
+
+        uid_t uid = geteuid();
+        struct passwd pwd;
+        struct passwd *pwd_ptr;
+        int err = -1;
+
+        do {
+            err = getpwuid_r(uid, &pwd, buffer.data(), buffer.size(), &pwd_ptr);
+            if (err == ERANGE) {
+                buffer.resize(buffer.size() + 1024);
+            }
+        } while (err == EINTR || err == ERANGE);
+
+
+        if (err != 0) {
+            LOG_WARNING("getpwuid_r failed: {1} ({2})", strerror(err), err);
+        } else if (pwd_ptr == NULL) {
+            LOG_WARNING("effective uid {1} does not have a passwd entry.", uid);
+        } else {
+            result.user_id = static_cast<int64_t>(uid);
+            result.user_name = pwd.pw_name;
+            result.privileged = (uid == 0);
+        }
+
+        buffer_size = sysconf(_SC_GETGR_R_SIZE_MAX);
+
+        if (buffer_size == -1) {
+            buffer.resize(1024);
+        } else {
+            buffer.resize(buffer_size);
+        }
+
+        gid_t gid = getegid();
+        struct group grp;
+        struct group *grp_ptr;
+
+        do {
+            err = getgrgid_r(gid, &grp, buffer.data(), buffer.size(), &grp_ptr);
+            if (err == ERANGE) {
+                buffer.resize(buffer.size() + 1024);
+            }
+        } while (err == EINTR || err == ERANGE);
+
+        if (err != 0) {
+            LOG_WARNING("getgrgid_r failed: {1} ({2})", strerror(err), err);
+        } else if (grp_ptr == NULL) {
+            LOG_WARNING("effective gid {1} does not have a group entry.", gid);
+        } else {
+            result.group_id = static_cast<int64_t>(gid);
+            result.group_name = grp.gr_name;
+        }
+
+        return result;
+    }
+
+}}}  // facter::facts::posix

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

@@ -0,0 +1,25 @@
+#include <internal/facts/posix/kernel_resolver.hpp>
+#include <facter/facts/collection.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <sys/utsname.h>
+
+using namespace std;
+
+namespace facter { namespace facts { namespace posix {
+
+    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 = result.release.substr(0, result.release.find('-'));
+        return result;
+    }
+
+}}}  // namespace facter::facts::posix

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

@@ -0,0 +1,136 @@
+#include <internal/facts/posix/networking_resolver.hpp>
+#include <internal/util/posix/scoped_addrinfo.hpp>
+#include <leatherman/file_util/file.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <boost/algorithm/string.hpp>
+#include <unistd.h>
+#include <limits.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+using namespace std;
+using namespace facter::util::posix;
+
+namespace lth_file = leatherman::file_util;
+
+namespace facter { namespace facts { namespace posix {
+
+    string networking_resolver::address_to_string(sockaddr const* addr, sockaddr const* mask) const
+    {
+        if (!addr) {
+            return {};
+        }
+
+        // Check for IPv4 and IPv6
+        if (addr->sa_family == AF_INET) {
+            in_addr ip = reinterpret_cast<sockaddr_in const*>(addr)->sin_addr;
+
+            // Apply an IPv4 mask
+            if (mask && mask->sa_family == addr->sa_family) {
+                ip.s_addr &= reinterpret_cast<sockaddr_in const*>(mask)->sin_addr.s_addr;
+            }
+
+            char buffer[INET_ADDRSTRLEN] = {};
+            inet_ntop(AF_INET, &ip, buffer, sizeof(buffer));
+            return buffer;
+        } else if (addr->sa_family == AF_INET6) {
+            in6_addr ip = reinterpret_cast<sockaddr_in6 const*>(addr)->sin6_addr;
+
+            // Apply an IPv6 mask
+            if (mask && mask->sa_family == addr->sa_family) {
+                auto mask_ptr = reinterpret_cast<sockaddr_in6 const*>(mask);
+                for (size_t i = 0; i < 16; ++i) {
+                    ip.s6_addr[i] &= mask_ptr->sin6_addr.s6_addr[i];
+                }
+            }
+
+            char buffer[INET6_ADDRSTRLEN] = {};
+            inet_ntop(AF_INET6, &ip, buffer, sizeof(buffer));
+            return buffer;
+        } else if (is_link_address(addr)) {
+            auto link_addr = get_link_address_bytes(addr);
+            if (link_addr) {
+                return macaddress_to_string(reinterpret_cast<uint8_t const*>(link_addr));
+            }
+        }
+
+        return {};
+    }
+
+    networking_resolver::data networking_resolver::collect_data(collection& facts)
+    {
+        data result;
+
+        // Get the maximum size of the host name
+        int size = sysconf(_SC_HOST_NAME_MAX);
+        if (size <= 0) {
+            size = 1024;
+        }
+        // Get the hostname (+1 to ensure a null is returned on platforms where maximum truncation may occur)
+        vector<char> name(size + 1);
+        if (gethostname(name.data(), size + 1) != 0) {
+            LOG_WARNING("gethostname failed: {1} ({2}): hostname is unavailable.", strerror(errno), errno);
+        } else {
+            // Check for fully-qualified hostname
+            auto it = find(name.begin(), name.end(), '.');
+            if (it != name.end()) {
+                LOG_DEBUG("using the FQDN returned by gethostname: {1}.", name.data());
+                result.hostname.assign(name.begin(), it);
+                if (++it != name.end()) {
+                    // Use the remainder of the string, up to the first null character
+                    result.domain = &*it;
+                }
+            } else {
+                // Not fully qualified; just set hostname
+                result.hostname = name.data();
+            }
+        }
+
+        // If the hostname was not already fully qualified, attempt to resolve it
+        if (result.domain.empty() && !result.hostname.empty()) {
+            // Retrieve the FQDN by resolving the hostname
+            scoped_addrinfo info(result.hostname);
+            if (info.result() != 0 && info.result() != EAI_NONAME) {
+                LOG_WARNING("getaddrinfo failed: {1} ({2}): hostname may not be externally resolvable.", gai_strerror(info.result()), info.result());
+            } else if (!info || info.result() == EAI_NONAME || result.hostname == static_cast<addrinfo*>(info)->ai_canonname) {
+                LOG_DEBUG("hostname \"{1}\" could not be resolved: hostname may not be externally resolvable.", result.hostname);
+            } else {
+                result.fqdn = static_cast<addrinfo*>(info)->ai_canonname;
+            }
+
+            // Set the domain name if the FQDN is prefixed with the hostname
+            if (boost::starts_with(result.fqdn, result.hostname + ".")) {
+                result.domain = result.fqdn.substr(result.hostname.size() + 1);
+            }
+        }
+
+        // If no domain, look it up based on resolv.conf
+        if (result.domain.empty()) {
+            string search;
+            lth_file::each_line("/etc/resolv.conf", [&](string& line) {
+                vector<boost::iterator_range<string::iterator>> parts;
+                boost::split(parts, line, boost::is_space(), boost::token_compress_on);
+                if (parts.size() < 2) {
+                    return true;
+                }
+                if (parts[0] == boost::as_literal("domain")) {
+                    // Treat the first domain entry as the domain
+                    result.domain.assign(parts[1].begin(), parts[1].end());
+                    return false;
+                }
+                if (search.empty() && parts[0] == boost::as_literal("search")) {
+                    // Found a "search" entry, but keep looking for other domain entries
+                    // We use the first search domain as the domain.
+                    search.assign(parts[1].begin(), parts[1].end());
+                    return true;
+                }
+                return true;
+            });
+            if (result.domain.empty()) {
+                result.domain = move(search);
+            }
+        }
+        return result;
+    }
+
+}}}  // namespace facter::facts::posix