cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,230 @@
+#include <internal/ruby/resolution.hpp>
+#include <internal/ruby/module.hpp>
+#include <leatherman/logging/logging.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::ruby;
+
+namespace facter { namespace ruby {
+
+    resolution::resolution() :
+        _has_weight(false),
+        _weight(0)
+    {
+        auto const& ruby = api::instance();
+        _name = ruby.nil_value();
+        _value = ruby.nil_value();
+        _flush_block = ruby.nil_value();
+    }
+
+    resolution::~resolution()
+    {
+    }
+
+    VALUE resolution::name() const
+    {
+        return _name;
+    }
+
+    void resolution::name(VALUE name)
+    {
+        _name = name;
+    }
+
+    size_t resolution::weight() const
+    {
+        if (_has_weight) {
+            return _weight;
+        }
+        return _confines.size();
+    }
+
+    void resolution::weight(size_t weight)
+    {
+        _has_weight = true;
+        _weight = weight;
+    }
+
+    VALUE resolution::value()
+    {
+        return _value;
+    }
+
+    void resolution::value(VALUE v)
+    {
+        _value = v;
+    }
+
+    bool resolution::suitable(module& facter) const
+    {
+        auto const& ruby = api::instance();
+
+        int tag = 0;
+        {
+            // Declare all C++ objects here
+            vector<ruby::confine>::const_iterator it;
+
+            VALUE result = ruby.protect(tag, [&]() {
+                // Do not declare any C++ objects inside the protect
+                // Their destructors will not be invoked if there is a Ruby exception
+                for (it = _confines.begin(); it != _confines.end(); ++it) {
+                    if (!it->suitable(facter)) {
+                        return ruby.false_value();
+                    }
+                }
+                return ruby.true_value();
+            });
+
+            // If all confines were suitable, the resolution is considered to be suitable
+            if (!tag) {
+                return ruby.is_true(result);
+            }
+        }
+
+        // Now that the above block has exited, it's safe to jump to the given tag
+        ruby.rb_jump_tag(tag);
+        return false;
+    }
+
+    void resolution::flush() const
+    {
+        auto const& ruby = api::instance();
+
+        if (ruby.is_nil(_flush_block)) {
+            return;
+        }
+
+        ruby.rb_funcall(_flush_block, ruby.rb_intern("call"), 0);
+    }
+
+    void resolution::confine(VALUE confines)
+    {
+        auto const& ruby = api::instance();
+
+        if (ruby.is_nil(confines)) {
+            // No confines, only a block is required
+            if (!ruby.rb_block_given_p()) {
+                ruby.rb_raise(*ruby.rb_eArgError, _("a block must be provided").c_str());
+            }
+            _confines.emplace_back(ruby::confine(ruby.nil_value(), ruby.nil_value(), ruby.rb_block_proc()));
+        } else {
+            if (ruby.is_symbol(confines)) {
+                confines = ruby.rb_sym_to_s(confines);
+            }
+            if (ruby.is_string(confines)) {
+                // Argument is a string and a is block required
+                if (!ruby.rb_block_given_p()) {
+                    ruby.rb_raise(*ruby.rb_eArgError, _("a block must be provided").c_str());
+                }
+                _confines.emplace_back(ruby::confine(confines, ruby.nil_value(), ruby.rb_block_proc()));
+            } else if (ruby.is_hash(confines)) {
+                // Argument is a hash (block should not be given)
+                if (ruby.rb_block_given_p()) {
+                    ruby.rb_raise(*ruby.rb_eArgError, _("a block is unexpected when passing a Hash").c_str());
+                }
+                ruby.hash_for_each(confines, [&](VALUE key, VALUE value) {
+                    if (ruby.is_symbol(key)) {
+                        key = ruby.rb_sym_to_s(key);
+                    }
+                    if (!ruby.is_string(key)) {
+                        ruby.rb_raise(*ruby.rb_eTypeError, _("expected a String or Symbol for confine key").c_str());
+                    }
+                    if (ruby.is_symbol(value)) {
+                        value = ruby.rb_sym_to_s(value);
+                    }
+                    _confines.emplace_back(ruby::confine(key, value, ruby.nil_value()));
+                    return true;
+                });
+            } else {
+                ruby.rb_raise(*ruby.rb_eTypeError, _("expected argument to be a String, Symbol, or Hash").c_str());
+            }
+        }
+    }
+
+    void resolution::define(VALUE klass)
+    {
+        auto const& ruby = api::instance();
+        ruby.rb_define_method(klass, "confine", RUBY_METHOD_FUNC(ruby_confine), -1);
+        ruby.rb_define_method(klass, "has_weight", RUBY_METHOD_FUNC(ruby_has_weight), 1);
+        ruby.rb_define_method(klass, "name", RUBY_METHOD_FUNC(ruby_name), 0);
+        ruby.rb_define_method(klass, "timeout=", RUBY_METHOD_FUNC(ruby_timeout), 1);
+        ruby.rb_define_method(klass, "on_flush", RUBY_METHOD_FUNC(ruby_on_flush), 0);
+    }
+
+    void resolution::mark() const
+    {
+        auto const& ruby = api::instance();
+
+        // Mark the name and value
+        ruby.rb_gc_mark(_name);
+        ruby.rb_gc_mark(_value);
+        ruby.rb_gc_mark(_flush_block);
+
+        // Mark all of the confines
+        for (auto const& confine : _confines) {
+            confine.mark();
+        }
+    }
+
+    VALUE resolution::ruby_confine(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());
+        }
+
+        ruby.to_native<resolution>(self)->confine(argc == 0 ? ruby.nil_value() : argv[0]);
+        return self;
+    }
+
+    VALUE resolution::ruby_has_weight(VALUE self, VALUE value)
+    {
+        auto const& ruby = api::instance();
+
+        int64_t val = ruby.rb_num2ll(value);
+        if (val < 0) {
+            ruby.rb_raise(*ruby.rb_eTypeError, "expected a non-negative value for has_weight (not %lld)", val);
+        }
+
+        auto instance = ruby.to_native<resolution>(self);
+        instance->_has_weight = true;
+        instance->_weight = static_cast<size_t>(val);
+        return self;
+    }
+
+    VALUE resolution::ruby_name(VALUE self)
+    {
+        auto const& ruby = api::instance();
+        return ruby.to_native<resolution>(self)->name();
+    }
+
+    VALUE resolution::ruby_timeout(VALUE self, VALUE timeout)
+    {
+        static bool timeout_warning = true;
+        if (timeout_warning) {
+            LOG_WARNING("timeout= is not supported for custom facts and will be ignored.")
+            timeout_warning = false;
+        }
+        // Do nothing as we don't support timeouts
+        return self;
+    }
+
+    VALUE resolution::ruby_on_flush(VALUE self)
+    {
+        auto const& ruby = api::instance();
+
+        if (!ruby.rb_block_given_p()) {
+            ruby.rb_raise(*ruby.rb_eArgError, _("a block must be provided").c_str());
+        }
+
+        ruby.to_native<resolution>(self)->_flush_block = ruby.rb_block_proc();
+        return self;
+    }
+
+}}  // namespace facter::ruby

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

@@ -0,0 +1,150 @@
+#include <facter/ruby/ruby.hpp>
+#include <facter/logging/logging.hpp>
+#include <internal/ruby/module.hpp>
+#include <internal/ruby/ruby_value.hpp>
+#include <leatherman/ruby/api.hpp>
+#include <leatherman/logging/logging.hpp>
+#ifdef _WIN32
+#include <internal/util/windows/wsa.hpp>
+#endif
+
+#include <numeric>
+
+using namespace std;
+using namespace facter::facts;
+using namespace leatherman::ruby;
+
+static const char load_puppet[] =
+"require 'puppet'\n"
+"Puppet.initialize_settings\n"
+"unless $LOAD_PATH.include?(Puppet[:libdir])\n"
+"  $LOAD_PATH << Puppet[:libdir]\n"
+"end\n"
+"Facter.reset\n"
+"Facter.search_external([Puppet[:pluginfactdest]])\n"
+"if Puppet.respond_to? :initialize_facts\n"
+"  Puppet.initialize_facts\n"
+"else\n"
+"  Facter.add(:puppetversion) do\n"
+"    setcode { Puppet.version.to_s }\n"
+"  end\n"
+"end\n";
+
+namespace facter { namespace ruby {
+
+    bool initialize(bool include_stack_trace)
+    {
+#ifdef FACTER_RUBY
+        api::ruby_lib_location = FACTER_RUBY;
+#endif
+        try {
+            auto& ruby = api::instance();
+            ruby.initialize();
+            ruby.include_stack_trace(include_stack_trace);
+        } catch (runtime_error& ex) {
+            LOG_WARNING("{1}: facts requiring Ruby will not be resolved.", ex.what());
+            return false;
+        }
+        return true;
+    }
+
+    void load_custom_facts(collection& facts, bool initialize_puppet, vector<string> const& paths)
+    {
+#ifdef _WIN32
+        // Initialize WSA before resolving custom facts. The Ruby runtime does this only when running
+        // in a Ruby process, it leaves it up to us when embedding it. See
+        // https://github.com/ruby/ruby/blob/v2_1_9/ruby.c#L2011-L2022 for comments.
+        // The only piece we seem to need out of rb_w32_sysinit is WSAStartup.
+        util::windows::wsa winsocket;
+#endif
+        api& ruby = api::instance();
+        module mod(facts, {}, !initialize_puppet);
+        if (initialize_puppet) {
+            try {
+                ruby.eval(load_puppet);
+            } catch (exception& ex) {
+                LOG_WARNING("Could not load puppet; some facts may be unavailable: {1}", ex.what());
+            }
+        }
+        mod.search(paths);
+        mod.resolve_facts();
+    }
+
+    void load_custom_facts(collection& facts, vector<string> const& paths)
+    {
+         load_custom_facts(facts, false, paths);
+    }
+
+    value const* lookup(value const* value, vector<string>::iterator segment, vector<string>::iterator end) {
+        auto rb_value = dynamic_cast<ruby_value const*>(value);
+        if (!rb_value) {
+             return nullptr;
+        }
+
+        // Check for a cached lookup
+        auto key = accumulate(segment, end, string{}, [](const string& a, const string& b) -> string {
+                 if (b.find(".") != string::npos) {
+                     return a+".\""+b+"\"";
+                 } else {
+                     return a+"."+b;
+                 }
+             });
+        auto child_value = rb_value->child(key);
+        if (child_value) {
+            return child_value;
+        }
+
+        auto val = rb_value->value();  // now we're in ruby land
+        api& ruby = api::instance();
+
+        for (; segment != end; ++segment) {
+            if (ruby.is_array(val)) {
+                long index;
+                try {
+                    index = stol(*segment);
+                } catch (logic_error&) {
+                    LOG_DEBUG("cannot lookup an array element with \"{1}\": expected an integral value.", *segment);
+                    return nullptr;
+                }
+                if (index < 0) {
+                    LOG_DEBUG("cannot lookup an array element with \"{1}\": expected a non-negative value.", *segment);
+                    return nullptr;
+                }
+                long length = ruby.array_len(val);
+                if (0 == length) {
+                    LOG_DEBUG("cannot lookup an array element with \"{1}\": the array is empty.", *segment);
+                    return nullptr;
+                }
+
+                if (index >= length) {
+                    LOG_DEBUG("cannot lookup an array element with \"{1}\": expected an integral value between 0 and {2} (inclusive).", *segment, length - 1);
+                    return nullptr;
+                }
+
+                val = ruby.rb_ary_entry(val, index);
+            } else if (ruby.is_hash(val)) {
+                // if we're anything but an array, we look up by name
+                auto key = ruby.utf8_value(*segment);
+                auto result = ruby.rb_hash_lookup(val, key);
+                if (ruby.is_nil(result)) {
+                    // We also want to try looking up as a symbol
+                    key = ruby.to_symbol(*segment);
+                    result = ruby.rb_hash_lookup(val, key);
+                }
+                val = result;
+            } else {
+                LOG_DEBUG("cannot lookup element \"{1}\": container is not an array or hash", *segment);
+            }
+            if (ruby.is_nil(val)) {
+                return nullptr;
+            }
+        }
+        return rb_value->wrap_child(val, move(key));
+    }
+
+    void uninitialize()
+    {
+        api& ruby = api::instance();
+        ruby.uninitialize();
+    }
+}}  // namespace facter::ruby

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

@@ -0,0 +1,288 @@
+#include <internal/ruby/ruby_value.hpp>
+#include <facter/util/string.hpp>
+#include <rapidjson/document.h>
+#include <yaml-cpp/yaml.h>
+#include <iomanip>
+
+using namespace std;
+using namespace facter::facts;
+using namespace facter::util;
+using namespace rapidjson;
+using namespace YAML;
+using namespace leatherman::ruby;
+
+namespace facter { namespace ruby {
+
+    ruby_value::ruby_value(VALUE value) :
+        _value(value)
+    {
+        auto const& ruby = api::instance();
+        ruby.rb_gc_register_address(&_value);
+    }
+
+    ruby_value::~ruby_value()
+    {
+        auto const& ruby = api::instance();
+        ruby.rb_gc_unregister_address(&_value);
+    }
+
+    ruby_value::ruby_value(ruby_value&& other) :
+        _value(other._value)
+    {
+        auto const& ruby = api::instance();
+        ruby.rb_gc_register_address(&_value);
+    }
+
+    ruby_value& ruby_value::operator=(ruby_value&& other)
+    {
+        _value = other._value;
+        return *this;
+    }
+
+    void ruby_value::to_json(json_allocator& allocator, json_value& value) const
+    {
+        auto const& ruby = api::instance();
+        to_json(ruby, _value, allocator, value);
+    }
+
+    ostream& ruby_value::write(ostream& os, bool quoted, unsigned int level) const
+    {
+        auto const& ruby = api::instance();
+        write(ruby, _value, os, quoted, level);
+        return os;
+    }
+
+    Emitter& ruby_value::write(Emitter& emitter) const
+    {
+        auto const& ruby = api::instance();
+        write(ruby, _value, emitter);
+        return emitter;
+    }
+
+    VALUE ruby_value::value() const
+    {
+        return _value;
+    }
+
+    void ruby_value::to_json(api const& ruby, VALUE value, json_allocator& allocator, json_value& json)
+    {
+        if (ruby.is_true(value)) {
+            json.SetBool(true);
+            return;
+        }
+        if (ruby.is_false(value)) {
+            json.SetBool(false);
+            return;
+        }
+        if (ruby.is_string(value) || ruby.is_symbol(value)) {
+            volatile VALUE temp = value;
+
+            if (ruby.is_symbol(value)) {
+                temp = ruby.rb_funcall(value, ruby.rb_intern("to_s"), 0);
+            }
+
+            size_t size = ruby.num2size_t(ruby.rb_funcall(temp, ruby.rb_intern("bytesize"), 0));
+            char const* str = ruby.rb_string_value_ptr(&temp);
+            json.SetString(str, size, allocator);
+            return;
+        }
+        if (ruby.is_integer(value)) {
+            json.SetInt64(ruby.rb_num2ll(value));
+            return;
+        }
+        if (ruby.is_float(value)) {
+            json.SetDouble(ruby.rb_num2dbl(value));
+            return;
+        }
+        if (ruby.is_array(value)) {
+            json.SetArray();
+            size_t size = ruby.num2size_t(ruby.rb_funcall(value, ruby.rb_intern("size"), 0));
+            json.Reserve(size, allocator);
+
+            ruby.array_for_each(value, [&](VALUE element) {
+                json_value child;
+                to_json(ruby, element, allocator, child);
+                json.PushBack(child, allocator);
+                return true;
+            });
+            return;
+        }
+        if (ruby.is_hash(value)) {
+            json.SetObject();
+
+            ruby.hash_for_each(value, [&](VALUE key, VALUE element) {
+                // If the key isn't a string, convert to string
+                if (!ruby.is_string(key)) {
+                    key = ruby.rb_funcall(key, ruby.rb_intern("to_s"), 0);
+                }
+                json_value child;
+                to_json(ruby, element, allocator, child);
+                json.AddMember(json_value(ruby.rb_string_value_ptr(&key), allocator), child, allocator);
+                return true;
+            });
+            return;
+        }
+
+        json.SetNull();
+    }
+
+    void ruby_value::write(api const& ruby, VALUE value, ostream& os, bool quoted, unsigned int level)
+    {
+        if (ruby.is_true(value)) {
+            os << boolalpha << true << noboolalpha;
+            return;
+        }
+        if (ruby.is_false(value)) {
+            os << boolalpha << false << noboolalpha;
+            return;
+        }
+        if (ruby.is_string(value) || ruby.is_symbol(value)) {
+            volatile VALUE temp = value;
+
+            if (ruby.is_symbol(value)) {
+                temp = ruby.rb_funcall(value, ruby.rb_intern("to_s"), 0);
+            }
+
+            size_t size = ruby.num2size_t(ruby.rb_funcall(temp, ruby.rb_intern("bytesize"), 0));
+            char const* str = ruby.rb_string_value_ptr(&temp);
+
+            if (quoted) {
+                os << '"';
+            }
+            os.write(str, size);
+            if (quoted) {
+                os << '"';
+            }
+            return;
+        }
+        if (ruby.is_integer(value)) {
+            os << ruby.rb_num2ll(value);
+            return;
+        }
+        if (ruby.is_float(value)) {
+            os << ruby.rb_num2dbl(value);
+            return;
+        }
+        if (ruby.is_array(value)) {
+            auto size = ruby.num2size_t(ruby.rb_funcall(value, ruby.rb_intern("size"), 0));
+            if (size == 0) {
+                os << "[]";
+                return;
+            }
+
+            os << "[\n";
+            bool first = true;
+            ruby.array_for_each(value, [&](VALUE element) {
+                if (first) {
+                    first = false;
+                } else {
+                    os << ",\n";
+                }
+                fill_n(ostream_iterator<char>(os), level * 2, ' ');
+                write(ruby, element, os, true, level + 1);
+                return true;
+            });
+            os << "\n";
+            fill_n(ostream_iterator<char>(os), (level > 0 ? (level - 1) : 0) * 2, ' ');
+            os << "]";
+            return;
+        }
+        if (ruby.is_hash(value)) {
+            auto size = ruby.num2size_t(ruby.rb_funcall(value, ruby.rb_intern("size"), 0));
+            if (size == 0) {
+                os << "{}";
+                return;
+            }
+            os << "{\n";
+            bool first = true;
+            ruby.hash_for_each(value, [&](VALUE key, VALUE element) {
+                if (first) {
+                    first = false;
+                } else {
+                    os << ",\n";
+                }
+
+                // If the key isn't a string, convert to string
+                if (!ruby.is_string(key)) {
+                    key = ruby.rb_funcall(key, ruby.rb_intern("to_s"), 0);
+                }
+
+                size_t size = ruby.num2size_t(ruby.rb_funcall(key, ruby.rb_intern("bytesize"), 0));
+                char const* str = ruby.rb_string_value_ptr(&key);
+
+                fill_n(ostream_iterator<char>(os), level * 2, ' ');
+                os.write(str, size);
+                os << " => ";
+                write(ruby, element, os, true, level + 1);
+                return true;
+            });
+            os << "\n";
+            fill_n(ostream_iterator<char>(os), (level > 0 ? (level - 1) : 0) * 2, ' ');
+            os << "}";
+            return;
+        }
+    }
+
+    void ruby_value::write(api const& ruby, VALUE value, YAML::Emitter& emitter)
+    {
+        if (ruby.is_true(value)) {
+            emitter << true;
+            return;
+        }
+        if (ruby.is_false(value)) {
+            emitter << false;
+            return;
+        }
+        if (ruby.is_string(value) || ruby.is_symbol(value)) {
+            auto str = ruby.to_string(value);
+            if (needs_quotation(str)) {
+                emitter << DoubleQuoted;
+            }
+            emitter << str;
+            return;
+        }
+        if (ruby.is_integer(value)) {
+            emitter << ruby.rb_num2ll(value);
+            return;
+        }
+        if (ruby.is_float(value)) {
+            emitter << ruby.rb_num2dbl(value);
+            return;
+        }
+        if (ruby.is_array(value)) {
+            emitter << BeginSeq;
+            ruby.array_for_each(value, [&](VALUE element) {
+                write(ruby, element, emitter);
+                return true;
+            });
+            emitter << EndSeq;
+            return;
+        }
+        if (ruby.is_hash(value)) {
+            emitter << BeginMap;
+            ruby.hash_for_each(value, [&](VALUE key, VALUE element) {
+                emitter << Key << ruby.to_string(key) << YAML::Value;
+                write(ruby, element, emitter);
+                return true;
+            });
+            emitter << EndMap;
+            return;
+        }
+
+        emitter << Null;
+    }
+
+    ruby_value const* ruby_value::wrap_child(VALUE child, string key) const {
+        return _children.emplace(move(key), std::unique_ptr<ruby_value>(new ruby_value(child))).first->second.get();
+    }
+
+    ruby_value const* ruby_value::child(const string& key) const {
+        auto child = _children.find(key);
+        if (child != end(_children)) {
+            return child->second.get();
+        } else {
+            return nullptr;
+        }
+    }
+
+}}  // namespace facter::ruby