cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,156 @@
+#include <internal/ruby/simple_resolution.hpp>
+#include <internal/ruby/module.hpp>
+#include <leatherman/execution/execution.hpp>
+#include <leatherman/locale/locale.hpp>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+using namespace facter::facts;
+using namespace leatherman::execution;
+using namespace leatherman::ruby;
+
+namespace facter { namespace ruby {
+
+    simple_resolution::simple_resolution()
+    {
+        auto const& ruby = api::instance();
+        _self = ruby.nil_value();
+        _block = ruby.nil_value();
+        _command = ruby.nil_value();
+    }
+
+    VALUE simple_resolution::define()
+    {
+        auto const& ruby = api::instance();
+
+        // Define the Resolution class
+        VALUE klass = ruby.rb_define_class_under(ruby.lookup({"Facter", "Util"}), "Resolution", *ruby.rb_cObject);
+        ruby.rb_define_alloc_func(klass, alloc);
+        ruby.rb_define_method(klass, "setcode", RUBY_METHOD_FUNC(ruby_setcode), -1);
+
+        // Deprecated in Facter 2.0; implementing for backwards compatibility
+        ruby.rb_define_singleton_method(klass, "which", RUBY_METHOD_FUNC(ruby_which), 1);
+        ruby.rb_define_singleton_method(klass, "exec", RUBY_METHOD_FUNC(ruby_exec), 1);
+
+        resolution::define(klass);
+        return klass;
+    }
+
+    VALUE simple_resolution::create()
+    {
+        auto const& ruby = api::instance();
+        return ruby.rb_class_new_instance(0, nullptr, ruby.lookup({"Facter", "Util", "Resolution"}));
+    }
+
+    VALUE simple_resolution::value()
+    {
+        auto const& ruby = api::instance();
+
+        volatile VALUE value = resolution::value();
+
+        // If the resolution has a value, return it
+        if (!ruby.is_nil(value)) {
+            return value;
+        }
+
+        // If given a block, call it to resolve
+        if (!ruby.is_nil(_block)) {
+            return ruby.rb_funcall(_block, ruby.rb_intern("call"), 0);
+        }
+
+        if (ruby.is_nil(_command)) {
+            return ruby.nil_value();
+        }
+
+        // Otherwise, we were given a command so execute it
+        VALUE result = ruby.rb_funcall(ruby.lookup({ "Facter", "Core", "Execution" }), ruby.rb_intern("exec"), 1, _command);
+        if (ruby.is_nil(result) || ruby.is_true(ruby.rb_funcall(result, ruby.rb_intern("empty?"), 0))) {
+            return ruby.nil_value();
+        }
+        return result;
+    }
+
+    VALUE simple_resolution::alloc(VALUE klass)
+    {
+        auto const& ruby = api::instance();
+
+        // Create a resolution and wrap with a Ruby data object
+        unique_ptr<simple_resolution> r(new simple_resolution());
+        VALUE self = r->_self = ruby.rb_data_object_alloc(klass, r.get(), mark, free);
+        ruby.register_data_object(self);
+
+        // Release the smart pointer; ownership is now with Ruby's GC
+        r.release();
+        return self;
+    }
+
+    void simple_resolution::mark(void* data)
+    {
+        // Mark all VALUEs contained in the simple resolution
+        auto const& ruby = api::instance();
+        auto instance = reinterpret_cast<simple_resolution*>(data);
+
+        // Call the base first
+        instance->resolution::mark();
+
+        // Mark the setcode block and command
+        ruby.rb_gc_mark(instance->_block);
+        ruby.rb_gc_mark(instance->_command);
+    }
+
+    void simple_resolution::free(void* data)
+    {
+        auto instance = reinterpret_cast<simple_resolution*>(data);
+
+        // Unregister the data object
+        auto const& ruby = api::instance();
+        ruby.unregister_data_object(instance->_self);
+
+        // Delete the simple resolution
+        delete instance;
+    }
+
+    VALUE simple_resolution::ruby_setcode(int argc, VALUE* argv, VALUE self)
+    {
+        auto const& ruby = api::instance();
+
+        if (argc > 1) {
+            ruby.rb_raise(*ruby.rb_eArgError, _("wrong number of arguments ({1} for 1)", argc).c_str());
+        }
+
+        auto instance = ruby.to_native<simple_resolution>(self);
+
+        if (argc == 0) {
+            // No arguments, only a block is required
+            if (!ruby.rb_block_given_p()) {
+                ruby.rb_raise(*ruby.rb_eArgError, _("a block must be provided").c_str());
+            }
+            instance->_block = ruby.rb_block_proc();
+        } else if (argc == 1) {
+            VALUE arg = argv[0];
+            if (!ruby.is_string(arg) || ruby.is_true(ruby.rb_funcall(arg, ruby.rb_intern("empty?"), 0))) {
+                ruby.rb_raise(*ruby.rb_eTypeError, _("expected a non-empty String for first argument").c_str());
+            }
+            if (ruby.rb_block_given_p()) {
+                ruby.rb_raise(*ruby.rb_eArgError, _("a block is unexpected when passing a String").c_str());
+            }
+            instance->_command = arg;
+        }
+        return self;
+    }
+
+    VALUE simple_resolution::ruby_which(VALUE klass, VALUE binary)
+    {
+        auto const& ruby = api::instance();
+        return ruby.rb_funcall(ruby.lookup({ "Facter", "Core", "Execution" }), ruby.rb_intern("which"), 1, binary);
+    }
+
+    VALUE simple_resolution::ruby_exec(VALUE klass, VALUE command)
+    {
+        auto const& ruby = api::instance();
+        return ruby.rb_funcall(ruby.lookup({ "Facter", "Core", "Execution" }), ruby.rb_intern("exec"), 1, command);
+    }
+
+}}  // namespace facter::ruby

data/ext/facter/facter/lib/src/util/bsd/scoped_ifaddrs.cc

@@ -0,0 +1,29 @@
+#include <internal/util/bsd/scoped_ifaddrs.hpp>
+
+using namespace std;
+using namespace leatherman::util;
+
+namespace facter { namespace util { namespace bsd {
+
+    scoped_ifaddrs::scoped_ifaddrs() :
+        scoped_resource(nullptr, free)
+    {
+        // Get the linked list of interfaces
+        if (getifaddrs(&_resource) == -1) {
+            _resource = nullptr;
+        }
+    }
+
+    scoped_ifaddrs::scoped_ifaddrs(ifaddrs* addrs) :
+        scoped_resource(move(addrs), free)
+    {
+    }
+
+    void scoped_ifaddrs::free(ifaddrs* addrs)
+    {
+        if (addrs) {
+            ::freeifaddrs(addrs);
+        }
+    }
+
+}}}  // namespace facter::util::bsd

data/ext/facter/facter/lib/src/util/config/config.cc

@@ -0,0 +1,83 @@
+#include <facter/util/config.hpp>
+#include <hocon/program_options.hpp>
+#include <leatherman/file_util/file.hpp>
+#include <facter/logging/logging.hpp>
+
+using namespace std;
+using namespace hocon;
+namespace po = boost::program_options;
+
+namespace facter { namespace util { namespace config {
+
+    shared_config load_config_from(string config_path) {
+        if (leatherman::file_util::file_readable(config_path)) {
+            return hocon::config::parse_file_any_syntax(config_path)->resolve();
+        }
+        return nullptr;
+    }
+
+    void load_global_settings(shared_config hocon_config, po::variables_map& vm) {
+        if (hocon_config && hocon_config->has_path("global")) {
+            auto global_settings = hocon_config->get_object("global")->to_config();
+            po::store(hocon::program_options::parse_hocon<char>(global_settings, global_config_options(), true), vm);
+        }
+    }
+
+    void load_cli_settings(shared_config hocon_config, po::variables_map& vm) {
+        if (hocon_config && hocon_config->has_path("cli")) {
+            auto cli_settings = hocon_config->get_object("cli")->to_config();
+            po::store(hocon::program_options::parse_hocon<char>(cli_settings, cli_config_options(), true), vm);
+        }
+    }
+
+    void load_fact_settings(shared_config hocon_config, po::variables_map& vm) {
+        if (hocon_config && hocon_config->has_path("facts")) {
+            auto fact_settings = hocon_config->get_object("facts")->to_config();
+            po::store(hocon::program_options::parse_hocon<char>(fact_settings, fact_config_options(), true), vm);
+        }
+    }
+
+    po::options_description global_config_options() {
+        po::options_description global_options("");
+        global_options.add_options()
+            ("custom-dir", po::value<vector<string>>(), "A directory or list of directories to use for custom facts.")
+            ("external-dir", po::value<vector<string>>(), "A directory or list of directories to use for external facts.")
+            ("no-custom-facts", po::value<bool>()->default_value(false), "Disables custom facts.")
+            ("no-external-facts", po::value<bool>()->default_value(false), "Disables external facts.")
+            ("no-ruby", po::value<bool>()->default_value(false), "Disables loading Ruby, facts requiring Ruby, and custom facts.");
+        return global_options;
+    }
+
+    po::options_description cli_config_options() {
+        po::options_description cli_options("");
+        cli_options.add_options()
+            ("debug", po::value<bool>()->default_value(false), "Enable debug output.")
+            ("log-level", po::value<logging::level>()->default_value(logging::level::warning, "warn"), "Set logging level.\nSupported levels are: none, trace, debug, info, warn, error, and fatal.")
+            ("trace", po::value<bool>()->default_value(false), "Enable backtraces for custom facts.")
+            ("verbose", po::value<bool>()->default_value(false), "Enable verbose (info) output.");
+        return cli_options;
+    }
+
+    po::options_description fact_config_options() {
+        po::options_description fact_settings("");
+        fact_settings.add_options()
+            ("blocklist", po::value<vector<string>>(), "A set of facts to block.");
+        return fact_settings;
+    }
+
+    unordered_map<string, int64_t> load_ttls(shared_config hocon_config) {
+        unordered_map<string, int64_t> ttls;
+        if (hocon_config && hocon_config->has_path("facts.ttls")) {
+            auto ttl_objs = hocon_config->get_object_list("facts.ttls");
+            for (auto entry : ttl_objs) {
+                shared_config entry_conf = entry->to_config();
+                // triple-quote this string so that cpp-hocon will correctly parse it as a single path element
+                // and ignore otherwise reserved characters
+                string fact = entry->key_set().front();
+                int64_t duration = entry_conf->get_duration("\"\"\"" + fact + "\"\"\"", time_unit::SECONDS);
+                ttls.insert({ fact, duration });
+            }
+        }
+        return ttls;
+    }
+}}}  // namespace facter::util::config;

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

@@ -0,0 +1,12 @@
+#include <facter/util/config.hpp>
+
+namespace facter { namespace util { namespace config {
+
+    hocon::shared_config load_default_config_file() {
+        return load_config_from(default_config_location());
+    }
+
+    std::string default_config_location() {
+        return "/etc/puppetlabs/facter/facter.conf";
+    }
+}}}  // namespace facter::util::config

data/ext/facter/facter/lib/src/util/config/windows/config.cc

@@ -0,0 +1,14 @@
+#include <facter/util/config.hpp>
+#include <leatherman/windows/file_util.hpp>
+
+namespace facter { namespace util { namespace config {
+
+    hocon::shared_config load_default_config_file() {
+        return load_config_from(default_config_location());
+    }
+
+    std::string default_config_location() {
+        return leatherman::windows::file_util::get_programdata_dir() +
+            "\\PuppetLabs\\facter\\etc\\facter.conf";
+    }
+}}}  // namespace facter::util::config

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

@@ -0,0 +1,41 @@
+#include <internal/util/posix/scoped_addrinfo.hpp>
+
+using namespace std;
+using namespace leatherman::util;
+
+namespace facter { namespace util { namespace posix {
+
+    scoped_addrinfo::scoped_addrinfo(string const& hostname) :
+        scoped_resource(nullptr, free)
+    {
+        addrinfo hints;
+        memset(&hints, 0, sizeof hints);
+        hints.ai_family = AF_UNSPEC;
+        hints.ai_socktype = SOCK_STREAM;
+        hints.ai_flags = AI_CANONNAME;
+
+        _result = getaddrinfo(hostname.c_str(), nullptr, &hints, &_resource);
+        if (_result != 0) {
+            _resource = nullptr;
+        }
+    }
+
+    scoped_addrinfo::scoped_addrinfo(addrinfo* info) :
+        scoped_resource(move(info), free),
+        _result(0)
+    {
+    }
+
+    int scoped_addrinfo::result() const
+    {
+        return _result;
+    }
+
+    void scoped_addrinfo::free(addrinfo* info)
+    {
+        if (info) {
+            ::freeaddrinfo(info);
+        }
+    }
+
+}}}  // namespace facter::util::posix

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

@@ -0,0 +1,29 @@
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#include <internal/util/posix/scoped_bio.hpp>
+
+using namespace std;
+using namespace leatherman::util;
+
+namespace facter { namespace util { namespace posix {
+
+    // Remove const-ness before calling BIO_new. This is "unsafe",
+    // but in isolation here will not cause issues. Allows the code to work
+    // with both OpenSSL 1.0 and 1.1.
+    scoped_bio::scoped_bio(const BIO_METHOD* method) :
+        scoped_resource(BIO_new(const_cast<BIO_METHOD*>(method)), free)
+    {
+    }
+
+    scoped_bio::scoped_bio(BIO* bio) :
+        scoped_resource(move(bio), free)
+    {
+    }
+
+    void scoped_bio::free(BIO* bio)
+    {
+        if (bio) {
+            BIO_free(bio);
+        }
+    }
+
+}}}  // namespace facter::util::posix

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

@@ -0,0 +1,20 @@
+#include <internal/util/posix/scoped_descriptor.hpp>
+
+using namespace std;
+using namespace leatherman::util;
+
+namespace facter { namespace util { namespace posix {
+
+    scoped_descriptor::scoped_descriptor(int descriptor) :
+        scoped_resource(move(descriptor), close)
+    {
+    }
+
+    void scoped_descriptor::close(int descriptor)
+    {
+        if (descriptor >= 0) {
+            ::close(descriptor);
+        }
+    }
+
+}}}  // namespace facter::util::posix

data/ext/facter/facter/lib/src/util/scoped_file.cc

@@ -0,0 +1,26 @@
+#include <internal/util/scoped_file.hpp>
+#include <boost/nowide/cstdio.hpp>
+
+using namespace std;
+using namespace leatherman::util;
+
+namespace facter { namespace util {
+
+    scoped_file::scoped_file(string const& path, string const& mode) :
+       scoped_resource(boost::nowide::fopen(path.c_str(), mode.c_str()), close)
+    {
+    }
+
+    scoped_file::scoped_file(FILE* file) :
+       scoped_resource(move(file), close)
+    {
+    }
+
+    void scoped_file::close(FILE* file)
+    {
+       if (file) {
+           fclose(file);
+       }
+    }
+
+}}  // namespace facter::util

data/ext/facter/facter/lib/src/util/solaris/k_stat.cc

@@ -0,0 +1,165 @@
+#include <internal/util/solaris/k_stat.hpp>
+#include <sys/kstat.h>
+#include <cstring>
+#include <leatherman/locale/locale.hpp>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+
+namespace facter { namespace util { namespace solaris {
+    k_stat::k_stat() {
+        if (ctrl == nullptr) {
+            throw kstat_exception(_("kstat_open failed"));
+        }
+    }
+
+    vector<k_stat_entry> k_stat::operator[](string const& module)
+    {
+        return lookup(module, -1, {});
+    }
+
+    vector<k_stat_entry> k_stat::operator[](pair<string, int> const& entry)
+    {
+        return lookup(entry.first, entry.second, {});
+    }
+
+    vector<k_stat_entry> k_stat::operator[](pair<string, string> const& entry)
+    {
+        return lookup(entry.first, -1, entry.second);
+    }
+
+    vector<k_stat_entry> k_stat::lookup(string const& module, int instance, string const& name)
+    {
+        kstat_t* kp = kstat_lookup(ctrl, const_cast<char*>(module.c_str()), instance, name.empty() ? nullptr : const_cast<char *>(name.c_str()));
+        if (kp == nullptr) {
+            throw kstat_exception(_("kstat_lookup of module {1}/{2}/{3} failed: {4} ({5})",
+                                    module,
+                                    to_string(instance),
+                                    name,
+                                    string(strerror(errno)),
+                                    to_string(errno)));
+        }
+
+        vector<k_stat_entry> arr;
+        while (kp) {
+            if (kstat_read(ctrl, kp, 0) == -1) {
+                throw kstat_exception(_("kstat_read failed: {1} ({2})",
+                                        string(strerror(errno)),
+                                        to_string(errno)));
+            }
+
+            bool insert = true;
+            if (!module.empty() && module != kp->ks_module) {
+                insert = false;
+            }
+            if (instance != -1 && instance != kp->ks_instance) {
+                insert = false;
+            }
+            if (!name.empty() && name != kp->ks_name) {
+                insert = false;
+            }
+            if (insert) {
+                arr.push_back(k_stat_entry(kp));
+            }
+            kp = kp->ks_next;
+        }
+
+        return arr;
+    }
+
+    k_stat_entry::k_stat_entry(kstat_t* kp) :
+        k_stat(kp)
+    {
+    }
+
+    int k_stat_entry::instance()
+    {
+        return k_stat->ks_instance;
+    }
+
+    string k_stat_entry::klass()
+    {
+        return k_stat->ks_class;
+    }
+
+    string k_stat_entry::module()
+    {
+        return k_stat->ks_module;
+    }
+
+    string k_stat_entry::name()
+    {
+        return k_stat->ks_name;
+    }
+
+    kstat_named_t* k_stat_entry::lookup(const string& attrib) const
+    {
+        kstat_named_t* knp = reinterpret_cast<kstat_named_t*>(kstat_data_lookup(k_stat, const_cast<char*>(attrib.c_str())));
+        if (knp == nullptr) {
+            throw kstat_exception(_("kstat_data_lookup failed for {1}", attrib));
+        }
+        return knp;
+    }
+
+     kstat_named_t* k_stat_entry::lookup(int datatype, const string& attrib) const
+    {
+        kstat_named_t* knp = reinterpret_cast<kstat_named_t*>(kstat_data_lookup(k_stat, const_cast<char*>(attrib.c_str())));
+        if (knp == nullptr) {
+            throw kstat_exception(_("kstat_data_lookup failed for {1}", attrib));
+        }
+        if (knp->data_type != datatype) {
+            throw kstat_exception(_("invalid datatype {1} {2}", attrib, to_string(knp->data_type)));
+        }
+        return knp;
+    }
+
+    template<>
+    ulong_t k_stat_entry::value(const std::string& attrib) const
+    {
+        return lookup(KSTAT_DATA_ULONG, attrib)->value.ul;
+    }
+
+    template<>
+    long k_stat_entry::value(const std::string& attrib) const
+    {
+        return lookup(KSTAT_DATA_LONG, attrib)->value.l;
+    }
+
+    template<>
+    int32_t k_stat_entry::value(const std::string& attrib) const
+    {
+        return lookup(KSTAT_DATA_INT32, attrib)->value.i32;
+    }
+
+    template<>
+    uint32_t k_stat_entry::value(const std::string& attrib) const
+    {
+        return lookup(KSTAT_DATA_UINT32, attrib)->value.ui32;
+    }
+
+    template<>
+    int64_t k_stat_entry::value(const std::string& attrib) const
+    {
+        return lookup(KSTAT_DATA_INT64, attrib)->value.i64;
+    }
+
+    template<>
+    uint64_t k_stat_entry::value(const std::string& attrib) const
+    {
+        return lookup(KSTAT_DATA_UINT64, attrib)->value.ui64;
+    }
+
+    template<>
+    std::string k_stat_entry::value(const std::string& attrib) const
+    {
+        auto res = lookup(attrib);
+        if (res->data_type == KSTAT_DATA_STRING) {
+            return res->value.str.addr.ptr;
+        } else if (res->data_type == KSTAT_DATA_CHAR) {
+            return string(res->value.c);
+        }
+        throw kstat_exception(_("invalid datatype {1} {2}", attrib, to_string(res->data_type)));
+    }
+}}}  // namespace facter::util::solaris