facter 3.12.2.cfacter.20181217 → 4.0.7.pre

data/ext/facter/facter/lib/schema/translation_tooling.rb

@@ -1,67 +0,0 @@
-require 'yaml'
-
-fact_schema = YAML.load_file(File.join(File.dirname(__FILE__), "facter.yaml"))
-facts = []
-
-fact_schema.each do |fact|
-  fact_name = fact[0]
-  fact_details = fact[1]
-
-  fact_data = {:name => fact_name,
-               :description => fact_details['description'],
-               :resolution => fact_details['resolution'],
-               :caveats => fact_details['caveats']}
-
-  facts << fact_data
-end
-
-File.open(File.join(File.dirname(__FILE__), "core_facts.pot"), 'w') do |file|
-  file.puts <<-HEADER
-# CORE FACTS SCHEMA
-# Copyright (C) 2016 Puppet, LLC
-# This file is distributed under the same license as the FACTER package.
-# FIRST AUTHOR <docs@puppet.com>, 2016.
-#
-#, fuzzy
-msgid ""
-msgstr ""
-"Project-Id-Version: FACTER \\n"
-"Report-Msgid-Bugs-To: docs@puppet.com\\n"
-"POT-Creation-Date: \\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
-"Language-Team: LANGUAGE <LL@li.org>\\n"
-"Language: \\n"
-"MIME-Version: 1.0\\n"
-"Content-Type: text/plain; charset=UTF-8\\n"
-"Content-Transfer-Encoding: 8bit\\n"
-"Plural-Forms: nplurals=INTEGER; plural=EXPRESSION;\\n"
-\n
-  HEADER
-
-  facts.each do |fact|
-    if fact[:description]
-      descriptions = fact[:description].split("\n")
-
-      descriptions.each do |string|
-        file.puts "#. #{fact[:name]} description\nmsgid \"#{string}\"\nmsgstr \"\"\n\n"
-      end
-    end
-
-    if fact[:resolution]
-      resolutions = fact[:resolution].split("\n")
-
-      resolutions.each do |string|
-        file.puts "#. #{fact[:name]} resolution\nmsgid \"#{string}\"\nmsgstr \"\"\n\n"
-      end
-    end
-
-    if fact[:caveats]
-      caveats = fact[:caveats].split("\n")
-
-      caveats.each do |string|
-        file.puts "#. #{fact[:name]} caveats\nmsgid \"#{string}\"\nmsgstr \"\"\n\n"
-      end
-    end
-  end
-end

data/ext/facter/facter/lib/spec/unit/facter_spec.rb

@@ -1,136 +0,0 @@
-# encoding: UTF-8
-require 'spec_helper'
-
-Facter.on_message do |level, message|
-    puts message if level == :fatal
-end
-
-describe Facter do
-
-  it 'should provide a version' do
-    expect(Facter.version).to_not be_nil
-  end
-
-  describe 'without resetting' do
-
-    before :all do
-      Facter.reset
-    end
-
-    it 'should not be an empty hash' do
-      expect(Facter.to_hash).to_not be_empty
-    end
-
-    it 'should return a fact for []' do
-      fact = Facter[:facterversion]
-      expect(fact).to_not be_nil
-      expect(fact.name).to eq('facterversion')
-      expect(fact.value).to eq(Facter.version)
-    end
-
-    it 'should return nil value for [] with unknown fact' do
-      expect(Facter[:not_a_fact]).to be_nil
-    end
-
-    it 'should return nil for value with unknown fact' do
-      expect(Facter.value(:not_a_fact)).to be_nil
-    end
-
-    it 'should contain a matching facter version' do
-      version = Facter.value('facterversion')
-      expect(version).to eq(Facter.version)
-      expect(version).to eq(Facter::FACTERVERSION)
-    end
-  end
-
-  describe 'with resetting' do
-    before :each do
-      Facter.reset
-    end
-
-    it 'should load external facts' do
-      # Check for windows vs posix for executable external facts
-      windows = Facter.value('osfamily') == 'windows'
-      Facter.reset
-
-      Facter.search_external([
-        File.expand_path('../../../lib/tests/fixtures/facts/external/yaml', File.dirname(__FILE__)),
-        File.expand_path('../../../lib/tests/fixtures/facts/external/json', File.dirname(__FILE__)),
-        File.expand_path('../../../lib/tests/fixtures/facts/external/text', File.dirname(__FILE__)),
-        File.expand_path("../../../lib/tests/fixtures/facts/external/#{ if windows then 'windows' else 'posix' end }/execution", File.dirname(__FILE__))
-      ])
-
-      facts = Facter.to_hash
-      expect(facts['yaml_fact1']).to be_a(String)
-      expect(facts['yaml_fact2']).to be_a(Integer)
-      expect(facts['yaml_fact3']).to(satisfy { |v| v == true || v == false })
-      expect(facts['yaml_fact4']).to be_a(Float)
-      expect(facts['yaml_fact5']).to be_a(Array)
-      expect(facts['yaml_fact6']).to be_a(Hash)
-      expect(facts['yaml_fact7']).to be_a(String)
-      expect(facts['not_bool']).to be_a(String)
-      expect(facts['not_int']).to be_a(String)
-      expect(facts['not_double']).to be_a(String)
-      expect(facts['json_fact1']).to be_a(String)
-      expect(facts['json_fact2']).to be_a(Integer)
-      expect(facts['json_fact3']).to(satisfy { |v| v == true || v == false })
-      expect(facts['json_fact4']).to be_a(Float)
-      expect(facts['json_fact5']).to be_a(Array)
-      expect(facts['json_fact6']).to be_a(Hash)
-      expect(facts['exe_fact1']).to be_a(String)
-      expect(facts['exe_fact2']).to be_a(String)
-      expect(facts['exe_fact3']).to be_nil
-      expect(facts['txt_fact1']).to be_a(String)
-      expect(facts['txt_fact2']).to be_a(String)
-      expect(facts['txt_fact3']).to be_nil
-    end
-
-    it 'should set search paths' do
-      Facter.search('foo', 'bar', 'baz')
-      expect(Facter.search_path).to include('foo', 'bar', 'baz')
-      Facter.reset
-      expect(Facter.search_path).to eq([])
-    end
-
-    it 'should set external search paths' do
-      Facter.search_external(['foo', 'bar', 'baz'])
-      expect(Facter.search_external_path).to include('foo', 'bar', 'baz')
-    end
-
-    it 'should find encoded search paths' do
-      snowman_path = File.expand_path('../../../lib/tests/fixtures/facts/external/zö', File.dirname(__FILE__))
-      encoded_path = snowman_path.encode("Windows-1252")
-      Facter.search(encoded_path)
-      expect(Facter.search_path).to include(snowman_path)
-      expect(Facter.value('snowman_fact')).to eq('olaf')
-    end
-
-    it 'should find encoded external search paths' do
-      snowman_path = File.expand_path('../../../lib/tests/fixtures/facts/external/zö', File.dirname(__FILE__))
-      encoded_path = snowman_path.encode("Windows-1252")
-      Facter.search_external([encoded_path])
-      expect(Facter.search_external_path).to include(snowman_path)
-      expect(Facter.value('snowman_fact')).to eq('olaf')
-    end
-
-    it 'should support stubbing for confine testing' do
-      Facter.fact(:osfamily).expects(:value).at_least(1).returns 'foo'
-      expect(Facter.fact(:osfamily).value).to eq('foo')
-      Facter.add(:test) do
-        confine osfamily: 'foo'
-        setcode do
-          'bar'
-        end
-      end
-      expect(Facter.value(:test)).to eq('bar')
-    end
-
-    it 'should allow stubbing on which and exec' do
-      Facter::Util::Resolution.expects(:which).with("foo").returns('/usr/bin/foo')
-      Facter::Util::Resolution.expects(:exec).with("foo").returns('bar')
-      expect(Facter::Util::Resolution.which('foo')).to eq('/usr/bin/foo')
-      expect(Facter::Util::Resolution.exec('foo')).to eq('bar')
-    end
-  end
-
-end

data/ext/facter/facter/lib/spec_helper.rb.in

@@ -1,27 +0,0 @@
-# Set FACTERDIR so that facter.rb can find libfacter.so
-ENV['FACTERDIR'] = '${CMAKE_BINARY_DIR}'
-
-# Add the location of libfacter.so to the path for Windows
-ENV['PATH'] = '${CMAKE_BINARY_DIR}/${LIBFACTER_INSTALL_DESTINATION}' + File::PATH_SEPARATOR + ENV['PATH']
-
-require 'mocha'
-require 'rspec'
-require '${CMAKE_BINARY_DIR}/lib/facter.rb'
-
-RSpec.configure do |config|
-  config.mock_with :mocha
-
-  config.before :each do
-    # Store any environment variables away to be restored later
-    @old_env = {}
-    ENV.each_key {|k| @old_env[k] = ENV[k]}
-  end
-
-  config.after :each do
-    # Restore environment variables after execution of each test
-    @old_env.each_pair {|k, v| ENV[k] = v}
-    to_remove = ENV.keys.reject {|key| @old_env.include? key }
-    to_remove.each {|key| ENV.delete key }
-  end
-end
-

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

@@ -1,45 +0,0 @@
-#include <facter/cwrapper.hpp>
-
-#include <facter/facts/collection.hpp>
-#include <facter/util/config.hpp>
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <sstream>
-
-uint8_t get_default_facts(char **result) {
-    try {
-        // NB: ssh resolver cannot be blocked
-        facter::facts::collection facts {{},      // blocklist set
-                                         {},      // ttls map (resolvers - ttl)
-                                         true};   // ignore_cache flag
-
-        // The boolean arg is meant to avoid including ruby facts
-        facts.add_default_facts(false);
-
-        // NB: skipping the add_environment_facts() call
-
-        // TODO: consider iterating only the facts we're interested
-        // in by using the 'queries' arg
-        std::ostringstream stream;
-        facts.write(stream,
-                    facter::facts::format::json,
-                    {},     // queries vector
-                    true,   // show_legacy flag
-                    true);  // strict_errors flag
-
-        auto json_facts = stream.str();
-        auto l = json_facts.length()+1;
-
-        *result = static_cast<char*>(malloc(sizeof(char)*l));
-        if (*result == nullptr) {
-            return EXIT_FAILURE;
-        }
-
-        strncpy(*result, json_facts.c_str(), l);
-    } catch (const std::exception&) {
-        return EXIT_FAILURE;
-    }
-
-    return EXIT_SUCCESS;
-}

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

@@ -1,34 +0,0 @@
-#include <facter/facts/collection.hpp>
-#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>
-#include <internal/facts/aix/processor_resolver.hpp>
-#include <internal/facts/aix/serial_number_resolver.hpp>
-#include <internal/facts/posix/ssh_resolver.hpp>
-#include <internal/facts/posix/identity_resolver.hpp>
-#include <internal/facts/posix/timezone_resolver.hpp>
-#include <internal/facts/posix/uptime_resolver.hpp>
-
-using namespace std;
-
-namespace facter { namespace facts {
-    void collection::add_platform_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>());
-        add(make_shared<aix::processor_resolver>());
-        add(make_shared<aix::serial_number_resolver>());
-        add(make_shared<posix::ssh_resolver>());
-        add(make_shared<posix::identity_resolver>());
-        add(make_shared<posix::timezone_resolver>());
-        add(make_shared<posix::uptime_resolver>());
-    }
-}}  // namespace facter::facts

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

@@ -1,75 +0,0 @@
-#include <internal/facts/aix/disk_resolver.hpp>
-#include <internal/util/aix/odm.hpp>
-#include <internal/util/posix/scoped_descriptor.hpp>
-#include <leatherman/logging/logging.hpp>
-
-#include <fcntl.h>
-#include <odmi.h>
-#include <sys/cfgodm.h>
-#include <sys/ioctl.h>
-#include <sys/devinfo.h>
-
-using namespace facter::util::aix;
-using namespace facter::util::posix;
-using namespace std;
-
-namespace facter { namespace facts { namespace aix {
-
-    disk_resolver::data disk_resolver::collect_data(collection& facts)
-    {
-        data result;
-        vector<string> disk_types;
-        auto pd_dv_query = odm_class<PdDv>::open("PdDv").query("class=disk");
-        for (auto& pd_dv : pd_dv_query) {
-            LOG_DEBUG("got a disk type: {1}", pd_dv.uniquetype);
-            disk_types.push_back(pd_dv.uniquetype);
-        }
-
-        auto cu_dv = odm_class<CuDv>::open("CuDv");
-        for (string& type : disk_types) {
-            string query = (boost::format("PdDvLn=%1%") % type).str();
-            auto cu_dv_query = cu_dv.query(query);
-            for (auto& cu_dv : cu_dv_query) {
-                LOG_DEBUG("got a disk: {1}", cu_dv.name);
-                disk d;
-                d.name = cu_dv.name;
-
-                {
-                    string device = (boost::format("/dev/%1%") % d.name).str();
-                    auto descriptor = open(device.c_str(), O_RDONLY);
-                    if (descriptor < 0) {
-                        LOG_DEBUG("Could not open device %1% for reading: %2% (%3%). Disk facts will not be populated for this device", d.name, strerror(errno), errno);
-                        continue;
-                    }
-                    scoped_descriptor fd(descriptor);
-                    devinfo info;
-                    auto result = ioctl(fd, IOCINFO, &info);
-                    if (result < 0) {
-                        LOG_DEBUG("Ioctl IOCINFO failed for device %1%: %2% (%3%). Disk facts will not be populated for this device", d.name, strerror(errno), errno);
-                        continue;
-                    }
-                    switch (info.devtype) {
-                    case DD_DISK:
-                    case DD_SCDISK:
-                        if (info.flags & DF_LGDSK) {
-                            d.size = (uint32_t)info.un.scdk64.hi_numblks;
-                            d.size <<= 32;
-                            d.size |= (uint32_t)info.un.scdk64.lo_numblks;
-                            d.size *= info.un.scdk64.blksize;
-                        } else {
-                            d.size = (uint32_t)info.un.scdk.numblks;
-                            d.size *= info.un.scdk.blksize;
-                        }
-                        break;
-                    default:
-                        LOG_WARNING("Expected a Disk or SCSI disk device, got device code '{1}'. This is probably a Facter bug. Please report it, and include this error message.", info.devtype);
-                        break;
-                    }
-                }
-                result.disks.emplace_back(move(d));
-            }
-        }
-
-        return result;
-    }
-}}}  // namespace facter::facts::aix

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

@@ -1,132 +0,0 @@
-#include <internal/facts/aix/filesystem_resolver.hpp>
-#include <internal/util/aix/odm.hpp>
-#include <internal/util/aix/vmount.hpp>
-#include <leatherman/file_util/file.hpp>
-#include <leatherman/logging/logging.hpp>
-
-#include <boost/algorithm/string.hpp>
-
-#include <map>
-#include <string>
-#include <vector>
-
-#include <lvm.h>
-#include <odmi.h>
-#include <sys/cfgodm.h>
-#include <sys/statfs.h>
-
-using namespace std;
-using namespace facter::util::aix;
-namespace fu = leatherman::file_util;
-
-namespace facter { namespace facts { namespace aix {
-    filesystem_resolver::data filesystem_resolver::collect_data(collection& facts)
-    {
-        data result;
-        collect_filesystem_data(result);
-        collect_mountpoint_data(result);
-        collect_partition_data(result);
-        return result;
-    }
-
-    void filesystem_resolver::collect_filesystem_data(data& result)
-    {
-        fu::each_line("/etc/vfs", [&](const string& line) {
-            auto first_char = line.find_first_not_of(" \t");
-            if (first_char != string::npos &&  // skip completely blank lines
-                line[first_char] != '#' &&  // skip comment lines
-                line[first_char] != '%')  {  // skip defaultvfs line
-                vector<string> tokens;
-                boost::split(tokens, line, boost::is_space(), boost::token_compress_on);
-                _filesystems.emplace(make_pair(stoul(tokens[1]), tokens[0]));
-                result.filesystems.emplace(move(tokens[0]));
-            }
-            return true;
-        });
-    }
-
-    void filesystem_resolver::collect_mountpoint_data(data& result)
-    {
-        for (const auto& mount : mountctl()) {
-            mountpoint m;
-            // AIX Version 5.3 does not define the MNT_AHAFS variable.
-            // Anything above aix 5.3 will have _AIXVERSION_610 defined.
-#ifndef _AIXVERSION_610
-            if (mount.vmt_gfstype == MNT_PROCFS) {
-                continue;
-            }
-#else
-            if (mount.vmt_gfstype == MNT_PROCFS || mount.vmt_gfstype == MNT_AHAFS) {
-                continue;
-            }
-#endif
-            m.filesystem = _filesystems[mount.vmt_gfstype];
-            m.device = reinterpret_cast<char*>(vmt2dataptr(&mount, VMT_OBJECT));
-            m.name = reinterpret_cast<char*>(vmt2dataptr(&mount, VMT_STUB));
-
-            string opts = reinterpret_cast<char*>(vmt2dataptr(&mount, VMT_ARGS));
-            boost::split(m.options, opts, boost::is_any_of(","));
-
-            struct statfs64 fs;
-            if (0 != statfs64(const_cast<char*>(m.name.c_str()), &fs)) {
-                LOG_WARNING("Could not get fs data for {1}: {2}", m.name, errno);
-            } else {
-                m.size = fs.f_bsize*fs.f_blocks;
-                m.available = fs.f_bsize*fs.f_bfree;
-            }
-
-            _mounts[m.device] = m.name;
-            result.mountpoints.emplace_back(move(m));
-        }
-    }
-
-    void filesystem_resolver::collect_partition_data(data& result)
-    {
-        auto cu_dv = odm_class<CuDv>::open("CuDv");
-        auto cu_at = odm_class<CuAt>::open("CuAt");
-        for (auto& dv : cu_dv.query("PdDvLn=logical_volume/lvsubclass/lvtype")) {
-            partition p;
-            p.name = string("/dev/") + dv.name;
-
-            string query = (boost::format("name=%1%") % dv.name).str();
-            for (auto& at : cu_at.query(query)) {
-                if (0 == strcmp(at.attribute, "label")) {
-                    p.label = at.value;
-                } else if (0 == strcmp(at.attribute, "lvserial_id")) {
-                    struct lv_id id;
-                    // AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDD.EEEE format
-                    // First four chunks are hexadecimal 32-bit integers.
-                    // After the dot is a decimal integer
-                    // Volume groups from the 90s only have 64-bit IDs,
-                    // rather than the full 128.
-
-                    auto vgid = string(at.value);
-                    auto length = vgid.find_first_of('.');
-                    id.vg_id.word1 = stoul(vgid.substr(0, 8), nullptr, 16);
-                    id.vg_id.word2 = stoul(vgid.substr(8, 8), nullptr, 16);
-                    if (length == 32) {
-                        id.vg_id.word3 = stoul(vgid.substr(16, 8), nullptr, 16);
-                        id.vg_id.word4 = stoul(vgid.substr(24, 8), nullptr, 16);
-                    }
-                    id.minor_num = stoul(vgid.substr(length+1, string::npos), nullptr, 10);
-
-                    struct querylv* lv;
-                    if (0 != lvm_querylv(&id, &lv, nullptr)) {
-                        LOG_WARNING("Could not get info for partition '{1}' from the LVM subsystem", p.name);
-                    } else if (!lv) {
-                        LOG_WARNING("querylv returned success but we got a null LV. WTF?");
-                    } else {
-                        // Size is calculated as "currentsize * 2^ppsize".
-                        p.size = lv->currentsize;
-                        p.size <<= lv->ppsize;
-                    }
-                } else if (0 == strcmp(at.attribute, "type")) {
-                    p.filesystem = at.value;
-                }
-            }
-
-            p.mount = _mounts[p.name];
-            result.partitions.emplace_back(move(p));
-        }
-    }
-}}}