cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,276 @@
+#include <internal/facts/resolvers/operating_system_resolver.hpp>
+#include <internal/util/versions.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <facter/facts/map_value.hpp>
+#include <facter/facts/collection.hpp>
+#include <facter/facts/fact.hpp>
+#include <facter/facts/os.hpp>
+#include <leatherman/util/regex.hpp>
+
+using namespace std;
+using namespace facter::util;
+using namespace leatherman::util;
+
+namespace facter { namespace facts { namespace resolvers {
+
+    operating_system_resolver::operating_system_resolver() :
+        resolver(
+            "operating system",
+            {
+                fact::os,
+                fact::operating_system,
+                fact::os_family,
+                fact::operating_system_release,
+                fact::operating_system_major_release,
+                fact::hardware_model,
+                fact::architecture,
+                fact::lsb_dist_id,
+                fact::lsb_dist_release,
+                fact::lsb_dist_codename,
+                fact::lsb_dist_description,
+                fact::lsb_dist_major_release,
+                fact::lsb_dist_minor_release,
+                fact::lsb_release,
+                fact::macosx_buildversion,
+                fact::macosx_productname,
+                fact::macosx_productversion,
+                fact::macosx_productversion_major,
+                fact::macosx_productversion_minor,
+                fact::windows_system32,
+                fact::selinux,
+                fact::selinux_enforced,
+                fact::selinux_policyversion,
+                fact::selinux_current_mode,
+                fact::selinux_config_mode,
+                fact::selinux_config_policy,
+            })
+    {
+    }
+
+    void operating_system_resolver::resolve(collection& facts)
+    {
+        auto data = collect_data(facts);
+
+        auto os = make_value<map_value>();
+        if (!data.family.empty()) {
+            facts.add(fact::os_family, make_value<string_value>(data.family, true));
+            os->add("family", make_value<string_value>(move(data.family)));
+        }
+
+        if (!data.release.empty()) {
+            auto value = make_value<map_value>();
+
+            // When we have no major or minor, do a 'trivial' parse of
+            // the release to try to get SOMETHING out of it.
+            if (data.minor.empty() && data.major.empty()) {
+                 std::tie(data.major, data.minor) = versions::major_minor(data.release);
+            }
+
+            if (!data.major.empty()) {
+                facts.add(fact::operating_system_major_release, make_value<string_value>(data.major, true));
+                value->add("major", make_value<string_value>(move(data.major)));
+            }
+            if (!data.minor.empty()) {
+                value->add("minor", make_value<string_value>(move(data.minor)));
+            }
+
+            facts.add(fact::operating_system_release, make_value<string_value>(data.release, true));
+            value->add("full", make_value<string_value>(move(data.release)));
+
+            os->add("release", move(value));
+        }
+
+        // Add the OS hardware and architecture facts
+        if (!data.hardware.empty()) {
+            facts.add(fact::hardware_model, make_value<string_value>(data.hardware, true));
+            os->add("hardware", make_value<string_value>(move(data.hardware)));
+        }
+        if (!data.architecture.empty()) {
+            facts.add(fact::architecture, make_value<string_value>(data.architecture, true));
+            os->add("architecture", make_value<string_value>(move(data.architecture)));
+        }
+
+        // Add distro facts
+        auto distro = make_value<map_value>();
+        if (!data.distro.id.empty()) {
+            facts.add(fact::lsb_dist_id, make_value<string_value>(data.distro.id, true));
+            distro->add("id", make_value<string_value>(move(data.distro.id)));
+        }
+        if (!data.distro.codename.empty()) {
+            facts.add(fact::lsb_dist_codename, make_value<string_value>(data.distro.codename, true));
+            distro->add("codename", make_value<string_value>(move(data.distro.codename)));
+        }
+        if (!data.distro.description.empty()) {
+            facts.add(fact::lsb_dist_description, make_value<string_value>(data.distro.description, true));
+            distro->add("description", make_value<string_value>(move(data.distro.description)));
+        }
+        if (!data.distro.release.empty()) {
+            auto value = make_value<map_value>();
+
+            string major, minor;
+            tie(major, minor) = parse_distro(data.name, data.distro.release);
+
+            if (major.empty()) {
+                major = data.distro.release;
+            }
+            facts.add(fact::lsb_dist_major_release, make_value<string_value>(major, true));
+            value->add("major", make_value<string_value>(move(major)));
+
+            if (!minor.empty()) {
+                facts.add(fact::lsb_dist_minor_release, make_value<string_value>(minor, true));
+                value->add("minor", make_value<string_value>(move(minor)));
+            }
+
+            facts.add(fact::lsb_dist_release, make_value<string_value>(data.distro.release, true));
+            value->add("full", make_value<string_value>(move(data.distro.release)));
+            distro->add("release", move(value));
+        }
+        if (!data.specification_version.empty()) {
+            facts.add(fact::lsb_release, make_value<string_value>(data.specification_version, true));
+            distro->add("specification", make_value<string_value>(move(data.specification_version)));
+        }
+
+        // Add the name last since the above release parsing is dependent on it
+        if (!data.name.empty()) {
+            facts.add(fact::operating_system, make_value<string_value>(data.name, true));
+            os->add("name", make_value<string_value>(move(data.name)));
+        }
+
+        if (!distro->empty()) {
+             os->add("distro", move(distro));
+        }
+
+        // Populate OSX-specific data
+        auto macosx = make_value<map_value>();
+        if (!data.osx.product.empty()) {
+            facts.add(fact::macosx_productname, make_value<string_value>(data.osx.product, true));
+            macosx->add("product", make_value<string_value>(move(data.osx.product)));
+        }
+        if (!data.osx.build.empty()) {
+            facts.add(fact::macosx_buildversion, make_value<string_value>(data.osx.build, true));
+            macosx->add("build", make_value<string_value>(move(data.osx.build)));
+        }
+
+        if (!data.osx.version.empty()) {
+            // Look for the last '.' for major/minor
+            auto version = make_value<map_value>();
+            auto pos = data.osx.version.rfind('.');
+            if (pos != string::npos) {
+                string major = data.osx.version.substr(0, pos);
+                string minor = data.osx.version.substr(pos + 1);
+
+                // If the major doesn't have a '.', treat the entire version as the major
+                // and use a minor of "0"
+                if (major.find('.') == string::npos) {
+                    major = data.osx.version;
+                    minor = "0";
+                }
+
+                if (!major.empty()) {
+                    facts.add(fact::macosx_productversion_major, make_value<string_value>(major, true));
+                    version->add("major", make_value<string_value>(move(major)));
+                }
+                if (!minor.empty()) {
+                    facts.add(fact::macosx_productversion_minor, make_value<string_value>(minor, true));
+                    version->add("minor", make_value<string_value>(move(minor)));
+                }
+            }
+            facts.add(fact::macosx_productversion, make_value<string_value>(data.osx.version, true));
+            version->add("full", make_value<string_value>(move(data.osx.version)));
+            macosx->add("version", move(version));
+        }
+
+        if (!macosx->empty()) {
+            os->add("macosx", move(macosx));
+        }
+
+        // Populate Windows-specific data
+        auto windows = make_value<map_value>();
+        if (!data.win.system32.empty()) {
+            facts.add(fact::windows_system32, make_value<string_value>(data.win.system32, true));
+            windows->add("system32", make_value<string_value>(move(data.win.system32)));
+        }
+
+        if (!windows->empty()) {
+            os->add("windows", move(windows));
+        }
+
+        if (data.selinux.supported) {
+            auto selinux = make_value<map_value>();
+            facts.add(fact::selinux, make_value<boolean_value>(data.selinux.enabled, true));
+            selinux->add("enabled", make_value<boolean_value>(data.selinux.enabled));
+            if (data.selinux.enabled) {
+                facts.add(fact::selinux_enforced, make_value<boolean_value>(data.selinux.enforced, true));
+                selinux->add("enforced", make_value<boolean_value>(data.selinux.enforced));
+                if (!data.selinux.current_mode.empty()) {
+                    facts.add(fact::selinux_current_mode, make_value<string_value>(data.selinux.current_mode, true));
+                    selinux->add("current_mode", make_value<string_value>(move(data.selinux.current_mode)));
+                }
+                if (!data.selinux.config_mode.empty()) {
+                    facts.add(fact::selinux_config_mode, make_value<string_value>(data.selinux.config_mode, true));
+                    selinux->add("config_mode", make_value<string_value>(move(data.selinux.config_mode)));
+                }
+                if (!data.selinux.config_policy.empty()) {
+                    facts.add(fact::selinux_config_policy, make_value<string_value>(data.selinux.config_policy, true));
+                    selinux->add("config_policy", make_value<string_value>(move(data.selinux.config_policy)));
+                }
+                if (!data.selinux.policy_version.empty()) {
+                    facts.add(fact::selinux_policyversion, make_value<string_value>(data.selinux.policy_version, true));
+                    selinux->add("policy_version", make_value<string_value>(move(data.selinux.policy_version)));
+                }
+            }
+            os->add("selinux", move(selinux));
+        }
+
+        if (!os->empty()) {
+            facts.add(fact::os, move(os));
+        }
+    }
+
+    operating_system_resolver::data operating_system_resolver::collect_data(collection& facts)
+    {
+        data result;
+
+        collect_kernel_data(facts, result);
+        collect_release_data(facts, result);
+
+        return result;
+    }
+
+    void operating_system_resolver::collect_kernel_data(collection& facts, data& result)
+    {
+        auto kernel = facts.get<string_value>(fact::kernel);
+        if (kernel) {
+            result.name = kernel->value();
+            result.family = kernel->value();
+        }
+    }
+
+    void operating_system_resolver::collect_release_data(collection& facts, data& result)
+    {
+        auto release = facts.get<string_value>(fact::kernel_release);
+        if (release) {
+            result.release = release->value();
+        }
+    }
+
+    tuple<string, string> operating_system_resolver::parse_distro(string const& name, string const& release)
+    {
+        // This implementation couples all known formats for lsb_dist and the Linux release versions. If that
+        // coupling becomes a problem, we'll probably need to push parsing distro major/minor to inheriting resolvers,
+        // as we've done for parsing the release version.
+        if (name != os::ubuntu) {
+            auto pos = release.find('.');
+            if (pos != string::npos) {
+                auto second = release.find('.', pos + 1);
+                return make_tuple(release.substr(0, pos), release.substr(pos + 1, second - (pos + 1)));
+            }
+            return make_tuple(release, string());
+        }
+
+        string major, minor;
+        re_search(release, boost::regex("(\\d+\\.\\d*)\\.?(\\d*)"), &major, &minor);
+        return make_tuple(move(major), move(minor));
+    }
+
+}}}  // namespace facter::facts::resolvers

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

@@ -0,0 +1,25 @@
+#include <internal/facts/resolvers/path_resolver.hpp>
+#include <facter/facts/collection.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <facter/facts/fact.hpp>
+#include <leatherman/util/environment.hpp>
+
+using namespace std;
+using namespace leatherman::util;
+
+namespace facter { namespace facts { namespace resolvers {
+
+    path_resolver::path_resolver() :
+        resolver("path", {fact::path})
+    {
+    }
+
+    void path_resolver::resolve(collection& facts)
+    {
+        string path_val;
+        if (environment::get("PATH", path_val)) {
+            facts.add(fact::path, make_value<string_value>(move(path_val)));
+        }
+    }
+
+}}}  // namespace facter::facts::resolvers

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

@@ -0,0 +1,70 @@
+#include <internal/facts/resolvers/processor_resolver.hpp>
+#include <facter/facts/collection.hpp>
+#include <facter/facts/fact.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <facter/facts/map_value.hpp>
+#include <facter/facts/array_value.hpp>
+#include <facter/util/string.hpp>
+
+using namespace std;
+using namespace facter::util;
+
+namespace facter { namespace facts { namespace resolvers {
+
+    processor_resolver::processor_resolver() :
+        resolver(
+            "processor",
+            {
+                fact::processors,
+                fact::processor_count,
+                fact::physical_processor_count,
+                fact::hardware_isa,
+            },
+            {
+                string("^") + fact::processor + "[0-9]+$",
+            })
+    {
+    }
+
+    void processor_resolver::resolve(collection& facts)
+    {
+        auto data = collect_data(facts);
+
+        auto cpus = make_value<map_value>();
+
+        if (!data.isa.empty()) {
+            facts.add(fact::hardware_isa, make_value<string_value>(data.isa, true));
+            cpus->add("isa", make_value<string_value>(move(data.isa)));
+        }
+
+        if (data.logical_count > 0) {
+            facts.add(fact::processor_count, make_value<integer_value>(data.logical_count, true));
+            cpus->add("count", make_value<integer_value>(data.logical_count));
+        }
+
+        if (data.physical_count > 0) {
+            facts.add(fact::physical_processor_count, make_value<integer_value>(data.physical_count, true));
+            cpus->add("physicalcount", make_value<integer_value>(data.physical_count));
+        }
+
+        if (data.speed > 0) {
+            cpus->add("speed", make_value<string_value>(frequency(data.speed)));
+        }
+
+        auto models = make_value<array_value>();
+        int processor = 0;
+        for (auto& model : data.models) {
+            facts.add(fact::processor + to_string(processor++), make_value<string_value>(model, true));
+            models->add(make_value<string_value>(move(model)));
+        }
+
+        if (!models->empty()) {
+            cpus->add("models", move(models));
+        }
+
+        if (!cpus->empty()) {
+            facts.add(fact::processors, move(cpus));
+        }
+    }
+
+}}}  // namespace facter::facts::resolvers

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

@@ -0,0 +1,109 @@
+#include <internal/facts/resolvers/ruby_resolver.hpp>
+#include <facter/facts/collection.hpp>
+#include <facter/facts/fact.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <facter/facts/map_value.hpp>
+#include <leatherman/ruby/api.hpp>
+#include <leatherman/logging/logging.hpp>
+
+using namespace std;
+using namespace leatherman::ruby;
+
+namespace facter { namespace facts { namespace resolvers {
+
+    ruby_resolver::ruby_resolver() :
+        resolver(
+            "ruby",
+            {
+                fact::ruby,
+                fact::rubyplatform,
+                fact::rubysitedir,
+                fact::rubyversion
+            })
+    {
+    }
+
+    static void ruby_fact_rescue(api const& rb, function<VALUE()> cb, string const& label)
+    {
+        // Use rescue, because Ruby exceptions don't call destructors. The callback cb shouldn't
+        // have any object construction/destruction in it.
+        rb.rescue(cb, [&](VALUE ex) {
+            LOG_ERROR("error while resolving ruby {1} fact: {2}", label, rb.exception_to_string(ex));
+            return 0;
+        });
+    }
+
+    static string get_platform(api const& rb)
+    {
+        string platform;
+        ruby_fact_rescue(rb, [&]() {
+            auto val = rb.lookup({"RUBY_PLATFORM"});
+            platform = rb.to_string(val);
+            return 0;
+        }, "platform");
+        return platform;
+    }
+
+    static string get_sitedir(api const& rb)
+    {
+        string sitedir;
+        ruby_fact_rescue(rb, [&]() {
+            rb.rb_require("rbconfig");
+            auto config = rb.lookup({"RbConfig", "CONFIG"});
+            auto val = rb.rb_hash_lookup(config, rb.utf8_value("sitelibdir"));
+            sitedir = rb.to_string(val);
+            return 0;
+        }, "sitedir");
+        return sitedir;
+    }
+
+    static string get_version(api const& rb)
+    {
+        string version;
+        ruby_fact_rescue(rb, [&]() {
+            auto val = rb.lookup({"RUBY_VERSION"});
+            version = rb.to_string(val);
+            return 0;
+        }, "version");
+        return version;
+    }
+
+    static void add(collection& f, map_value& d, string s, string hidden, string nested)
+    {
+        if (!s.empty()) {
+            f.add(move(hidden), make_value<string_value>(s, true));
+            d.add(move(nested), make_value<string_value>(move(s)));
+        }
+    }
+
+    ruby_resolver::data ruby_resolver::collect_data(collection& facts)
+    {
+        data rb_data;
+
+        auto const& ruby = api::instance();
+        if (!ruby.initialized()) {
+            return rb_data;
+        }
+
+        rb_data.platform = get_platform(ruby);
+        rb_data.sitedir = get_sitedir(ruby);
+        rb_data.version = get_version(ruby);
+
+        return rb_data;
+    }
+
+    void ruby_resolver::resolve(collection& facts)
+    {
+        auto rb_data = collect_data(facts);
+
+        auto rb_map = make_value<map_value>();
+        add(facts, *rb_map, move(rb_data.platform), fact::rubyplatform, "platform");
+        add(facts, *rb_map, move(rb_data.sitedir), fact::rubysitedir, "sitedir");
+        add(facts, *rb_map, move(rb_data.version), fact::rubyversion, "version");
+
+        if (!rb_map->empty()) {
+            facts.add(fact::ruby, move(rb_map));
+        }
+    }
+
+}}}  // namespace facter::facts::resolvers