cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,83 @@
+#include <internal/facts/solaris/operating_system_resolver.hpp>
+#include <facter/facts/os.hpp>
+#include <facter/facts/os_family.hpp>
+#include <leatherman/file_util/file.hpp>
+#include <leatherman/util/regex.hpp>
+
+using namespace std;
+using namespace leatherman::util;
+
+namespace lth_file = leatherman::file_util;
+
+namespace facter { namespace facts { namespace solaris {
+
+    static string get_family(string const& name)
+    {
+        if (!name.empty()) {
+            static map<string, string> const systems = {
+                { string(os::sunos),                    string(os_family::solaris) },
+                { string(os::solaris),                  string(os_family::solaris) },
+                { string(os::nexenta),                  string(os_family::solaris) },
+                { string(os::omni),                     string(os_family::solaris) },
+                { string(os::open_indiana),             string(os_family::solaris) },
+                { string(os::smart),                    string(os_family::solaris) },
+            };
+            auto const& it = systems.find(name);
+            if (it != systems.end()) {
+                return it->second;
+            }
+        }
+        return {};
+    }
+
+    operating_system_resolver::data operating_system_resolver::collect_data(collection& facts)
+    {
+        // Default to the base implementation
+        auto result = posix::operating_system_resolver::collect_data(facts);
+        if (result.name == os::sunos) {
+            result.name = os::solaris;
+        }
+
+        auto family = get_family(result.name);
+        if (!family.empty()) {
+            result.family = move(family);
+        }
+
+        /*
+         Oracle Solaris 10 1/13 s10x_u11wos_24a X86
+         Oracle Solaris 10 9/10 s10s_u9wos_14a SPARC
+         Oracle Solaris 11 11/11 X86
+         Oracle Solaris 11.2 X86
+
+         There are a few places (operatingsystemmajrelease,...) where s10 and s11 differ
+         for similar versioning. For e.g it shifts from `10_u11` to `11 11/11` these needs
+         to be resolved further using the `pkg info kernel` command (TODO).
+         */
+
+        static boost::regex regexp_s10("Solaris \\d+ \\d+/\\d+ s(\\d+)[sx]?_u(\\d+)wos_");
+        static boost::regex regexp_s11("Solaris (\\d+)[.](\\d+)");
+        static boost::regex regexp_s11b("Solaris (\\d+) ");
+        lth_file::each_line("/etc/release", [&](string& line) {
+            string major, minor;
+            if (re_search(line, regexp_s10, &major, &minor)) {
+                result.release = major + "_u" + minor;
+                result.major = move(major);
+                result.minor = move(minor);
+                return false;
+            } else if (re_search(line, regexp_s11, &major, &minor)) {
+                result.release = major + "." + minor;
+                result.major = move(major);
+                result.minor = move(minor);
+                return false;
+            } else if (re_search(line, regexp_s11b, &major)) {
+                result.release = major + ".0";
+                result.major = move(major);
+                result.minor = "0";
+                return false;
+            }
+            return true;
+        });
+        return result;
+    }
+
+}}}  // namespace facter::facts::solaris

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

@@ -0,0 +1,105 @@
+#include <internal/facts/solaris/processor_resolver.hpp>
+#include <internal/util/solaris/k_stat.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <leatherman/execution/execution.hpp>
+#include <leatherman/util/regex.hpp>
+#include <unordered_set>
+#include <sys/processor.h>
+
+using namespace std;
+using namespace facter::util::solaris;
+using namespace leatherman::util;
+using namespace leatherman::execution;
+
+/*
+ * https://blogs.oracle.com/mandalika/entry/solaris_show_me_the_cpu
+ * What we want to do is to count the distinct number of chip_id (#nproc),
+ * then the distinct number of core_id (#ncores) and the number of instances
+ * of hardware threads (given by valid procid).
+ *
+ * Our info comes from the following structure
+ *
+ $ kstat -m cpu_info
+   module: cpu_info                        instance: 0
+   name:   cpu_info0                       class:    misc
+           brand                           Intel(r) Core(tm) i7-4850HQ CPU @ 2.30GHz
+           cache_id                        0
+           chip_id                         0
+           clock_MHz                       2300
+           clog_id                         0
+           core_id                         0
+           cpu_type                        i386
+           crtime                          6.654772184
+           current_clock_Hz                2294715939
+           current_cstate                  0
+           family                          6
+           fpu_type                        i387 compatible
+           implementation                  x86 (chipid 0x0 GenuineIntel family 6 model 70 step 1 clock 2300 MHz)
+           model                           70
+           ncore_per_chip                  1
+           ncpu_per_chip                   1
+           pg_id                           -1
+           pkg_core_id                     0
+           snaptime                        22631.883297199
+           state                           on-line
+           state_begin                     1409334365
+           stepping                        1
+           supported_frequencies_Hz        2294715939
+           supported_max_cstates           1
+           vendor_id                       GenuineIntel
+ */
+
+namespace facter { namespace facts { namespace solaris {
+
+    processor_resolver::data processor_resolver::collect_data(collection& facts)
+    {
+        auto result = posix::processor_resolver::collect_data(facts);
+
+        try {
+            unordered_set<int> chips;
+            k_stat kc;
+            auto kv = kc["cpu_info"];
+            for (auto const& ke : kv) {
+                try {
+                    ++result.logical_count;
+                    result.models.emplace_back(ke.value<string>("brand"));
+                    chips.insert(ke.value<int32_t>("chip_id"));
+
+                    // Get the speed of the first processor
+                    if (result.speed == 0) {
+                        result.speed = static_cast<int64_t>(ke.value<uint64_t>("current_clock_Hz"));
+                    }
+                } catch (kstat_exception& ex) {
+                    LOG_DEBUG("failed to read processor data entry: {1}.", ex.what());
+                }
+            }
+            result.physical_count = chips.size();
+        } catch (kstat_exception& ex) {
+            LOG_DEBUG("failed to read processor data from kstat api: {1}.", ex.what());
+
+            unordered_set<int> chips;
+            string brand;
+            int32_t chip_id;
+            int64_t current_clock_hz;
+
+            static boost::regex brand_rx("^\\s*brand\\s+(.+)$");
+            static boost::regex chip_id_rx("^\\s*chip_id\\s+(\\d+)$");
+            static boost::regex current_clock_hz_rx("^\\s*current_clock_Hz\\s+(\\d+)$");
+
+            each_line("/usr/bin/kstat", {"cpu_info"}, [&] (string& line) {
+                if (re_search(line, brand_rx, &brand)) {
+                    result.models.emplace_back(move(brand));
+                } else if (re_search(line, chip_id_rx, &chip_id)) {
+                    ++result.logical_count;
+                    chips.insert(chip_id);
+                } else if (result.speed == 0 && re_search(line, current_clock_hz_rx, &current_clock_hz)) {
+                    result.speed = current_clock_hz;
+                }
+                return true;
+            });
+            result.physical_count = chips.size();
+        }
+
+        return result;
+    }
+}}}  // namespace facter::facts::solaris

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

@@ -0,0 +1,38 @@
+#include <internal/facts/solaris/virtualization_resolver.hpp>
+#include <facter/facts/vm.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <facter/facts/collection.hpp>
+#include <facter/facts/fact.hpp>
+#include <leatherman/execution/execution.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <boost/algorithm/string.hpp>
+#include <map>
+
+using namespace std;
+using namespace facter::facts;
+using namespace leatherman::execution;
+
+namespace facter { namespace facts { namespace solaris {
+
+    string virtualization_resolver::get_hypervisor(collection& facts)
+    {
+        // If in an LDom, the LDom facts will resolve and we can use them to identify
+        // that we're in a virtual LDom environment. They should only resolve on SPARC.
+        auto ldom_domainrole_control = facts.get<string_value>("ldom_domainrole_control");
+        if (ldom_domainrole_control && ldom_domainrole_control->value() == "false") {
+            auto ldom_domainrole_impl = facts.get<string_value>("ldom_domainrole_impl");
+            if (ldom_domainrole_impl) {
+                return ldom_domainrole_impl->value();
+            }
+        }
+
+        // works for both x86 & sparc.
+        auto exec = execute("/usr/bin/zonename");
+        if (exec.success && exec.output != "global") {
+            return vm::zone;
+        }
+
+        // Look for hypervisor matches based on other facts
+        return get_fact_vm(facts);
+    }
+}}}  // namespace facter::facts::solaris

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

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

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

@@ -0,0 +1,33 @@
+#include <internal/facts/solaris/zone_resolver.hpp>
+#include <facter/facts/collection.hpp>
+#include <leatherman/execution/execution.hpp>
+#include <leatherman/util/regex.hpp>
+#include <boost/algorithm/string.hpp>
+
+using namespace std;
+using namespace facter::facts;
+using namespace leatherman::util;
+using namespace leatherman::execution;
+
+namespace facter { namespace facts { namespace solaris {
+
+    zone_resolver::data zone_resolver::collect_data(collection& facts)
+    {
+        data result;
+        auto exec = execute("/bin/zonename");
+        if (exec.success) {
+          result.current_zone_name = exec.output;
+        }
+
+        static boost::regex zone_pattern("(\\d+|-):([^:]*):([^:]*):([^:]*):([^:]*):([^:]*):([^:]*)");
+
+        each_line("/usr/sbin/zoneadm", {"list", "-cp"}, [&](string& line) {
+            zone z;
+            if (re_search(line, zone_pattern, &z.id, &z.name, &z.status, &z.path, &z.uuid, &z.brand, &z.ip_type)) {
+                result.zones.emplace_back(move(z));
+            }
+            return true;
+        });
+        return result;
+    }
+}}}  // namespace facter::facts::solaris

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

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

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

@@ -0,0 +1,11 @@
+#include <internal/facts/cache.hpp>
+#include <leatherman/windows/file_util.hpp>
+
+namespace facter { namespace facts { namespace cache {
+
+    std::string fact_cache_location() {
+        return leatherman::windows::file_util::get_programdata_dir() +
+            "\\PuppetLabs\\facter\\cache\\cached_facts\\";
+    }
+
+}}}  // namespace facter::facts::cache

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

@@ -0,0 +1,91 @@
+#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 <internal/facts/external/windows/powershell_resolver.hpp>
+#include <internal/facts/windows/dmi_resolver.hpp>
+#include <internal/facts/windows/identity_resolver.hpp>
+#include <internal/facts/windows/kernel_resolver.hpp>
+#include <internal/facts/windows/memory_resolver.hpp>
+#include <internal/facts/windows/networking_resolver.hpp>
+#include <internal/facts/windows/operating_system_resolver.hpp>
+#include <internal/facts/windows/processor_resolver.hpp>
+#include <internal/facts/windows/timezone_resolver.hpp>
+#include <internal/facts/windows/uptime_resolver.hpp>
+#include <internal/facts/windows/virtualization_resolver.hpp>
+#include <leatherman/util/environment.hpp>
+#include <leatherman/windows/file_util.hpp>
+#include <leatherman/windows/system_error.hpp>
+#include <leatherman/windows/user.hpp>
+#include <leatherman/windows/windows.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <boost/filesystem.hpp>
+#include <Shlobj.h>
+
+using namespace std;
+using namespace leatherman::windows;
+using namespace leatherman::util;
+using namespace facter::facts::external;
+using namespace boost::filesystem;
+
+namespace facter { namespace facts {
+
+    vector<string> collection::get_external_fact_directories() const
+    {
+        if (user::is_admin()) {
+            // Get the common data path
+            try {
+                path p = file_util::get_programdata_dir() / "PuppetLabs" / "facter" / "facts.d";
+                return {p.string()};
+            } catch (file_util::unknown_folder_exception &e) {
+                LOG_WARNING("external facts unavailable, %1%", e.what());
+            }
+        } else {
+            auto home = user::home_dir();
+            if (!home.empty()) {
+                path p1 = path(home) / ".puppetlabs" / "opt" / "facter" / "facts.d";
+                path p2 = path(home) / ".facter" / "facts.d";
+                return {p1.string(), p2.string()};
+            }
+
+            LOG_DEBUG("HOME environment variable not set, external facts unavailable");
+        }
+
+        return {};
+    }
+
+    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 is a catch-all for Windows executable types: .bat, .cmd, .com, .exe
+        resolvers.emplace_back(new execution_resolver());
+        resolvers.emplace_back(new powershell_resolver());
+        return resolvers;
+    }
+
+    void collection::add_platform_facts()
+    {
+        add(make_shared<windows::identity_resolver>());
+        add(make_shared<windows::kernel_resolver>());
+        add(make_shared<windows::memory_resolver>());
+        add(make_shared<windows::networking_resolver>());
+        add(make_shared<windows::timezone_resolver>());
+        add(make_shared<windows::uptime_resolver>());
+
+        try {
+            shared_ptr<wmi> shared_wmi = make_shared<wmi>();
+            add(make_shared<windows::dmi_resolver>(shared_wmi));
+            add(make_shared<windows::operating_system_resolver>(shared_wmi));
+            add(make_shared<windows::processor_resolver>(shared_wmi));
+            add(make_shared<windows::virtualization_resolver>(shared_wmi));
+        } catch (wmi_exception &e) {
+            LOG_ERROR("failed adding platform facts that require WMI: {1}", e.what());
+        }
+    }
+
+}}  // namespace facter::facts

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

@@ -0,0 +1,38 @@
+#include <internal/facts/windows/dmi_resolver.hpp>
+#include <leatherman/windows/wmi.hpp>
+#include <leatherman/logging/logging.hpp>
+
+using namespace std;
+using namespace leatherman::windows;
+
+namespace facter { namespace facts { namespace windows {
+
+    dmi_resolver::dmi_resolver(shared_ptr<wmi> wmi_conn) :
+        resolvers::dmi_resolver(),
+        _wmi(move(wmi_conn))
+    {
+    }
+
+    dmi_resolver::data dmi_resolver::collect_data(collection& facts)
+    {
+        data result;
+
+        auto vals = _wmi->query(wmi::computersystemproduct, {wmi::name});
+        if (vals.empty()) {
+            LOG_DEBUG("WMI query returned no results for {1} with value {2}.", wmi::computersystemproduct, wmi::name);
+        } else {
+            result.product_name = wmi::get(vals, wmi::name);
+        }
+
+        vals = _wmi->query(wmi::bios, {wmi::manufacturer, wmi::serialnumber});
+        if (vals.empty()) {
+            LOG_DEBUG("WMI query returned no results for {1} with values {2} and {3}.", wmi::bios, wmi::serialnumber, wmi::manufacturer);
+        } else {
+            result.serial_number = wmi::get(vals, wmi::serialnumber);
+            result.manufacturer = wmi::get(vals, wmi::manufacturer);
+        }
+
+        return result;
+    }
+
+}}}  // namespace facter::facts::windows

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

@@ -0,0 +1,46 @@
+#include <internal/facts/windows/identity_resolver.hpp>
+#include <leatherman/windows/system_error.hpp>
+#include <leatherman/windows/user.hpp>
+#include <leatherman/windows/windows.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <boost/nowide/convert.hpp>
+#include <security.h>
+
+using namespace std;
+using namespace leatherman::windows;
+
+namespace facter { namespace facts { namespace windows {
+
+    identity_resolver::data identity_resolver::collect_data(collection& facts)
+    {
+        data result;
+
+        // Groups are a lot more flexible on Windows than Linux. We only support
+        // identifying the user right now.
+        ULONG size = 0ul;
+        auto nameformat = NameSamCompatible;
+        GetUserNameExW(nameformat, nullptr, &size);
+        if (GetLastError() != ERROR_MORE_DATA) {
+            LOG_DEBUG("failure resolving identity facts: {1}", leatherman::windows::system_error());
+            return result;
+        }
+
+        // Use the string as a raw buffer that supports move and ref operations.
+        wstring buffer(size, '\0');
+        if (!GetUserNameExW(nameformat, &buffer[0], &size)) {
+            LOG_DEBUG("failure resolving identity facts: {1}", leatherman::windows::system_error());
+            return result;
+        }
+
+        // Resize the buffer to the returned string size.
+        buffer.resize(size);
+        result.user_name = boost::nowide::narrow(buffer);
+
+        // Check whether this thread is running with elevated privileges
+        // (or with the privileges of the local Administrators group on
+        // older versions of Windows not supporting privileges elevation).
+        result.privileged = user::is_admin();
+
+        return result;
+    }
+}}}  // facter::facts::windows