cfacter 3.11.0.rc.20180314

data/ext/facter/facter/lib/src/facts/bsd/uptime_resolver.cc

@@ -0,0 +1,23 @@
+#include <internal/facts/bsd/uptime_resolver.hpp>
+#include <ctime>
+#include <sys/sysctl.h>
+
+using namespace std;
+
+namespace facter { namespace facts { namespace bsd {
+
+    int64_t uptime_resolver::get_uptime()
+    {
+        // this approach adapted from: http://stackoverflow.com/a/11676260/1004272
+        timeval boottime;
+        size_t len = sizeof(boottime);
+        int mib[2] = { CTL_KERN, KERN_BOOTTIME };
+        if (sysctl(mib, 2, &boottime, &len, NULL, 0) == 0) {
+            time_t bsec = boottime.tv_sec;
+            time_t now = time(NULL);
+            return now - bsec;
+        }
+        return posix::uptime_resolver::get_uptime();
+    }
+
+}}}  // namespace facter::facts::bsd

data/ext/facter/facter/lib/src/facts/cache.cc

@@ -0,0 +1,117 @@
+#include <internal/facts/cache.hpp>
+#include <internal/facts/external/json_resolver.hpp>
+
+#include <rapidjson/document.h>
+#include <rapidjson/prettywriter.h>
+#include <leatherman/logging/logging.hpp>
+#include <leatherman/file_util/directory.hpp>
+#include <leatherman/file_util/file.hpp>
+#include <boost/nowide/fstream.hpp>
+#include <boost/system/error_code.hpp>
+#include <time.h>
+
+using namespace std;
+using namespace rapidjson;
+using namespace facter::facts::external;
+namespace boost_file = boost::filesystem;
+
+namespace facter { namespace facts { namespace cache {
+
+    void clean_cache(unordered_map<string, int64_t> const& facts_to_cache, string cache_location) {
+        boost_file::path cache_dir = boost_file::path(cache_location);
+        if (!boost_file::is_directory(cache_dir)) {
+            return;
+        }
+        for (boost_file::directory_iterator itr(cache_dir);
+                itr != boost_file::directory_iterator();
+                ++itr) {
+            boost_file::path cache_file = itr->path();
+            if (!facts_to_cache.count(cache_file.filename().string())) {
+                boost::system::error_code ec;
+                boost_file::remove(cache_file, ec);
+                if (!ec) {
+                    LOG_DEBUG("Deleting unused cache file {1}", cache_file.string());
+                } else {
+                    continue;
+                }
+            }
+        }
+    }
+
+    bool cache_is_valid(boost_file::path const& cache_file, int64_t ttl) {
+        time_t last_mod = boost_file::last_write_time(cache_file);
+        time_t now;
+        double lifetime_seconds = difftime(time(&now), last_mod);
+        return static_cast<int64_t>(lifetime_seconds) < ttl;
+    }
+
+    void load_facts_from_cache(boost_file::path const& cache_file, shared_ptr<resolver> res, collection& facts) {
+        string cache_file_path = cache_file.string();
+        if (leatherman::file_util::file_readable(cache_file_path)) {
+            try {
+                json_resolver json_res;
+                json_res.resolve(cache_file_path, facts);
+            } catch (external_fact_exception& ex) {
+                LOG_DEBUG("cache file for {1} facts contained invalid JSON, refreshing", res->name());
+                refresh_cache(res, cache_file, facts);
+                return;
+            }
+        } else {
+            LOG_DEBUG("cache file for {1} facts was missing, refreshing", res->name());
+            refresh_cache(res, cache_file, facts);
+            return;
+        }
+    }
+
+    void refresh_cache(shared_ptr<resolver> res, boost_file::path const& cache_file, collection& facts) {
+        res->resolve(facts);
+        boost_file::remove(cache_file);
+        write_json_cache_file(facts, cache_file.string(), res->names());
+    }
+
+    void use_cache(collection& facts, shared_ptr<resolver> res, int64_t ttl) {
+        boost_file::path cache_dir = boost_file::path(fact_cache_location());
+        if (!boost_file::is_directory(cache_dir)) {
+            boost_file::create_directories(cache_dir);
+        }
+        boost_file::path cache_file = cache_dir / res->name();
+        if (leatherman::file_util::file_readable(cache_file.string()) && cache_is_valid(cache_file, ttl)) {
+            LOG_DEBUG("loading cached values for {1} facts", res->name());
+            load_facts_from_cache(cache_file, res, facts);
+        } else {
+            LOG_DEBUG("caching values for {1} facts", res->name());
+            refresh_cache(res, cache_file, facts);
+        }
+    }
+
+    void write_json_cache_file(collection& facts, boost_file::path const& file_path, vector<string> const& fact_names)
+    {
+        json_document document;
+        document.SetObject();
+
+        auto builder = ([&](string const& key, value const* val) {
+            json_value value;
+            if (val) {
+                val->to_json(document.GetAllocator(), value);
+            } else {
+                value.SetString("", 0);
+            }
+            document.AddMember(StringRef(key.c_str(), key.size()), value, document.GetAllocator());
+        });
+
+        for (auto const& name : fact_names) {
+            auto fact_value = facts.get_resolved(name);
+            if (fact_value) {
+                builder(name, fact_value);
+            }
+        }
+
+        string file_path_string = file_path.string();
+        boost::nowide::ofstream stream(file_path_string);
+        stream_adapter adapter(stream);
+        PrettyWriter<stream_adapter> writer(adapter);
+        writer.SetIndent(' ', 2);
+        document.Accept(writer);
+    }
+
+}}}  // namespace facter::facts::cache

data/ext/facter/facter/lib/src/facts/collection.cc

@@ -0,0 +1,661 @@
+#include <facter/facts/collection.hpp>
+#include <facter/facts/resolver.hpp>
+#include <facter/facts/value.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <facter/facts/array_value.hpp>
+#include <facter/facts/map_value.hpp>
+#include <facter/ruby/ruby.hpp>
+#include <facter/util/string.hpp>
+#include <facter/version.h>
+#include <internal/facts/resolvers/hypervisors_resolver.hpp>
+#include <internal/facts/resolvers/ruby_resolver.hpp>
+#include <internal/facts/resolvers/path_resolver.hpp>
+#include <internal/facts/resolvers/ec2_resolver.hpp>
+#include <internal/facts/resolvers/gce_resolver.hpp>
+#include <internal/facts/resolvers/augeas_resolver.hpp>
+#include <internal/ruby/ruby_value.hpp>
+#include <internal/facts/cache.hpp>
+#include <leatherman/dynamic_library/dynamic_library.hpp>
+#include <leatherman/file_util/directory.hpp>
+#include <leatherman/util/environment.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/algorithm/string.hpp>
+#include <rapidjson/document.h>
+#include <rapidjson/prettywriter.h>
+#include <yaml-cpp/yaml.h>
+#include <algorithm>
+
+using namespace std;
+using namespace facter::util;
+using namespace rapidjson;
+using namespace YAML;
+using namespace boost::filesystem;
+using namespace leatherman::util;
+using namespace leatherman::file_util;
+using facter::util::maybe_stoi;
+
+namespace facter { namespace facts {
+
+    collection::collection(set<string> const& blocklist, unordered_map<string, int64_t> const& ttls, bool ignore_cache) :
+        _blocklist(blocklist), _ttls(ttls), _ignore_cache(ignore_cache)
+    {
+        // This needs to be defined here since we use incomplete types in the header
+    }
+
+    collection::~collection()
+    {
+        // This needs to be defined here since we use incomplete types in the header
+    }
+
+    collection::collection(collection&& other)
+    {
+        *this = std::move(other);
+    }
+
+    collection& collection::operator=(collection&& other)
+    {
+        if (this != &other) {
+            _facts = std::move(other._facts);
+            _resolvers = std::move(other._resolvers);
+            _resolver_map = std::move(other._resolver_map);
+            _pattern_resolvers = std::move(other._pattern_resolvers);
+            _blocklist = std::move(other._blocklist);
+            _ttls = std::move(other._ttls);
+        }
+        return *this;
+    }
+
+    void collection::add_default_facts(bool include_ruby_facts)
+    {
+        add_common_facts(include_ruby_facts);
+        add_platform_facts();
+    }
+
+    void collection::add(shared_ptr<resolver> const& res)
+    {
+        if (!res) {
+            return;
+        }
+
+        for (auto const& name : res->names()) {
+            _resolver_map.insert({ name, res });
+        }
+
+        if (res->has_patterns()) {
+            _pattern_resolvers.push_back(res);
+        }
+
+        _resolvers.push_back(res);
+    }
+
+    void collection::add(string name, unique_ptr<value> value)
+    {
+        // Ensure the fact is resolved before replacing it
+        auto old_value = get_value(name);
+
+        if (LOG_IS_DEBUG_ENABLED()) {
+            if (old_value) {
+                ostringstream old_value_ss;
+                old_value->write(old_value_ss);
+                if (!value) {
+                    LOG_DEBUG("fact \"{1}\" resolved to null and the existing value of {2} will be removed.", name, old_value_ss.str());
+                } else {
+                    ostringstream new_value_ss;
+                    value->write(new_value_ss);
+                    if (old_value->weight() > value->weight()) {
+                      LOG_DEBUG("new value for fact \"{1}\" ignored, because it's a lower weight", name);
+                    } else {
+                      LOG_DEBUG("fact \"{1}\" has changed from {2} to {3}.", name, old_value_ss.str(), new_value_ss.str());
+                    }
+                }
+            } else {
+                if (!value) {
+                    LOG_DEBUG("fact \"{1}\" resolved to null and will not be added.", name);
+                } else {
+                    ostringstream new_value_ss;
+                    value->write(new_value_ss);
+                    LOG_DEBUG("fact \"{1}\" has resolved to {2}.", name, new_value_ss.str());
+                }
+            }
+        }
+
+        if (!value) {
+            if (old_value) {
+                remove(name);
+            }
+            return;
+        }
+
+        // keep existing value if it has a larger weight value
+        if (old_value && old_value->weight() > value->weight())
+            return;
+
+        _facts[move(name)] = move(value);
+    }
+
+    void collection::add_custom(string name, unique_ptr<value> value, size_t weight)
+    {
+        if (value)
+            value->weight(weight);
+        add(move(name), move(value));
+    }
+
+    void collection::add_external(string name, unique_ptr<value> value)
+    {
+        if (value)
+            value->weight(external_fact_weight);
+        add(move(name), move(value));
+    }
+
+    bool collection::add_external_facts_dir(vector<unique_ptr<external::resolver>> const& resolvers, string const& dir, bool warn)
+    {
+        // If dir is relative, make it an absolute path before passing to can_resolve.
+        bool found = false;
+        boost::system::error_code ec;
+        path search_dir = absolute(dir);
+
+        if (!is_directory(search_dir, ec)) {
+            // Warn the user if not using the default search directories
+            string msg = ec ? ec.message() : "not a directory";
+            if (warn) {
+                LOG_WARNING("skipping external facts for \"{1}\": {2}", dir, msg);
+            } else {
+                LOG_DEBUG("skipping external facts for \"{1}\": {2}", dir, msg);
+            }
+            return found;
+        }
+
+        LOG_DEBUG("searching {1} for external facts.", search_dir);
+
+        each_file(search_dir.string(), [&](string const& path) {
+            for (auto const& res : resolvers) {
+                if (res->can_resolve(path)) {
+                    try {
+                        found = true;
+                        res->resolve(path, *this);
+                    }
+                    catch (external::external_fact_exception& ex) {
+                        LOG_ERROR("error while processing \"{1}\" for external facts: {2}", path, ex.what());
+                    }
+                    break;
+                }
+            }
+            return true;
+        });
+        return found;
+    }
+
+    void collection::add_external_facts(vector<string> const& directories)
+    {
+        auto resolvers = get_external_resolvers();
+
+        // Build a map between a file and the resolver that can resolve it
+        // Start with default Facter search directories, then user-specified directories.
+        bool found = false;
+        for (auto const& dir : get_external_fact_directories()) {
+            found |= add_external_facts_dir(resolvers, dir, false);
+        }
+
+        for (auto const& dir : directories) {
+            found |= add_external_facts_dir(resolvers, dir, true);
+        }
+
+        if (!found) {
+            LOG_DEBUG("no external facts were found.");
+        }
+    }
+
+    void collection::add_environment_facts(function<void(string const& name)> callback)
+    {
+        environment::each([&](string& name, string& value) {
+            // If the variable starts with "FACTER_", the remainder of the variable is the fact name
+            if (!boost::istarts_with(name, "FACTER_")) {
+                return true;
+            }
+
+            auto fact_name = name.substr(7);
+            boost::to_lower(fact_name);
+            LOG_DEBUG("setting fact \"{1}\" based on the value of environment variable \"{2}\".", fact_name, name);
+
+            // Add the value based on the environment variable
+            auto fact_value = make_value<string_value>(move(value));
+            fact_value->weight(external_fact_weight);
+            add(fact_name, move(fact_value));
+            if (callback) {
+                callback(fact_name);
+            }
+            return true;
+        });
+    }
+
+    void collection::remove(shared_ptr<resolver> const& res)
+    {
+        if (!res) {
+            return;
+        }
+
+        // Remove all name associations
+        for (auto const& name : res->names()) {
+            auto range = _resolver_map.equal_range(name);
+            auto it = range.first;
+            while (it != range.second) {
+                if (it->second != res) {
+                    ++it;
+                    continue;
+                }
+                it = _resolver_map.erase(it);
+            }
+        }
+
+        _pattern_resolvers.remove(res);
+        _resolvers.remove(res);
+    }
+
+    void collection::remove(string const& name)
+    {
+        // Ensure the fact is in the collection
+        // This will properly resolve the fact prior to removing it
+        if (!get_value(name)) {
+            return;
+        }
+
+        _facts.erase(name);
+    }
+
+    void collection::clear()
+    {
+        _facts.clear();
+        _resolvers.clear();
+        _resolver_map.clear();
+        _pattern_resolvers.clear();
+    }
+
+    bool collection::empty()
+    {
+        return _facts.empty() && _resolvers.empty();
+    }
+
+    map<string, vector<string>> collection::get_fact_groups() {
+        map<string, vector<string>> fact_groups;
+        for (auto res : _resolvers) {
+            fact_groups.emplace(res->name(), res->names());
+        }
+        return fact_groups;
+    }
+
+    map<string, vector<string>> collection::get_blockable_fact_groups() {
+        map<string, vector<string>> blockgroups;
+        for (auto res : _resolvers) {
+            if (res->is_blockable()) {
+                blockgroups.emplace(res->name(), res->names());
+            }
+        }
+        return blockgroups;
+    }
+
+    size_t collection::size()
+    {
+        resolve_facts();
+        return _facts.size();
+    }
+
+    value const* collection::operator[](string const& name)
+    {
+        return get_value(name);
+    }
+
+    void collection::each(function<bool(string const&, value const*)> func)
+    {
+        resolve_facts();
+
+        find_if(begin(_facts), end(_facts), [&func](map<string, unique_ptr<value>>::value_type const& it) {
+            return !func(it.first, it.second.get());
+        });
+    }
+
+    ostream& collection::write(ostream& stream, format fmt, set<string> const& queries)
+    {
+        return write(stream, fmt, queries, false, false);
+    }
+
+    ostream& collection::write(ostream& stream, format fmt, set<string> const& queries, bool show_legacy, bool strict_errors)
+    {
+        if (queries.empty()) {
+            // Resolve all facts
+            resolve_facts();
+        }
+
+        if (fmt == format::hash) {
+            write_hash(stream, queries, show_legacy, strict_errors);
+        } else if (fmt == format::json) {
+            write_json(stream, queries, show_legacy, strict_errors);
+        } else if (fmt == format::yaml) {
+            write_yaml(stream, queries, show_legacy, strict_errors);
+        }
+        return stream;
+    }
+
+    bool collection::try_block(shared_ptr<resolver> const& res) {
+        if (_blocklist.count(res->name())) {
+            if (res->is_blockable()) {
+                LOG_DEBUG("blocking collection of {1} facts.", res->name());
+                return true;
+            } else {
+                LOG_DEBUG("{1} resolver cannot be blocked.", res->name());
+            }
+        }
+        return false;
+    }
+
+    void collection::resolve(shared_ptr<resolver> const& res) {
+        remove(res);
+
+        // Check if the resolver has been blocked
+        if (try_block(res)) {
+            return;
+        }
+
+        // Check if the resolver should be cached
+        auto resolver_ttl = _ttls.find(res->name());
+        if (!_ignore_cache && resolver_ttl != _ttls.end()) {
+           cache::use_cache(*this, res, (*resolver_ttl).second);
+           return;
+        }
+
+        // Resolve normally
+        LOG_DEBUG("resolving {1} facts.", res->name());
+        try {
+            res->resolve(*this);
+        } catch (std::runtime_error &e) {
+            LOG_WARNING("exception resolving {1} facts, some facts will not be available: {2}", res->name(), e.what());
+        }
+    }
+
+    void collection::resolve_facts()
+    {
+        // Delete any unused cache files
+        if (!_ignore_cache) {
+            cache::clean_cache(_ttls);
+        }
+        // Remove the front of the resolvers list and resolve until no resolvers are left
+        while (!_resolvers.empty()) {
+            auto resolver = _resolvers.front();
+            resolve(resolver);
+       }
+    }
+
+    void collection::resolve_fact(string const& name)
+    {
+        // Resolve every resolver mapped to this name first
+        auto range = _resolver_map.equal_range(name);
+        auto it = range.first;
+        while (it != range.second) {
+            auto resolver = (it++)->second;
+            resolve(resolver);
+        }
+
+         // Resolve every resolver that matches the given name
+        auto pattern_it = _pattern_resolvers.begin();
+        while (pattern_it != _pattern_resolvers.end()) {
+            if (!(*pattern_it)->is_match(name)) {
+                ++pattern_it;
+                continue;
+            }
+            auto resolver = *(pattern_it++);
+            resolve(resolver);
+        }
+    }
+
+    value const* collection::get_value(string const& name)
+    {
+        resolve_fact(name);
+
+        // Lookup the fact
+        auto it = _facts.find(name);
+        return it == _facts.end() ? nullptr : it->second.get();
+    }
+
+    value const* collection::query_value(string const& query, bool strict_errors)
+    {
+        // First attempt to lookup a fact with the exact name of the query
+        value const* current = get_value(query);
+        if (current) {
+            return current;
+        }
+
+        bool in_quotes = false;
+        vector<string> segments;
+        string segment;
+        for (auto const& c : query) {
+            if (c == '"') {
+                in_quotes = !in_quotes;
+                continue;
+            }
+            if (in_quotes || c != '.') {
+                segment += c;
+                continue;
+            }
+            segments.emplace_back(move(segment));
+            segment.clear();
+        }
+        if (!segment.empty()) {
+            segments.emplace_back(move(segment));
+        }
+
+        auto segment_end = end(segments);
+        for (auto segment = begin(segments); segment != segment_end; ++segment) {
+            auto rb_val = dynamic_cast<ruby::ruby_value const *>(current);
+            if (rb_val) {
+                current = facter::ruby::lookup(current, segment, segment_end);
+                if (!current) {
+                    LOG_DEBUG("cannot lookup an element with \"{1}\" from Ruby fact", *segment);
+                }
+                // Once we hit Ruby there's no going back, so whatever we get from Ruby is the value.
+                return current;
+            } else {
+                current = lookup(current, *segment, strict_errors);
+            }
+            if (!current) {
+                // Break out early if there's no value for this segment
+                return nullptr;
+            }
+        }
+
+        return current;
+    }
+
+    value const* collection::lookup(value const* value, string const& name, bool strict_errors)
+    {
+        if (!value) {
+            value = get_value(name);
+            if (!value) {
+                string message = "fact \"{1}\" does not exist.";
+                if (strict_errors) {
+                    LOG_ERROR(message, name);
+                } else {
+                    LOG_DEBUG(message, name);
+                }
+            }
+            return value;
+        }
+
+        auto map = dynamic_cast<map_value const*>(value);
+        if (map) {
+            value = (*map)[name];
+            if (!value) {
+                LOG_DEBUG("cannot lookup a hash element with \"{1}\": element does not exist.", name);
+            }
+            return value;
+        }
+
+        auto array = dynamic_cast<array_value const*>(value);
+        if (!array) {
+            return nullptr;
+        }
+
+        auto maybe_index = maybe_stoi(name);;
+        if (!maybe_index) {
+            LOG_DEBUG("cannot lookup an array element with \"{1}\": expected an integral value.", name);
+            return nullptr;
+        }
+
+        int index = maybe_index.get();
+        if (index < 0) {
+            LOG_DEBUG("cannot lookup an array element with \"{1}\": expected a non-negative value.", name);
+            return nullptr;
+        }
+
+        if (array->empty()) {
+            LOG_DEBUG("cannot lookup an array element with \"{1}\": the array is empty.", name);
+            return nullptr;
+        }
+
+        if (static_cast<size_t>(index) >= array->size()) {
+            LOG_DEBUG("cannot lookup an array element with \"{1}\": expected an integral value between 0 and {2} (inclusive).", name, array->size() - 1);
+            return nullptr;
+        }
+
+        return (*array)[index];
+    }
+
+    void collection::write_hash(ostream& stream, set<string> const& queries, bool show_legacy, bool strict_errors)
+    {
+        // If there's only one query, print the result without the name
+        if (queries.size() == 1u) {
+            auto value = query_value(*queries.begin(), strict_errors);
+            if (value) {
+                value->write(stream, false);
+            }
+            return;
+        }
+
+        bool first = true;
+        auto writer = ([&](string const& key, value const* val) {
+            // Ignore facts with hidden values
+            if (!show_legacy && queries.empty() && val && val->hidden()) {
+                return;
+            }
+            if (first) {
+                first = false;
+            } else {
+                stream << '\n';
+            }
+            stream << key << " => ";
+            if (val) {
+                val->write(stream, false);
+            }
+        });
+
+        if (!queries.empty()) {
+            // Print queried facts
+            vector<pair<string, value const*>> facts;
+            for (auto const& query : queries) {
+                facts.push_back(make_pair(query, this->query_value(query, strict_errors)));
+            }
+
+            for (auto const& kvp : facts) {
+                writer(kvp.first, kvp.second);
+            }
+        } else {
+            // Print all facts in the map
+            for (auto const& kvp : _facts) {
+                writer(kvp.first, kvp.second.get());
+            }
+        }
+    }
+
+    void collection::write_json(ostream& stream, set<string> const& queries, bool show_legacy, bool strict_errors)
+    {
+        json_document document;
+        document.SetObject();
+
+        auto builder = ([&](string const& key, value const* val) {
+            // Ignore facts with hidden values
+            if (!show_legacy && queries.empty() && val && val->hidden()) {
+                return;
+            }
+            json_value value;
+            if (val) {
+                val->to_json(document.GetAllocator(), value);
+            } else {
+                value.SetString("", 0);
+            }
+            document.AddMember(StringRef(key.c_str(), key.size()), value, document.GetAllocator());
+        });
+
+        if (!queries.empty()) {
+            for (auto const& query : queries) {
+                builder(query, this->query_value(query, strict_errors));
+            }
+        } else {
+            for (auto const& kvp : _facts) {
+                builder(kvp.first, kvp.second.get());
+            }
+        }
+
+        stream_adapter adapter(stream);
+        PrettyWriter<stream_adapter> writer(adapter);
+        writer.SetIndent(' ', 2);
+        document.Accept(writer);
+    }
+
+    void collection::write_yaml(ostream& stream, set<string> const& queries, bool show_legacy, bool strict_errors)
+    {
+        Emitter emitter(stream);
+        emitter << BeginMap;
+
+        auto writer = ([&](string const& key, value const* val) {
+            // Ignore facts with hidden values
+            if (!show_legacy && queries.empty() && val && val->hidden()) {
+                return;
+            }
+            emitter << Key;
+            if (needs_quotation(key)) {
+                emitter << DoubleQuoted;
+            }
+            emitter << key << YAML::Value;
+            if (val) {
+                val->write(emitter);
+            } else {
+                emitter << DoubleQuoted << "";
+            }
+        });
+
+        if (!queries.empty()) {
+            vector<pair<string, value const*>> facts;
+            for (auto const& query : queries) {
+                facts.push_back(make_pair(query, this->query_value(query, strict_errors)));
+            }
+
+            for (auto const& kvp : facts) {
+                writer(kvp.first, kvp.second);
+            }
+        } else {
+            for (auto const& kvp : _facts) {
+                writer(kvp.first, kvp.second.get());
+            }
+        }
+        emitter << EndMap;
+    }
+
+    void collection::add_common_facts(bool include_ruby_facts)
+    {
+        add("facterversion", make_value<string_value>(LIBFACTER_VERSION));
+#ifdef AIO_AGENT_VERSION
+        add("aio_agent_version", make_value<string_value>(AIO_AGENT_VERSION));
+#endif
+
+        if (include_ruby_facts) {
+            add(make_shared<resolvers::ruby_resolver>());
+        }
+        add(make_shared<resolvers::path_resolver>());
+        add(make_shared<resolvers::ec2_resolver>());
+        add(make_shared<resolvers::gce_resolver>());
+        add(make_shared<resolvers::augeas_resolver>());
+#ifdef USE_WHEREAMI
+        add(make_shared<resolvers::hypervisors_resolver>());
+#endif
+    }
+
+}}  // namespace facter::facts