facter 3.11.6.cfacter.20181031 → 3.12.0.cfacter.20180918

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

@@ -309,8 +309,6 @@ namespace facter { namespace facts {
     {
         resolve_facts();
 
-        // We intentionally are using find_if with no return value as a "map until" construct.
-        // cppcheck-suppress ignoredReturnValue
         find_if(begin(_facts), end(_facts), [&func](map<string, unique_ptr<value>>::value_type const& it) {
             return !func(it.first, it.second.get());
         });

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

@@ -1,5 +1,5 @@
 #include <facter/facts/collection.hpp>
-#include <internal/facts/bsd/filesystem_resolver.hpp>
+#include <internal/facts/freebsd/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>
@@ -14,6 +14,7 @@
 #include <internal/facts/freebsd/zpool_resolver.hpp>
 #include <internal/facts/freebsd/virtualization_resolver.hpp>
 #include <internal/facts/freebsd/memory_resolver.hpp>
+#include <internal/facts/freebsd/disk_resolver.hpp>
 
 using namespace std;
 
@@ -25,7 +26,7 @@ namespace facter { namespace facts {
         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<freebsd::filesystem_resolver>());
         add(make_shared<posix::ssh_resolver>());
         add(make_shared<posix::identity_resolver>());
         add(make_shared<posix::timezone_resolver>());
@@ -36,6 +37,7 @@ namespace facter { namespace facts {
         add(make_shared<freebsd::zpool_resolver>());
         add(make_shared<freebsd::virtualization_resolver>());
         add(make_shared<freebsd::memory_resolver>());
+        add(make_shared<freebsd::disk_resolver>());
     }
 
 }}  // namespace facter::facts

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

@@ -0,0 +1,34 @@
+#include <internal/facts/freebsd/disk_resolver.hpp>
+#include <internal/util/freebsd/geom.hpp>
+#include <leatherman/logging/logging.hpp>
+
+#include <libgeom.h>
+
+using namespace std;
+
+namespace facter { namespace facts { namespace freebsd {
+
+    disk_resolver::data disk_resolver::collect_data(collection& facts)
+    {
+        data result;
+
+        try {
+            facter::util::freebsd::geom_class disks("DISK");
+
+            for (auto& geom : disks.geoms) {
+                for (auto& provider : geom.providers) {
+                    disk d;
+                    d.name = provider.name();
+                    d.size = provider.mediasize();
+                    d.model = provider.config("descr");
+                    result.disks.push_back(move(d));
+                }
+            }
+        } catch (util::freebsd::geom_exception const &e) {
+            LOG_ERROR(e.what());
+        }
+
+        return result;
+    }
+
+}}}  // namespace facter::facts::freebsd

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

@@ -0,0 +1,37 @@
+#include <internal/facts/freebsd/filesystem_resolver.hpp>
+#include <internal/util/freebsd/geom.hpp>
+#include <leatherman/logging/logging.hpp>
+
+#include <libgeom.h>
+
+using namespace std;
+
+namespace facter { namespace facts { namespace freebsd {
+
+    filesystem_resolver::data filesystem_resolver::collect_data(collection& facts)
+    {
+        data result = bsd::filesystem_resolver::collect_data(facts);
+
+        try {
+            facter::util::freebsd::geom_class disks("PART");
+
+            for (auto& geom : disks.geoms) {
+                for (auto& provider : geom.providers) {
+                    partition p;
+                    p.name = provider.name();
+                    p.size = provider.mediasize();
+                    if (geom.config("scheme") == "GPT") {
+                        p.partition_label = provider.config("label");
+                        p.partition_uuid = provider.config("rawuuid");
+                    }
+                    result.partitions.push_back(move(p));
+                }
+            }
+        } catch (util::freebsd::geom_exception const& e) {
+            LOG_ERROR(e.what());
+        }
+
+        return result;
+    }
+
+}}}  // namespace facter::facts::freebsd

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

@@ -84,8 +84,10 @@ namespace facter { namespace facts { namespace linux {
                 make_tuple(boost::regex("(?i)scientific linux CERN"),         string(os::scientific_cern)),
                 make_tuple(boost::regex("(?i)scientific linux release"),      string(os::scientific)),
                 make_tuple(boost::regex("(?im)^cloudlinux"),                  string(os::cloud_linux)),
+                make_tuple(boost::regex("(?im)^virtuozzo linux"),             string(os::virtuozzo_linux)),
                 make_tuple(boost::regex("(?i)Ascendos"),                      string(os::ascendos)),
                 make_tuple(boost::regex("(?im)^XenServer"),                   string(os::xen_server)),
+                make_tuple(boost::regex("(?im)^XCP-ng"),                      string(os::xcp_ng)),
                 make_tuple(boost::regex("XCP"),                               string(os::zen_cloud_platform)),
                 make_tuple(boost::regex("(?im)^Parallels Server Bare Metal"), string(os::psbm)),
                 make_tuple(boost::regex("(?m)^Fedora release"),               string(os::fedora)),
@@ -228,6 +230,7 @@ namespace facter { namespace facts { namespace linux {
             { string(os::oracle_enterprise_linux),  string(os_family::redhat) },
             { string(os::amazon),                   string(os_family::redhat) },
             { string(os::xen_server),               string(os_family::redhat) },
+            { string(os::xcp_ng),                   string(os_family::redhat) },
             { string(os::photon_os),                string(os_family::redhat) },
             { string(os::huawei),                   string(os_family::debian) },
             { string(os::linux_mint),               string(os_family::debian) },
@@ -265,6 +268,7 @@ namespace facter { namespace facts { namespace linux {
                 { string(os::cloud_linux),              string(release_file::redhat) },
                 { string(os::psbm),                     string(release_file::redhat) },
                 { string(os::xen_server),               string(release_file::redhat) },
+                { string(os::xcp_ng),                   string(release_file::redhat) },
                 { string(os::fedora),                   string(release_file::fedora) },
                 { string(os::meego),                    string(release_file::meego) },
                 { string(os::oracle_linux),             string(release_file::oracle_linux) },

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

@@ -17,12 +17,11 @@ namespace facter { namespace facts { namespace windows {
     {
         data result;
 
-        auto vals = _wmi->query(wmi::computersystemproduct, {wmi::name, wmi::uuid});
+        auto vals = _wmi->query(wmi::computersystemproduct, {wmi::name});
         if (vals.empty()) {
-            LOG_DEBUG("WMI query returned no results for {1} with values {2} and {3}.", wmi::computersystemproduct, wmi::name, wmi::uuid);
+            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);
-            result.uuid = wmi::get(vals, wmi::uuid);
         }
 
         vals = _wmi->query(wmi::bios, {wmi::manufacturer, wmi::serialnumber});

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

@@ -2,9 +2,7 @@
 #include <leatherman/windows/system_error.hpp>
 #include <leatherman/windows/wmi.hpp>
 #include <leatherman/windows/windows.hpp>
-#include <facter/facts/fact.hpp>
 #include <facter/facts/collection.hpp>
-#include <facter/facts/scalar_value.hpp>
 #include <facter/facts/os_family.hpp>
 #include <leatherman/logging/logging.hpp>
 #include <leatherman/util/regex.hpp>
@@ -12,7 +10,6 @@
 #include <winnt.h>
 #include <Shlobj.h>
 #include <map>
-#include <string>
 #include <boost/filesystem.hpp>
 
 using namespace std;
@@ -104,26 +101,7 @@ namespace facter { namespace facts { namespace windows {
         auto version = result.release.substr(0, lastDot);
         bool consumerrel = (wmi::get(vals, wmi::producttype) == "1");
         if (version == "10.0") {
-            // Calculate the build number to distinguish between
-            // Windows Server 2016 and 2019. Note that the kernel
-            // version is written as <major>.<minor>.<build_number>
-            auto kernel_version_fact = facts.get<string_value>(fact::kernel_version);
-            if (! kernel_version_fact) {
-                LOG_DEBUG("Could not resolve the OS release and OS major version facts from the kernel version fact");
-                return result;
-            }
-            auto kernel_version = kernel_version_fact->value();
-            auto build_number_as_str = kernel_version.substr(
-                kernel_version.find_last_of('.') + 1);
-            auto build_number = stol(build_number_as_str);
-
-            if (consumerrel) {
-              result.release = "10";
-            } else if (build_number >= 17623L) {
-              result.release = "2019";
-            } else {
-              result.release = "2016";
-            }
+            result.release = consumerrel ? "10" : "2016";
         } else if (version == "6.3") {
             result.release = consumerrel ? "8.1" : "2012 R2";
         } else if (version == "6.2") {

data/ext/facter/facter/lib/src/ruby/fact.cc

@@ -83,69 +83,53 @@ namespace facter { namespace ruby {
         });
 
         _resolving = true;
-        bool add = true;
-
-        vector<VALUE>::iterator it;
-        ruby.rescue([&]() {
-            volatile VALUE value = ruby.nil_value();
-            size_t weight = 0;
 
-            // Look through the resolutions and find the first allowed resolution that resolves
-            for (it = _resolutions.begin(); it != _resolutions.end(); ++it) {
-                auto res = ruby.to_native<resolution>(*it);
-                if (!res->suitable(*facter)) {
-                    continue;
-                }
-                value = res->value();
-                if (!ruby.is_nil(value)) {
-                    weight = res->weight();
-                    break;
-                }
+        // If no resolutions or the top resolution has a weight of 0, first check the native collection for the fact
+        // This way we treat the "built-in" as implicitly having a resolution with weight 0
+        bool add = true;
+        if (_resolutions.empty() || ruby.to_native<resolution>(_resolutions.front())->weight() == 0) {
+            // Check to see the value is in the collection
+            auto value = facts[ruby.to_string(_name)];
+            if (value) {
+                // Already in collection, do not add
+                add = false;
+                _value = facter->to_ruby(value);
+                _weight = value->weight();
             }
+        }
 
-            // Set the value to what was resolved
-            _value = value;
-            _weight = weight;
+        if (ruby.is_nil(_value)) {
+            vector<VALUE>::iterator it;
+            ruby.rescue([&]() {
+                volatile VALUE value = ruby.nil_value();
+                size_t weight = 0;
+
+                // Look through the resolutions and find the first allowed resolution that resolves
+                for (it = _resolutions.begin(); it != _resolutions.end(); ++it) {
+                    auto res = ruby.to_native<resolution>(*it);
+                    if (!res->suitable(*facter)) {
+                        continue;
+                    }
+                    value = res->value();
+                    if (!ruby.is_nil(value)) {
+                        weight = res->weight();
+                        break;
+                    }
+                }
 
-            if (! ruby.is_nil(_value) && _weight != 0) {
+                // Set the value to what was resolved
+                _value = value;
+                _weight = weight;
                 return 0;
-            }
-
-            // There's two possibilities here:
-            //   1. None of our resolvers could resolve the value
-            //   2. A resolver of weight 0 resolved the value
-            //
-            // In both cases, we attempt to use the "built-in" fact's
-            // value. This serves as a fallback resolver for Case (1)
-            // while for Case (2), we want built-in values to take
-            // precedence over 0-weight custom facts.
-
-            auto builtin_value = facts[ruby.to_string(_name)];
-            if (! builtin_value) {
-              return 0;
-            }
-            auto builtin_ruby_value = facter->to_ruby(builtin_value);
-
-            // We need this check for Case (2). Otherwise, we risk
-            // overwriting our resolved value in the small chance
-            // that builtin_value exists, but its ruby value is
-            // nil.
-            if (! ruby.is_nil(builtin_ruby_value)) {
-              // Already in collection, do not add
-              add = false;
-              _value = builtin_ruby_value;
-              _weight = builtin_value->weight();
-            }
-
-            return 0;
-        }, [&](VALUE ex) {
-            LOG_ERROR("error while resolving custom fact \"{1}\": {2}", ruby.rb_string_value_ptr(&_name), ruby.exception_to_string(ex));
+            }, [&](VALUE ex) {
+                LOG_ERROR("error while resolving custom fact \"{1}\": {2}", ruby.rb_string_value_ptr(&_name), ruby.exception_to_string(ex));
 
-            // Failed, so set to nil
-            _value = ruby.nil_value();
-            _weight = 0;
-            return 0;
-        });
+                // Failed, so set to nil
+                _value = ruby.nil_value();
+                _weight = 0;
+                return 0;
+            });
+        }
 
         if (add) {
             facts.add_custom(ruby.to_string(_name), ruby.is_nil(_value) ? nullptr : make_value<ruby::ruby_value>(_value), _weight);

data/ext/facter/facter/lib/src/ruby/ruby.cc

@@ -30,27 +30,6 @@ static const char load_puppet[] =
 "  end\n"
 "end\n";
 
-// This struct redirects stdout to stderr in the ruby runtime for the
-// duration of its lifetime. We use this to ensure that any custom
-// facts writing to stdout during their initialization or execution
-// won't corrupt json/yaml output from the facter executable.
-struct RbStdoutGuard {
-    VALUE old_stdout;
-    api& ruby;
-
-    RbStdoutGuard(api& ruby) :ruby(ruby) {
-        LOG_DEBUG("Redirecting ruby's stdout to stderr");
-        auto rb_stderr = ruby.rb_gv_get("$stderr");
-        old_stdout = ruby.rb_gv_get("$stdout");
-        ruby.rb_gv_set("$stdout", rb_stderr);
-    }
-
-    ~RbStdoutGuard() {
-        LOG_DEBUG("Restoring Ruby's stdout");
-        ruby.rb_gv_set("$stdout", old_stdout);
-    }
-};
-
 namespace facter { namespace ruby {
 
     bool initialize(bool include_stack_trace)
@@ -69,7 +48,7 @@ namespace facter { namespace ruby {
         return true;
     }
 
-    void load_custom_facts(collection& facts, bool initialize_puppet, bool redirect_stdout, vector<string> const& paths)
+    void load_custom_facts(collection& facts, bool initialize_puppet, vector<string> const& paths)
     {
 #ifdef _WIN32
         // Initialize WSA before resolving custom facts. The Ruby runtime does this only when running
@@ -88,23 +67,12 @@ namespace facter { namespace ruby {
             }
         }
         mod.search(paths);
-        if (redirect_stdout) {
-            // Redirect stdout->stderr for custom facts.
-            RbStdoutGuard stdout_guard{ruby};
-            mod.resolve_facts();
-        } else {
-            mod.resolve_facts();
-        }
+        mod.resolve_facts();
     }
 
     void load_custom_facts(collection& facts, vector<string> const& paths)
     {
-        load_custom_facts(facts, false, false, paths);
-    }
-
-    void load_custom_facts(collection& facts, bool initialize_puppet, vector<string> const& paths)
-    {
-        load_custom_facts(facts, initialize_puppet, false, paths);
+         load_custom_facts(facts, false, paths);
     }
 
     value const* lookup(value const* value, vector<string>::iterator segment, vector<string>::iterator end) {

data/ext/facter/facter/lib/src/util/freebsd/geom.cc

@@ -0,0 +1,130 @@
+#include <internal/util/freebsd/geom.hpp>
+#include <leatherman/locale/locale.hpp>
+#include <leatherman/logging/logging.hpp>
+
+using leatherman::locale::_;
+
+using namespace std;
+
+namespace facter { namespace util { namespace freebsd {
+
+    geom_exception::geom_exception(std::string const& message) :
+        runtime_error(message)
+    {
+    }
+
+
+
+    geom_config::geom_config(string name, string value)
+    {
+        _name = name;
+        _value = value;
+    }
+
+    string
+    geom_config::name()
+    {
+        return _name;
+    }
+
+    string
+    geom_config::value()
+    {
+        return _value;
+    }
+
+
+
+    geom_object_with_config::geom_object_with_config(struct gconf *conf)
+    {
+        struct gconfig *config;
+        LIST_FOREACH(config, conf, lg_config) {
+            if (!config->lg_val) {
+                LOG_DEBUG(_("Skipping config {1} because it has a null value", config->lg_name));
+                continue;
+            }
+            _configs.push_back(geom_config(config->lg_name, config->lg_val));
+        }
+    }
+
+    string
+    geom_object_with_config::config(string name) {
+        for (auto config : _configs) {
+            if (config.name() == name)
+                return config.value();
+        }
+        return "";
+    }
+
+
+
+    geom_provider::geom_provider(struct gprovider* provider) :
+        geom_object_with_config(&provider->lg_config)
+    {
+        _name         = provider->lg_name;
+        _mode         = provider->lg_mode;
+        _mediasize    = provider->lg_mediasize;
+        _sectorsize   = provider->lg_sectorsize;
+        _stripeoffset = provider->lg_stripeoffset;
+        _stripesize   = provider->lg_stripesize;
+    }
+
+    string
+    geom_provider::name()
+    {
+        return _name;
+    }
+
+    off_t
+    geom_provider::mediasize()
+    {
+        return _mediasize;
+    }
+
+
+
+    geom_geom::geom_geom(struct ggeom *geom) :
+        geom_object_with_config(&geom->lg_config)
+    {
+        _name = geom->lg_name;
+        struct gprovider *provider;
+        LIST_FOREACH(provider, &geom->lg_provider, lg_provider) {
+            providers.push_back(geom_provider(provider));
+        }
+    }
+
+    string
+    geom_geom::name()
+    {
+        return _name;
+    }
+
+
+
+    geom_class::geom_class(string type)
+    {
+        if (geom_gettree(&_mesh) < 0) {
+            throw geom_exception(_("Unable to get GEOM tree"));
+        }
+
+        LIST_FOREACH(_class, &(_mesh.lg_class), lg_class) {
+            if (type == string(_class->lg_name))
+                break;
+        }
+
+        if (!_class) {
+            throw geom_exception(_("The GEOM class \"{1}\" was not found", type));
+        }
+
+        struct ggeom *geom;
+        LIST_FOREACH(geom, &(_class->lg_geom), lg_geom) {
+            geoms.push_back(geom_geom(geom));
+        }
+    }
+
+    geom_class::~geom_class()
+    {
+        geom_deletetree(&_mesh);
+    }
+
+}}}  // namespace facter::util::freebsd