cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,63 @@
+#include <internal/facts/resolvers/zfs_resolver.hpp>
+#include <facter/facts/fact.hpp>
+#include <facter/facts/collection.hpp>
+#include <facter/facts/scalar_value.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::execution;
+using namespace leatherman::util;
+
+namespace facter { namespace facts { namespace resolvers {
+
+    zfs_resolver::zfs_resolver() :
+        resolver(
+            "ZFS",
+            {
+                fact::zfs_version,
+                fact::zfs_versionnumbers
+            })
+    {
+    }
+
+    void zfs_resolver::resolve(collection& facts)
+    {
+        auto data = collect_data(facts);
+
+        if (!data.version.empty()) {
+            facts.add(fact::zfs_version, make_value<string_value>(move(data.version)));
+        }
+        if (!data.versions.empty()) {
+            facts.add(fact::zfs_versionnumbers, make_value<string_value>(boost::join(data.versions, ",")));
+        }
+    }
+
+    zfs_resolver::data zfs_resolver::collect_data(collection& facts)
+    {
+        data result;
+
+        // Get the ZFS version
+        static boost::regex zfs_version("currently running ZFS filesystem version (\\d+)[.]");
+        each_line(zfs_command(), {"upgrade"}, [&] (string& line) {
+            if (re_search(line, zfs_version, &result.version)) {
+                return false;
+            }
+            return true;
+        });
+
+        // Get the ZFS versions
+        static boost::regex zfs_supported_version("^\\s*(\\d+)[ ]");
+        each_line(zfs_command(), {"upgrade", "-v"}, [&] (string& line) {
+            string version;
+            if (re_search(line, zfs_supported_version, &version)) {
+                result.versions.emplace_back(move(version));
+            }
+            return true;
+        });
+        return result;
+    }
+
+}}}  // namespace facter::facts::resolvers

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

@@ -0,0 +1,91 @@
+#include <internal/facts/resolvers/zone_resolver.hpp>
+#include <facter/facts/collection.hpp>
+#include <facter/facts/fact.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <facter/facts/array_value.hpp>
+#include <facter/facts/map_value.hpp>
+
+using namespace std;
+using namespace facter::facts;
+
+namespace facter { namespace facts { namespace resolvers {
+
+    zone_resolver::zone_resolver() :
+        resolver(
+            "Solaris zone",
+            {
+                fact::zones,
+                fact::zonename,
+                fact::solaris_zones,
+            },
+            {
+                string("^zone_.+_") + fact::zone_id + "$",
+                string("^zone_.+_") + fact::zone_name + "$",
+                string("^zone_.+_") + fact::zone_status + "$",
+                string("^zone_.+_") + fact::zone_path + "$",
+                string("^zone_.+_") + fact::zone_uuid + "$",
+                string("^zone_.+_") + fact::zone_brand + "$",
+                string("^zone_.+_") + fact::zone_iptype + "$"
+            }
+        )
+    {
+    }
+
+    void zone_resolver::resolve(collection& facts)
+    {
+        auto data = collect_data(facts);
+
+        auto zones = make_value<map_value>();
+        for (auto& zone : data.zones) {
+            auto value = make_value<map_value>();
+
+            if (!zone.id.empty()) {
+                facts.add(string("zone_") + zone.name + "_" + fact::zone_id, make_value<string_value>(zone.id, true));
+                value->add("id", make_value<string_value>(move(zone.id)));
+            }
+            if (!zone.name.empty()) {
+                facts.add(string("zone_") + zone.name + "_" + fact::zone_name, make_value<string_value>(zone.name, true));
+            }
+            if (!zone.status.empty()) {
+                facts.add(string("zone_") + zone.name + "_" + fact::zone_status, make_value<string_value>(zone.status, true));
+                value->add("status", make_value<string_value>(move(zone.status)));
+            }
+            if (!zone.path.empty()) {
+                facts.add(string("zone_") + zone.name + "_" + fact::zone_path, make_value<string_value>(zone.path, true));
+                value->add("path", make_value<string_value>(move(zone.path)));
+            }
+            if (!zone.uuid.empty()) {
+                facts.add(string("zone_") + zone.name + "_" + fact::zone_uuid, make_value<string_value>(zone.uuid, true));
+                value->add("uuid", make_value<string_value>(move(zone.uuid)));
+            }
+            if (!zone.brand.empty()) {
+                facts.add(string("zone_") + zone.name + "_" + fact::zone_brand, make_value<string_value>(zone.brand, true));
+                value->add("brand", make_value<string_value>(move(zone.brand)));
+            }
+            if (!zone.ip_type.empty()) {
+                facts.add(string("zone_") + zone.name + "_" + fact::zone_iptype, make_value<string_value>(zone.ip_type, true));
+                value->add("ip_type", make_value<string_value>(move(zone.ip_type)));
+            }
+
+            zones->add(move(zone.name), move(value));
+        }
+
+        facts.add(fact::zones, make_value<integer_value>(zones->size(), true));
+
+        if (zones->size() > 0) {
+            auto solaris_zones = make_value<map_value>();
+
+            if (!data.current_zone_name.empty()) {
+                solaris_zones->add("current", make_value<string_value>(data.current_zone_name));
+            }
+
+            solaris_zones->add("zones", move(zones));
+            facts.add(fact::solaris_zones, move(solaris_zones));
+        }
+
+        if (!data.current_zone_name.empty()) {
+            facts.add(fact::zonename, make_value<string_value>(move(data.current_zone_name), true));
+        }
+    }
+
+}}}  // namespace facter::facts::resolvers

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

@@ -0,0 +1,93 @@
+#include <internal/facts/resolvers/zpool_resolver.hpp>
+#include <facter/facts/fact.hpp>
+#include <facter/facts/collection.hpp>
+#include <facter/facts/scalar_value.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::execution;
+using namespace leatherman::util;
+
+namespace facter { namespace facts { namespace resolvers {
+
+    zpool_resolver::zpool_resolver() :
+        resolver(
+            "ZFS storage pool",
+            {
+                fact::zpool_version,
+                fact::zpool_featureflags,
+                fact::zpool_versionnumbers,
+            })
+    {
+    }
+
+    void zpool_resolver::resolve(collection& facts)
+    {
+        auto data = collect_data(facts);
+
+        if (!data.version.empty()) {
+            facts.add(fact::zpool_version, make_value<string_value>(move(data.version)));
+        }
+        if (!data.feature_flags.empty()) {
+            facts.add(fact::zpool_featureflags, make_value<string_value>(boost::join(data.feature_flags, ",")));
+        }
+        if (!data.versions.empty()) {
+            facts.add(fact::zpool_versionnumbers, make_value<string_value>(boost::join(data.versions, ",")));
+        }
+    }
+
+    zpool_resolver::data zpool_resolver::collect_data(collection& facts)
+    {
+        data result;
+
+        enum { UNKNOWN, FEATURES, VERSIONS } state = UNKNOWN;
+
+        // Get the zpool version and features
+        static boost::regex zpool_version("^This system is currently running ZFS pool version (\\d+)\\.$");
+        static boost::regex zpool_feature_flags("^This system supports ZFS pool feature flags\\.$");
+
+        static boost::regex zpool_supported_feature_header("^The following features are supported:$");
+        static boost::regex zpool_supported_versions_header("^The following versions are supported:$");
+        static boost::regex zpool_supported_legacy_versions_header("^The following legacy versions are also supported:$");
+
+        static boost::regex zpool_supported_feature("^([[:alnum:]_]+)(\\s+\\(read-only compatible\\))?$");
+        static boost::regex zpool_supported_version("^\\s*(\\d+)[ ]");
+
+        string feature;
+        each_line(zpool_command(), {"upgrade", "-v"}, [&] (string& line) {
+            switch (state) {
+            case UNKNOWN:
+                if (re_search(line, zpool_version, &result.version)) {
+                } else if (re_search(line, zpool_feature_flags)) {
+                    result.version = "5000";
+                } else if (re_search(line, zpool_supported_feature_header)) {
+                    state = FEATURES;
+                } else if (re_search(line, zpool_supported_versions_header)) {
+                    state = VERSIONS;
+                }
+                break;
+
+            case FEATURES:
+                if (re_search(line, zpool_supported_feature, &feature)) {
+                    result.feature_flags.emplace_back(move(feature));
+                } else if (re_search(line, zpool_supported_legacy_versions_header)) {
+                    state = VERSIONS;
+                }
+                break;
+
+            case VERSIONS:
+                string feature;
+                if (re_search(line, zpool_supported_version, &feature)) {
+                    result.versions.emplace_back(move(feature));
+                }
+                break;
+            }
+            return true;
+        });
+        return result;
+    }
+
+}}}  // namespace facter::facts::resolvers

data/ext/facter/facter/lib/src/facts/scalar_value.cc

@@ -0,0 +1,73 @@
+#include <facter/facts/scalar_value.hpp>
+#include <facter/util/string.hpp>
+#include <rapidjson/document.h>
+#include <yaml-cpp/yaml.h>
+#include <iomanip>
+
+using namespace std;
+using namespace facter::util;
+using namespace rapidjson;
+using namespace YAML;
+
+namespace facter { namespace facts {
+
+    template <>
+    void scalar_value<string>::to_json(json_allocator& allocator, json_value& value) const
+    {
+        value.SetString(_value.c_str(), _value.size());
+    }
+
+    template <>
+    void scalar_value<int64_t>::to_json(json_allocator& allocator, json_value& value) const
+    {
+        value.SetInt64(_value);
+    }
+
+    template <>
+    void scalar_value<bool>::to_json(json_allocator& allocator, json_value& value) const
+    {
+        value.SetBool(_value);
+    }
+
+    template <>
+    void scalar_value<double>::to_json(json_allocator& allocator, json_value& value) const
+    {
+        value.SetDouble(_value);
+    }
+
+    template <>
+    Emitter& scalar_value<string>::write(Emitter& emitter) const
+    {
+        if (needs_quotation(_value)) {
+            emitter << DoubleQuoted;
+        }
+        emitter << _value;
+        return emitter;
+    }
+
+    template <>
+    ostream& scalar_value<bool>::write(ostream& os, bool quoted, unsigned int level) const
+    {
+        os << boolalpha << _value << noboolalpha;
+        return os;
+    }
+
+    template <>
+    ostream& scalar_value<string>::write(ostream& os, bool quoted, unsigned int level) const
+    {
+        if (quoted) {
+            os << '"';
+        }
+        os << _value;
+        if (quoted) {
+            os << '"';
+        }
+        return os;
+    }
+
+    template struct scalar_value<string>;
+    template struct scalar_value<int64_t>;
+    template struct scalar_value<bool>;
+    template struct scalar_value<double>;
+
+}}  // namespace facter::facts

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

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

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

@@ -0,0 +1,35 @@
+#include <internal/facts/solaris/disk_resolver.hpp>
+#include <internal/util/solaris/k_stat.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <boost/algorithm/string.hpp>
+
+using namespace std;
+using namespace facter::util::solaris;
+
+namespace facter { namespace facts { namespace solaris {
+
+    disk_resolver::data disk_resolver::collect_data(collection& facts)
+    {
+        try {
+            data result;
+            k_stat ks;
+            auto ke = ks["sderr"];
+            for (auto& kv : ke) {
+                disk d;
+                string name = kv.name();
+                d.name = name.substr(0, name.find(','));
+                d.product = kv.value<string>("Product");
+                boost::trim(d.product);
+                d.vendor = kv.value<string>("Vendor");
+                boost::trim(d.vendor);
+                d.size = static_cast<int64_t>(kv.value<uint64_t>("Size"));
+                result.disks.emplace_back(move(d));
+            }
+            return result;
+        } catch (kstat_exception& ex) {
+            LOG_DEBUG("disk information is unavailable: {1}.", ex.what());
+            return {};
+        }
+    }
+
+}}}  // namespace facter::facts::solaris

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

@@ -0,0 +1,86 @@
+#include <internal/facts/solaris/dmi_resolver.hpp>
+#include <facter/facts/collection.hpp>
+#include <facter/facts/fact.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <leatherman/execution/execution.hpp>
+#include <leatherman/util/regex.hpp>
+#include <boost/algorithm/string.hpp>
+
+using namespace std;
+using namespace leatherman::util;
+using namespace leatherman::execution;
+
+namespace facter { namespace facts { namespace solaris {
+
+    dmi_resolver::data dmi_resolver::collect_data(collection& facts)
+    {
+        data result;
+
+        auto isa = facts.get<string_value>(fact::hardware_isa);
+        if (isa && isa->value() == "i386") {
+            static boost::regex bios_vendor_re("Vendor: (.+)");
+            static boost::regex bios_version_re("Version String: (.+)");
+            static boost::regex bios_release_re("Release Date: (.+)");
+            each_line("/usr/sbin/smbios", {"-t", "SMB_TYPE_BIOS"}, [&](string& line) {
+                if (result.bios_vendor.empty()) {
+                    re_search(line, bios_vendor_re, &result.bios_vendor);
+                }
+                if (result.bios_version.empty()) {
+                    re_search(line, bios_version_re, &result.bios_version);
+                }
+                if (result.bios_release_date.empty()) {
+                    re_search(line, bios_release_re, &result.bios_release_date);
+                }
+                return result.bios_release_date.empty() || result.bios_vendor.empty() || result.bios_version.empty();
+            });
+
+            static boost::regex manufacturer_re("Manufacturer: (.+)");
+            static boost::regex uuid_re("UUID: (.+)");
+            static boost::regex serial_re("Serial Number: (.+)");
+            static boost::regex product_re("Product: (.+)");
+            each_line("/usr/sbin/smbios", {"-t", "SMB_TYPE_SYSTEM"}, [&](string& line) {
+                if (result.manufacturer.empty()) {
+                    re_search(line, manufacturer_re, &result.manufacturer);
+                }
+                if (result.product_name.empty()) {
+                    re_search(line, product_re, &result.product_name);
+                }
+                if (result.uuid.empty()) {
+                    re_search(line, uuid_re, &result.uuid);
+                }
+                if (result.serial_number.empty()) {
+                    re_search(line, serial_re, &result.serial_number);
+                }
+                return result.manufacturer.empty() || result.product_name.empty() || result.uuid.empty() || result.serial_number.empty();
+            });
+
+            static boost::regex chassis_type_re("(?:Chassis )?Type: (.+)");
+            static boost::regex chassis_asset_tag_re("Asset Tag: (.+)");
+            each_line("/usr/sbin/smbios", {"-t", "SMB_TYPE_CHASSIS"}, [&](string& line) {
+                if (result.chassis_type.empty()) {
+                    re_search(line, chassis_type_re, &result.chassis_type);
+                }
+                if (result.chassis_asset_tag.empty()) {
+                    re_search(line, chassis_asset_tag_re, &result.chassis_asset_tag);
+                }
+                return result.chassis_type.empty() || result.chassis_asset_tag.empty();
+            });
+        } else if (isa && isa->value() == "sparc") {
+            static boost::regex product_name_manufacturer_re("^System Configuration:\\s+(.+?)\\s+sun\\d+\\S+\\s+(.+)");
+            each_line("/usr/sbin/prtdiag", [&](string& line) {
+                re_search(line, product_name_manufacturer_re, &result.manufacturer, &result.product_name);
+                return result.manufacturer.empty() || result.product_name.empty();
+            });
+            // Manufacturer appears to have two spaces before and after it, but we don't want to rely on that formatting.
+            boost::trim(result.manufacturer);
+
+            auto exec = execute("/usr/sbin/sneep");
+            if (exec.success) {
+                result.serial_number = exec.output;
+            }
+        }
+        return result;
+    }
+
+}}}  // namespace facter::facts::solaris