facter 3.11.3.cfacter.20180716 → 3.11.4.cfacter.20180821

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 59604eb95692d9fe7a11d3c65c28f32a4b807e11
-  data.tar.gz: e11014d9bfff774641b5fe5c75f81c831671bbe1
+  metadata.gz: bcbeadda3a08eb363825fbaa0dbc28aa0ea7d722
+  data.tar.gz: 0ceba75967ddc26ded11b2349024518dfe99ab55
 SHA512:
-  metadata.gz: dee599e4596509d648066b32ade20990dbe4d430c6a7b8364f3ee75423827e65a6194f871541301a05aed4c28b0e1f79c0590c3d1eabb0f7f12749b91389c6ff
-  data.tar.gz: 68e4ab3e73b07dbba067e591582199a996a6fd2b58c5f887e010e0dbb4c220d31bed3d7da7eae085c1800233aa96791fb80fa34a6d2c91b9a94de1c17ce8324d
+  metadata.gz: be5fb3cf4c2f375c26cc4a0442a03aaa51459295c8851d8155328bcb5a287ec2fb2323a6267d175b4ec087619510932f53a65eb916c5178ea006ac0e1445b73a
+  data.tar.gz: f43786a9d453221a5bca2808ceb375aacca08044a0bcc487602cdc0f9c8b52b5d35f670d1161ea1d66f7afed5ffbc6873855ee629a18d39f5d95683983d7641d

data/ext/facter/facter/CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.2.2)
-project(FACTER VERSION 3.11.3)
+project(FACTER VERSION 3.11.4)
 
 # Set this early, so it's available. AIX gets weird, man.
 if("${CMAKE_SYSTEM_NAME}" MATCHES "AIX")

data/ext/facter/facter/Rakefile

@@ -4,39 +4,5 @@ $LOAD_PATH << File.join(RAKE_ROOT, 'tasks')
 require 'rake'
 Dir['tasks/**/*.rake'].each { |t| load t }
 
-build_defs_file = File.join(RAKE_ROOT, 'ext', 'build_defaults.yaml')
-if File.exist?(build_defs_file)
-  begin
-    require 'yaml'
-    @build_defaults ||= YAML.load_file(build_defs_file)
-  rescue Exception => e
-    STDERR.puts "Unable to load yaml from #{build_defs_file}:"
-    raise e
-  end
-  @packaging_url  = @build_defaults['packaging_url']
-  @packaging_repo = @build_defaults['packaging_repo']
-  raise "Could not find packaging url in #{build_defs_file}" if @packaging_url.nil?
-  raise "Could not find packaging repo in #{build_defs_file}" if @packaging_repo.nil?
-
-  namespace :package do
-    desc "Bootstrap packaging automation, e.g. clone into packaging repo"
-    task :bootstrap do
-      if File.exist?(File.join(RAKE_ROOT, "ext", @packaging_repo))
-        puts "It looks like you already have ext/#{@packaging_repo}. If you don't like it, blow it away with package:implode."
-      else
-        cd File.join(RAKE_ROOT, 'ext') do
-          %x{git clone #{@packaging_url}}
-        end
-      end
-    end
-    desc "Remove all cloned packaging automation"
-    task :implode do
-      rm_rf File.join(RAKE_ROOT, "ext", @packaging_repo)
-    end
-  end
-end
-
-begin
-  load File.join(RAKE_ROOT, 'ext', 'packaging', 'packaging.rake')
-rescue LoadError
-end
+require 'packaging'
+Pkg::Util::RakeUtils.load_packaging_tasks

data/ext/facter/facter/ext/build_defaults.yaml

@@ -1,6 +1,4 @@
 ---
-packaging_url: 'git@github.com:puppetlabs/packaging --branch=master'
-packaging_repo: 'packaging'
 deb_build_mirrors:
   - deb http://pl-build-tools.delivery.puppetlabs.net/debian __DIST__ main
 packager: 'puppetlabs'

data/ext/facter/facter/lib/CMakeLists.txt

@@ -91,6 +91,7 @@ if (UNIX)
         "src/facts/posix/cache.cc"
         "src/util/posix/scoped_addrinfo.cc"
         "src/util/posix/scoped_descriptor.cc"
+        "src/util/posix/utmpx_file.cc"
         "src/util/config/posix/config.cc"
     )
     if (OPENSSL_FOUND)
@@ -120,6 +121,7 @@ if (AIX)
         "src/facts/aix/disk_resolver.cc"
         "src/facts/aix/filesystem_resolver.cc"
         "src/facts/aix/kernel_resolver.cc"
+        "src/facts/aix/load_average_resolver.cc"
         "src/facts/aix/memory_resolver.cc"
         "src/facts/aix/networking_resolver.cc"
         "src/facts/aix/operating_system_resolver.cc"

data/ext/facter/facter/lib/Doxyfile

@@ -38,7 +38,7 @@ PROJECT_NAME           = facter
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 3.11.3
+PROJECT_NUMBER         = 3.11.4
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

data/ext/facter/facter/lib/inc/internal/facts/aix/load_average_resolver.hpp

@@ -0,0 +1,24 @@
+/**
+ * @file
+ * Declares the AIX load average fact resolver.
+ */
+#pragma once
+
+#include "../resolvers/load_average_resolver.hpp"
+
+namespace facter { namespace facts { namespace aix {
+
+    /**
+     * Responsible for resolving the load average facts.
+     */
+    struct load_average_resolver : resolvers::load_average_resolver
+    {
+     protected:
+        /**
+         * Gets the load averages (for 1, 5 and 15 minutes period).
+         * @return The load averages.
+         */
+        virtual boost::optional<std::tuple<double, double, double>> get_load_averages() override;
+    };
+
+}}}  // namespace facter::facts::aix

data/ext/facter/facter/lib/inc/internal/util/aix/odm.hpp

@@ -117,7 +117,18 @@ namespace facter { namespace util { namespace aix {
               * @return true if the iterators are not equal
               */
              bool operator != (const iterator& rhs) {
-                 return _data != rhs._data && _owner != rhs._owner;
+                 return _owner != rhs._owner || _data != rhs._data;
+             }
+
+             /**
+              * equality comparison.
+              * @param rhs the other iterator to compare to
+              * @return true if the iterators are equal
+              */
+             bool operator == (const iterator& rhs) {
+                 // We could do !(*this != rhs) here, but it's better to inline
+                 // the expression for performance reasons. It's simple enough.
+                 return _owner == rhs._owner && _data == rhs._data;
              }
 
              /**
@@ -150,6 +161,14 @@ namespace facter { namespace util { namespace aix {
                  return *_data;
              }
 
+             /**
+              * arrow operator
+              * @return a pointer to the held ODM data structure
+              */
+             const T* operator->() const{
+                 return _data;
+             }
+
              /**
               * Destructor. Frees any held ODM data.
               */

data/ext/facter/facter/lib/inc/internal/util/posix/utmpx_file.hpp

@@ -0,0 +1,57 @@
+/**
+ * @file
+ * Declares an interface for querying the contents of the utmpx file
+ */
+#pragma once
+
+#include <utmpx.h>
+
+namespace facter { namespace util { namespace posix {
+
+    /**
+     * Class representing a utmpx file. We create only one instance at a time since
+     * the utmpx API calls deal with global state. See https://linux.die.net/man/3/getutxid
+     * for the documentation.
+    */
+    class utmpx_file {
+    public:
+         /**
+          * Constructs a utmpx_file instance. We only do this if no other utmpx_file instance exists,
+          * which we can determine by querying the 'instance_exists' static variable. Otherwise,
+          * we throw an std::logic_error.
+          */
+         utmpx_file();
+
+         /// deleted copy constructor
+         utmpx_file(const utmpx_file&) = delete;
+
+         /// deleted assignment operator
+         /// @return nothing
+         utmpx_file& operator=(const utmpx_file&) = delete;
+
+         /**
+          * Destroys our utmpx_file instance. Here, we also set `instance_exists` to false so that another
+          * utmpx_file instance can be created.
+          */
+         ~utmpx_file();
+
+         /**
+          * Returns a pointer to the utmpx entry corresponding to the passed-in query. Make sure
+          * that the calling instance does not go out of scope after invoking this method, otherwise
+          * the data in the returned utmpx entry will be garbage. Note that this will move the
+          * underlying utmpx file pointer forward, so be sure to call reset() if you want subsequent
+          * calls to this routine to always start from the beginning of the utmpx file.
+          * @param query the utmpx query. See https://www.systutorials.com/docs/linux/man/5-utmpx/
+          * @return pointer to the utmpx entry satisfying the query
+          */
+         const utmpx* query(utmpx const& query) const;
+
+         /**
+          * Resets the utmpx file.
+          */
+         void reset() const;
+
+    private:
+         static bool instance_exists;  // set to true if a utmpx_file instance exists, false otherwise
+    };
+}}}  // namespace facter::util::posix

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

@@ -2,6 +2,7 @@
 #include <internal/facts/aix/disk_resolver.hpp>
 #include <internal/facts/aix/filesystem_resolver.hpp>
 #include <internal/facts/aix/kernel_resolver.hpp>
+#include <internal/facts/aix/load_average_resolver.hpp>
 #include <internal/facts/aix/memory_resolver.hpp>
 #include <internal/facts/aix/networking_resolver.hpp>
 #include <internal/facts/aix/operating_system_resolver.hpp>
@@ -19,6 +20,7 @@ namespace facter { namespace facts {
         add(make_shared<aix::disk_resolver>());
         add(make_shared<aix::filesystem_resolver>());
         add(make_shared<aix::kernel_resolver>());
+        add(make_shared<aix::load_average_resolver>());
         add(make_shared<aix::memory_resolver>());
         add(make_shared<aix::networking_resolver>());
         add(make_shared<aix::operating_system_resolver>());

data/ext/facter/facter/lib/src/facts/aix/load_average_resolver.cc

@@ -0,0 +1,50 @@
+#include <internal/facts/aix/load_average_resolver.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <leatherman/locale/locale.hpp>
+
+#include <sys/inttypes.h>
+#include <sys/kinfo.h>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+
+/**
+ * This system call lets us query the kernel directly for system
+ * information. We use it to get our current load averages.
+ *
+ * @param info the info we're retrieving from the kernel.
+ * @param buf the buffer that we'll store the information in
+ * @param buf_size a pointer to the variable containing the size of the buffer in bytes
+ * @param arg no idea what this param. represents. we will usually set this to 0.
+ * @return 0 if we successfully retrieve the information, else a negative value
+ */
+extern "C" int getkerninfo(int info, char* buf, int* buf_size, int32long64_t arg);
+
+// Converts the given integer average into a load average.
+static double to_load_avg(double average) {
+  // 65536 is the load average scale on AIX machines.
+  return average / 65536;
+}
+
+namespace facter { namespace facts { namespace aix {
+
+    boost::optional<tuple<double, double, double> > load_average_resolver::get_load_averages()
+    {
+        // This approach was adapted from screen-4.6.2's loadav.c file. See
+        // https://www.mail-archive.com/opensuse-commit@opensuse.org/msg122486.html
+        array<long long, 3> averages;
+        int buf_size = averages.size() * sizeof(long long);
+        int rc = getkerninfo(KINFO_GET_AVENRUN, reinterpret_cast<char*>(averages.data()), &buf_size, 0);
+        if (rc < 0) {
+            LOG_DEBUG(_("failed to retrieve the load averages"));
+            return boost::none;
+        }
+
+        return make_tuple(
+            to_load_avg(averages[0]),
+            to_load_avg(averages[1]),
+            to_load_avg(averages[2]));
+    }
+}}}  // namespace facter::facts::aix

data/ext/facter/facter/lib/src/facts/aix/memory_resolver.cc

@@ -1,6 +1,7 @@
 #include <internal/facts/aix/memory_resolver.hpp>
 #include <internal/util/aix/odm.hpp>
 
+#include <leatherman/logging/logging.hpp>
 #include <sys/vminfo.h>
 #include <sys/cfgodm.h>
 #include <sys/limits.h>
@@ -9,6 +10,15 @@
 using namespace std;
 using namespace facter::util::aix;
 
+// This routine is useful to encapsulate knowledge of the PAGE_SIZE
+// in one place and to also handle implicit conversions of numeric
+// values to uint64_t, which is what we use to represent bytes. Otherwise,
+// we risk accidentally capturing an overflowed value in our computed
+// memory facts.
+static uint64_t pages_to_bytes(uint64_t num_pages) {
+    return num_pages * PAGE_SIZE;
+}
+
 namespace facter { namespace facts { namespace aix {
     memory_resolver::data memory_resolver::collect_data(collection& facts)
     {
@@ -19,8 +29,8 @@ namespace facter { namespace facts { namespace aix {
         if (res < 0) {
             throw system_error(errno, system_category());
         }
-        result.mem_total = info.memsizepgs * PAGE_SIZE;
-        result.mem_free = info.numfrb * PAGE_SIZE;
+        result.mem_total = pages_to_bytes(info.memsizepgs);
+        result.mem_free = pages_to_bytes(info.numfrb);
 
         auto cu_at_query = odm_class<CuAt>::open("CuAt").query("value=paging and attribute=type");
         for (auto& cu_at : cu_at_query) {
@@ -33,14 +43,19 @@ namespace facter { namespace facts { namespace aix {
                 // swapqry the things that have an attribute we
                 // expect, but ignore any errno values that look like
                 // "this just wasn't a good device to query"
+                // ENXIO: No such device address.
                 if (errno != ENODEV &&
                     errno != ENOENT &&
-                    errno != ENOTBLK) {
-                    throw system_error(errno, system_category());
+                    errno != ENOTBLK &&
+                    errno != ENXIO) {
+                    throw system_error(errno, system_category(), device);
+                } else {
+                    LOG_DEBUG("cannot use device {1}: error is {2}", device, errno);
                 }
             }
-            result.swap_total += info.size * PAGE_SIZE;
-            result.swap_free += info.free * PAGE_SIZE;
+
+            result.swap_total += pages_to_bytes(info.size);
+            result.swap_free += pages_to_bytes(info.free);
         }
 
         return result;

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

@@ -1,43 +1,72 @@
 #include <internal/facts/aix/operating_system_resolver.hpp>
+#include <internal/util/aix/odm.hpp>
+#include <facter/facts/collection.hpp>
+#include <facter/facts/fact.hpp>
 #include <facter/facts/os.hpp>
-#include <leatherman/execution/execution.hpp>
-#include <leatherman/file_util/file.hpp>
+#include <facter/facts/array_value.hpp>
+#include <facter/facts/map_value.hpp>
+#include <facter/facts/scalar_value.hpp>
 #include <leatherman/logging/logging.hpp>
-#include <leatherman/util/regex.hpp>
 
 #include <boost/algorithm/string.hpp>
+#include <odmi.h>
+#include <sys/cfgodm.h>
 
 using namespace std;
-using namespace leatherman::util;
-using namespace leatherman::file_util;
-using namespace boost;
-namespace execution = leatherman::execution;
+using namespace facter::util::aix;
 
+// This routine's meant to be a general utility function that replicates the behavior of
+// lsattr -El <object> -a <field>. Although it's only used to get the modelname of the
+// sys0 device, we still would like to have it here in case we ever need to separate it
+// out to an AIX utils file to query other attributes. Part of what lsattr does is check
+// PdAt if we don't have an entry for the object's attribute in CuAt, even though it is very
+// unlikely that sys0.modelname will not have a CuAt entry. That is why we have the extra code
+// in here.
 static string getattr(string object, string field)
 {
-    string result;
-
-    execution::each_line(
-        "/usr/sbin/lsattr", {"-El", object, "-a", field},
-        [&](string& line) {
-            if (!line.empty()) {
-                vector<string> tokens;
-                boost::split(tokens, line, boost::is_space(), boost::token_compress_on);
-                if (tokens.size() < 2) {
-                    return true;
-                }
-                result = tokens[1];
-                return false;
-            }
-            return true;
-        },
-        nullptr,
-        0);
-
-    if (result == "") {
-        LOG_WARNING("Could not get a value from lsattr -El {1} -a {2}", object, field);
+    // High-level logic here is:
+    //   * Check if there's an entry for our object's field attribute in CuAt (the device-specific
+    //   attribute entry).
+    //
+    //   * Else, check for the field attribute's default value in PdAt. We do this by first
+    //   figuring out the PdDv type from the CuDv entry for the object, then use our PdDv type
+    //   to query the field's default value in PdAt.
+    string query = (boost::format("name = %1% AND attribute = %2%") % object % field).str();
+    auto cuat_query = odm_class<CuAt>::open("CuAt").query(query);
+
+    // This is a more verbose way of saying that we only expect our query to have one element
+    auto cuat_ref = cuat_query.begin();
+    if (cuat_ref != cuat_query.end()) {
+      auto value = string(cuat_ref->value);
+      if (value.empty()) {
+        LOG_DEBUG("Could not get a value from the ODM for {1}'s '{2}' attribute.", object, field);
+      }
+      return value;
+    }
+
+    // Get the PdDv type from the CuDv entry
+    query = (boost::format("name = %1%") % object).str();
+    auto cudv_query = odm_class<CuDv>::open("CuDv").query(query);
+    auto cudv_ref = cudv_query.begin();
+    if (cudv_ref == cudv_query.end()) {
+      LOG_DEBUG("Could not get a value from the ODM for {1}'s '{2}' attribute: There is no CuDv entry for {1}.", object, field);
+      return "";
     }
-    return result;
+    auto pddv_type = cudv_ref->PdDvLn_Lvalue;
+
+    query = (boost::format("uniquetype = %1% AND attribute = %2%") % pddv_type % field).str();
+    auto pdat_query = odm_class<PdAt>::open("PdAt").query(query);
+    auto pdat_ref = pdat_query.begin();
+    if (pdat_ref != pdat_query.end()) {
+      auto value = string(pdat_ref->deflt);
+      if (value.empty()) {
+        LOG_DEBUG("Could not get a value from the ODM for {1}'s '{2}' attribute.", object, field);
+      }
+      return value;
+    }
+
+    LOG_DEBUG("Could not get a value from the ODM for {1}'s '{2}' attribute: There is no PdAt entry for {1} with {2}.", object, field);
+    return "";
 }
 
 namespace facter { namespace facts { namespace aix {
@@ -53,9 +82,18 @@ namespace facter { namespace facts { namespace aix {
         boost::split(tokens, result.release, boost::is_any_of("-"));
         result.major = tokens[0];
 
-        result.architecture = getattr("proc0", "type");
+        // Get the hardware
         result.hardware = getattr("sys0", "modelname");
 
+        // Now get the architecture. We use processor.models[0] for this information.
+        auto processors = facts.get<map_value>(fact::processors);
+        auto models = processors ? processors->get<array_value>("models") : nullptr;
+        if (! models || models->empty()) {
+          LOG_DEBUG("Could not get a value for the OS architecture. Your machine does not have any processors!");
+        } else {
+          result.architecture = models->get<string_value>(0)->value();
+        }
+
         return result;
     }
 }}}

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

@@ -148,7 +148,7 @@ namespace facter { namespace facts { namespace linux {
             "throw"
         };
 
-        auto parse_route_line = [&known_route_types](string& line, std::vector<route>& routes) {
+        auto parse_route_line = [&known_route_types](string& line, int family, std::vector<route>& routes) {
             vector<boost::iterator_range<string::iterator>> parts;
             boost::split(parts, line, boost::is_space(), boost::token_compress_on);
 
@@ -181,6 +181,18 @@ namespace facter { namespace facts { namespace linux {
 
             route r;
             r.destination.assign(parts[dst_idx].begin(), parts[dst_idx].end());
+
+            // Check if we queried for the IPV6 routing tables. If yes, then check if our
+            // destination address is missing a ':'. If yes, then IPV6 is disabled since
+            // IPV6 addresses have a ':' in them. Our ip command has mistakenly outputted IPV4
+            // information. This is bogus data that we want to flush.
+            //
+            // See FACT-1475 for more details.
+            if (family == AF_INET6 && r.destination.find(':') == string::npos) {
+              routes = {};
+              return false;
+            }
+
             // Iterate over key/value pairs and add the ones we care
             // about to our routes entries
             for (size_t i = dst_idx+1; i < parts.size(); i += 2) {
@@ -197,10 +209,10 @@ namespace facter { namespace facts { namespace linux {
         };
 
         lth_exe::each_line(ip_command, { "route", "show" }, [this, &parse_route_line](string& line) {
-            return parse_route_line(line, this->routes4);
+            return parse_route_line(line, AF_INET, this->routes4);
         });
         lth_exe::each_line(ip_command, { "-6", "route", "show" }, [this, &parse_route_line](string& line) {
-            return parse_route_line(line, this->routes6);
+            return parse_route_line(line, AF_INET6, this->routes6);
         });
     }
 

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

@@ -61,11 +61,13 @@ namespace facter { namespace facts { namespace linux {
 
     operating_system_resolver::selinux_data operating_system_resolver::collect_selinux_data()
     {
+        static string SELINUX_CONFIG_FILE("/etc/selinux/config");
+
         selinux_data result;
         result.supported = true;
 
         string mountpoint = get_selinux_mountpoint();
-        result.enabled = !mountpoint.empty();
+        result.enabled = !mountpoint.empty() && exists(SELINUX_CONFIG_FILE);
         if (!result.enabled) {
             return result;
         }
@@ -87,7 +89,7 @@ namespace facter { namespace facts { namespace linux {
         // Parse the SELinux config for mode and policy
         static boost::regex mode_regex("(?m)^SELINUX=(\\w+)$");
         static boost::regex policy_regex("(?m)^SELINUXTYPE=(\\w+)$");
-        lth_file::each_line("/etc/selinux/config", [&](string& line) {
+        lth_file::each_line(SELINUX_CONFIG_FILE, [&](string& line) {
             if (re_search(line, mode_regex, &result.config_mode)) {
                 return true;
             }

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

@@ -1,10 +1,19 @@
 #include <internal/facts/posix/uptime_resolver.hpp>
+#include <internal/util/posix/utmpx_file.hpp>
 #include <leatherman/util/regex.hpp>
 #include <leatherman/execution/execution.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <leatherman/locale/locale.hpp>
+
+#include <ctime>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
 
 using namespace std;
 using namespace leatherman::util;
 using namespace leatherman::execution;
+using namespace facter::util::posix;
 
 namespace facter { namespace facts { namespace posix {
 
@@ -43,6 +52,16 @@ namespace facter { namespace facts { namespace posix {
 
     int64_t uptime_resolver::get_uptime()
     {
+        LOG_DEBUG(_("Attempting to calculate the uptime from the utmpx file"));
+        utmpx query;
+        query.ut_type = BOOT_TIME;
+        utmpx_file file;
+        auto ent = file.query(query);
+        if (ent) {
+          return time(NULL) - ent->ut_tv.tv_sec;
+        }
+        LOG_DEBUG(_("Could not calculate the uptime from the utmpx file"));
+
         auto exec = execute("uptime");
         if (!exec.success) {
             return -1;

data/ext/facter/facter/lib/src/util/posix/utmpx_file.cc

@@ -0,0 +1,36 @@
+#include <internal/util/posix/utmpx_file.hpp>
+#include <leatherman/locale/locale.hpp>
+#include <leatherman/logging/logging.hpp>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+
+namespace facter { namespace util { namespace posix {
+
+    bool utmpx_file::instance_exists = false;
+
+    utmpx_file::utmpx_file() {
+      if (utmpx_file::instance_exists) {
+        throw logic_error(_("only one utmpx_file instance can exist at a time!"));
+      }
+
+      utmpx_file::instance_exists = true;
+      reset();
+    }
+
+    utmpx_file::~utmpx_file() {
+        endutxent();
+        utmpx_file::instance_exists = false;
+    }
+
+    const utmpx* utmpx_file::query(utmpx const& query) const {
+        LOG_DEBUG(_("Reading the utmpx file ..."));
+        return getutxid(&query);
+    }
+
+    void utmpx_file::reset() const {
+        setutxent();
+    }
+}}}  // namespace facter::util::posix

data/ext/facter/facter/locales/FACTER.pot

@@ -6,7 +6,7 @@
 #, fuzzy
 msgid ""
 msgstr ""
-"Project-Id-Version: FACTER 3.11.3\n"
+"Project-Id-Version: FACTER 3.11.4\n"
 "Report-Msgid-Bugs-To: docs@puppet.com\n"
 "POT-Creation-Date: \n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
@@ -316,6 +316,15 @@ msgstr ""
 msgid "querylv returned success but we got a null LV. WTF?"
 msgstr ""
 
+#: lib/src/facts/aix/load_average_resolver.cc
+msgid "failed to retrieve the load averages"
+msgstr ""
+
+#. debug
+#: lib/src/facts/aix/memory_resolver.cc
+msgid "cannot use device {1}: error is {2}"
+msgstr ""
+
 #: lib/src/facts/aix/networking_resolver.cc
 msgid "getkerninfo call was unsuccessful"
 msgstr ""
@@ -352,9 +361,42 @@ msgstr ""
 msgid "got an unknown RT_IFLIST message: {1}"
 msgstr ""
 
-#. warning
 #: lib/src/facts/aix/operating_system_resolver.cc
-msgid "Could not get a value from lsattr -El {1} -a {2}"
+msgid "name = %1% AND attribute = %2%"
+msgstr ""
+
+#. debug
+#: lib/src/facts/aix/operating_system_resolver.cc
+msgid "Could not get a value from the ODM for {1}'s '{2}' attribute."
+msgstr ""
+
+#: lib/src/facts/aix/operating_system_resolver.cc
+msgid "name = %1%"
+msgstr ""
+
+#. debug
+#: lib/src/facts/aix/operating_system_resolver.cc
+msgid ""
+"Could not get a value from the ODM for {1}'s '{2}' attribute: There is no "
+"CuDv entry for {1}."
+msgstr ""
+
+#: lib/src/facts/aix/operating_system_resolver.cc
+msgid "uniquetype = %1% AND attribute = %2%"
+msgstr ""
+
+#. debug
+#: lib/src/facts/aix/operating_system_resolver.cc
+msgid ""
+"Could not get a value from the ODM for {1}'s '{2}' attribute: There is no "
+"PdAt entry for {1} with {2}."
+msgstr ""
+
+#. debug
+#: lib/src/facts/aix/operating_system_resolver.cc
+msgid ""
+"Could not get a value for the OS architecture. Your machine does not have "
+"any processors!"
 msgstr ""
 
 #. debug
@@ -959,6 +1001,14 @@ msgstr ""
 msgid "strftime failed: timezone is unavailable."
 msgstr ""
 
+#: lib/src/facts/posix/uptime_resolver.cc
+msgid "Attempting to calculate the uptime from the utmpx file"
+msgstr ""
+
+#: lib/src/facts/posix/uptime_resolver.cc
+msgid "Could not calculate the uptime from the utmpx file"
+msgstr ""
+
 #. debug
 #: lib/src/facts/posix/xen_resolver.cc
 msgid "failure executing {1}: {2}"
@@ -1493,6 +1543,14 @@ msgstr ""
 msgid "a block is unexpected when passing a String"
 msgstr ""
 
+#: lib/src/util/posix/utmpx_file.cc
+msgid "only one utmpx_file instance can exist at a time!"
+msgstr ""
+
+#: lib/src/util/posix/utmpx_file.cc
+msgid "Reading the utmpx file ..."
+msgstr ""
+
 #: lib/src/util/solaris/k_stat.cc
 msgid "kstat_open failed"
 msgstr ""

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: facter
 version: !ruby/object:Gem::Version
-  version: 3.11.3.cfacter.20180716
+  version: 3.11.4.cfacter.20180821
 platform: ruby
 authors:
 - Puppet
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-16 00:00:00.000000000 Z
+date: 2018-08-21 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: info@puppet.com
@@ -360,6 +360,7 @@ files:
 - ext/facter/facter/lib/inc/internal/facts/aix/disk_resolver.hpp
 - ext/facter/facter/lib/inc/internal/facts/aix/filesystem_resolver.hpp
 - ext/facter/facter/lib/inc/internal/facts/aix/kernel_resolver.hpp
+- ext/facter/facter/lib/inc/internal/facts/aix/load_average_resolver.hpp
 - ext/facter/facter/lib/inc/internal/facts/aix/memory_resolver.hpp
 - ext/facter/facter/lib/inc/internal/facts/aix/networking_resolver.hpp
 - ext/facter/facter/lib/inc/internal/facts/aix/operating_system_resolver.hpp
@@ -485,6 +486,7 @@ files:
 - ext/facter/facter/lib/inc/internal/util/posix/scoped_addrinfo.hpp
 - ext/facter/facter/lib/inc/internal/util/posix/scoped_bio.hpp
 - ext/facter/facter/lib/inc/internal/util/posix/scoped_descriptor.hpp
+- ext/facter/facter/lib/inc/internal/util/posix/utmpx_file.hpp
 - ext/facter/facter/lib/inc/internal/util/scoped_file.hpp
 - ext/facter/facter/lib/inc/internal/util/solaris/k_stat.hpp
 - ext/facter/facter/lib/inc/internal/util/solaris/scoped_kstat.hpp
@@ -501,6 +503,7 @@ files:
 - ext/facter/facter/lib/src/facts/aix/disk_resolver.cc
 - ext/facter/facter/lib/src/facts/aix/filesystem_resolver.cc
 - ext/facter/facter/lib/src/facts/aix/kernel_resolver.cc
+- ext/facter/facter/lib/src/facts/aix/load_average_resolver.cc
 - ext/facter/facter/lib/src/facts/aix/memory_resolver.cc
 - ext/facter/facter/lib/src/facts/aix/networking_resolver.cc
 - ext/facter/facter/lib/src/facts/aix/operating_system_resolver.cc
@@ -641,6 +644,7 @@ files:
 - ext/facter/facter/lib/src/util/posix/scoped_addrinfo.cc
 - ext/facter/facter/lib/src/util/posix/scoped_bio.cc
 - ext/facter/facter/lib/src/util/posix/scoped_descriptor.cc
+- ext/facter/facter/lib/src/util/posix/utmpx_file.cc
 - ext/facter/facter/lib/src/util/scoped_file.cc
 - ext/facter/facter/lib/src/util/solaris/k_stat.cc
 - ext/facter/facter/lib/src/util/solaris/scoped_kstat.cc