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/facts/external/execution_resolver.cc DELETED

@@ -1,89 +0,0 @@
-#include <internal/facts/external/execution_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/array_value.hpp>
-#include <facter/facts/map_value.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <internal/util/yaml.hpp>
-#include <leatherman/execution/execution.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <boost/algorithm/string.hpp>
-#include <yaml-cpp/yaml.h>
-using namespace std;
-using namespace leatherman::execution;
-using namespace facter::facts;
-using namespace facter::facts::external;
-using namespace facter::util::yaml;
-namespace facter { namespace facts { namespace external {
-    bool execution_resolver::can_resolve(string const& path) const
-    {
-        // If the path can be resolved as an executable, this resolver can handle it.
-        // However, only allow absolute paths.
-        LOG_DEBUG("checking execution on {1}", path);
-        return !which(path, {}).empty();
-    }
-    void execution_resolver::resolve(string const& path, collection& facts) const
-    {
-        LOG_DEBUG("resolving facts from executable file \"{1}\".", path);
-        try
-        {
-            bool resolved = false;
-            auto result = execute(path, 0,
-                {
-                    execution_options::trim_output,
-                    execution_options::merge_environment,
-                    execution_options::throw_on_failure,
-                    execution_options::convert_newlines
-                });
-            try {
-                auto node = YAML::Load(result.output);
-                for (auto const& kvp : node) {
-                    add_value(kvp.first.as<string>(), kvp.second, facts);
-                    // If YAML doesn't correctly parse, it will
-                    // sometimes just return an empty node instead of
-                    // erroring. Only claiming we've resolved if we
-                    // add at least one child value from the YAML
-                    // allows us to still pass on to the keyval
-                    // interpretation in those cases.
-                    resolved = true;
-                }
-            }  catch (YAML::Exception& ex) {
-                LOG_DEBUG("Could not parse executable fact output as YAML or JSON ({1})", ex.msg);
-            }
-            if (!resolved) {
-                std::vector<string> lines;
-                boost::split(lines, result.output, boost::is_any_of("\n"));
-                for (const auto& line : lines) {
-                    auto pos = line.find('=');
-                    if (pos == string::npos) {
-                        LOG_DEBUG("ignoring line in output: {1}", line);
-                        continue;
-                    }
-                    // Add as a string fact
-                    string fact = line.substr(0, pos);
-                    boost::to_lower(fact);
-                    facts.add_external(move(fact), make_value<string_value>(line.substr(pos+1)));
-                }
-            }
-            // Log a warning if there is error output from the command
-            if (!result.error.empty()) {
-                LOG_WARNING("external fact file \"{1}\" had output on stderr: {2}", path, result.error);
-            }
-        }
-        catch (execution_exception& ex) {
-            throw external_fact_exception(ex.what());
-        }
-        LOG_DEBUG("completed resolving facts from executable file \"{1}\".", path);
-    }
-}}}  // namespace facter::facts::external

data/ext/facter/facter/lib/src/facts/external/json_resolver.cc DELETED

@@ -1,219 +0,0 @@
-#include <internal/facts/external/json_resolver.hpp>
-#include <internal/util/scoped_file.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/array_value.hpp>
-#include <facter/facts/map_value.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <leatherman/locale/locale.hpp>
-#include <rapidjson/reader.h>
-#include <rapidjson/filereadstream.h>
-#include <rapidjson/error/en.h>
-#include <boost/algorithm/string.hpp>
-#include <stack>
-#include <tuple>
-// Mark string for translation (alias for leatherman::locale::format)
-using leatherman::locale::_;
-using namespace std;
-using namespace facter::facts;
-using namespace facter::util;
-using namespace rapidjson;
-namespace facter { namespace facts { namespace external {
-    // Helper event handler for parsing JSON data
-    struct json_event_handler
-    {
-        explicit json_event_handler(collection& facts) :
-            _initialized(false),
-            _facts(facts)
-        {
-        }
-        bool Null()
-        {
-            check_initialized();
-            // Ignore this fact as values cannot be null
-            _key.clear();
-            return true;
-        }
-        bool Bool(bool b)
-        {
-            add_value(make_value<boolean_value>(b));
-            return true;
-        }
-        bool Int(int i)
-        {
-            Int64(static_cast<uint64_t>(i));
-            return true;
-        }
-        bool Uint(unsigned int i)
-        {
-            Int64(static_cast<uint64_t>(i));
-            return true;
-        }
-        bool Int64(int64_t i)
-        {
-            add_value(make_value<integer_value>(i));
-            return true;
-        }
-        bool Uint64(uint64_t i)
-        {
-            Int64(static_cast<uint64_t>(i));
-            return true;
-        }
-        bool Double(double d)
-        {
-            add_value(make_value<double_value>(d));
-            return true;
-        }
-        bool String(char const* str, SizeType length, bool copy)
-        {
-            add_value(make_value<string_value>(string(str, length)));
-            return true;
-        }
-        bool Key(const char* str, SizeType length, bool copy)
-        {
-            check_initialized();
-            _key = string(str, length);
-            return true;
-        }
-        bool StartObject()
-        {
-            if (!_initialized) {
-                _initialized = true;
-                return true;
-            }
-            // Push a map onto the stack
-            _stack.emplace(make_tuple(move(_key), make_value<map_value>()));
-            return true;
-        }
-        bool EndObject(SizeType count)
-        {
-            // Check to see if the stack is empty since we don't push for the top-level object
-            if (_stack.empty()) {
-                return true;
-            }
-            // Pop the data off the stack
-            auto top = move(_stack.top());
-            _stack.pop();
-            // Restore the key and add the value
-            _key = move(get<0>(top));
-            add_value(move(get<1>(top)));
-            return true;
-        }
-        bool StartArray()
-        {
-            check_initialized();
-            // Push an array onto the stack
-            _stack.emplace(make_tuple(move(_key), make_value<array_value>()));
-            return true;
-        }
-        bool EndArray(SizeType count)
-        {
-            // Pop the data off the stack
-            auto top = move(_stack.top());
-            _stack.pop();
-            // Restore the key and add the value
-            _key = move(get<0>(top));
-            add_value(move(get<1>(top)));
-            return true;
-        }
-     private:
-        template <typename T> void add_value(unique_ptr<T>&& val)
-        {
-            check_initialized();
-            // If the stack is empty, just add it as a top-level fact
-            if (_stack.empty()) {
-                if (_key.empty()) {
-                    throw external::external_fact_exception(_("expected non-empty key in object."));
-                }
-                boost::to_lower(_key);
-                _facts.add_external(move(_key), move(val));
-                return;
-            }
-            // If there's an array or map on the stack, add the value as an element
-            auto& top = _stack.top();
-            auto& current = get<1>(top);
-            auto array = dynamic_cast<array_value*>(current.get());
-            if (array) {
-                array->add(move(val));
-                return;
-            }
-            auto map = dynamic_cast<map_value*>(current.get());
-            if (map) {
-                if (_key.empty()) {
-                    throw external::external_fact_exception(_("expected non-empty key in object."));
-                }
-                map->add(move(_key), move(val));
-            }
-        }
-        void check_initialized() const
-        {
-            if (!_initialized) {
-                throw external::external_fact_exception(_("expected document to contain an object."));
-            }
-        }
-        bool _initialized;
-        collection& _facts;
-        string _key;
-        stack<tuple<string, unique_ptr<value>>> _stack;
-    };
-    bool json_resolver::can_resolve(string const& path) const
-    {
-        return boost::iends_with(path, ".json");
-    }
-    void json_resolver::resolve(string const& path, collection& facts) const
-    {
-        LOG_DEBUG("resolving facts from JSON file \"{1}\".", path);
-        // Open the file
-        // We used a scoped_file here because rapidjson expects a FILE*
-        scoped_file file(path, "r");
-        if (file == nullptr) {
-            throw external_fact_exception(_("file could not be opened."));
-        }
-        // Use the existing FileStream class
-        char buffer[4096];
-        FileReadStream stream(file, buffer, sizeof(buffer));
-        // Parse the file and report any errors
-        Reader reader;
-        json_event_handler handler(facts);
-        auto result = reader.Parse(stream, handler);
-        if (!result) {
-            throw external_fact_exception(GetParseError_En(result.Code()));
-        }
-        LOG_DEBUG("completed resolving facts from JSON file \"{1}\".", path);
-    }
-}}}  // namespace facter::facts::external

data/ext/facter/facter/lib/src/facts/external/resolver.cc DELETED

@@ -1,12 +0,0 @@
-#include <facter/facts/external/resolver.hpp>
-using namespace std;
-namespace facter { namespace facts { namespace external {
-    external_fact_exception::external_fact_exception(string const& message) :
-        runtime_error(message)
-    {
-    }
-}}}  // namespace facter::facts::external

data/ext/facter/facter/lib/src/facts/external/text_resolver.cc DELETED

@@ -1,45 +0,0 @@
-#include <internal/facts/external/text_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <leatherman/file_util/file.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <leatherman/locale/locale.hpp>
-#include <boost/algorithm/string.hpp>
-// Mark string for translation (alias for leatherman::locale::format)
-using leatherman::locale::_;
-using namespace std;
-namespace lth_file = leatherman::file_util;
-namespace facter { namespace facts { namespace external {
-    bool text_resolver::can_resolve(string const& path) const
-    {
-        return boost::iends_with(path, ".txt");
-    }
-    void text_resolver::resolve(string const& path, collection& facts) const
-    {
-        LOG_DEBUG("resolving facts from text file \"{1}\".", path);
-        if (!lth_file::each_line(path, [&facts](string& line) {
-            auto pos = line.find('=');
-            if (pos == string::npos) {
-                LOG_DEBUG("ignoring line in output: {1}", line);
-                return true;
-            }
-            // Add as a string fact
-            string fact = line.substr(0, pos);
-            boost::to_lower(fact);
-            facts.add_external(move(fact), make_value<string_value>(line.substr(pos+1)));
-            return true;
-        })) {
-            throw external_fact_exception(_("file could not be opened."));
-        }
-        LOG_DEBUG("completed resolving facts from text file \"{1}\".", path);
-    }
-}}}  // namespace facter::facts::external

data/ext/facter/facter/lib/src/facts/external/windows/powershell_resolver.cc DELETED

@@ -1,117 +0,0 @@
-#include <internal/facts/external/windows/powershell_resolver.hpp>
-#include <internal/util/yaml.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <facter/facts/fact.hpp>
-#include <leatherman/execution/execution.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <leatherman/util/strings.hpp>
-#include <boost/algorithm/string.hpp>
-#include <boost/filesystem.hpp>
-using namespace std;
-using namespace boost::filesystem;
-using namespace facter::util::yaml;
-using namespace leatherman::execution;
-namespace facter { namespace facts { namespace external {
-    bool powershell_resolver::can_resolve(string const& file) const
-    {
-        try {
-            path p = file;
-            return boost::iends_with(file, ".ps1") && is_regular_file(p);
-        } catch (filesystem_error &e) {
-            LOG_TRACE("error reading status of path {1}: {2}", file, e.what());
-            return false;
-        }
-    }
-    void powershell_resolver::resolve(string const& file, collection& facts) const
-    {
-        LOG_DEBUG("resolving facts from powershell script \"{1}\".", file);
-        try
-        {
-            bool resolved = false;
-            string pwrshell = "powershell";
-            // When facter is a 32-bit process running on 64-bit windows (such as in a 32-bit puppet installation that
-            // includes native facter), PATH-lookp finds the 32-bit powershell and leads to problems. For example, if
-            // using powershell to read values from the registry, it will read the 32-bit view of the registry. Also 32
-            // and 64-bit versions have different modules available (since PSModulePath is in system32). Use the
-            // system32 fact to find the correct powershell executable.
-            auto system32 = facts.get<string_value>(fact::windows_system32);
-            if (system32) {
-                auto pathNative = path(system32->value()) / "WindowsPowerShell" / "v1.0" / "powershell.exe";
-                auto pwrshellNative = which(pathNative.string());
-                if (!pwrshellNative.empty()) {
-                    pwrshell = move(pwrshellNative);
-                }
-            }
-            auto const pwrshell_opts = vector<string> {
-                "-NoProfile",
-                "-NonInteractive",
-                "-NoLogo",
-                "-ExecutionPolicy",
-                "Bypass",
-                "-File",
-                file
-            };
-            auto result = execute(pwrshell, pwrshell_opts, 0, {
-                execution_options::trim_output,
-                execution_options::merge_environment,
-                execution_options::throw_on_failure
-            });
-            try {
-                auto node = YAML::Load(result.output);
-                for (auto const& kvp : node) {
-                    string key = kvp.first.as<string>();
-                    boost::to_lower(key);
-                    add_value(key, kvp.second, facts);
-                    // If YAML doesn't correctly parse, it will
-                    // sometimes just return an empty node instead of
-                    // erroring. Only claiming we've resolved if we
-                    // add at least one child value from the YAML
-                    // allows us to still pass on to the key=val
-                    // interpretation in those cases.
-                    resolved = true;
-                }
-            } catch (YAML::Exception& ex) {
-                LOG_DEBUG("Could not parse executable fact output as YAML or JSON ({1})", ex.msg);
-            }
-            if (!resolved) {
-                // YAML/JSON parse not successful; Look for key=value pairs
-                leatherman::util::each_line(result.output, [&facts](string const& line) {
-                    auto pos = line.find('=');
-                    if (pos == string::npos) {
-                        LOG_DEBUG("ignoring line in output: {1}", line);
-                        return true;
-                    }
-                    // Add as a string fact
-                    string fact = line.substr(0, pos);
-                    boost::to_lower(fact);
-                    string value = line.substr(pos + 1);
-                    facts.add_external(move(fact), make_value<string_value>(move(value)));
-                    return true;
-                });
-            }
-            // Log a warning if the script had any error output
-            if (!result.error.empty()) {
-                LOG_WARNING("external fact file \"{1}\" had output on stderr: {2}", file, result.error);
-            }
-        }
-        catch (execution_exception& ex) {
-            throw external_fact_exception(ex.what());
-        }
-        LOG_DEBUG("completed resolving facts from powershell script \"{1}\".", file);
-    }
-}}}  // namespace facter::facts::external