cfacter 3.11.0.rc.20180314

data/ext/facter/facter/lib/Facter.java.in

@@ -0,0 +1,110 @@
+package com.puppetlabs;
+
+import java.util.HashMap;
+import java.util.TreeSet;
+
+/**
+ * The Java shim for libfacter.
+ */
+public class Facter {
+    static {
+        // Look for libfacter in the same place as facter.rb does
+        String facterDir = System.getenv("FACTERDIR");
+        if (facterDir == null) {
+            facterDir = "${CMAKE_INSTALL_PREFIX}/${LIBFACTER_INSTALL_DESTINATION}";
+        }
+
+        // Load the library
+        System.load(facterDir.replaceAll("/$", "") + "/libfacter.so");
+    }
+
+    /**
+     * Lookup a fact value by name.
+     * @param name The fact name.
+     * @return Returns the fact's value or null if not found.
+     */
+    public static native Object lookup(String name);
+
+    /**
+     * Entry point for testing.
+     * Expects one argument which is the fact to lookup.
+     * @param args The program arguments.
+     */
+    public static void main(String[] args) {
+        if (args.length != 1) {
+            System.out.println("usage: Facter <fact>");
+            return;
+        }
+        print(lookup(args[0]), 1);
+        System.out.println();
+    }
+
+    private static void indent(int level) {
+        if (level < 1) {
+            return;
+        }
+        for (int i = 0; i < (level * 2); ++i) {
+            System.out.print(" ");
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static void print(Object value, int level) {
+        if (value == null) {
+            return;
+        }
+
+        // Check for arrays
+        if (value instanceof Object[]) {
+            Object[] array = (Object[])value;
+            System.out.print("[\n");
+            boolean first = true;
+            for (Object element : array) {
+                if (first) {
+                    first = false;
+                } else {
+                    System.out.print(",\n");
+                }
+                indent(level);
+                print(element, 0);
+            }
+            System.out.print("\n");
+            indent(level - 1);
+            System.out.print("]");
+            return;
+        }
+
+        // Check for maps
+        if (value instanceof HashMap) {
+            HashMap map = (HashMap)value;
+            System.out.print("{\n");
+
+            // Print out the keys in lexicographical order (like a std::map)
+            TreeSet<String> keys = new TreeSet<String>(map.keySet());
+            boolean first = true;
+            for (String key : keys) {
+                if (first) {
+                    first = false;
+                } else {
+                    System.out.print(",\n");
+                }
+                indent(level);
+                System.out.format("%s => ", key);
+                print(map.get(key), level + 1);
+            }
+            System.out.print("\n");
+            indent(level - 1);
+            System.out.print("}");
+            return;
+        }
+
+        // Check for strings (print with quotes)
+        if (value instanceof String) {
+            System.out.format("\"%s\"", value);
+            return;
+        }
+
+        // Output the value
+        System.out.print(value);
+    }
+}

data/ext/facter/facter/lib/Gemfile

@@ -0,0 +1,11 @@
+source ENV['GEM_SOURCE'] || "https://rubygems.org"
+
+group :development, :test do
+    gem 'rake', "~> 10.1.0"
+    gem 'rspec', "~> 2.11.0"
+    gem 'mocha', "~> 0.10.5"
+end
+
+if File.exists? "#{__FILE__}.local"
+  eval(File.read("#{__FILE__}.local"), binding)
+end

data/ext/facter/facter/lib/Rakefile

@@ -0,0 +1,8 @@
+# Rakefile for facter
+
+require 'rake'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+task :default do
+  exec 'rake -T'
+end

data/ext/facter/facter/lib/docs/generate.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# Generates a markdown file containing fact documentation.
+# usage: ruby generate.rb > facts.md
+
+require 'yaml'
+require 'erb'
+require 'ostruct'
+
+PATH_TO_SCHEMA = File.join(File.dirname(__FILE__), '../schema/facter.yaml')
+PATH_TO_TEMPLATE = File.join(File.dirname(__FILE__), 'template.erb')
+
+schema = YAML.load_file(PATH_TO_SCHEMA)
+
+def format_facts(fact_hash)
+  scope = OpenStruct.new({
+    :facts => fact_hash
+  })
+
+  ERB.new(File.read(PATH_TO_TEMPLATE), nil, '-').result(scope.instance_eval {binding})
+end
+
+print "## Modern Facts\n\n"
+print format_facts(schema.reject {|name, info| info['hidden'] == true})
+print "## Legacy Facts\n\n"
+print format_facts(schema.reject {|name, info| info['hidden'].nil? || info['hidden'] == false})

data/ext/facter/facter/lib/docs/namespaces.dox

@@ -0,0 +1,129 @@
+/**
+ * The root namespace for facter.
+ */
+namespace facter {
+
+    /**
+     * The namespace for executing commands.
+     */
+    namespace execution {
+
+    }
+
+    /**
+     * The namespace for fact-related types.
+     */
+    namespace facts {
+
+        /**
+         * The namespace for BSD-related types and fact resolvers.
+         */
+        namespace bsd {
+
+        }
+
+        /**
+         * The namespace for external types and fact resolvers.
+         */
+        namespace external {
+
+        }
+
+        /**
+         * The namespace for Linux-related types and fact resolvers.
+         */
+        namespace linux {
+
+        }
+
+        /**
+         * The namespace for OSX-related types and fact resolvers.
+         */
+        namespace osx {
+
+        }
+
+        /**
+         * The namespace for POSIX-related types and fact resolvers.
+         */
+        namespace posix {
+
+        }
+
+        /**
+         * The namespace for base resolvers.
+         */
+        namespace resolvers {
+
+        }
+
+        /**
+         * The namespace for Solaris-related types and fact resolvers.
+         */
+        namespace solaris {
+
+        }
+
+        /**
+         * The namespace for Windows-related types and fact resolvers.
+         */
+        namespace windows {
+
+        }
+
+        /**
+         * The namespace for ZFS fact resolvers.
+         */
+        namespace zfs {
+
+        }
+    }
+
+    /**
+     * The namespace for logging functions and macros.
+     */
+    namespace logging {
+
+    }
+
+    /**
+     * The namespace for the Ruby compatibility layer.
+     */
+    namespace ruby {
+
+    }
+
+    /**
+     * The namespace for utilty functions and types.
+     */
+    namespace util {
+
+        /**
+         * The namespace for utility types that are BSD-specific.
+         */
+        namespace bsd {
+
+        }
+
+        /**
+         * The namespace for utility types that are POSIX-specific.
+         */
+        namespace posix {
+
+        }
+
+        /**
+         * The namespace for utility types that are Solaris-specific.
+         */
+        namespace solaris {
+
+        }
+
+        /**
+         * The namespace for utility types that are Windows-specific.
+         */
+        namespace windows {
+
+        }
+    }
+}

data/ext/facter/facter/lib/docs/template.erb

@@ -0,0 +1,43 @@
+<%# This template is used to generate a markdown file documenting facts. -%>
+<%# Run 'ruby generate.rb > facts.md' to generate the markdown file. -%>
+<%
+  def format_fact_element(name, info, indent = '')
+    subelements = (info['elements'] || {}).map{|n, i| format_fact_element(n, i, "#{indent}    ")}.join('')
+
+    "#{indent}* `#{name}` (#{info['type']}) --- #{info['description']}\n#{subelements}"
+  end
+-%>
+<% facts.each do |name, schema| -%>
+### `<%= name %>`
+
+<% if schema['hidden'] -%>
+This legacy fact is hidden by default in Facter's command-line output.
+
+<% end -%>
+**Type:** <%= schema['type'] %>
+
+**Purpose:**
+
+<%= schema['description'] %>
+
+<% if schema['elements'] -%>
+**Elements:**
+
+<%= schema['elements'].map{|name, info| format_fact_element(name, info)}.join('') %>
+<% end -%>
+
+<% if schema['resolution'] -%>
+**Resolution:**
+
+<%= schema['resolution'].split("\n").map { |line| "* " + line }.join("\n") %>
+<% end -%>
+
+<% if schema['caveats'] -%>
+**Caveats:**
+
+<%= schema['caveats'].split("\n").map { |line| "* " + line }.join("\n") %>
+<% end -%>
+
+([↑ Back to top](#page-nav))
+
+<% end -%>

data/ext/facter/facter/lib/facter.rb.in

@@ -0,0 +1,45 @@
+module Facter
+  if RUBY_PLATFORM == "java"
+    # For JRuby, require 'facter.jar'
+    begin
+      require 'facter.jar'
+    rescue LoadError
+      raise LoadError.new('libfacter was not built with JRuby support.')
+    end
+
+    # Pass value call through to JNI interface
+    def self.value(name)
+      Java::ComPuppetlabs::Facter.lookup(name)
+    end
+
+    def self.search(*paths)
+      # No-op; we don't support custom facts under JRuby
+    end
+
+    def self.version
+      Java::ComPuppetlabs::Facter.lookup("facterversion")
+    end
+
+    def self.add(*params)
+      raise 'adding facts under JRuby is not implemented.'
+    end
+
+  else
+    # Simply require libfacter.so; this will define all of the Facter API
+    begin
+      facter_dir = ENV['FACTERDIR'] || File.join(File.expand_path("#{File.dirname(__FILE__)}"), '${LIBFACTER_INSTALL_RELATIVE}')
+      #
+      # This is a cmake pre-processor check. On *nix it will end up '' == '1'
+      # On windows, where we want the changes it will be '1' == '1'
+      #
+      # Facter requires the extra inclusion of puppet/bin as the libfacter.so
+      # lib requires libraries and executables from that directory
+      if '${WIN32}' == '1'
+        ENV['PATH'] = "#{File.join(facter_dir, 'bin')}#{File::PATH_SEPARATOR}#{File.join(facter_dir, '../puppet/bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
+      end
+      require "#{facter_dir}/${LIBFACTER_INSTALL_DESTINATION}/libfacter.so"
+    rescue LoadError
+      raise LoadError, "libfacter was not found. Please make sure it was installed to the expected location.\n" + ($!.message || ''), $!.backtrace
+    end
+  end
+end

data/ext/facter/facter/lib/gemspec.in

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "facter"
+  version = "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@"
+  mdata = version.match(/(\d+\.\d+\.\d+)/)
+  s.version = mdata ? mdata[1] : version
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0")
+  s.authors = ["Puppet Labs"]
+  s.date = "2015-10-22"
+  s.description = "You can prove anything with facts!"
+  s.email = "info@puppetlabs.com"
+  s.files = ["bin/facter"]
+  s.homepage = "https://puppetlabs.com"
+  s.require_paths = ["lib"]
+  s.summary = "Facter, a system inventory tool"
+  s.specification_version = 3
+  s.required_ruby_version = '~> 2.1.7'
+
+end

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

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "stdint.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Collects all default facts and store them as a C-string in JSON format. 
+ * @param result a pointer to the C-string pointer to the collected facts.
+ * @return Returns EXIT_FAILURE if it fails to retrieve or copy facts; EXIT_SUCCESS otherwise.
+ */
+uint8_t get_default_facts(char **result);
+
+#ifdef __cplusplus
+}
+#endif

data/ext/facter/facter/lib/inc/facter/facts/array_value.hpp

@@ -0,0 +1,125 @@
+/**
+ * @file
+ * Declares the fact value for arrays.
+ */
+#pragma once
+
+#include "value.hpp"
+#include "../export.h"
+#include <vector>
+#include <memory>
+#include <functional>
+
+namespace facter { namespace facts {
+
+    /**
+     * Represents an array of values.
+     * This type can be moved but cannot be copied.
+     */
+    struct LIBFACTER_EXPORT array_value : value
+    {
+        /**
+         * Constructs an array_value.
+         * @param hidden True if the fact is hidden from output by default or false if not.
+         */
+        array_value(bool hidden = false) :
+            value(hidden)
+        {
+        }
+
+        /**
+         * Prevents the array_value from being copied.
+         */
+        array_value(array_value const&) = delete;
+
+        /**
+         * Prevents the array_value from being copied.
+         * @returns Returns this array_value.
+         */
+        array_value& operator=(array_value const&) = delete;
+
+        /**
+         * Moves the given array_value into this array_value.
+         * @param other The array_value to move into this array_value.
+         */
+        // Visual Studio 12 still doesn't allow default for move constructor.
+        array_value(array_value&& other);
+
+        /**
+         * Moves the given array_value into this array_value.
+         * @param other The array_value to move into this array_value.
+         * @return Returns this array_value.
+         */
+        // Visual Studio 12 still doesn't allow default for move assignment.
+        array_value& operator=(array_value&& other);
+
+        /**
+         * Adds a value to the array.
+         * @param value The value to add to the array.
+         */
+        void add(std::unique_ptr<value> value);
+
+        /**
+         * Checks to see if the array is empty.
+         * @return Returns true if the array is empty or false if it is not.
+         */
+        bool empty() const;
+
+        /**
+         * Gets the size of the array.
+         * @return Returns the number of values in the array.
+         */
+        size_t size() const;
+
+        /**
+         * Enumerates all facts in the array.
+         * @param func The callback function called for each value in the array.
+         */
+        void each(std::function<bool(value const*)> func) const;
+
+        /**
+         * 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(json_allocator& allocator, json_value& value) const override;
+
+        /**
+         * Gets the element at the given index.
+         * @tparam T The expected type of the value.
+         * @param i The index in the array to get the element at.
+         * @return Returns the value at the given index or nullptr if the value is not of the expected type.
+         */
+        template <typename T = value> T const* get(size_t i) const
+        {
+            return dynamic_cast<T const*>(_elements.at(i).get());
+        }
+
+        /**
+         * Gets the value at the given index.
+         * @param i The index in the array to get the element at.
+         * @return Returns the value at the given index.
+         */
+        value const* operator[](size_t i) const;
+
+        /**
+          * 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;
+
+     private:
+        std::vector<std::unique_ptr<value>> _elements;
+    };
+
+}}  // namespace facter::facts