RubyGems - facter - Versions diffs - 3.12.2.cfacter.20181217 → 4.0.7.pre - Mend

facter 3.12.2.cfacter.20181217 → 4.0.7.pre

Files changed (1564) hide show

data/ext/facter/facter/lib/src/facts/freebsd/zfs_resolver.cc DELETED

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

data/ext/facter/facter/lib/src/facts/freebsd/zpool_resolver.cc DELETED

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

data/ext/facter/facter/lib/src/facts/glib/load_average_resolver.cc DELETED

@@ -1,22 +0,0 @@
-#include <internal/facts/glib/load_average_resolver.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <cstdlib>
-#ifdef __sun
-#include <sys/loadavg.h>
-#endif
-using namespace std;
-namespace facter { namespace facts { namespace glib {
-    boost::optional<tuple<double, double, double> > load_average_resolver::get_load_averages()
-    {
-        array<double, 3> averages;
-        if (getloadavg(averages.data(), averages.size()) == -1) {
-            LOG_DEBUG("failed to retrieve load averages: {1} ({2}).", strerror(errno), errno);
-            return boost::none;
-        }
-        return make_tuple(averages[0], averages[1], averages[2]);
-    }
-}}}  // namespace facter::facts::glib

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

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

data/ext/facter/facter/lib/src/facts/linux/disk_resolver.cc DELETED

@@ -1,80 +0,0 @@
-#include <internal/facts/linux/disk_resolver.hpp>
-#include <leatherman/file_util/file.hpp>
-#include <leatherman/file_util/directory.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/algorithm/string.hpp>
-using namespace std;
-using namespace boost::filesystem;
-using boost::lexical_cast;
-using boost::bad_lexical_cast;
-namespace lth_file = leatherman::file_util;
-namespace facter { namespace facts { namespace linux {
-    disk_resolver::data disk_resolver::collect_data(collection& facts)
-    {
-        static string root_directory = "/sys/block";
-        // The size of the block devices is in 512 byte blocks
-        const int block_size = 512;
-        data result;
-        boost::system::error_code ec;
-        if (!is_directory(root_directory, ec)) {
-            LOG_DEBUG("{1}: {2}: disk facts are unavailable.", root_directory, ec.message());
-            return result;
-        }
-        lth_file::each_subdirectory(root_directory, [&](string const& dir) {
-            path device_directory(dir);
-            disk d;
-            d.name = device_directory.filename().string();
-            // Check for the device subdirectory's existence
-            path device_subdirectory = device_directory / "device";
-            boost::system::error_code ec;
-            if (!is_directory(device_subdirectory, ec)) {
-                return true;
-            }
-            string size_file_path = (device_directory / "size").string();
-            string vendor_file_path = (device_subdirectory / "vendor").string();
-            string model_file_path = (device_subdirectory / "model").string();
-            // Read the size of the block device
-            // The size is in 512 byte blocks
-            if (is_regular_file(size_file_path, ec)) {
-                try {
-                    string blocks = lth_file::read(size_file_path);
-                    boost::trim(blocks);
-                    d.size = lexical_cast<uint64_t>(blocks) * block_size;
-                } catch (bad_lexical_cast& ex) {
-                    LOG_DEBUG("size of disk {1} is invalid: size information is unavailable.", d.name);
-                }
-            }
-            // Read the vendor fact
-            if (is_regular_file(vendor_file_path, ec)) {
-                d.vendor = lth_file::read(vendor_file_path);
-                boost::trim(d.vendor);
-            }
-            // Read the model fact
-            if (is_regular_file(model_file_path, ec)) {
-                d.model = lth_file::read(model_file_path);
-                boost::trim(d.model);
-            }
-            result.disks.emplace_back(move(d));
-            return true;
-        });
-        return result;
-    }
-}}}  // namespace facter::facts::linux

data/ext/facter/facter/lib/src/facts/linux/dmi_resolver.cc DELETED

@@ -1,208 +0,0 @@
-#include <internal/facts/linux/dmi_resolver.hpp>
-#include <internal/util/agent.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <leatherman/util/regex.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <leatherman/file_util/file.hpp>
-#include <leatherman/execution/execution.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/algorithm/string.hpp>
-using namespace std;
-using namespace boost::filesystem;
-namespace bs = boost::system;
-namespace lth_file = leatherman::file_util;
-using namespace facter::util;
-using namespace leatherman::util;
-namespace facter { namespace facts { namespace linux {
-    dmi_resolver::data dmi_resolver::collect_data(collection& facts)
-    {
-        data result;
-        // Check that /sys/class/dmi exists (requires kernel 2.6.23+)
-        bs::error_code ec;
-        if (exists("/sys/class/dmi/", ec)) {
-            result.bios_vendor          = read("/sys/class/dmi/id/bios_vendor");
-            result.bios_version         = read("/sys/class/dmi/id/bios_version");
-            result.bios_release_date    = read("/sys/class/dmi/id/bios_date");
-            result.board_asset_tag      = read("/sys/class/dmi/id/board_asset_tag");
-            result.board_manufacturer   = read("/sys/class/dmi/id/board_vendor");
-            result.board_product_name   = read("/sys/class/dmi/id/board_name");
-            result.board_serial_number  = read("/sys/class/dmi/id/board_serial");
-            result.chassis_asset_tag    = read("/sys/class/dmi/id/chassis_asset_tag");
-            result.manufacturer         = read("/sys/class/dmi/id/sys_vendor");
-            result.product_name         = read("/sys/class/dmi/id/product_name");
-            result.serial_number        = read("/sys/class/dmi/id/product_serial");
-            result.uuid                 = read("/sys/class/dmi/id/product_uuid");
-            result.chassis_type         = to_chassis_description(read("/sys/class/dmi/id/chassis_type"));
-        } else {
-            // dmidecode does not work on power machines, so if we're on one, then there's no need
-            // to proceed any further
-            auto isa = facts.get<string_value>(fact::hardware_isa);
-            if (isa && boost::starts_with(isa->value(), "ppc64")) {
-                return result;
-            }
-            LOG_DEBUG("/sys/class/dmi cannot be accessed: using dmidecode to query DMI information.");
-            int dmi_type = -1;
-            string dmidecode = agent::which("dmidecode");
-            leatherman::execution::each_line(dmidecode, [&](string& line) {
-                parse_dmidecode_output(result, line, dmi_type);
-                return true;
-            });
-        }
-        return result;
-    }
-    void dmi_resolver::parse_dmidecode_output(data& result, string& line, int& dmi_type)
-    {
-        static const boost::regex dmi_section_pattern("^Handle 0x.{4}, DMI type (\\d{1,3})");
-        // Stores the relevant sections; this is in order based on DMI type ID
-        // Ensure there's a trailing semicolon on each entry and keep in sync with the switch statement below
-        static const vector<vector<string>> sections = {
-            {   // BIOS (0)
-                "vendor:",
-                "version:",
-                "release date:",
-            },
-            {   // System (1)
-                "manufacturer:",
-                "product:",
-                "product name:",
-                "serial number:",
-                "uuid:",
-            },
-            {   // Base Board (2)
-                "manufacturer:",
-                "product:",
-                "product name:",
-                "serial number:",
-                "asset tag:",
-            },
-            {   // Chassis (3)
-                "type:",
-                "chassis type:",
-                "asset tag:",
-            }
-        };
-        // Check for a section header
-        if (re_search(line, dmi_section_pattern, &dmi_type)) {
-            return;
-        }
-        // Check that we're in a relevant section
-        if (dmi_type < 0 || static_cast<size_t>(dmi_type) >= sections.size()) {
-            return;
-        }
-        // Trim leading whitespace
-        boost::trim_left(line);
-        // Find a matching header
-        auto const& headers = sections[dmi_type];
-        auto it = find_if(headers.begin(), headers.end(), [&](string const& header) {
-            return boost::istarts_with(line, header);
-        });
-        if (it == headers.end()) {
-            return;
-        }
-        // Get the value and trim it
-        string value = line.substr(it->size());
-        boost::trim(value);
-        // Calculate the index into the header vector
-        size_t index = it - headers.begin();
-        // Assign to the appropriate member
-        string* member = nullptr;
-        switch (dmi_type) {
-            case 0: {  // BIOS information
-                if (index == 0) {
-                    member = &result.bios_vendor;
-                } else if (index == 1) {
-                    member = &result.bios_version;
-                }  else if (index == 2) {
-                    member = &result.bios_release_date;
-                }
-                break;
-            }
-            case 1: {  // System information
-                if (index == 0) {
-                    member = &result.manufacturer;
-                } else if (index == 1 || index == 2) {
-                    member = &result.product_name;
-                } else if (index == 3) {
-                    member = &result.serial_number;
-                } else if (index == 4) {
-                    member = &result.uuid;
-                }
-                break;
-            }
-            case 2: {  // Base board information
-                if (index == 0) {
-                    member = &result.board_manufacturer;
-                } else if (index == 1 || index == 2) {
-                    member = &result.board_product_name;
-                } else if (index == 3) {
-                    member = &result.board_serial_number;
-                } else if (index == 4) {
-                    member = &result.board_asset_tag;
-                }
-                break;
-            }
-            case 3: {  // Chassis information
-                if (index == 0 || index == 1) {
-                    member = &result.chassis_type;
-                } else if (index == 2) {
-                    member = &result.chassis_asset_tag;
-                }
-                break;
-            }
-            default:
-                break;
-        }
-        if (member) {
-            *member = std::move(value);
-        }
-    }
-    string dmi_resolver::read(std::string const& path)
-    {
-        bs::error_code ec;
-        if (!is_regular_file(path, ec)) {
-            LOG_DEBUG("{1}: {2}.", path, ec.message());
-            return {};
-        }
-        string value;
-        if (!lth_file::read(path, value)) {
-            LOG_DEBUG("{1}: file could not be read.", path);
-            return {};
-        }
-        boost::trim(value);
-        // Replace any non-printable ASCII characters with '.'
-        // This mimics the behavior of dmidecode
-        for (auto& c : value) {
-            if (c < 32 || c == 127) {
-                c = '.';
-            }
-        }
-        return value;
-    }
-}}}  // namespace facter::facts::linux

data/ext/facter/facter/lib/src/facts/linux/filesystem_resolver.cc DELETED

@@ -1,282 +0,0 @@
-#include <internal/facts/linux/filesystem_resolver.hpp>
-#include <internal/util/scoped_file.hpp>
-#include <leatherman/file_util/file.hpp>
-#include <leatherman/file_util/directory.hpp>
-#include <leatherman/util/regex.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <boost/algorithm/string.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/lexical_cast.hpp>
-#include <mntent.h>
-#include <sys/vfs.h>
-#include <set>
-#include <map>
-#ifdef USE_BLKID
-#include <blkid/blkid.h>
-#endif  // USE_BLKID
-using namespace std;
-using namespace facter::facts;
-using namespace facter::util;
-using namespace boost::filesystem;
-namespace sys = boost::system;
-namespace lth_file = leatherman::file_util;
-using namespace leatherman::util;
-using boost::lexical_cast;
-using boost::bad_lexical_cast;
-namespace facter { namespace facts { namespace linux {
-    string filesystem_resolver::safe_convert(char const* value)
-    {
-        string result;
-        if (value) {
-            while (*value) {
-                unsigned char c = static_cast<unsigned char>(*value);
-                if (c >= 128) {
-                    result += "M-";
-                    c -= 128;
-                }
-                if (c < 32 || c == 0xf7) {
-                    result += '^';
-                    c ^= 0x40;
-                } else if (c == '"' || c == '\\') {
-                    result += '\\';
-                }
-                result += static_cast<char>(c);
-                ++value;
-            }
-        }
-        return result;
-    }
-    filesystem_resolver::data filesystem_resolver::collect_data(collection& facts)
-    {
-        data result;
-        collect_mountpoint_data(result);
-        collect_filesystem_data(result);
-        collect_partition_data(result);
-        return result;
-    }
-    void filesystem_resolver::collect_mountpoint_data(data& result)
-    {
-        // Populate the mountpoint data
-        scoped_file file(setmntent("/etc/mtab", "r"));
-        if (!static_cast<FILE *>(file)) {
-            LOG_ERROR("setmntent failed: {1} ({2}): mountpoints are unavailable.", strerror(errno), errno);
-            return;
-        }
-        string root_device;
-        mntent entry;
-        char buffer[4096];
-        while (mntent *ptr = getmntent_r(file, &entry, buffer, sizeof(buffer))) {
-            string device = ptr->mnt_fsname;
-            string mtype = ptr->mnt_type;
-            // Skip over anything that doesn't map to a device and is not tmpfs
-            if (!boost::starts_with(device, "/dev/") && mtype != "tmpfs") {
-                continue;
-            }
-            // If the "root" device, lookup the actual device from the kernel options
-            // This is done because not all systems symlink /dev/root
-            if (device == "/dev/root") {
-                if (root_device.empty()) {
-                    boost::regex root_pattern("root=([^\\s]+)");
-                    lth_file::each_line("/proc/cmdline", [&](string& line) {
-                        if (re_search(line, root_pattern, &root_device)) {
-                            return false;
-                        }
-                        return true;
-                    });
-                }
-                if (!root_device.empty()) {
-                    device = root_device;
-                }
-            }
-            mountpoint point;
-            point.name = ptr->mnt_dir;
-            point.device = std::move(device);
-            point.filesystem = ptr->mnt_type;
-            boost::split(point.options, ptr->mnt_opts, boost::is_any_of(","), boost::token_compress_on);
-            struct statfs stats;
-            if (statfs(ptr->mnt_dir, &stats) != -1) {
-                point.size = (static_cast<uint64_t>(stats.f_frsize)
-                              * static_cast<uint64_t>(stats.f_blocks));
-                point.available = (static_cast<uint64_t>(stats.f_frsize)
-                                   * static_cast<uint64_t>(stats.f_bfree));
-            }
-            result.mountpoints.emplace_back(move(point));
-        }
-    }
-    void filesystem_resolver::collect_filesystem_data(data& result)
-    {
-        // Populate the partition data
-        lth_file::each_line("/proc/filesystems", [&](string &line) {
-            boost::trim(line);
-            // Ignore lines without devices or fuseblk
-            if (boost::starts_with(line, "nodev") || line == "fuseblk") {
-                return true;
-            }
-            result.filesystems.emplace(move(line));
-            return true;
-        });
-    }
-    void filesystem_resolver::collect_partition_data(data& result)
-    {
-        // Populate a map of device -> mountpoint
-        map<string, string> mountpoints;
-        for (auto const& point : result.mountpoints) {
-            mountpoints.insert(make_pair(point.device, point.name));
-        }
-        void* cache = nullptr;
-#ifdef USE_BLKID
-        blkid_cache actual = nullptr;
-        if (blkid_get_cache(&actual, "/dev/null") == 0) {
-            // Do a probe since we're not using a cache file
-            if (blkid_probe_all(actual) != 0) {
-                LOG_DEBUG("blkid_probe_all failed: partition attributes are not available.");
-                blkid_put_cache(actual);
-                actual = nullptr;
-            }
-            cache = actual;
-        } else {
-            LOG_DEBUG("blkid_get_cache failed: partition attributes are not available.");
-        }
-#else
-        LOG_DEBUG("facter was built without libblkid support: partition attributes are not available.");
-#endif  // USE_BLKID
-        lth_file::each_subdirectory("/sys/block", [&](string const& subdirectory) {
-            path block_device_path(subdirectory);
-            auto block_device_filename = block_device_path.filename().string();
-            // For devices, look up partition subdirectories
-            sys::error_code ec;
-            if (is_directory(block_device_path / "device", ec)) {
-                lth_file::each_subdirectory(subdirectory, [&](string const& subdirectory) {
-                    path partition_path(subdirectory);
-                    auto partition_name = partition_path.filename().string();
-                    // Ignore any subdirectory that does not start with the device file name
-                    if (!boost::starts_with(partition_name, block_device_filename)) {
-                        return true;
-                    }
-                    partition part;
-                    part.name = "/dev/" + partition_name;
-                    populate_partition_attributes(part, subdirectory, cache, mountpoints);
-                    result.partitions.emplace_back(std::move(part));
-                    return true;
-                });
-            } else if (is_directory(block_device_path / "dm", ec)) {
-                // For mapped devices, lookup the mapping name
-                partition part;
-                string mapping_name = lth_file::read((block_device_path / "dm" / "name").string());
-                boost::trim(mapping_name);
-                if (mapping_name.empty()) {
-                    mapping_name = "/dev/" + block_device_filename;
-                } else {
-                    mapping_name = "/dev/mapper/" + mapping_name;
-                }
-                part.name = std::move(mapping_name);
-                populate_partition_attributes(part, block_device_path.string(), cache, mountpoints);
-                result.partitions.emplace_back(std::move(part));
-            } else if (is_directory(block_device_path / "loop")) {
-                // Lookup the backing file
-                partition part;
-                part.name = "/dev/" + block_device_filename;
-                part.backing_file = lth_file::read((block_device_path / "loop" / "backing_file").string());
-                boost::trim(part.backing_file);
-                populate_partition_attributes(part, block_device_path.string(), cache, mountpoints);
-                result.partitions.emplace_back(std::move(part));
-            }
-            return true;
-        });
-#ifdef USE_BLKID
-        // Cleanup the blkid cache if there is one
-        if (cache) {
-            blkid_put_cache(static_cast<blkid_cache>(cache));
-            cache = nullptr;
-        }
-#endif  // USE_BLKID
-    }
-    void filesystem_resolver::populate_partition_attributes(partition& part, string const& device_directory, void* cache, map<string, string> const& mountpoints)
-    {
-#ifdef USE_BLKID
-        if (cache) {
-            auto device = blkid_get_dev(static_cast<blkid_cache>(cache), part.name.c_str(), 0);
-            if (!device) {
-                LOG_DEBUG("blkid_get_dev failed: partition attributes are unavailable for '{1}'.", part.name);
-            } else {
-                // Populate the attributes
-                auto it = blkid_tag_iterate_begin(device);
-                if (it) {
-                    const char* name;
-                    const char* value;
-                    while (blkid_tag_next(it, &name, &value) == 0) {
-                        string* ptr = nullptr;
-                        string attribute = name;
-                        boost::to_lower(attribute);
-                        if (attribute == "type") {
-                            ptr = &part.filesystem;
-                        } else if (attribute == "label") {
-                            ptr = &part.label;
-                        } else if (attribute == "partlabel") {
-                            ptr = &part.partition_label;
-                        } else if (attribute == "uuid") {
-                            ptr = &part.uuid;
-                        } else if (attribute == "partuuid") {
-                            ptr = &part.partition_uuid;
-                        }
-                        if (!ptr) {
-                            continue;
-                        }
-                        (*ptr) = safe_convert(value);
-                    }
-                    blkid_tag_iterate_end(it);
-                }
-            }
-        }
-#endif  // USE_BLKID
-        // Lookup the mountpoint
-        auto it = mountpoints.find(part.name);
-        if (it != mountpoints.end()) {
-            part.mount = it->second;
-        }
-        // The size of a block, in bytes
-        const int block_size = 512;
-        // Read the size
-        string blocks = lth_file::read(device_directory + "/size");
-        boost::trim(blocks);
-        if (!blocks.empty()) {
-            try {
-                part.size = lexical_cast<uint64_t>(blocks) * block_size;
-            } catch (bad_lexical_cast& ex) {
-                LOG_DEBUG("cannot determine size of partition '{1}': '{2}' is not an integral value.", part.name, blocks);
-            }
-        }
-    }
-}}}  // namespace facter::facts::linux