bolt 0.7.0 → 0.8.0

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

@@ -11,13 +11,13 @@ class Puppet::Configurer::PluginHandler
   # 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)
+    locales_downloader = @factory.create_locales_downloader(environment)
+    result = []
     result += plugin_fact_downloader.evaluate
-
     result += plugin_downloader.evaluate
+    result += locales_downloader.evaluate
+
     Puppet::Util::Autoload.reload_changed
 
     result

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

@@ -1498,6 +1498,13 @@ EOT
           \"never run.\" If you want puppet agent to never run, you should start
           it with the `--no-client` option. #{AS_DURATION}",
     },
+    :runtimeout => {
+      :default  => 0,
+      :type     => :duration,
+      :desc     => "The maximum amount of time an agent run is allowed to take.
+          A Puppet agent run that exceeds this timeout will be aborted.
+          Defaults to 0, which is unlimited. #{AS_DURATION}",
+    },
     :ca_server => {
       :default    => "$server",
       :desc       => "The server to use for certificate
@@ -1712,6 +1719,19 @@ EOT
       :default  => "puppet:///pluginfacts",
       :desc     => "Where to retrieve external facts for pluginsync",
     },
+    :localedest => {
+      :type       => :directory,
+      :default    => "$vardir/locales",
+      :desc       => "Where Puppet should store translation files that it pulls down from the central
+      server.",
+    },
+    :localesource => {
+      :default    => "puppet:///locales",
+      :desc       => "From where to retrieve translation files.  The standard Puppet `file` type
+      is used for retrieval, so anything that is a valid file source can
+      be used here.",
+    },
+
     :pluginsync => {
       :default    => true,
       :type       => :boolean,
@@ -1721,9 +1741,8 @@ EOT
         Puppet.deprecation_warning "Setting 'pluginsync' is deprecated."
       }
     },
-
     :pluginsignore => {
-        :default  => ".svn CVS .git .hg",
+        :default  => ".svn CVS .git .hg *.pot",
         :desc     => "What files to ignore when pulling down plugins.",
     }
   )

data/vendored/puppet/lib/puppet/external/nagios/parser.rb

@@ -14,7 +14,7 @@ require 'strscan'
 class ::Nagios::Parser::SyntaxError < RuntimeError; end
 
 def parse(src)
-  if src.respond_to?("force_encoding") then
+  if (RUBY_VERSION < '2.1.0') && src.respond_to?("force_encoding") then
     src.force_encoding("ASCII-8BIT")
   end
   @ss = StringScanner.new(src)

data/vendored/puppet/lib/puppet/file_serving/configuration.rb

@@ -4,6 +4,7 @@ require 'puppet/file_serving/mount'
 require 'puppet/file_serving/mount/file'
 require 'puppet/file_serving/mount/modules'
 require 'puppet/file_serving/mount/plugins'
+require 'puppet/file_serving/mount/locales'
 require 'puppet/file_serving/mount/pluginfacts'
 require 'puppet/file_serving/mount/tasks'
 
@@ -81,6 +82,8 @@ class Puppet::FileServing::Configuration
     @mounts["modules"].allow('*') if @mounts["modules"].empty?
     @mounts["plugins"] ||= Mount::Plugins.new("plugins")
     @mounts["plugins"].allow('*') if @mounts["plugins"].empty?
+    @mounts["locales"] ||= Mount::Locales.new("locales")
+    @mounts["locales"].allow('*') if @mounts["locales"].empty?
     @mounts["pluginfacts"] ||= Mount::PluginFacts.new("pluginfacts")
     @mounts["pluginfacts"].allow('*') if @mounts["pluginfacts"].empty?
     @mounts["tasks"] ||= Mount::Tasks.new("tasks")

data/vendored/puppet/lib/puppet/file_serving/configuration/parser.rb

@@ -94,6 +94,8 @@ class Puppet::FileServing::Configuration::Parser
       mount = Mount::Plugins.new(name)
     when "tasks"
       mount = Mount::Tasks.new(name)
+    when "locales"
+      mount = Mount::Locales.new(name)
     else
       mount = Mount::File.new(name)
     end

data/vendored/puppet/lib/puppet/file_serving/mount/locales.rb

@@ -0,0 +1,35 @@
+require 'puppet/file_serving/mount'
+
+# Find files in the modules' locales directories.
+# This is a very strange mount because it merges
+# many directories into one.
+class Puppet::FileServing::Mount::Locales < Puppet::FileServing::Mount
+  # Return an instance of the appropriate class.
+  def find(relative_path, request)
+    return nil unless mod = request.environment.modules.find { |m|  m.locale(relative_path) }
+
+    path = mod.locale(relative_path)
+
+    path
+  end
+
+  def search(relative_path, request)
+    # We currently only support one kind of search on locales - return
+    # them all.
+    Puppet.debug("Warning: calling Locales.search with empty module path.") if request.environment.modules.empty?
+    paths = request.environment.modules.find_all { |mod| mod.locales? }.collect { |mod| mod.locale_directory }
+    if paths.empty?
+      # If the modulepath is valid then we still need to return a valid root
+      # directory for the search, but make sure nothing inside it is
+      # returned.
+      request.options[:recurse] = false
+      request.environment.modulepath.empty? ? nil : request.environment.modulepath
+    else
+      paths
+    end
+  end
+
+  def valid?
+    true
+  end
+end

data/vendored/puppet/lib/puppet/forge.rb

@@ -65,7 +65,7 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
 
       if response.code == '200'
         result = JSON.parse(response.body)
-        uri = result['pagination']['next']
+        uri = decode_uri(result['pagination']['next'])
         matches.concat result['results']
       else
         raise ResponseError.new(:uri => URI.parse(@host).merge(uri), :response => response)
@@ -90,7 +90,7 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
   # @see SemanticPuppet::Dependency::Source#fetch
   def fetch(input)
     name = input.tr('/', '-')
-    uri = "/v3/releases?module=#{name}"
+    uri = "/v3/releases?module=#{name}&sort_by=version"
     if Puppet[:module_groups]
       uri += "&module_groups=#{Puppet[:module_groups].gsub('+', ' ')}"
     end
@@ -107,7 +107,7 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
       end
 
       releases.concat(process(response['results']))
-      uri = response['pagination']['next']
+      uri = decode_uri(response['pagination']['next'])
     end
 
     return releases
@@ -226,4 +226,10 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
 
     l.select { |r| r }
   end
+
+  def decode_uri(uri)
+    return if uri.nil?
+
+    URI.decode(uri.gsub('+', ' '))
+  end
 end

data/vendored/puppet/lib/puppet/forge/repository.rb

@@ -44,8 +44,8 @@ class Puppet::Forge
 
     # Return a Net::HTTPResponse read for this +path+.
     def make_http_request(path, io = nil)
-      Puppet.debug "HTTP GET #{@host}#{path}"
       request = get_request_object(@uri.path.chomp('/')+path)
+      Puppet.debug "HTTP GET #{@host}#{request.path}"
       return read_response(request, io)
     end
 

data/vendored/puppet/lib/puppet/functions/file_upload.rb

@@ -1,34 +1,33 @@
-# Uploads the given file or directory to the given set of nodes and returns the result from each upload.
-#
-# * This function does nothing if the list of nodes is empty.
-# * It is possible to run on the node 'localhost'
-# * A node is a String with a node's hostname or a URI that also describes how to connect and run the task on that node
-#   including "user" and "password" parts of a URI.
-# * The returned value contains information about the result per node. TODO: needs mapping to a runtime Pcore Object to be useful
+# Uploads the given file or directory to the given set of targets and returns the result from each upload.
 #
+# * This function does nothing if the list of targets is empty.
+# * It is possible to run on the target 'localhost'
+# * 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 'NodeOrNodes = Variant[String[1], Array[NodeOrNodes]]'
+    type 'TargetOrTargets = Variant[String[1], Target, Array[TargetOrTargets]]'
   end
 
   dispatch :file_upload do
     scope_param
     param 'String[1]', :source
     param 'String[1]', :destination
-    repeated_param 'NodeOrNodes', :nodes
+    repeated_param 'TargetOrTargets', :targets
   end
 
-  def file_upload(scope, source, destination, *nodes)
+  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'})
     end
 
-    unless Puppet.features.bolt?
+    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'))
     end
 
@@ -37,12 +36,18 @@ Puppet::Functions.create_function(:file_upload, Puppet::Functions::InternalFunct
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::NO_SUCH_FILE_OR_DIRECTORY, {:file => source})
     end
 
-    hosts = nodes.flatten
-    if hosts.empty?
-      call_function('debug', "Simulating file upload of '#{found}' - no hosts given - no action taken")
+    # 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 file upload of '#{found}' - no targets given - no action taken")
       Puppet::Pops::Types::ExecutionResult::EMPTY_RESULT
     else
-      Puppet::Pops::Types::ExecutionResult.from_bolt(Bolt::Executor.from_uris(hosts).file_upload(found, destination))
+      # Awaits change in the executor, enabling it receive Target instances
+      hosts = targets.map { |h| h.host }
+
+      Puppet::Pops::Types::ExecutionResult.from_bolt(
+        executor.file_upload(executor.from_uris(hosts), found, destination)
+      )
     end
   end
 end

data/vendored/puppet/lib/puppet/functions/new.rb

@@ -14,10 +14,7 @@ Puppet::Functions.create_function(:new, Puppet::Functions::InternalFunction) do
 
   def new_instance(scope, t, *args)
     return args[0] if args.size == 1 && !t.is_a?(Puppet::Pops::Types::PInitType) && t.instance?(args[0])
-    result = catch :undefined_value do
-      new_function_for_type(t, scope).call(scope, *args)
-    end
-    assert_type(t, result)
+    result = assert_type(t, new_function_for_type(t, scope).call(scope, *args))
     return block_given? ? yield(result) : result
   end
 

data/vendored/puppet/lib/puppet/functions/run_command.rb

@@ -1,25 +1,23 @@
-# Runs a command on the given set of nodes and returns the result from each command execution.
-#
-# * This function does nothing if the list of nodes is empty.
-# * It is possible to run on the node 'localhost'
-# * A node is a String with a node's hostname or a URI that also describes how to connect and run the task on that node
-#   including "user" and "password" parts of a URI.
-# * The returned value contains information about the result per node. TODO: needs mapping to a runtime Pcore Object to be useful
+# Runs a command on the given set of targets and returns the result from each command execution.
 #
+# * This function does nothing if the list of targets is empty.
+# * It is possible to run on the target 'localhost'
+# * 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 'NodeOrNodes = Variant[String[1], Array[NodeOrNodes]]'
+    type 'TargetOrTargets = Variant[String[1], Target, Array[TargetOrTargets]]'
   end
 
   dispatch :run_command do
     param 'String[1]', :command
-    repeated_param 'NodeOrNodes', :nodes
+    repeated_param 'TargetOrTargets', :targets
   end
 
-  def run_command(command, *nodes)
+  def run_command(command, *targets)
     unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
         Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING,
@@ -31,11 +29,15 @@ Puppet::Functions.create_function(:run_command) do
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::TASK_MISSING_BOLT, :action => _('run a command'))
     end
 
-    hosts = nodes.flatten
-    if hosts.empty?
-      call_function('debug', "Simulating run_command('#{command}') - no hosts given - no action taken")
+    # 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 }
+
       Puppet::Pops::Types::ExecutionResult.from_bolt(
         executor.run_command(executor.from_uris(hosts), command)
       )

data/vendored/puppet/lib/puppet/functions/run_script.rb

@@ -1,26 +1,35 @@
-# Uploads the given script to the given set of nodes and returns the result of having each node execute the script.
-#
-# * This function does nothing if the list of nodes is empty.
-# * It is possible to run on the node 'localhost'
-# * A node is a String with a node's hostname or a URI that also describes how to connect and run the task on that node
-#   including "user" and "password" parts of a URI.
-# * The returned value contains information about the result per node. TODO: needs mapping to a runtime Pcore Object to be useful
+# Uploads the given script to the given set of targets and returns the result of having each target execute the script.
 #
+# * This function does nothing if the list of targets is empty.
+# * It is possible to run on the target 'localhost'
+# * 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 'NodeOrNodes = Variant[String[1], Array[NodeOrNodes]]'
+    type 'TargetOrTargets = Variant[String[1], Target, Array[TargetOrTargets]]'
+  end
+
+  dispatch :run_script_with_args do
+    scope_param
+    param 'String[1]', :script
+    param 'TargetOrTargets', :targets
+    param 'Struct[arguments => Array[String]]', :arguments
   end
 
   dispatch :run_script do
     scope_param
     param 'String[1]', :script
-    repeated_param 'NodeOrNodes', :nodes
+    repeated_param 'TargetOrTargets', :targets
+  end
+
+  def run_script(scope, script, *targets)
+    run_script_with_args(scope, script, targets, 'arguments' => [])
   end
 
-  def run_script(scope, script, *nodes)
+  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,
@@ -40,13 +49,17 @@ Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFuncti
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::NOT_A_FILE, {:file => script})
     end
 
-    hosts = nodes.flatten
-    if hosts.empty?
-      call_function('debug', "Simulating run_script of '#{found}' - no hosts given - no action taken")
+    # 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_script of '#{found}' - 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 }
+
       Puppet::Pops::Types::ExecutionResult.from_bolt(
-        executor.run_script(executor.from_uris(hosts), found)
+        executor.run_script(executor.from_uris(hosts), found, args_hash['arguments'])
       )
     end
   end

data/vendored/puppet/lib/puppet/functions/run_task.rb

@@ -1,54 +1,51 @@
-# Runs a given instance of a `Task` on the given set of nodes and returns the result from each.
-#
-# * This function does nothing if the list of nodes is empty.
-# * It is possible to run on the node 'localhost'
-# * A node is a String with a node's hostname or a URI that also describes how to connect and run the task on that node
-#   including "user" and "password" parts of a URI.
-# * The returned value contains information about the result per node. TODO: needs mapping to a runtime Pcore Object to be useful
+# Runs a given instance of a `Task` on the given set of targets and returns the result from each.
 #
+# * This function does nothing if the list of targets is empty.
+# * It is possible to run on the target 'localhost'
+# * 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 'NodeOrNodes = Variant[String[1], Array[NodeOrNodes]]'
+    type 'TargetOrTargets = Variant[String[1], Target, Array[TargetOrTargets]]'
   end
 
   dispatch :run_task_type do
     param 'Type[Task]', :task_type
-    param 'NodeOrNodes', :nodes
+    param 'TargetOrTargets', :targets
     optional_param 'Hash[String[1], Any]', :task_args
   end
 
   dispatch :run_named_task do
     param 'String[1]', :task_type
-    param 'NodeOrNodes', :nodes
+    param 'TargetOrTargets', :targets
     optional_param 'Hash[String[1], Any]', :task_args
   end
 
   dispatch :run_task_instance do
     param 'Task', :task
-    repeated_param 'NodeOrNodes', :nodes
+    repeated_param 'TargetOrTargets', :targets
   end
 
-  def run_task_type(task_type, nodes, task_args = nil)
+  def run_task_type(task_type, targets, task_args = nil)
     use_args = task_args.nil? ? {} : task_args
     task_instance = call_function('new', task_type, use_args)
-    run_task_instance(task_instance, nodes)
+    run_task_instance(task_instance, targets)
   end
 
-  def run_named_task(task_name, nodes, task_args = nil)
+  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)
     end
     use_args = task_args.nil? ? {} : task_args
     task_instance = call_function('new', task_type, use_args)
-    run_task_instance(task_instance, nodes)
+    run_task_instance(task_instance, targets)
   end
 
-  def run_task_instance(task, *nodes)
-    hosts = nodes.flatten
+  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,
@@ -60,10 +57,15 @@ Puppet::Functions.create_function(:run_task) do
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::TASK_MISSING_BOLT, :action => _('run a task'))
     end
 
-    if hosts.empty?
-      call_function('debug', "Simulating run of task #{task._pcore_type.name} - no hosts given - no action taken")
+    # 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 of task #{task._pcore_type.name} - 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 }
+
       # TODO: separate handling of default since it's platform specific
       input_method = task._pcore_type['input_method'].value