bolt 0.8.0 → 0.9.0

data/lib/bolt/version.rb

@@ -1,3 +1,3 @@
 module Bolt
-  VERSION = '0.8.0'.freeze
+  VERSION = '0.9.0'.freeze
 end

data/{vendored/puppet → modules/boltlib}/lib/puppet/functions/file_upload.rb

@@ -5,8 +5,6 @@
 # * A target is a String with a targets's hostname or a Target.
 # * The returned value contains information about the result per target.
 #
-# Since > 5.4.0 TODO: Update when version is known
-#
 Puppet::Functions.create_function(:file_upload, Puppet::Functions::InternalFunction) do
   local_types do
     type 'TargetOrTargets = Variant[String[1], Target, Array[TargetOrTargets]]'
@@ -22,18 +20,22 @@ Puppet::Functions.create_function(:file_upload, Puppet::Functions::InternalFunct
   def file_upload(scope, source, destination, *targets)
     unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING,
-        {:operation => 'file_upload'})
+        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'file_upload'
+      )
     end
 
     executor = Puppet.lookup(:bolt_executor) { nil }
     unless executor && Puppet.features.bolt?
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::TASK_MISSING_BOLT, :action => _('do file uploads'))
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('do file uploads')
+      )
     end
 
     found = Puppet::Parser::Files.find_file(source, scope.compiler.environment)
     unless found && Puppet::FileSystem.exist?(found)
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::NO_SUCH_FILE_OR_DIRECTORY, {:file => source})
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::NO_SUCH_FILE_OR_DIRECTORY, file: source
+      )
     end
 
     # Ensure that that given targets are all Target instances
@@ -43,7 +45,7 @@ Puppet::Functions.create_function(:file_upload, Puppet::Functions::InternalFunct
       Puppet::Pops::Types::ExecutionResult::EMPTY_RESULT
     else
       # Awaits change in the executor, enabling it receive Target instances
-      hosts = targets.map { |h| h.host }
+      hosts = targets.map(&:host)
 
       Puppet::Pops::Types::ExecutionResult.from_bolt(
         executor.file_upload(executor.from_uris(hosts), found, destination)

data/{vendored/puppet → modules/boltlib}/lib/puppet/functions/run_command.rb

@@ -5,8 +5,6 @@
 # * A target is a String with a targets's hostname or a Target.
 # * The returned value contains information about the result per target.
 #
-# Since > 5.4.0 TODO: Update when version is known
-#
 Puppet::Functions.create_function(:run_command) do
   local_types do
     type 'TargetOrTargets = Variant[String[1], Target, Array[TargetOrTargets]]'
@@ -20,27 +18,28 @@ Puppet::Functions.create_function(:run_command) do
   def run_command(command, *targets)
     unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING,
-        {:operation => 'run_command'})
+        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'run_command'
+      )
     end
 
     executor = Puppet.lookup(:bolt_executor) { nil }
     unless executor && Puppet.features.bolt?
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::TASK_MISSING_BOLT, :action => _('run a command'))
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('run a command')
+      )
     end
 
     # Ensure that that given targets are all Target instances
     targets = targets.flatten.map { |t| t.is_a?(String) ? Puppet::Pops::Types::TypeFactory.target.create(t) : t }
+
     if targets.empty?
       call_function('debug', "Simulating run_command('#{command}') - no targets given - no action taken")
       Puppet::Pops::Types::ExecutionResult::EMPTY_RESULT
     else
       # Awaits change in the executor, enabling it receive Target instances
-      hosts = targets.map { |h| h.host }
+      hosts = targets.map(&:host)
 
-      Puppet::Pops::Types::ExecutionResult.from_bolt(
-        executor.run_command(executor.from_uris(hosts), command)
-      )
+      Puppet::Pops::Types::ExecutionResult.from_bolt(executor.run_command(executor.from_uris(hosts), command))
     end
   end
 end

data/{vendored/puppet → modules/boltlib}/lib/puppet/functions/run_plan.rb

@@ -1,15 +1,13 @@
-# Runs the `plan` referenced by its name passing giving arguments to it given as a hash of name to value mappings
+# Runs the `plan` referenced by its name passing giving arguments to it given as a hash of name to value mappings.
 # A plan is autoloaded from under <root>/plans if not already defined.
 #
 # @example defining and running a plan
-#   plan myplan($x) { 
+#   plan myplan($x) {
 #     # do things with tasks
 #     notice "plan done with param x = ${x}"
 #   }
 #   run_plan('myplan', {x => 'testing' }
 #
-# @since > 5.2 TODO: change this when known
-#
 Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction) do
   dispatch :run_plan do
     scope_param
@@ -20,21 +18,19 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
   def run_plan(scope, plan_name, named_args = {})
     unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING,
-        {:operation => 'run_plan'})
+        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'run_plan'
+      )
     end
 
     loaders = closure_scope.compiler.loaders
-    # The perspective of the environment is wanted here (for now) to not have to require modules
-    # to have dependencies defined in meta data.
+    # The perspective of the environment is wanted here (for now) to not have to
+    # require modules to have dependencies defined in meta data.
     loader = loaders.private_environment_loader
-    if loader && func = loader.load(:plan, plan_name)
+    if loader && (func = loader.load(:plan, plan_name))
       # TODO: Add profiling around this
-        return func.class.dispatcher.dispatchers[0].call_by_name_with_scope(scope, named_args, true)
+      return func.class.dispatcher.dispatchers[0].call_by_name_with_scope(scope, named_args, true)
     end
     # Could not find plan
     raise ArgumentError, "Function #{self.class.name}(): Unknown plan: '#{plan_name}'"
   end
-
 end
-

data/{vendored/puppet → modules/boltlib}/lib/puppet/functions/run_script.rb

@@ -5,8 +5,6 @@
 # * A target is a String with a targets's hostname or a Target.
 # * The returned value contains information about the result per target.
 #
-# Since > 5.4.0 TODO: Update when version is known
-#
 Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFunction) do
   local_types do
     type 'TargetOrTargets = Variant[String[1], Target, Array[TargetOrTargets]]'
@@ -32,21 +30,27 @@ Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFuncti
   def run_script_with_args(scope, script, targets, args_hash)
     unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING,
-        {:operation => 'run_script'})
+        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'run_script'
+      )
     end
 
     executor = Puppet.lookup(:bolt_executor) { nil }
     unless executor && Puppet.features.bolt?
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::TASK_MISSING_BOLT, :action => _('run a script'))
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('run a script')
+      )
     end
 
     found = Puppet::Parser::Files.find_file(script, scope.compiler.environment)
     unless found && Puppet::FileSystem.exist?(found)
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::NO_SUCH_FILE_OR_DIRECTORY, {:file => script})
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::NO_SUCH_FILE_OR_DIRECTORY, file: script
+      )
     end
     unless Puppet::FileSystem.file?(found)
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::NOT_A_FILE, {:file => script})
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::NOT_A_FILE, file: script
+      )
     end
 
     # Ensure that that given targets are all Target instances)
@@ -56,7 +60,7 @@ Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFuncti
       Puppet::Pops::Types::ExecutionResult::EMPTY_RESULT
     else
       # Awaits change in the executor, enabling it receive Target instances
-      hosts = targets.map { |h| h.host }
+      hosts = targets.map(&:host)
 
       Puppet::Pops::Types::ExecutionResult.from_bolt(
         executor.run_script(executor.from_uris(hosts), found, args_hash['arguments'])

data/{vendored/puppet → modules/boltlib}/lib/puppet/functions/run_task.rb

@@ -5,8 +5,6 @@
 # * A target is a String with a targets's hostname or a Target.
 # * The returned value contains information about the result per target.
 #
-# Since > 5.4.0 TODO: Update when version is known
-#
 Puppet::Functions.create_function(:run_task) do
   local_types do
     type 'TargetOrTargets = Variant[String[1], Target, Array[TargetOrTargets]]'
@@ -38,7 +36,9 @@ Puppet::Functions.create_function(:run_task) do
   def run_named_task(task_name, targets, task_args = nil)
     task_type = Puppet.lookup(:loaders).private_environment_loader.load(:type, task_name)
     if task_type.nil?
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::UNKNOWN_TASK, :type_name => task_name)
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::UNKNOWN_TASK, type_name: task_name
+      )
     end
     use_args = task_args.nil? ? {} : task_args
     task_instance = call_function('new', task_type, use_args)
@@ -48,13 +48,15 @@ Puppet::Functions.create_function(:run_task) do
   def run_task_instance(task, *targets)
     unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING,
-        {:operation => 'run_task'})
+        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'run_task'
+      )
     end
 
     executor = Puppet.lookup(:bolt_executor) { nil }
     unless executor && Puppet.features.bolt?
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::TASK_MISSING_BOLT, :action => _('run a task'))
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('run a task')
+      )
     end
 
     # Ensure that that given targets are all Target instances
@@ -64,16 +66,14 @@ Puppet::Functions.create_function(:run_task) do
       Puppet::Pops::Types::ExecutionResult::EMPTY_RESULT
     else
       # Awaits change in the executor, enabling it receive Target instances
-      hosts = targets.map { |h| h.host }
+      hosts = targets.map(&:host)
 
       # TODO: separate handling of default since it's platform specific
       input_method = task._pcore_type['input_method'].value
 
       arguments = task.task_args
       Puppet::Pops::Types::ExecutionResult.from_bolt(
-        executor.run_task(
-          executor.from_uris(hosts), task.executable_path, input_method, arguments
-        )
+        executor.run_task(executor.from_uris(hosts), task.executable_path, input_method, arguments)
       )
     end
   end

data/vendored/puppet/lib/puppet/agent.rb

@@ -122,7 +122,7 @@ class Puppet::Agent
   # to it during the yield.
   def with_client(transaction_uuid, job_id = nil)
     begin
-      @client = client_class.new(Puppet::Configurer::DownloaderFactory.new, transaction_uuid, job_id)
+      @client = client_class.new(transaction_uuid, job_id)
     rescue StandardError => detail
       Puppet.log_exception(detail, _("Could not create instance of %{client_class}: %{detail}") % { client_class: client_class, detail: detail })
       return

data/vendored/puppet/lib/puppet/application/lookup.rb

@@ -340,7 +340,6 @@ Copyright (c) 2015 Puppet Inc., LLC Licensed under the Apache 2.0 License
     fact_file = options[:fact_file]
 
     if fact_file
-      original_facts = node.parameters
       if fact_file.end_with?("json")
         given_facts = JSON.parse(Puppet::FileSystem.read(fact_file, :encoding => 'utf-8'))
       else
@@ -350,8 +349,7 @@ Copyright (c) 2015 Puppet Inc., LLC Licensed under the Apache 2.0 License
       unless given_facts.instance_of?(Hash)
         raise _("Incorrect formatted data in %{fact_file} given via the --facts flag") % { fact_file: fact_file }
       end
-
-      node.parameters = original_facts.merge(given_facts)
+      node.add_extra_facts(given_facts)
     end
 
     Puppet[:code] = 'undef' unless options[:compile]

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

@@ -8,7 +8,6 @@ require 'securerandom'
 class Puppet::Configurer
   require 'puppet/configurer/fact_handler'
   require 'puppet/configurer/plugin_handler'
-  require 'puppet/configurer/downloader_factory'
 
   include Puppet::Configurer::FactHandler
 
@@ -56,7 +55,7 @@ class Puppet::Configurer
     end
   end
 
-  def initialize(factory = Puppet::Configurer::DownloaderFactory.new, transaction_uuid = nil, job_id = nil)
+  def initialize(transaction_uuid = nil, job_id = nil)
     @running = false
     @splayed = false
     @cached_catalog_status = 'not_used'
@@ -65,7 +64,7 @@ class Puppet::Configurer
     @job_id = job_id
     @static_catalog = true
     @checksum_type = Puppet[:supported_checksum_types]
-    @handler = Puppet::Configurer::PluginHandler.new(factory)
+    @handler = Puppet::Configurer::PluginHandler.new()
   end
 
   # Get the remote catalog, yo.  Returns nil if no catalog can be found.

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

@@ -4,15 +4,33 @@
 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)
-    plugin_fact_downloader = @factory.create_plugin_facts_downloader(environment)
-    locales_downloader = @factory.create_locales_downloader(environment)
+    source_permissions = Puppet.features.microsoft_windows? ? :ignore : :use
+
+    plugin_downloader = Puppet::Configurer::Downloader.new(
+      "plugin",
+      Puppet[:plugindest],
+      Puppet[:pluginsource],
+      Puppet[:pluginsignore],
+      environment
+    )
+    plugin_fact_downloader = Puppet::Configurer::Downloader.new(
+      "pluginfacts",
+      Puppet[:pluginfactdest],
+      Puppet[:pluginfactsource],
+      Puppet[:pluginsignore],
+      environment,
+      source_permissions
+    )
+    locales_downloader = Puppet::Configurer::Downloader.new(
+      "locales",
+      Puppet[:localedest],
+      Puppet[:localesource],
+      Puppet[:localeignore],
+      environment
+    )
+
     result = []
     result += plugin_fact_downloader.evaluate
     result += plugin_downloader.evaluate

data/vendored/puppet/lib/puppet/defaults.rb

@@ -166,6 +166,13 @@ module Puppet
         :type     => :boolean,
         :desc     => "Whether to enable experimental performance profiling",
     },
+    :future_features => {
+      :default => false,
+      :type => :boolean,
+      :desc => "Whether or not to enable all features currently being developed for future
+        major releases of Puppet. Should be used with caution, as in development
+        features are experimental and can have unexpected effects."
+    },
     :static_catalogs => {
       :default    => true,
       :type       => :boolean,
@@ -294,7 +301,8 @@ module Puppet
         :desc     => "The environment Puppet is running in.  For clients
           (e.g., `puppet agent`) this determines the environment itself, which
           is used to find modules and much more.  For servers (i.e., `puppet master`)
-          this provides the default environment for nodes we know nothing about."
+          this provides the default environment for nodes we know nothing about.",
+        :short    => "E"
     },
     :environmentpath => {
       :default => "$codedir/environments",

data/vendored/puppet/lib/puppet/face/epp.rb

@@ -92,7 +92,8 @@ Puppet::Face.define(:epp, '0.0.1') do
         end
       end
       if !missing_files.empty?
-        raise Puppet::Error, _("One or more file(s) specified did not exist:\n") + missing_files.map { |f| "   #{f}" }.join("\n")
+        raise Puppet::Error, _("One or more file(s) specified did not exist:\n%{missing_files_list}") %
+            { missing_files_list: missing_files.map { |f| "   #{f}" }.join("\n") }
       else
         # Exit with 1 if there were errors
         raise Puppet::Error, _("Errors while validating epp") unless status
@@ -180,7 +181,8 @@ Puppet::Face.define(:epp, '0.0.1') do
         end
 
         if !missing_files.empty?
-          raise Puppet::Error, _("One or more file(s) specified did not exist:\n") + missing_files.collect { |f| "   #{f}" }.join("\n")
+          raise Puppet::Error, _("One or more file(s) specified did not exist:\n%{missing_files_list}") %
+              { missing_files_list:  missing_files.collect { |f| "   #{f}" }.join("\n") }
         end
       end
       buffer.string

data/vendored/puppet/lib/puppet/face/module/build.rb

@@ -57,7 +57,7 @@ Puppet::Face.define(:module, '1.0.0') do
 
     when_rendering :console do |return_value|
       # Get the string representation of the Pathname object.
-      _("Module built: ") + return_value.expand_path.to_s
+      _("Module built: %{path}") % { path: return_value.expand_path.to_s }
     end
   end
 end

data/vendored/puppet/lib/puppet/face/module/list.rb

@@ -109,20 +109,10 @@ Puppet::Face.define(:module, '1.0.0') do
   end
 
   def warn_unmet_dependencies(environment)
-    error_types = {
-      :non_semantic_version => {
-        :title => _("Non semantic version dependency")
-      },
-      :missing => {
-        :title => _("Missing dependency")
-      },
-      :version_mismatch => {
-        :title => _("Module '%s' (v%s) fails to meet some dependencies:")
-      }
-    }
+    error_types = [:non_semantic_version, :version_mismatch, :missing]
 
     @unmet_deps = {}
-    error_types.each_key do |type|
+    error_types.each do |type|
       @unmet_deps[type] = Hash.new do |hash, key|
         hash[key] = { :errors => [], :parent => nil }
       end
@@ -162,17 +152,16 @@ Puppet::Face.define(:module, '1.0.0') do
       unless @unmet_deps[type].empty?
         @unmet_deps[type].keys.sort_by {|dep| dep }.each do |dep|
           name    = dep.gsub('/', '-')
-          title   = error_types[type][:title]
           errors  = @unmet_deps[type][dep][:errors]
           version = @unmet_deps[type][dep][:version]
 
           msg = case type
                 when :version_mismatch
-                  title % [name, version] + "\n"
+                  _("Module '%{name}' (v%{version}) fails to meet some dependencies:\n") % { name: name, version: version }
                 when :non_semantic_version
-                  title + " '#{name}' (v#{version}):\n"
+                  _("Non semantic version dependency %{name} (v%{version}):\n") % { name: name, version: version }
                 else
-                  title + " '#{name}':\n"
+                  _("Missing dependency '%{name}':\n") % { name: name }
                 end
 
           errors.each { |error_string| msg << "  #{error_string}\n" }