cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,136 @@
+# 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

@@ -0,0 +1,27 @@
+# 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

@@ -0,0 +1,45 @@
+#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

@@ -0,0 +1,32 @@
+#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/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::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

@@ -0,0 +1,66 @@
+#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();
+                    scoped_descriptor fd(open(device.c_str(), O_RDONLY));
+                    devinfo info;
+                    ioctl(fd, IOCINFO, &info);
+                    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

@@ -0,0 +1,132 @@
+#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));
+        }
+    }
+}}}