cfacter 3.11.0.rc.20180314

data/ext/facter/facter/lib/inc/internal/facts/windows/identity_resolver.hpp

@@ -0,0 +1,25 @@
+/**
+ * @file
+ * Declares the Windows user and group resolver.
+ */
+#pragma once
+
+#include "../resolvers/identity_resolver.hpp"
+
+namespace facter { namespace facts { namespace windows {
+
+    /**
+     * Responsible for resolving the user and group facts.
+     */
+    struct identity_resolver : resolvers::identity_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::windows

data/ext/facter/facter/lib/inc/internal/facts/windows/kernel_resolver.hpp

@@ -0,0 +1,25 @@
+/**
+ * @file
+ * Declares the Windows kernel fact resolver.
+ */
+#pragma once
+
+#include "../resolvers/kernel_resolver.hpp"
+
+namespace facter { namespace facts { namespace windows {
+
+    /**
+     * Responsible for resolving kernel facts.
+     */
+    struct kernel_resolver : resolvers::kernel_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::windows

data/ext/facter/facter/lib/inc/internal/facts/windows/memory_resolver.hpp

@@ -0,0 +1,25 @@
+/**
+ * @file
+ * Declares the Windows memory fact resolver.
+ */
+#pragma once
+
+#include "../resolvers/memory_resolver.hpp"
+
+namespace facter { namespace facts { namespace windows {
+
+    /**
+     * Responsible for resolving memory facts.
+     */
+    struct memory_resolver : resolvers::memory_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::windows

data/ext/facter/facter/lib/inc/internal/facts/windows/networking_resolver.hpp

@@ -0,0 +1,74 @@
+/**
+ * @file
+ * Declares the Windows networking fact resolver.
+ */
+#pragma once
+
+#include "../resolvers/networking_resolver.hpp"
+#include <vector>
+#include <string>
+#include <functional>
+
+/*
+ * Forward declarations from winsock2.h, ws2tcpip.h, windows.h
+ * To use these APIs, include those headers. The headers are not included here
+ * to avoid polluting the global namespace.
+ */
+struct sockaddr;
+struct sockaddr_in;
+struct sockaddr_in6;
+
+namespace facter { namespace facts { namespace windows {
+
+    /**
+     * Responsible for resolving networking facts.
+     */
+    struct networking_resolver : resolvers::networking_resolver
+    {
+        /**
+         * Constructs a Windows networking resolver.
+         */
+        networking_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;
+
+        /**
+         * Creates an IPv4 sockaddr_in of the mask. If masklen is too large, returns a full mask.
+         * Windows only allows contiguous subnet masks, representing them by their length.
+         * @param masklen Length of the contiguous mask.
+         * @return The sockaddr_in representation of the mask.
+         */
+        sockaddr_in create_ipv4_mask(uint8_t masklen);
+
+        /**
+         * Creates an IPv6 sockaddr_in6 of the mask. If masklen is too large, returns a full mask.
+         * Windows only allows contiguous subnet masks, representing them by their length.
+         * @param masklen Length of the contiguous mask.
+         * @return The sockaddr_in6 representation of the mask.
+         */
+        sockaddr_in6 create_ipv6_mask(uint8_t masklen);
+
+        /**
+         * Applies a mask to an IPv4 address, returning a new sockaddr_in.
+         * @param addr A sockaddr structure defining a valid IPv4 address.
+         * @param mask A sockaddr_in structure defining a valid IPv4 mask.
+         * @return A new sockaddr_in structure representing the masked IPv4 address.
+         */
+        static sockaddr_in mask_ipv4_address(sockaddr const* addr, sockaddr_in const& mask);
+
+        /**
+         * Applies a mask to an IPv6 address, returning a new sockaddr_in6.
+         * @param addr A sockaddr structure defining a valid IPv6 address.
+         * @param mask A sockaddr_in6 structure defining a valid IPv6 mask.
+         * @return A new sockaddr_in6 structure representing the masked IPv6 address.
+         */
+        static sockaddr_in6 mask_ipv6_address(sockaddr const* addr, sockaddr_in6 const& mask);
+    };
+
+}}}  // namespace facter::facts::windows

data/ext/facter/facter/lib/inc/internal/facts/windows/operating_system_resolver.hpp

@@ -0,0 +1,36 @@
+/**
+ * @file
+ * Declares the Windows operating system fact resolver.
+ */
+#pragma once
+
+#include "../resolvers/operating_system_resolver.hpp"
+#include <leatherman/windows/wmi.hpp>
+#include <memory>
+
+namespace facter { namespace facts { namespace windows {
+
+    /**
+     * Responsible for resolving operating system facts.
+     */
+    struct operating_system_resolver : resolvers::operating_system_resolver
+    {
+        /**
+         * Constructs the operating_system_resolver.
+         * @param wmi_conn The WMI connection to use when resolving facts.
+         */
+        operating_system_resolver(std::shared_ptr<leatherman::windows::wmi> wmi_conn = std::make_shared<leatherman::windows::wmi>());
+
+     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;
+
+     private:
+        std::shared_ptr<leatherman::windows::wmi> _wmi;
+    };
+
+}}}  // namespace facter::facts::windows

data/ext/facter/facter/lib/inc/internal/facts/windows/processor_resolver.hpp

@@ -0,0 +1,36 @@
+/**
+ * @file
+ * Declares the Windows processor fact resolver.
+ */
+#pragma once
+
+#include "../resolvers/processor_resolver.hpp"
+#include <leatherman/windows/wmi.hpp>
+#include <memory>
+
+namespace facter { namespace facts { namespace windows {
+
+    /**
+     * Responsible for resolving processor-related facts.
+     */
+    struct processor_resolver : resolvers::processor_resolver
+    {
+        /**
+         * Constructs the processor_resolver.
+         * @param wmi_conn The WMI connection to use when resolving facts.
+         */
+        processor_resolver(std::shared_ptr<leatherman::windows::wmi> wmi_conn = std::make_shared<leatherman::windows::wmi>());
+
+     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;
+
+     private:
+        std::shared_ptr<leatherman::windows::wmi> _wmi;
+    };
+
+}}}  // namespace facter::facts::windows

data/ext/facter/facter/lib/inc/internal/facts/windows/timezone_resolver.hpp

@@ -0,0 +1,24 @@
+/**
+ * @file
+ * Declares the Windows timezone fact resolver.
+ */
+#pragma once
+
+#include "../resolvers/timezone_resolver.hpp"
+
+namespace facter { namespace facts { namespace windows {
+
+    /**
+     * Responsible for resolving time zone facts.
+     */
+    struct timezone_resolver : resolvers::timezone_resolver
+    {
+     protected:
+        /**
+         * Gets the system timezone.
+         * @return Returns the system timezone.
+         */
+        virtual std::string get_timezone() override;
+    };
+
+}}}  // namespace facter::facts::windows

data/ext/facter/facter/lib/inc/internal/facts/windows/uptime_resolver.hpp

@@ -0,0 +1,32 @@
+/**
+ * @file
+ * Declares the Windows uptime fact resolver.
+ */
+#pragma once
+
+#include "../resolvers/uptime_resolver.hpp"
+#include <leatherman/windows/wmi.hpp>
+#include <string>
+#include <memory>
+
+namespace facter { namespace facts { namespace windows {
+
+    /**
+     * Responsible for resolving uptime facts.
+     */
+    struct uptime_resolver : resolvers::uptime_resolver
+    {
+        /**
+         * Constructs the uptime_resolver.
+         */
+        uptime_resolver();
+
+     protected:
+        /**
+         * Gets the system uptime in seconds.
+         * @return Returns the system uptime in seconds.
+         */
+        virtual int64_t get_uptime() override;
+    };
+
+}}}  // namespace facter::facts::windows

data/ext/facter/facter/lib/inc/internal/facts/windows/virtualization_resolver.hpp

@@ -0,0 +1,37 @@
+/**
+ * @file
+ * Declares the Windows virtualization fact resolver.
+ */
+#pragma once
+
+#include "../resolvers/virtualization_resolver.hpp"
+#include <leatherman/windows/wmi.hpp>
+#include <string>
+#include <memory>
+
+namespace facter { namespace facts { namespace windows {
+
+    /**
+     * Responsible for resolving virtualization facts.
+     */
+    struct virtualization_resolver : resolvers::virtualization_resolver
+    {
+        /**
+         * Constructs the virtualization_resolver.
+         * @param wmi_conn The WMI connection to use when resolving facts.
+         */
+        virtualization_resolver(std::shared_ptr<leatherman::windows::wmi> wmi_conn = std::make_shared<leatherman::windows::wmi>());
+
+     protected:
+        /**
+         * Gets the name of the hypervisor.
+         * @param facts The fact collection that is resolving facts.
+         * @return Returns the name of the hypervisor or empty string if no hypervisor.
+         */
+        virtual std::string get_hypervisor(collection& facts) override;
+
+     private:
+        std::shared_ptr<leatherman::windows::wmi> _wmi;
+    };
+
+}}}  // namespace facter::facts::windows

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

@@ -0,0 +1,77 @@
+/**
+ * @file
+ * Declares the Ruby Facter::Core::Aggregate class.
+ */
+#pragma once
+
+#include "resolution.hpp"
+#include "chunk.hpp"
+#include <string>
+#include <map>
+
+namespace facter { namespace ruby {
+
+    /**
+     * Represents the Ruby Facter::Core::Aggregate class.
+     */
+    struct aggregate_resolution : resolution
+    {
+        /**
+         * Defines the Facter::Core::Aggregate class.
+         * @return Returns the Facter::Core::Aggregate class.
+         */
+        static leatherman::ruby::VALUE define();
+
+        /**
+         * Creates an instance of the Facter::Core::Aggregate 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();
+
+        /**
+         * Finds the value of the given chunk.
+         * @param name The name of the chunk to find the value of.
+         * @return Returns the value of the chunk or nil if the chunk is not found.
+         */
+        leatherman::ruby::VALUE find_chunk(leatherman::ruby::VALUE name);
+
+        /**
+         * Defines a chunk.
+         * @param name The name of the chunk.
+         * @param options The options for defining the chunk.
+         */
+        void define_chunk(leatherman::ruby::VALUE name, leatherman::ruby::VALUE options);
+
+     private:
+        // Construction and assignment
+        aggregate_resolution();
+        aggregate_resolution(aggregate_resolution const&) = delete;
+        aggregate_resolution& operator=(aggregate_resolution const&) = delete;
+        aggregate_resolution(aggregate_resolution&& other) = delete;
+        aggregate_resolution& operator=(aggregate_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);
+
+        // Methods called from Ruby
+        static leatherman::ruby::VALUE ruby_chunk(int argc, leatherman::ruby::VALUE* argv, leatherman::ruby::VALUE self);
+        static leatherman::ruby::VALUE ruby_aggregate(leatherman::ruby::VALUE self);
+        static leatherman::ruby::VALUE ruby_merge_hashes(leatherman::ruby::VALUE obj, leatherman::ruby::VALUE context, int argc, leatherman::ruby::VALUE* argv);
+
+        // Helper functions
+        static leatherman::ruby::VALUE deep_merge(leatherman::ruby::api const& ruby, leatherman::ruby::VALUE left, leatherman::ruby::VALUE right);
+
+        leatherman::ruby::VALUE _self;
+        leatherman::ruby::VALUE _block;
+        std::map<leatherman::ruby::VALUE, ruby::chunk> _chunks;
+    };
+
+}}  // namespace facter::ruby

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

@@ -0,0 +1,83 @@
+/**
+ * @file
+ * Declares the class for aggregate resolution chunks.
+ */
+#pragma once
+
+#include <leatherman/ruby/api.hpp>
+
+namespace facter { namespace ruby {
+
+    struct aggregate_resolution;
+
+    /**
+     * Represents a aggregate resolution chunk.
+     */
+    struct chunk
+    {
+        /**
+         * Constructs an aggregate resolution chunk.
+         * @param dependencies The symbol or array of symbols this chunk depends on.
+         * @param block The block to run to resolve the chunk.
+         */
+        chunk(leatherman::ruby::VALUE dependencies, leatherman::ruby::VALUE block);
+
+        /**
+         * Moves the given chunk into this chunk.
+         * @param other The chunk to move into this chunk.
+         */
+        chunk(chunk&& other);
+
+        /**
+         * Moves the given chunk into this chunk.
+         * @param other The chunk to move into this chunk.
+         * @return Returns this chunk.
+         */
+        chunk& operator=(chunk&& other);
+
+        /**
+         * Gets the value of the chunk.
+         * @param resolution The aggregate resolution being resolved.
+         * @return Returns the value of the chunk.
+         */
+        leatherman::ruby::VALUE value(aggregate_resolution& resolution);
+
+        /**
+         * Gets the chunk's dependencies.
+         * @return Returns the chunk's dependencies.
+         */
+        leatherman::ruby::VALUE dependencies() const;
+
+        /**
+         * Sets the chunk's dependencies.
+         * @param dependencies The chunk's dependencies.
+         */
+        void dependencies(leatherman::ruby::VALUE dependencies);
+
+        /**
+         * Gets the chunk's block.
+         * @return Returns the chunk's block.
+         */
+        leatherman::ruby::VALUE block() const;
+
+        /**
+         * Sets the chunk's block.
+         * @param block The chunk's block.
+         */
+        void block(leatherman::ruby::VALUE block);
+
+     private:
+        chunk(chunk const&) = delete;
+        chunk& operator=(chunk const&) = delete;
+        void mark() const;
+
+        friend struct aggregate_resolution;
+
+        leatherman::ruby::VALUE _dependencies;
+        leatherman::ruby::VALUE _block;
+        leatherman::ruby::VALUE _value;
+        bool _resolved;
+        bool _resolving;
+    };
+
+}}  // namespace facter::ruby