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/ruby/simple_resolution.cc DELETED

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

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

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

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

@@ -1,14 +0,0 @@
-#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/freebsd/geom.cc DELETED

@@ -1,130 +0,0 @@
-#include <internal/util/freebsd/geom.hpp>
-#include <leatherman/locale/locale.hpp>
-#include <leatherman/logging/logging.hpp>
-using leatherman::locale::_;
-using namespace std;
-namespace facter { namespace util { namespace freebsd {
-    geom_exception::geom_exception(std::string const& message) :
-        runtime_error(message)
-    {
-    }
-    geom_config::geom_config(string name, string value)
-    {
-        _name = name;
-        _value = value;
-    }
-    string
-    geom_config::name()
-    {
-        return _name;
-    }
-    string
-    geom_config::value()
-    {
-        return _value;
-    }
-    geom_object_with_config::geom_object_with_config(struct gconf *conf)
-    {
-        struct gconfig *config;
-        LIST_FOREACH(config, conf, lg_config) {
-            if (!config->lg_val) {
-                LOG_DEBUG(_("Skipping config {1} because it has a null value", config->lg_name));
-                continue;
-            }
-            _configs.push_back(geom_config(config->lg_name, config->lg_val));
-        }
-    }
-    string
-    geom_object_with_config::config(string name) {
-        for (auto config : _configs) {
-            if (config.name() == name)
-                return config.value();
-        }
-        return "";
-    }
-    geom_provider::geom_provider(struct gprovider* provider) :
-        geom_object_with_config(&provider->lg_config)
-    {
-        _name         = provider->lg_name;
-        _mode         = provider->lg_mode;
-        _mediasize    = provider->lg_mediasize;
-        _sectorsize   = provider->lg_sectorsize;
-        _stripeoffset = provider->lg_stripeoffset;
-        _stripesize   = provider->lg_stripesize;
-    }
-    string
-    geom_provider::name()
-    {
-        return _name;
-    }
-    off_t
-    geom_provider::mediasize()
-    {
-        return _mediasize;
-    }
-    geom_geom::geom_geom(struct ggeom *geom) :
-        geom_object_with_config(&geom->lg_config)
-    {
-        _name = geom->lg_name;
-        struct gprovider *provider;
-        LIST_FOREACH(provider, &geom->lg_provider, lg_provider) {
-            providers.push_back(geom_provider(provider));
-        }
-    }
-    string
-    geom_geom::name()
-    {
-        return _name;
-    }
-    geom_class::geom_class(string type)
-    {
-        if (geom_gettree(&_mesh) < 0) {
-            throw geom_exception(_("Unable to get GEOM tree"));
-        }
-        LIST_FOREACH(_class, &(_mesh.lg_class), lg_class) {
-            if (type == string(_class->lg_name))
-                break;
-        }
-        if (!_class) {
-            throw geom_exception(_("The GEOM class \"{1}\" was not found", type));
-        }
-        struct ggeom *geom;
-        LIST_FOREACH(geom, &(_class->lg_geom), lg_geom) {
-            geoms.push_back(geom_geom(geom));
-        }
-    }
-    geom_class::~geom_class()
-    {
-        geom_deletetree(&_mesh);
-    }
-}}}  // namespace facter::util::freebsd

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

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