cfacter 3.11.0.rc.20180314

data/ext/facter/facter/lib/inc/facter/logging/logging.hpp

@@ -0,0 +1,192 @@
+/**
+* @file
+* Declares the Facter logging functions.
+*/
+#pragma once
+
+#include <stdexcept>
+#include <ostream>
+#include <string>
+#include <boost/format.hpp>
+#include "../export.h"
+
+namespace facter { namespace logging {
+
+    /**
+     * Represents the supported logging levels.
+     */
+    enum class level
+    {
+        /**
+         * No logging level.
+         */
+        none,
+        /**
+         * Trace level.
+         */
+        trace,
+        /**
+         * Debug level.
+         */
+        debug,
+        /**
+         * Info level.
+         */
+        info,
+        /**
+         * Warning level.
+         */
+        warning,
+        /**
+         * Error level.
+         */
+        error,
+        /**
+         * Fatal error level.
+         */
+        fatal
+    };
+
+    /**
+     * Reads a logging level from an input stream.
+     * This is used in boost::lexical_cast<level>.
+     * @param in The input stream.
+     * @param lvl The returned logging level.
+     * @returns Returns the input stream.
+     */
+    LIBFACTER_EXPORT std::istream& operator>>(std::istream& in, level& lvl);
+
+    /**
+     * Produces the printed representation of a logging level.
+     * @param os The stream to write.
+     * @param lvl The logging level to write.
+     * @return Returns the stream after writing to it.
+     */
+    LIBFACTER_EXPORT std::ostream& operator<<(std::ostream& os, level lvl);
+
+    /**
+     * Sets up logging for the given stream.
+     * The logging level is set to warning by default.
+     * @param os The output stream to configure for logging.
+     */
+    LIBFACTER_EXPORT void setup_logging(std::ostream& os);
+
+    /**
+     * Sets the current logging level.
+     * @param lvl The new current logging level to set.
+     */
+    LIBFACTER_EXPORT void set_level(level lvl);
+
+    /**
+     * Gets the current logging level.
+     * @return Returns the current logging level.
+     */
+    LIBFACTER_EXPORT level get_level();
+
+    /**
+     * Sets whether or not log output is colorized.
+     * @param color Pass true if log output is colorized or false if it is not colorized.
+     */
+    LIBFACTER_EXPORT void set_colorization(bool color);
+
+    /**
+     * Gets whether or not the log output is colorized.
+     * @return Returns true if log output is colorized or false if it is not colorized.
+     */
+    LIBFACTER_EXPORT bool get_colorization();
+
+    /**
+     * Determines if the given logging level is enabled.
+     * @param lvl The logging level to check.
+     * @return Returns true if the logging level is enabled or false if it is not.
+     */
+    LIBFACTER_EXPORT bool is_enabled(level lvl);
+
+    /**
+     * Determine if an error has been logged.
+     * @return Returns true if an error or critical message has been logged.
+     */
+    LIBFACTER_EXPORT bool error_logged();
+
+    /**
+     * Clears logged errors.
+     */
+    LIBFACTER_EXPORT void clear_logged_errors();
+
+    /**
+     * Translate text using the locale initialized by this library.
+     * @param msg The string to translate.
+     * @return The translated string.
+     */
+    LIBFACTER_EXPORT std::string translate(std::string const& msg);
+
+    /**
+     * Format a text message.
+     * @tparam TArgs The format argument types.
+     * @param fmt The format string.
+     * @param args The format arguments.
+     * @return The formatted string.
+     */
+    template <typename... TArgs>
+    std::string format(std::string const& fmt, TArgs... args)
+    {
+        boost::format msg{translate(fmt)};
+        (void) std::initializer_list<int>{ ((void)(msg % args), 0)... };
+        return msg.str();
+    }
+
+    /**
+     * Format a text message.
+     * Alias for format(...); Convenience function for adding i18n support.
+     * @tparam TArgs The format argument types.
+     * @param fmt The format string.
+     * @param args The format arguments.
+     * @return The formatted string.
+     */
+    template<typename... TArgs>
+    inline std::string _(std::string const& fmt, TArgs&&... args)
+    {
+        return format(std::forward<decltype(fmt)>(fmt), std::forward<TArgs>(args)...);
+    }
+
+    /**
+     * Log a message.
+     * @param lvl The logging level to log with.
+     * @param msg The message to log.
+     */
+    LIBFACTER_EXPORT void log(level lvl, std::string const& msg);
+
+    /**
+     * Log a formatted message.
+     * @tparam TArgs The format argument types.
+     * @param lvl The logging level to log with.
+     * @param fmt The format string.
+     * @param args The format arguments.
+     */
+    template <typename... TArgs>
+    inline void log(level lvl, std::string const& fmt, TArgs... args)
+    {
+        log(std::forward<decltype(lvl)>(lvl), format(fmt, std::forward<TArgs>(args)...));
+    }
+
+    /**
+     * Starts colorizing for the given logging level.
+     * This is a no-op on platforms that don't natively support terminal colors.
+     * @param os The stream to colorize.
+     * @param lvl The logging level to colorize for. Defaults to none, which resets colorization.
+     */
+    LIBFACTER_EXPORT void colorize(std::ostream &os, level lvl = level::none);
+
+    /**
+     * Exception to indicate that locale setup was not possible.
+     */
+    class locale_error : public std::runtime_error {
+    public:
+         /**
+          * Constructs a locale_error exception.
+          * @param msg The exception message.
+          */
+         explicit locale_error(const std::string& msg) : std::runtime_error(msg) {}
+    };
+
+}}  // namespace facter::logging

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

@@ -0,0 +1,62 @@
+/**
+* @file
+* Declares the Facter Ruby functions.
+*/
+#pragma once
+
+#include "../facts/collection.hpp"
+#include "../facts/value.hpp"
+#include "../export.h"
+#include <vector>
+#include <string>
+
+namespace facter { namespace ruby {
+
+    /**
+     * Initialize Ruby integration in Facter.
+     * Important: this function must be called in main().
+     * Calling this function from an arbitrary stack depth may result in segfaults during Ruby GC.
+     * @param include_stack_trace True if Ruby exception messages should include a stack trace or false if not.
+     * @return Returns true if Ruby was initialized or false if Ruby could not be initialized (likely not found).
+     */
+    LIBFACTER_EXPORT bool initialize(bool include_stack_trace = false);
+
+    /**
+     * Loads custom facts into the given collection.
+     * Important: this function should be called from main().
+     * Calling this function from an arbitrary stack depth may result in segfaults during Ruby GC.
+     * @param facts The collection to populate with custom facts.
+     * @param initialize_puppet Whether puppet should be loaded to find additional facts.
+     * @param paths The paths to search for custom facts.
+     */
+    LIBFACTER_EXPORT void load_custom_facts(facter::facts::collection& facts, bool initialize_puppet, std::vector<std::string> const& paths = {});
+
+    /**
+     * Loads custom facts into the given collection.
+     * Important: this function should be called from main().
+     * Calling this function from an arbitrary stack depth may result in segfaults during Ruby GC.
+     * This is provided for backwards compatibility.
+     * @param facts The collection to populate with custom facts.
+     * @param paths The paths to search for custom facts.
+     */
+    LIBFACTER_EXPORT void load_custom_facts(facter::facts::collection& facts, std::vector<std::string> const& paths = {});
+
+    /**
+     * Traverses a ruby fact and returns a new value based on the
+     * query segments passed in the range.
+     * @param value The original value to query
+     * @param segment The beginning of the query segment range
+     * @param end The end of the query segment range
+     * @return Returns a pointer to the value queried, or nullptr if it does not exist.
+     */
+    LIBFACTER_EXPORT facts::value const* lookup(facts::value const* value, std::vector<std::string>::iterator segment, std::vector<std::string>::iterator end);
+
+    /**
+     * Uninitialize Ruby integration in Facter.
+     * This is unneeded if libfacter was loaded from Ruby. If libfacter instead loads Ruby's dynamic library
+     * you should call uninitialize before exiting to avoid dynamic library unload ordering issues with
+     * destructors and atexit handlers.
+     */
+    LIBFACTER_EXPORT void uninitialize();
+
+}}  // namespace facter::ruby

data/ext/facter/facter/lib/inc/facter/util/config.hpp

@@ -0,0 +1,84 @@
+/**
+ * @file
+ * Declares methods for interacting with Facter's config file.
+ */
+#pragma once
+
+#include "../export.h"
+#include <hocon/config.hpp>
+#include <boost/program_options.hpp>
+
+namespace facter { namespace util { namespace config {
+    /**
+     * Parses the contents of Facter's config file from its default location
+     * for the current operating system.
+     * @return HOCON config object, or nullptr if no file was found
+     */
+    LIBFACTER_EXPORT hocon::shared_config load_default_config_file();
+
+    /**
+     * Returns the default location of the config file.
+     * @return the absolute path to the default config file
+     */
+    LIBFACTER_EXPORT std::string default_config_location();
+
+    /**
+     * Parses the contents of the config pile at the specified path.
+     * @param config_path the path to the config file
+     * @return HOCON config object, or nullptr if no file was found
+     */
+    LIBFACTER_EXPORT hocon::shared_config load_config_from(std::string config_path);
+
+    /**
+     * Loads the "global" section of the config file into the settings map.
+     * @param hocon_config the config object representing the parsed config file
+     * @param vm the key-value map in which to store the settings
+     */
+    LIBFACTER_EXPORT void load_global_settings(hocon::shared_config hocon_config, boost::program_options::variables_map& vm);
+
+    /**
+     * Loads the "cli" section of the config file into the settings map.
+     * @param hocon_config the config object representing the parsed config file
+     * @param vm the key-value map in which to store the settings
+     */
+    LIBFACTER_EXPORT void load_cli_settings(hocon::shared_config hocon_config, boost::program_options::variables_map& vm);
+
+    /**
+     * Loads the "blocklist" section of the config file into the settings map.
+     * @param hocon_config the config object representing the parsed config file
+     * @param vm the key-value map in which to store the settings
+     */
+    LIBFACTER_EXPORT void load_fact_settings(hocon::shared_config hocon_config, boost::program_options::variables_map& vm);
+
+    /**
+     * Returns a schema of the valid global options that can appear in the config file.
+     * @return names, values, and descriptions of global Facter options
+     */
+    LIBFACTER_EXPORT boost::program_options::options_description global_config_options();
+
+    /**
+     * Returns a schema of the valid config file options affecting Facter's command line interface.
+     * @return names, values, and descriptions of command line options
+     */
+    LIBFACTER_EXPORT boost::program_options::options_description cli_config_options();
+
+    /**
+     * Returns a schema for options dealing with block fact collection.
+     * @return names, values, and descriptions of fact blocking config options
+     */
+    LIBFACTER_EXPORT boost::program_options::options_description fact_config_options();
+
+    /**
+     * Returns a map of resolver names and durations (in milliseconds). The listed resolvers will
+     * have their output cached, then re-resolved no more frequently than the given interval.
+     * @param hocon_config the config object representing the parsed config file
+     * @return a map of resolvers to time-to-live durations (in milliseconds)
+     */
+    LIBFACTER_EXPORT std::unordered_map<std::string, int64_t> load_ttls(hocon::shared_config hocon_config);
+
+    /**
+     * Returns the directory of the fact cache.
+     * @return the absolute path to the fact cache
+     */
+    LIBFACTER_EXPORT std::string fact_cache_location();
+}}}  // namespace facter::util::config

data/ext/facter/facter/lib/inc/facter/util/string.hpp

@@ -0,0 +1,72 @@
+/**
+ * @file
+ * Declares the utility functions for parsing and manipulating strings.
+ */
+#pragma once
+
+#include "../export.h"
+#include <boost/optional.hpp>
+#include <string>
+#include <vector>
+#include <functional>
+#include <initializer_list>
+#include <cctype>
+#include <cstdint>
+
+namespace facter { namespace util {
+
+    /**
+     * Converts the given bytes to a hexadecimal string.
+     * @param bytes The pointer to the bytes to convert.
+     * @param length The number of bytes to convert.
+     * @param uppercase True if the hexadecimal string should be uppercase or false if it should be lowercase.
+     * @return Returns the hexadecimal string.
+     */
+    std::string to_hex(uint8_t const* bytes, size_t length, bool uppercase = false);
+
+    /**
+     * Reads each line from the given string.
+     * @param s The string to read.
+     * @param callback The callback function that is passed each line in the string.
+     */
+    void each_line(std::string const& s, std::function<bool(std::string&)> callback);
+
+   /**
+     * Converts a size, in bytes, to a corresponding string using SI-prefixed units.
+     * @param size The size in bytes.
+     * @return Returns the size in largest SI unit greater than 1 (e.g. 4.05 GiB, 5.20 MiB, etc).
+     */
+    std::string si_string(uint64_t size);
+
+    /**
+     * Converts an amount used to a percentage.
+     * @param used The amount used out of the total.
+     * @param total The total amount.
+     * @return Returns the percentage (e.g. "41.53%"), to two decimal places, as a string.
+     */
+    std::string percentage(uint64_t used, uint64_t total);
+
+    /**
+     * Converts the given frequency, in Hz, to a string.
+     * @param freq The frequency to convert, in Hz.
+     * @return Returns the frequency as a string (e.g. "1.24 GHz").
+     */
+    std::string frequency(int64_t freq);
+
+    /**
+     * Checks to see if the given string definitely needs to be quoted for YAML.
+     * This exists as a workaround to yaml-cpp's poor handling of maintaining numerical string types in the output.
+     * @param str The string to check.
+     * @return Returns true if the string needs to be quoted or false if it may not need to be.
+     */
+    bool needs_quotation(std::string const& str);
+
+    /**
+     * Converts the given string to an integer, if it is a valid integer.
+     * @param str The string to convert.
+     * @return Returns the converted string if the string is a valid integer,
+     * otherwise it returns "nothing"
+     */
+    boost::optional<int> maybe_stoi(std::string const& str);
+
+}}  // namespace facter::util

data/ext/facter/facter/lib/inc/internal/facts/aix/disk_resolver.hpp

@@ -0,0 +1,25 @@
+/**
+ * @file
+ * Declares the AIX disk fact resolver.
+ */
+#pragma once
+
+#include "../resolvers/disk_resolver.hpp"
+
+namespace facter { namespace facts { namespace aix {
+
+    /**
+     * Responsible for resolving disk facts.
+     */
+    struct disk_resolver : resolvers::disk_resolver
+    {
+     protected:
+        /**
+         * Collects the resolver data.
+         * @param facts The fact collection that is resolving facts.
+         * @return Returns the resolver data.
+         */
+        virtual data collect_data(collection& facts) override;
+    };
+
+}}}  // namespace facter::facts::aix

data/ext/facter/facter/lib/inc/internal/facts/aix/filesystem_resolver.hpp

@@ -0,0 +1,41 @@
+/**
+ * @file
+ * Declares the AIX file system fact resolver.
+ */
+#pragma once
+
+#include "../resolvers/filesystem_resolver.hpp"
+#include <map>
+
+namespace facter { namespace facts { namespace aix {
+
+    /**
+     * Responsible for resolving AIX file system facts.
+     */
+    struct filesystem_resolver : resolvers::filesystem_resolver
+    {
+     protected:
+        /**
+         * Collects the DMI data.
+         * @param facts The fact collection that is resolving facts.
+         * @return Returns the DMI data.
+         */
+        virtual data collect_data(collection& facts) override;
+
+     private:
+        void collect_filesystem_data(data& result);
+        void collect_mountpoint_data(data& result);
+        void collect_partition_data(data& result);
+
+    private:
+        // AIX tracks filesystems as numeric IDs. We need to load up
+        // the human-readable names from /etc before we can print them
+        // out nicely.
+        std::map<int, std::string> _filesystems;
+
+        // This stores which partitions are mounted where, so we don't have
+        // to scan the array of mountpoints when populating partitions.
+        std::map<std::string, std::string> _mounts;
+    };
+
+}}}  // namespace facter::facts::aix