facter 2.0.2-x86-mingw32 → 2.1.0-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 64f643985bca64231e41c2bfdc6500bf1cc296cc
-  data.tar.gz: e3aa694f21cb8e42807633b708b59eda05c98575
+  metadata.gz: d58657a0fe9d2a305caacc71f35007a163b8d2a5
+  data.tar.gz: 1ad521ad3d89e27546b1aa78549459a63354258d
 SHA512:
-  metadata.gz: 22151a671acd9b9b10d05ff243950a9a3036a3b2c9d9450a50e2ea11f34db51ef1abe5f5a0dd817399a19f755bf7987c4c3dec001588f517fa4237f09b4a782b
-  data.tar.gz: 8024c25ae4e13449986cf4f15b19a1532b980a0f42a177d406348a8415553a0e9782d6d935bfdfe2ceb3952416897793267832e61c6e741f4d8c0126337cce22
+  metadata.gz: f3224ef984761af60d22aa25a6fb88ba6644b3ebfc3f6e1bd59262f6b3918cf21872ae34b939442571ab51990748125dc9bd3ef0a2a29315f735a384676079a4
+  data.tar.gz: 7352719baf45455d0b26e3d43ea28614213ab77ae8d1a344fc33120b6567eb6eb21d2a62245aa2f886a73503966657180fe48962f24415ec019387ba4c43cf87

data/Gemfile

@@ -20,6 +20,7 @@ require 'yaml'
 data = YAML.load_file(File.join(File.dirname(__FILE__), 'ext', 'project_data.yaml'))
 bundle_platforms = data['bundle_platforms']
 data['gem_platform_dependencies'].each_pair do |gem_platform, info|
+  next if gem_platform =~ /mingw/
   if bundle_deps = info['gem_runtime_dependencies']
     bundle_platform = bundle_platforms[gem_platform] or raise "Missing bundle_platform"
     platform(bundle_platform.intern) do
@@ -30,6 +31,19 @@ data['gem_platform_dependencies'].each_pair do |gem_platform, info|
   end
 end
 
+platform(:mingw_19) do
+  gem 'win32console', '~> 1.3.2', :require => false
+end
+
+mingw = [:mingw]
+mingw << :x64_mingw if Bundler::Dsl::VALID_PLATFORMS.include?(:x64_mingw)
+
+platform(*mingw) do
+  gem 'ffi', '~> 1.9.3', :require => false
+  gem 'win32-dir', '~> 0.4.8', :require => false
+  gem 'win32-security', '~> 0.2.5', :require => false
+end
+
 gem 'facter', ">= 1.0.0", :path => File.expand_path("..", __FILE__)
 
 if File.exists? "#{__FILE__}.local"

data/ext/project_data.yaml

@@ -19,15 +19,18 @@ gem_platform_dependencies:
       CFPropertyList: '~> 2.2.6'
   x86-mingw32:
     gem_runtime_dependencies:
-      ffi: '1.9.0'
-      sys-admin: '1.5.6'
-      win32-api: '1.4.8'
-      win32-dir: '~> 0.4.3'
-      windows-api: '~> 0.4.2'
-      windows-pr: '~> 1.2.2'
+      ffi: '~> 1.9.3'
+      win32-dir: '~> 0.4.8'
+      win32-security: '~> 0.2.5'
       win32console: '~> 1.3.2'
+  x64-mingw32:
+    gem_runtime_dependencies:
+      ffi: '~> 1.9.3'
+      win32-dir: '~> 0.4.8'
+      win32-security: '~> 0.2.5'
 bundle_platforms:
   universal-darwin: ruby
   x86-mingw32: mingw
+  x64-mingw32: x64_mingw
 pre_tasks:
   'package:apple': 'cfpropertylist'

data/lib/facter/core/execution/base.rb

@@ -31,9 +31,9 @@ class Facter::Core::Execution::Base
 
     on_fail = options.fetch(:on_fail, :raise)
 
-    ## Set LANG to force i18n to C for the duration of this exec; this ensures that any code that parses the
-    ## output of the command can expect it to be in a consistent / predictable format / locale
-    with_env "LANG" => "C" do
+    # Set LC_ALL and LANG to force i18n to C for the duration of this exec; this ensures that any code that parses the
+    # output of the command can expect it to be in a consistent / predictable format / locale
+    with_env 'LC_ALL' => 'C', 'LANG' => 'C' do
 
       expanded_command = expand_command(command)
 

data/lib/facter/core/suitable.rb

@@ -108,10 +108,6 @@ module Facter::Core::Suitable
   #
   # @api private
   def suitable?
-    unless defined? @suitable
-      @suitable = ! @confines.detect { |confine| ! confine.true? }
-    end
-
-    return @suitable
+    @confines.all? { |confine| confine.true? }
   end
 end

data/lib/facter/dhcp_servers.rb

@@ -0,0 +1,39 @@
+# Fact: dhcp_servers
+#
+# Purpose:
+#   Return the DHCP server addresses for all interfaces as a hash.
+#   If the interface that is the default gateway is dhcp assigned, there
+#   will also be a 'system' entry in the hash.
+#
+# Resolution:
+#   Parses the output of nmcli to find the DHCP server for the interface if available
+#
+# Caveats:
+#   Requires nmcli to be available and the interface must use network-manager.
+#
+
+require 'facter'
+require 'facter/util/dhcp_servers'
+
+
+Facter.add(:dhcp_servers) do
+  confine :kernel => :linux
+  confine do
+    Facter::Core::Execution.which('nmcli')
+  end
+
+  setcode do
+    gwdev   = Facter::Util::DHCPServers.gateway_device
+    devices = Facter::Util::DHCPServers.devices
+
+    dhcp_servers = {}
+    devices.each do |device|
+      if server = Facter::Util::DHCPServers.device_dhcp_server(device)
+        dhcp_servers['system'] = server if device == gwdev
+        dhcp_servers[device]   = server
+      end
+    end
+
+    dhcp_servers.keys.length > 0 ? dhcp_servers : nil
+  end
+end

data/lib/facter/ec2.rb

@@ -1,37 +1,44 @@
-require 'facter/util/ec2'
-require 'open-uri'
+require 'facter/ec2/rest'
 
-def metadata(id = "")
-  open("http://169.254.169.254/2008-02-01/meta-data/#{id||=''}").read.
-    split("\n").each do |o|
-    key = "#{id}#{o.gsub(/\=.*$/, '/')}"
-    if key[-1..-1] != '/'
-      value = open("http://169.254.169.254/2008-02-01/meta-data/#{key}").read.
-        split("\n")
-      symbol = "ec2_#{key.gsub(/\-|\//, '_')}".to_sym
-      Facter.add(symbol) { setcode { value.join(',') } }
-    else
-      metadata(key)
+Facter.define_fact(:ec2_metadata) do
+  define_resolution(:rest) do
+    confine do
+      Facter.value(:virtual).match /^xen/
+    end
+
+    @querier = Facter::EC2::Metadata.new
+    confine do
+      @querier.reachable?
+    end
+
+    setcode do
+      @querier.fetch
     end
   end
-rescue => details
-  Facter.warn "Could not retrieve ec2 metadata: #{details.message}"
 end
 
-def userdata()
-  Facter.add(:ec2_userdata) do
+Facter.define_fact(:ec2_userdata) do
+  define_resolution(:rest) do
+    confine do
+      Facter.value(:virtual).match /^xen/
+    end
+
+    @querier = Facter::EC2::Userdata.new
+    confine do
+      @querier.reachable?
+    end
+
     setcode do
-      if userdata = Facter::Util::EC2.userdata
-        userdata.split
-      end
+      @querier.fetch
     end
   end
 end
 
-if (Facter::Util::EC2.has_euca_mac? || Facter::Util::EC2.has_openstack_mac? ||
-    Facter::Util::EC2.has_ec2_arp?) && Facter::Util::EC2.can_connect?
-  metadata
-  userdata
-else
-  Facter.debug "Not an EC2 host"
+# The flattened version of the EC2 facts are deprecated and will be removed in
+# a future release of Facter.
+if (ec2_metadata = Facter.value(:ec2_metadata))
+  ec2_facts = Facter::Util::Values.flatten_structure("ec2", ec2_metadata)
+  ec2_facts.each_pair do |factname, factvalue|
+    Facter.add(factname, :value => factvalue)
+  end
 end

data/lib/facter/ec2/rest.rb

@@ -0,0 +1,130 @@
+require 'timeout'
+require 'open-uri'
+
+module Facter
+  module EC2
+    CONNECTION_ERRORS = [
+      Errno::EHOSTDOWN,
+      Errno::EHOSTUNREACH,
+      Errno::ENETUNREACH,
+      Errno::ECONNABORTED,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::ETIMEDOUT,
+    ]
+
+    class Base
+      def reachable?(retry_limit = 3)
+        timeout = 0.2
+        able_to_connect = false
+        attempts = 0
+
+        begin
+          Timeout.timeout(timeout) do
+            open(@baseurl).read
+          end
+          able_to_connect = true
+        rescue OpenURI::HTTPError => e
+          if e.message.match /404 Not Found/i
+            able_to_connect = false
+          else
+            attempts = attempts + 1
+            retry if attempts < retry_limit
+          end
+        rescue Timeout::Error
+          attempts = attempts + 1
+          retry if attempts < retry_limit
+        rescue *CONNECTION_ERRORS
+          attempts = attempts + 1
+          retry if attempts < retry_limit
+        end
+
+        able_to_connect
+      end
+    end
+
+    class Metadata < Base
+
+      DEFAULT_URI = "http://169.254.169.254/latest/meta-data/"
+
+      def initialize(uri = DEFAULT_URI)
+        @baseurl = uri
+      end
+
+      def fetch(path = '')
+        results = {}
+
+        keys = fetch_endpoint(path)
+        keys.each do |key|
+          if key.match(%r[/$])
+            # If a metadata key is suffixed with '/' then it's a general metadata
+            # resource, so we have to recursively look up all the keys in the given
+            # collection.
+            name = key[0..-2]
+            results[name] = fetch("#{path}#{key}")
+          else
+            # This is a simple key/value pair, we can just query the given endpoint
+            # and store the results.
+            ret = fetch_endpoint("#{path}#{key}")
+            results[key] = ret.size > 1 ? ret : ret.first
+          end
+        end
+
+        results
+      end
+
+      # @param path [String] The path relative to the object base url
+      #
+      # @return [Array, NilClass]
+      def fetch_endpoint(path)
+        uri = @baseurl + path
+        body = open(uri).read
+        parse_results(body)
+      rescue OpenURI::HTTPError => e
+        if e.message.match /404 Not Found/i
+          return nil
+        else
+          Facter.log_exception(e, "Failed to fetch ec2 uri #{uri}: #{e.message}")
+          return nil
+        end
+      rescue *CONNECTION_ERRORS => e
+        Facter.log_exception(e, "Failed to fetch ec2 uri #{uri}: #{e.message}")
+        return nil
+      end
+
+      private
+
+      def parse_results(body)
+        lines = body.split("\n")
+        lines.map do |line|
+          if (match = line.match(/^(\d+)=.*$/))
+            # Metadata arrays are formatted like '<index>=<associated key>/', so
+            # we need to extract the index from that output.
+            "#{match[1]}/"
+          else
+            line
+          end
+        end
+      end
+    end
+
+    class Userdata < Base
+      DEFAULT_URI = "http://169.254.169.254/latest/user-data/"
+
+      def initialize(uri = DEFAULT_URI)
+        @baseurl = uri
+      end
+
+      def fetch
+        open(@baseurl).read
+      rescue OpenURI::HTTPError => e
+        if e.message.match /404 Not Found/i
+          return nil
+        else
+          Facter.log_exception(e, "Failed to fetch ec2 uri #{uri}: #{e.message}")
+          return nil
+        end
+      end
+    end
+  end
+end

data/lib/facter/fqdn.rb

@@ -15,6 +15,8 @@ Facter.add(:fqdn) do
     domain = Facter.value(:domain)
     if host and domain
       [host, domain].join(".")
+    elsif host
+      host
     else
       nil
     end

data/lib/facter/gce.rb

@@ -0,0 +1,16 @@
+require 'facter/gce/metadata'
+
+Facter.define_fact(:gce) do
+  define_resolution(:rest) do
+    confine :virtual => 'gce'
+
+    confine do
+      Facter.json?
+    end
+
+    setcode do
+      querier = Facter::GCE::Metadata.new
+      querier.fetch
+    end
+  end
+end

data/lib/facter/gce/metadata.rb

@@ -0,0 +1,87 @@
+require 'open-uri'
+
+module Facter
+  module GCE
+
+    # @api private
+    class Metadata
+      CONNECTION_ERRORS = [
+        OpenURI::HTTPError,
+        Errno::EHOSTDOWN,
+        Errno::EHOSTUNREACH,
+        Errno::ENETUNREACH,
+        Errno::ECONNABORTED,
+        Errno::ECONNREFUSED,
+        Errno::ECONNRESET,
+        Errno::ETIMEDOUT,
+        Timeout::Error,
+      ]
+
+      METADATA_URL = "http://metadata/computeMetadata/v1beta1/?recursive=true&alt=json"
+
+      def initialize(url = METADATA_URL)
+        @url = url
+      end
+
+      def fetch
+        with_metadata_server do |body|
+          # This will only be reached if the confine associated with this class
+          # was true which means that JSON was required, but it's a bit
+          # questionable that we're relying on JSON being loaded as a side
+          # effect of that.
+          hash = ::JSON.parse(body)
+          transform_metadata!(hash)
+          hash
+        end
+      end
+
+      private
+
+      def with_metadata_server
+        retry_limit = 3
+        timeout = 0.05
+        body = nil
+        attempts = 0
+
+        begin
+          Timeout.timeout(timeout) do
+            body = open(@url).read
+          end
+        rescue *CONNECTION_ERRORS => e
+          attempts = attempts + 1
+          if attempts < retry_limit
+            retry
+          else
+            Facter.log_exception(e, "Unable to fetch metadata from #{@url}: #{e.message}")
+            return nil
+          end
+        end
+
+        if body
+          yield body
+        end
+      end
+
+      # @return [void]
+      def transform_metadata!(data)
+        case data
+        when Hash
+          data.keys.each do |key|
+            value = data[key]
+            if ["image", "machineType", "zone", "network"].include? key
+              data[key] = value.split('/').last
+            elsif key == "sshKeys"
+              data['sshKeys'] = value.split("\n")
+            end
+            transform_metadata!(value)
+          end
+        when Array
+          data.each do |value|
+            transform_metadata!(value)
+          end
+        end
+        nil
+      end
+    end
+  end
+end