facter 3.12.2.cfacter.20181217 → 4.0.7.pre

data/ext/facter/facter/lib/inc/internal/ruby/resolution.hpp

@@ -1,126 +0,0 @@
-/**
- * @file
- * Declares the base class for Ruby resolution classes.
- */
-#pragma once
-
-#include <leatherman/ruby/api.hpp>
-#include "confine.hpp"
-#include <vector>
-#include <memory>
-
-namespace facter { namespace facts {
-
-    struct value;
-
-}}  // namespace facter::facts
-
-namespace facter { namespace ruby {
-
-    struct module;
-
-    /**
-     * The base class for Ruby resolution classes.
-     */
-    struct resolution
-    {
-        /**
-         * Gets the name of the resolution.
-         * @return Returns the name of the resolution or nil if the resolution has no name.
-         */
-        leatherman::ruby::VALUE name() const;
-
-        /**
-         * Sets the name of the resolution.
-         * @param name The name of the resolution.
-         */
-        void name(leatherman::ruby::VALUE name);
-
-        /**
-         * Gets the weight of the resolution.
-         * The higher the weight value, the more precedence is given to the resolution.
-         * @return Returns the weight of the resolution.
-         */
-        size_t weight() const;
-
-        /**
-         * Sets the weight of the resolution.
-         * @param weight The weight of the resolution.
-         */
-        void weight(size_t weight);
-
-        /**
-         * Gets the value of the resolution.
-         * @return Returns the value of the resolution or nil if the value did not resolve.
-         */
-        virtual leatherman::ruby::VALUE value();
-
-        /**
-         * Sets the value of the resolution.
-         * @param v The value of the resolution.
-         */
-        void value(leatherman::ruby::VALUE v);
-
-        /**
-         * Determines if the resolution is suitable.
-         * @param facter The Ruby facter module to resolve facts with.
-         * @returns Returns true if the resolution is allowed or false if it is not.
-         */
-        bool suitable(module& facter) const;
-
-        /**
-         * Confines the resolution.
-         * @param confines The confines for the resolution.
-         */
-        void confine(leatherman::ruby::VALUE confines);
-
-        /**
-         * Calls the on_flush block for the resolution, if there is one.
-         */
-        void flush() const;
-
-     protected:
-        /**
-         * Constructs the resolution.
-         */
-        resolution();
-
-        /**
-         * Destructs the resolution.
-         */
-        virtual ~resolution();
-
-        /**
-         * Defines the base methods on the given class.
-         * @param klass The Ruby class to define the base methods on.
-         */
-        static void define(leatherman::ruby::VALUE klass);
-
-        /**
-         * Called to mark this object's values during GC.
-         */
-        void mark() const;
-
-     private:
-        // Construction and assignment
-        resolution(resolution const&) = delete;
-        resolution& operator=(resolution const&) = delete;
-        resolution(resolution&& other) = delete;
-        resolution& operator=(resolution&& other) = delete;
-
-        // Methods called from Ruby
-        static leatherman::ruby::VALUE ruby_confine(int argc, leatherman::ruby::VALUE* argv, leatherman::ruby::VALUE self);
-        static leatherman::ruby::VALUE ruby_has_weight(leatherman::ruby::VALUE self, leatherman::ruby::VALUE value);
-        static leatherman::ruby::VALUE ruby_name(leatherman::ruby::VALUE self);
-        static leatherman::ruby::VALUE ruby_timeout(leatherman::ruby::VALUE self, leatherman::ruby::VALUE timeout);
-        static leatherman::ruby::VALUE ruby_on_flush(leatherman::ruby::VALUE self);
-
-        leatherman::ruby::VALUE _name;
-        leatherman::ruby::VALUE _value;
-        leatherman::ruby::VALUE _flush_block;
-        std::vector<ruby::confine> _confines;
-        bool _has_weight;
-        size_t _weight;
-    };
-
-}}  // namespace facter::ruby

data/ext/facter/facter/lib/inc/internal/ruby/ruby_value.hpp

@@ -1,119 +0,0 @@
-/**
- * @file
- * Declares the Ruby fact value.
- */
-#pragma once
-
-#include <leatherman/ruby/api.hpp>
-#include "fact.hpp"
-#include <facter/facts/value.hpp>
-
-#include <unordered_map>
-
-namespace facter { namespace ruby {
-
-    /**
-     * Represents a value for a Ruby fact.
-     */
-    struct ruby_value : facter::facts::value
-    {
-        /**
-         * Constructs a ruby_value.
-         * @param value The Ruby value.
-         */
-        ruby_value(leatherman::ruby::VALUE value);
-
-        /**
-         * Destructs a ruby_value.
-         */
-        ~ruby_value();
-
-        /**
-         * Prevents the ruby_value from being copied.
-         */
-        ruby_value(ruby_value const&) = delete;
-
-        /**
-         * Prevents the ruby_value from being copied.
-         * @returns Returns this ruby_value.
-         */
-        ruby_value& operator=(ruby_value const&) = delete;
-
-        /**
-         * Moves the given ruby_value into this ruby_value.
-         * @param other The ruby_value to move into this ruby_value.
-         */
-        ruby_value(ruby_value&& other);
-
-        /**
-         * Moves the given ruby_value into this ruby_value.
-         * @param other The ruby_value to move into this ruby_value.
-         * @return Returns this ruby_value.
-         */
-        ruby_value& operator=(ruby_value&& other);
-
-        /**
-         * Converts the value to a JSON value.
-         * @param allocator The allocator to use for creating the JSON value.
-         * @param value The returned JSON value.
-         */
-        virtual void to_json(facts::json_allocator& allocator, facts::json_value& value) const override;
-
-        /**
-          * Writes the value to the given stream.
-          * @param os The stream to write to.
-          * @param quoted True if string values should be quoted or false if not.
-          * @param level The current indentation level.
-          * @returns Returns the stream being written to.
-          */
-        virtual std::ostream& write(std::ostream& os, bool quoted = true, unsigned int level = 1) const override;
-
-        /**
-          * Writes the value to the given YAML emitter.
-          * @param emitter The YAML emitter to write to.
-          * @returns Returns the given YAML emitter.
-          */
-        virtual YAML::Emitter& write(YAML::Emitter& emitter) const override;
-
-        /**
-         * Gets the Ruby value.
-         * @return Returns the Ruby value.
-         */
-        leatherman::ruby::VALUE value() const;
-
-        /**
-         * Exposes an owned ruby VALUE as a facter ruby_value
-         * @param child the owned child object to wrap
-         * @param key the query string for the child
-         * @return pointer to the ruby_value wrapper for the child object
-         */
-        ruby_value const* wrap_child(leatherman::ruby::VALUE child, std::string key) const;
-
-        /**
-         * Get a cached ruby_value wrapper for a child VALUE
-         * @param key the query string for the child
-         * @return pointer to the ruby_value wrapper, or nullptr if none exists
-         */
-        ruby_value const* child(const std::string& key) const;
-
-     private:
-        static void to_json(leatherman::ruby::api const& ruby, leatherman::ruby::VALUE value, facts::json_allocator& allocator, facts::json_value& json);
-        static void write(leatherman::ruby::api const& ruby, leatherman::ruby::VALUE value, std::ostream& os, bool quoted, unsigned int level);
-        static void write(leatherman::ruby::api const& ruby, leatherman::ruby::VALUE value, YAML::Emitter& emitter);
-
-        leatherman::ruby::VALUE _value;
-
-        // This is mutable because of constness that's passed down
-        // from the collection object during dot-syntax fact
-        // querying. That query is const over the collection, which
-        // means the collection's actions on values also need to be
-        // const. Unfortunately, we need a place to stash the owning
-        // pointer to the new value that we extract from a ruby object
-        // during lookup. The logical place for that ownership is the
-        // parent ruby object (right here). So we get this cool
-        // mutable field that owns the C++ wrappers for looked-up ruby
-        // values.
-        mutable std::unordered_map<std::string, std::unique_ptr<ruby_value>> _children;
-    };
-
-}}  // namespace facter::ruby

data/ext/facter/facter/lib/inc/internal/ruby/simple_resolution.hpp

@@ -1,56 +0,0 @@
-/**
- * @file
- * Declares the Ruby Facter::Util::Resolution class.
- */
-#pragma once
-
-#include "resolution.hpp"
-
-namespace facter { namespace ruby {
-
-    /**
-     * Represents the Ruby Facter::Util::Resolution class.
-     */
-    struct simple_resolution : resolution
-    {
-        /**
-         * Defines the Facter::Util::Resolution class.
-         * @return Returns theFacter::Util::Resolution class.
-         */
-        static leatherman::ruby::VALUE define();
-
-        /**
-         * Creates an instance of the Facter::Util::Resolution class.
-         * @return Returns the new instance.
-         */
-        static leatherman::ruby::VALUE create();
-
-        /**
-         * Gets the value of the resolution.
-         * @return Returns the value of the resolution or nil if the value did not resolve.
-         */
-        virtual leatherman::ruby::VALUE value();
-
-     private:
-        // Construction and assignment
-        simple_resolution();
-        simple_resolution(simple_resolution const&) = delete;
-        simple_resolution& operator=(simple_resolution const&) = delete;
-        simple_resolution(simple_resolution&& other) = delete;
-        simple_resolution& operator=(simple_resolution&& other) = delete;
-
-        // Ruby lifecycle functions
-        static leatherman::ruby::VALUE alloc(leatherman::ruby::VALUE klass);
-        static void mark(void* data);
-        static void free(void* data);
-
-        static leatherman::ruby::VALUE ruby_setcode(int argc, leatherman::ruby::VALUE* argv, leatherman::ruby::VALUE self);
-        static leatherman::ruby::VALUE ruby_which(leatherman::ruby::VALUE self, leatherman::ruby::VALUE binary);
-        static leatherman::ruby::VALUE ruby_exec(leatherman::ruby::VALUE self, leatherman::ruby::VALUE command);
-
-        leatherman::ruby::VALUE _self;
-        leatherman::ruby::VALUE _block;
-        leatherman::ruby::VALUE _command;
-    };
-
-}}  // namespace facter::ruby

data/ext/facter/facter/lib/inc/internal/util/agent.hpp

@@ -1,29 +0,0 @@
-/**
- * @file
- * Declares methods for Facter's integration with the puppet-agent package.
- */
-#pragma once
-
-#include <leatherman/execution/execution.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <string>
-
-namespace facter { namespace util { namespace agent {
-    /**
-     * Looks for an executable in Facter's built-in PATH.  Falls back
-     * to the system PATH (with a warning) if the requested executable
-     * doesn't exist in Facter's PATH.
-     * @param exe the name of the executable
-     * @return the path to the executable
-     */
-    inline std::string which(const std::string& exe) {
-#ifdef FACTER_PATH
-        std::string fixed = leatherman::execution::which(exe, {FACTER_PATH});
-        if (!fixed.empty()) {
-            return fixed;
-        }
-        LOG_WARNING("{1} not found at configured location {2}, using PATH instead", exe, FACTER_PATH);
-#endif
-        return exe;
-    }
-}}}  // namespace facter::util::agent

data/ext/facter/facter/lib/inc/internal/util/aix/odm.hpp

@@ -1,392 +0,0 @@
-/**
- * @file
- * Declares an iterator interface for examining the AIX object data manager
- */
-
-#include <odmi.h>
-
-#include <cstdint>
-#include <memory>
-#include <string>
-#include <utility>
-#include <leatherman/locale/locale.hpp>
-
-namespace facter { namespace util { namespace aix {
-
-    /**
-     * Singleton representing the ODM subsystem.
-     * The ODM subsystem needs to be explicitly initialized and terminated when
-     * it is used. This wraps that initialization/cleanup such that ODM is
-     * initialized when it is first used, and cleaned up when all consumers
-     * have released their references to it.
-     *
-     * some helper methods for interacting with the ODM are also defined here,
-     * since we can't have a `namespace odm` here.
-     */
-    class odm {
-    public:
-         /// shared_ptr to the odm reference
-         using ptr = std::shared_ptr<odm>;
-
-         /**
-          * Grab a reference to the ODM subsystem to keep it open.
-          * If no references currently exist, this will initialize the ODM
-          * subsystem.
-          * @return 
-          */
-         static ptr open() {
-             static std::weak_ptr<odm> self;
-
-             auto result = self.lock();
-             if (!result) {
-                 result = ptr(new odm);
-                 self = result;
-             }
-             return result;
-         }
-
-         /// deleted copy constructor
-         odm(const odm&) = delete;
-
-         /// deleted assignment operator
-         /// @return nothing
-         odm& operator=(const odm&) = delete;
-
-         /**
-          * Clean up the odm library when there are no more users
-          */
-         ~odm() {
-             odm_terminate();
-         }
-
-         /**
-          * Get the error string for an ODM error state.
-          * @return an error string owned by the ODM subsystem
-          */
-         static std::string error_string() {
-             char* msg;
-             int result = odm_err_msg(odmerrno, &msg);
-             if (result < 0) {
-                 return leatherman::locale::format("failed to retrieve ODM error message");
-             } else {
-                 return std::string(msg);
-             }
-         }
-
-    private:
-         /**
-          * Initialize the ODM library
-          */
-         odm() {
-             if (odm_initialize() < 0) {
-                 throw std::runtime_error(odm::error_string());
-             }
-         }
-    };
-
-    /**
-     * This represents an ODM class as an iterable thing.  An ODM
-     * class can be throught of as a table in a typical database.
-     * Each templatized version of this has a singleton instance,
-     * which represents a process' handle to that table. Each process
-     * can open a single ODM class only once, and concurrent
-     * operations are not supported.
-     *
-     * @tparam T the struct that is stored in the ODM class.
-     */
-    template <typename T>
-    class odm_class : public std::enable_shared_from_this<odm_class<T>> {
-    public:
-        /// shared_ptr to an odm_class
-        using ptr = std::shared_ptr<odm_class<T>>;
-
-        /**
-         * Implements the standard C++ iterator interface for an
-         * odm_class. Iterators can be incremented and compared for
-         * inequality. This is the minimum to make range-based for
-         * loops work.
-         *
-         * Additional members may need to be added to make other
-         * algorithms play nice.
-         */
-        class iterator {
-        public:
-             /**
-              * inequality comparison.
-              * @param rhs the other iterator to compare to
-              * @return true if the iterators are not equal
-              */
-             bool operator != (const iterator& rhs) {
-                 return _owner != rhs._owner || _data != rhs._data;
-             }
-
-             /**
-              * equality comparison.
-              * @param rhs the other iterator to compare to
-              * @return true if the iterators are equal
-              */
-             bool operator == (const iterator& rhs) {
-                 // We could do !(*this != rhs) here, but it's better to inline
-                 // the expression for performance reasons. It's simple enough.
-                 return _owner == rhs._owner && _data == rhs._data;
-             }
-
-             /**
-              * pre-increment operator. This invalidates any
-              * references held to the current data of this iterator.
-              * @return the new value of the iterator
-              */
-             iterator& operator++() {
-                 if (!_data || !_owner) {
-                     return *this;
-                 }
-                 free(_data);
-                 _data = static_cast<T*>(odm_get_next(_owner->_class, nullptr));
-                 // If data == nullptr, we have reached the end of this query
-                 if (!_data) {
-                     _owner->_locked = false;
-                     _owner = ptr(nullptr);
-                 }
-                 if ((intptr_t)_data < 0) {
-                     throw std::runtime_error(odm::error_string());
-                 }
-                 return *this;
-             }
-
-             /**
-              * dereference operator
-              * @return a reference to the held ODM data structure
-              */
-             const T& operator*() const{
-                 return *_data;
-             }
-
-             /**
-              * arrow operator
-              * @return a pointer to the held ODM data structure
-              */
-             const T* operator->() const{
-                 return _data;
-             }
-
-             /**
-              * Destructor. Frees any held ODM data.
-              */
-             ~iterator() {
-                 if (_data) {
-                     free(_data);
-                 }
-             }
-
-        protected:  // Constructor is protected so iterators must come from an odm_class<T> or its associated query_proxy
-             /**
-              * Construct an iterator from an odm_class ptr and the first ODM data pointer
-              * @param data the ODM data we point to
-              * @param owner the odm_class object that owns this iterator
-              */
-             iterator(T* data, ptr owner) : _data(data), _owner(owner) {
-                 if (_data) {
-                     if (!_owner) {
-                         throw std::logic_error(leatherman::locale::format("Tried to construct an iterator with valid data but no owner. Naughty naughty."));
-                     }
-                     _owner->_locked = true;
-                 } else {
-                     // In theory nobody should be constructing us with
-                     // null data and valid owner, but why take the risk?
-                     _owner = ptr(nullptr);
-                 }
-             }
-
-        private:
-             T *_data;
-             ptr _owner;
-
-             friend class odm_class::query_proxy;
-             friend class odm_class;
-        };
-        friend class iterator;  // iterator is our friend so it can lock/unlock us.
-
-        /**
-         * A query_proxy instance represents a query of an ODM
-         * class. The proxy has begin and end methods to allow it to
-         * be used in context of a range-based for loop or other
-         * algorithm.
-         */
-        class query_proxy {
-        public:
-             /**
-              * Begin the actual ODM query. This locks the odm_class until all valid iterators from this query are destroyed.
-              * @return first iterator of the query
-              */
-             iterator begin() {
-                 if (_owner->_locked) {
-                     throw std::logic_error(leatherman::locale::format("Cannot iterate over the same ODM class concurrently"));
-                 }
-                 auto data = static_cast<T*>(odm_get_first(_owner->_class, const_cast<char*>(_query.c_str()), nullptr));
-                 if ((intptr_t)data < 0) {
-                     throw std::runtime_error(odm::error_string());
-                 }
-                 return iterator(data, _owner);
-             }
-
-             /// @return an end iterator
-             iterator end() {
-                 return iterator(nullptr, nullptr);
-             }
-
-        protected:
-             /**
-              * Construct a query_proxy for an odm_class query
-              * @param query the query string
-              * @param owner the odm_class that owns this query
-              */
-             template <typename Arg>
-             query_proxy(Arg&& query, ptr owner) : _query(std::forward<Arg>(query)), _owner(owner) {}
-
-        private:
-             std::string _query;
-             ptr _owner;
-
-             friend class odm_class;
-        };
-        friend class query_proxy;  // query proxy needs to know if we're locked so it can begin() properly.
-
-        /**
-         * This class exists purely to allow nicer syntax when
-         * iterating over an odm_class. Using the proxy, it's possible
-         * to use `.begin()` and `.end()`, isntead of `->begin()`.
-         */
-        class proxy {
-        public:
-             /**
-              * Begin iterating over the entire odm_class. This could
-              * potentially be MANY values, so use wisely. You
-              * probably want query(). This will lock the odm_class
-              * until iteration is complete or all valid iterators are
-              * destructed.
-              * @return an iterator
-              */
-             iterator begin() {
-                 return _self->begin();
-             }
-
-             /**
-              * Get the end iterator. All end iterators are identical
-              * @return the end iterator
-              */
-             iterator end() {
-                 return _self->end();
-             }
-
-             /**
-              * Begin a query. This does not look the odm_class until
-              * query_proxy::begin() is called.
-              * @param query the query string
-              * @return a query_proxy representing this query
-              */
-             template <typename Arg>
-             query_proxy query(Arg&& query) {
-                 return _self->query(std::forward<Arg>(query));
-             }
-
-        protected:
-             /**
-              * Construct a proxy for an odm_class
-              * @param self The odm_class that we proxy for
-              */
-             proxy(ptr self) : _self(self) {}
-
-        private:
-             ptr _self;
-
-             friend class odm_class;
-        };
-        friend class proxy;  // proxy needs to, well, proxy to us.
-
-        /**
-         * Get a reference to an odm_class named "name". This will
-         * open the class if it is not yet open. The class will be
-         * closed when all existing references are released.
-         * @param name The name of the ODM class. Usually the string form of T
-         * @return an odm_class::proxy object that represents the requested class
-         */
-        static proxy open(std::string name) {
-            static std::weak_ptr<odm_class<T>> self;
-
-            auto result = self.lock();
-            if (!result) {
-                result = ptr(new odm_class<T>(name));
-                self = result;
-            }
-            return proxy { result };
-        }
-
-        /// deleted default constructor
-        odm_class() = delete;
-
-        /// deleted copy constructor
-        odm_class(const odm_class&) = delete;
-
-        /// deleted assignment operator
-        /// @return nothing
-        odm& operator=(const odm&) = delete;
-
-        /**
-         * Releases an ODM class when there are no more users of it.
-         */
-        ~odm_class() {
-            odm_close_class(_class);
-        }
-
-    protected:
-        /**
-         * @see proxy::query
-         * @param query the query string
-         * @return a query_proxy representing the provided query
-         */
-        template <typename Arg>
-        query_proxy query(Arg&& query) {
-            return query_proxy(std::forward<Arg>(query), this->shared_from_this());
-        }
-
-        /**
-         * @see proxy::begin
-         * @return an iterator
-         */
-        iterator begin() {
-            return query("").begin();
-        }
-
-        /**
-         * @see proxy::end
-         * @return the end/invalid iterator
-         */
-        iterator end() {
-            return iterator(nullptr, nullptr);
-        }
-
-    private:
-        odm_class(std::string name) : _locked(false) {
-            _the_odm = odm::open();
-            _class = odm_mount_class(const_cast<char*>(name.c_str()));
-            if (reinterpret_cast<intptr_t>(_class) < 0) {
-                throw std::runtime_error(odm::error_string());
-            }
-            _class = odm_open_class_rdonly(_class);
-            if (reinterpret_cast<intptr_t>(_class) < 0) {
-                throw std::runtime_error(odm::error_string());
-            }
-        }
-
-    protected:
-        /// The ODM class that we are wrapping
-        CLASS_SYMBOL _class;
-
-        /// whether we are currently locked for iteration
-        bool _locked;
-
-    private:
-        odm::ptr _the_odm;
-    };
-
-}}}  // namespace facter::util::aix