bolt 0.0.1 → 0.5.0

data/vendored/puppet/lib/puppet/configurer/downloader.rb

@@ -0,0 +1,67 @@
+require 'puppet/configurer'
+require 'puppet/resource/catalog'
+
+class Puppet::Configurer::Downloader
+  attr_reader :name, :path, :source, :ignore
+
+  # Evaluate our download, returning the list of changed values.
+  def evaluate
+    Puppet.info _("Retrieving %{name}") % { name: name }
+
+    files = []
+    begin
+      catalog.apply do |trans|
+        trans.changed?.each do |resource|
+          yield resource if block_given?
+          files << resource[:path]
+        end
+      end
+    rescue Puppet::Error => detail
+      Puppet.log_exception(detail, _("Could not retrieve %{name}: %{detail}") % { name: name, detail: detail })
+    end
+    files
+  end
+
+  def initialize(name, path, source, ignore = nil, environment = nil, source_permissions = :ignore)
+    @name, @path, @source, @ignore, @environment, @source_permissions = name, path, source, ignore, environment, source_permissions
+  end
+
+  def catalog
+    catalog = Puppet::Resource::Catalog.new("PluginSync", @environment)
+    catalog.host_config = false
+    catalog.add_resource(file)
+    catalog
+  end
+
+  def file
+    args = default_arguments.merge(:path => path, :source => source)
+    args[:ignore] = ignore.split if ignore
+    Puppet::Type.type(:file).new(args)
+  end
+
+  private
+
+  def default_arguments
+    defargs = {
+      :path => path,
+      :recurse => true,
+      :links => :follow,
+      :source => source,
+      :source_permissions => @source_permissions,
+      :tag => name,
+      :purge => true,
+      :force => true,
+      :backup => false,
+      :noop => false
+    }
+    if !Puppet.features.microsoft_windows?
+      defargs.merge!(
+        {
+          :owner => Process.uid,
+          :group => Process.gid
+        }
+      )
+    end
+    return defargs
+  end
+end

data/vendored/puppet/lib/puppet/configurer/downloader_factory.rb

@@ -0,0 +1,34 @@
+require 'puppet/configurer'
+
+# Factory for <tt>Puppet::Configurer::Downloader</tt> objects.
+#
+# Puppet's pluginsync facilities can be used to download modules
+# and external facts, each with a different destination directory
+# and related settings.
+#
+# @api private
+#
+class Puppet::Configurer::DownloaderFactory
+  def create_plugin_downloader(environment)
+    plugin_downloader = Puppet::Configurer::Downloader.new(
+      "plugin",
+      Puppet[:plugindest],
+      Puppet[:pluginsource],
+      Puppet[:pluginsignore],
+      environment
+    )
+  end
+
+  def create_plugin_facts_downloader(environment)
+    source_permissions = Puppet.features.microsoft_windows? ? :ignore : :use
+
+    plugin_fact_downloader = Puppet::Configurer::Downloader.new(
+      "pluginfacts",
+      Puppet[:pluginfactdest],
+      Puppet[:pluginfactsource],
+      Puppet[:pluginsignore],
+      environment,
+      source_permissions
+    )
+  end
+end

data/vendored/puppet/lib/puppet/configurer/fact_handler.rb

@@ -0,0 +1,46 @@
+require 'puppet/indirector/facts/facter'
+
+require 'puppet/configurer'
+require 'puppet/configurer/downloader'
+
+# Break out the code related to facts.  This module is
+# just included into the agent, but having it here makes it
+# easier to test.
+module Puppet::Configurer::FactHandler
+  def find_facts
+    # This works because puppet agent configures Facts to use 'facter' for
+    # finding facts and the 'rest' terminus for caching them.  Thus, we'll
+    # compile them and then "cache" them on the server.
+    begin
+      facts = Puppet::Node::Facts.indirection.find(Puppet[:node_name_value], :environment => Puppet::Node::Environment.remote(@environment))
+      unless Puppet[:node_name_fact].empty?
+        Puppet[:node_name_value] = facts.values[Puppet[:node_name_fact]]
+        facts.name = Puppet[:node_name_value]
+      end
+      facts
+    rescue SystemExit,NoMemoryError
+      raise
+    rescue Exception => detail
+      message = _("Could not retrieve local facts: %{detail}") % { detail: detail }
+      Puppet.log_exception(detail, message)
+      raise Puppet::Error, message, detail.backtrace
+    end
+  end
+
+  def facts_for_uploading
+    facts = find_facts
+
+    # NOTE: :facts specified as parameters are URI encoded here,
+    # then  encoded for a second time depending on their length:
+    #
+    # <= 1024 characters sent via query string of a HTTP GET, additionally query string encoded
+    # > 1024 characters sent in POST data, additionally x-www-form-urlencoded
+    # so it's only important that encoding method here return original values
+    # correctly when CGI.unescape called against it (in compiler code)
+    if Puppet[:preferred_serialization_format] == "pson"
+      {:facts_format => :pson, :facts => Puppet::Util.uri_query_encode(facts.render(:pson)) }
+    else
+      {:facts_format => 'application/json', :facts => Puppet::Util.uri_query_encode(facts.render(:json)) }
+    end
+  end
+end

data/vendored/puppet/lib/puppet/configurer/plugin_handler.rb

@@ -0,0 +1,25 @@
+# Break out the code related to plugins.  This module is
+# just included into the agent, but having it here makes it
+# easier to test.
+require 'puppet/configurer'
+
+class Puppet::Configurer::PluginHandler
+  def initialize(factory)
+    @factory = factory
+  end
+
+  # Retrieve facts from the central server.
+  def download_plugins(environment)
+    plugin_downloader = @factory.create_plugin_downloader(environment)
+
+    result = []
+
+    plugin_fact_downloader = @factory.create_plugin_facts_downloader(environment)
+    result += plugin_fact_downloader.evaluate
+
+    result += plugin_downloader.evaluate
+    Puppet::Util::Autoload.reload_changed
+
+    result
+  end
+end

data/vendored/puppet/lib/puppet/confine.rb

@@ -0,0 +1,80 @@
+# The class that handles testing whether our providers
+# actually work or not.
+require 'puppet/util'
+
+class Puppet::Confine
+  include Puppet::Util
+
+  @tests = {}
+
+  class << self
+    attr_accessor :name
+  end
+
+  def self.inherited(klass)
+    name = klass.to_s.split("::").pop.downcase.to_sym
+    raise "Test #{name} is already defined" if @tests.include?(name)
+
+    klass.name = name
+
+    @tests[name] = klass
+  end
+
+  def self.test(name)
+    unless @tests[name]
+      begin
+        require "puppet/confine/#{name}"
+      rescue LoadError => detail
+        unless detail.to_s =~ /No such file|cannot load such file/i
+          warn "Could not load confine test '#{name}': #{detail}"
+        end
+        # Could not find file
+      end
+    end
+    @tests[name]
+  end
+
+  attr_reader :values
+
+  # Mark that this confine is used for testing binary existence.
+  attr_accessor :for_binary
+  def for_binary?
+    for_binary
+  end
+
+  # Used for logging.
+  attr_accessor :label
+
+  def initialize(values)
+    values = [values] unless values.is_a?(Array)
+    @values = values
+  end
+
+  # Provide a hook for the message when there's a failure.
+  def message(value)
+    ""
+  end
+
+  # Collect the results of all of them.
+  def result
+    values.collect { |value| pass?(value) }
+  end
+
+  # Test whether our confine matches.
+  def valid?
+    values.each do |value|
+      unless pass?(value)
+        Puppet.debug(label + ": " + message(value))
+        return false
+      end
+    end
+
+    return true
+  ensure
+    reset
+  end
+
+  # Provide a hook for subclasses.
+  def reset
+  end
+end

data/vendored/puppet/lib/puppet/confine/any.rb

@@ -0,0 +1,26 @@
+class Puppet::Confine::Any < Puppet::Confine
+  def self.summarize(confines)
+    confines.inject(0) { |count, confine| count + confine.summary }
+  end
+
+  def pass?(value)
+    !! value
+  end
+
+  def message(value)
+    "0 confines (of #{value.length}) were true"
+  end
+
+  def summary
+    result.find_all { |v| v == true }.length
+  end
+
+  def valid?
+    if @values.any? { |value| pass?(value) }
+      true
+    else
+      Puppet.debug("#{label}: #{message(@values)}")
+      false
+    end
+  end
+end

data/vendored/puppet/lib/puppet/confine/exists.rb

@@ -0,0 +1,19 @@
+require 'puppet/confine'
+
+class Puppet::Confine::Exists < Puppet::Confine
+  def self.summarize(confines)
+    confines.inject([]) { |total, confine| total + confine.summary }
+  end
+
+  def pass?(value)
+    value && (for_binary? ? which(value) : Puppet::FileSystem.exist?(value))
+  end
+
+  def message(value)
+    "file #{value} does not exist"
+  end
+
+  def summary
+    result.zip(values).inject([]) { |array, args| val, f = args; array << f unless val; array }
+  end
+end

data/vendored/puppet/lib/puppet/confine/false.rb

@@ -0,0 +1,19 @@
+require 'puppet/confine'
+
+class Puppet::Confine::False < Puppet::Confine
+  def self.summarize(confines)
+    confines.inject(0) { |count, confine| count + confine.summary }
+  end
+
+  def pass?(value)
+    ! value
+  end
+
+  def message(value)
+    "true value when expecting false"
+  end
+
+  def summary
+    result.find_all { |v| v == false }.length
+  end
+end

data/vendored/puppet/lib/puppet/confine/feature.rb

@@ -0,0 +1,17 @@
+require 'puppet/confine'
+
+class Puppet::Confine::Feature < Puppet::Confine
+  def self.summarize(confines)
+    confines.collect { |c| c.values }.flatten.uniq.find_all { |value| ! confines[0].pass?(value) }
+  end
+
+  # Is the named feature available?
+  def pass?(value)
+    Puppet.features.send(value.to_s + "?")
+  end
+
+  def message(value)
+    "feature #{value} is missing"
+  end
+end
+

data/vendored/puppet/lib/puppet/confine/true.rb

@@ -0,0 +1,20 @@
+require 'puppet/confine'
+
+class Puppet::Confine::True < Puppet::Confine
+  def self.summarize(confines)
+    confines.inject(0) { |count, confine| count + confine.summary }
+  end
+
+  def pass?(value)
+    # Double negate, so we only get true or false.
+    ! ! value
+  end
+
+  def message(value)
+    "false value when expecting true"
+  end
+
+  def summary
+    result.find_all { |v| v == true }.length
+  end
+end

data/vendored/puppet/lib/puppet/confine/variable.rb

@@ -0,0 +1,59 @@
+require 'puppet/confine'
+
+# Require a specific value for a variable, either a Puppet setting
+# or a Facter value.  This class is a bit weird because the name
+# is set explicitly by the ConfineCollection class -- from this class,
+# it's not obvious how the name would ever get set.
+class Puppet::Confine::Variable < Puppet::Confine
+  # Provide a hash summary of failing confines -- the key of the hash
+  # is the name of the confine, and the value is the missing yet required values.
+  # Only returns failed values, not all required values.
+  def self.summarize(confines)
+    result = Hash.new { |hash, key| hash[key] = [] }
+    confines.inject(result) { |total, confine| total[confine.name] += confine.values unless confine.valid?; total }
+  end
+
+  # This is set by ConfineCollection.
+  attr_accessor :name
+
+  # Retrieve the value from facter
+  def facter_value
+    @facter_value ||= ::Facter.value(name).to_s.downcase
+  end
+
+  def initialize(values)
+    super
+    @values = @values.collect { |v| v.to_s.downcase }
+  end
+
+  def message(value)
+    "facter value '#{test_value}' for '#{self.name}' not in required list '#{values.join(",")}'"
+  end
+
+  # Compare the passed-in value to the retrieved value.
+  def pass?(value)
+    test_value.downcase.to_s == value.to_s.downcase
+  end
+
+  def reset
+    # Reset the cache.  We want to cache it during a given
+    # run, but not across runs.
+    @facter_value = nil
+  end
+
+  def valid?
+    @values.include?(test_value.to_s.downcase)
+  ensure
+    reset
+  end
+
+  private
+
+  def setting?
+    Puppet.settings.valid?(name)
+  end
+
+  def test_value
+    setting? ? Puppet.settings[name] : facter_value
+  end
+end

data/vendored/puppet/lib/puppet/confine_collection.rb

@@ -0,0 +1,50 @@
+# Manage a collection of confines, returning a boolean or
+# helpful information.
+require 'puppet/confine'
+
+class Puppet::ConfineCollection
+  def confine(hash)
+    if hash.include?(:for_binary)
+      for_binary = true
+      hash.delete(:for_binary)
+    else
+      for_binary = false
+    end
+    hash.each do |test, values|
+      if klass = Puppet::Confine.test(test)
+        @confines << klass.new(values)
+        @confines[-1].for_binary = true if for_binary
+      else
+        confine = Puppet::Confine.test(:variable).new(values)
+        confine.name = test
+        @confines << confine
+      end
+      @confines[-1].label = self.label
+    end
+  end
+
+  attr_reader :label
+  def initialize(label)
+    @label = label
+    @confines = []
+  end
+
+  # Return a hash of the whole confine set, used for the Provider
+  # reference.
+  def summary
+    confines = Hash.new { |hash, key| hash[key] = [] }
+    @confines.each { |confine| confines[confine.class] << confine }
+    result = {}
+    confines.each do |klass, list|
+      value = klass.summarize(list)
+      next if (value.respond_to?(:length) and value.length == 0) or (value == 0)
+      result[klass.name] = value
+
+    end
+    result
+  end
+
+  def valid?
+    ! @confines.detect { |c| ! c.valid? }
+  end
+end