bolt 0.14.0 → 0.15.0

data/modules/boltlib/lib/puppet/datatypes/target.rb

@@ -1,8 +1,11 @@
 Puppet::DataTypes.create_type('Target') do
   interface <<-PUPPET
     attributes => {
-      host => String[1],
+      uri => String[1],
       options => { type => Hash[String[1], Data], value => {} }
+    },
+    functions => {
+      name => Callable[[], String[1]],
     }
     PUPPET
 

data/modules/boltlib/lib/puppet/functions/file_upload.rb

@@ -5,6 +5,8 @@
 # * A target is a String with a targets's hostname or a Target.
 # * The returned value contains information about the result per target.
 #
+require 'bolt/error'
+
 Puppet::Functions.create_function(:file_upload, Puppet::Functions::InternalFunction) do
   local_types do
     type 'TargetOrTargets = Variant[String[1], Target, Array[TargetOrTargets]]'
@@ -14,11 +16,13 @@ Puppet::Functions.create_function(:file_upload, Puppet::Functions::InternalFunct
     scope_param
     param 'String[1]', :source
     param 'String[1]', :destination
-    repeated_param 'TargetOrTargets', :targets
-    return_type 'ExecutionResult'
+    param 'TargetOrTargets', :targets
+    optional_param 'Hash[String[1], Any]', :options
+    return_type 'ResultSet'
   end
 
-  def file_upload(scope, source, destination, *targets)
+  def file_upload(scope, source, destination, targets, options = nil)
+    options ||= {}
     unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
         Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'file_upload'
@@ -40,17 +44,18 @@ Puppet::Functions.create_function(:file_upload, Puppet::Functions::InternalFunct
     end
 
     # Ensure that that given targets are all Target instances
-    targets = targets.flatten.map { |t| t.is_a?(String) ? Bolt::Target.new(t) : t }
+    targets = [targets] unless targets.is_a?(Array)
+    targets = targets.flatten.map { |t| t.is_a?(String) ? Bolt::Target.from_uri(t) : t }
     if targets.empty?
       call_function('debug', "Simulating file upload of '#{found}' - no targets given - no action taken")
-      Bolt::ExecutionResult::EMPTY_RESULT
+      r = Bolt::ResultSet.new([])
     else
-      # Awaits change in the executor, enabling it receive Target instances
-      hosts = targets.map(&:host)
+      r = executor.file_upload(targets, found, destination)
+    end
 
-      Bolt::ExecutionResult.from_bolt(
-        executor.file_upload(executor.from_uris(hosts), found, destination)
-      )
+    if !r.ok && !options['_catch_errors']
+      raise Bolt::RunFailure.new(r, 'upload_file', source)
     end
+    r
   end
 end

data/modules/boltlib/lib/puppet/functions/run_command.rb

@@ -5,6 +5,8 @@
 # * A target is a String with a targets's hostname or a Target.
 # * The returned value contains information about the result per target.
 #
+require 'bolt/error'
+
 Puppet::Functions.create_function(:run_command) do
   local_types do
     type 'TargetOrTargets = Variant[String[1], Target, Array[TargetOrTargets]]'
@@ -12,11 +14,13 @@ Puppet::Functions.create_function(:run_command) do
 
   dispatch :run_command do
     param 'String[1]', :command
-    repeated_param 'TargetOrTargets', :targets
-    return_type 'ExecutionResult'
+    param 'TargetOrTargets', :targets
+    optional_param 'Hash[String[1], Any]', :options
+    return_type 'ResultSet'
   end
 
-  def run_command(command, *targets)
+  def run_command(command, targets, options = nil)
+    options ||= {}
     unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
         Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'run_command'
@@ -31,16 +35,19 @@ Puppet::Functions.create_function(:run_command) do
     end
 
     # Ensure that that given targets are all Target instances
-    targets = targets.flatten.map { |t| t.is_a?(String) ? Bolt::Target.new(t) : t }
+    targets = [targets] unless targets.is_a?(Array)
+    targets = targets.flatten.map { |t| t.is_a?(String) ? Bolt::Target.from_uri(t) : t }
 
     if targets.empty?
       call_function('debug', "Simulating run_command('#{command}') - no targets given - no action taken")
-      Bolt::ExecutionResult::EMPTY_RESULT
+      r = Bolt::ResultSet.new([])
     else
-      # Awaits change in the executor, enabling it receive Target instances
-      hosts = targets.map(&:host)
+      r = executor.run_command(targets, command)
+    end
 
-      Bolt::ExecutionResult.from_bolt(executor.run_command(executor.from_uris(hosts), command))
+    if !r.ok && !options['_catch_errors']
+      raise Bolt::RunFailure.new(r, 'run_command', command)
     end
+    r
   end
 end

data/modules/boltlib/lib/puppet/functions/run_script.rb

@@ -10,26 +10,16 @@ Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFuncti
     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
-    return_type 'ExecutionResult'
-  end
-
   dispatch :run_script do
     scope_param
     param 'String[1]', :script
-    repeated_param 'TargetOrTargets', :targets
-    return_type 'ExecutionResult'
-  end
-
-  def run_script(scope, script, *targets)
-    run_script_with_args(scope, script, targets, 'arguments' => [])
+    param 'TargetOrTargets', :targets
+    optional_param 'Hash[String[1], Any]', :options
+    return_type 'ResultSet'
   end
 
-  def run_script_with_args(scope, script, targets, args_hash)
+  def run_script(scope, script, targets, options = nil)
+    options ||= {}
     unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
         Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'run_script'
@@ -56,17 +46,16 @@ Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFuncti
     end
 
     # Ensure that that given targets are all Target instances)
-    targets = [targets].flatten.map { |t| t.is_a?(String) ? Bolt::Target.new(t) : t }
-    if targets.empty?
-      call_function('debug', "Simulating run_script of '#{found}' - no targets given - no action taken")
-      Bolt::ExecutionResult::EMPTY_RESULT
-    else
-      # Awaits change in the executor, enabling it receive Target instances
-      hosts = targets.map(&:host)
-
-      Bolt::ExecutionResult.from_bolt(
-        executor.run_script(executor.from_uris(hosts), found, args_hash['arguments'])
-      )
+    targets = [targets].flatten.map { |t| t.is_a?(String) ? Bolt::Target.from_uri(t) : t }
+    r = if targets.empty?
+          Bolt::ResultSet.new([])
+        else
+          executor.run_script(targets, found, options['arguments'] || [])
+        end
+
+    if !r.ok && !options['_catch_errors']
+      raise Bolt::RunFailure.new(r, 'run_script', script)
     end
+    r
   end
 end

data/modules/boltlib/lib/puppet/functions/run_task.rb

@@ -5,6 +5,8 @@
 # * A target is a String with a targets's hostname or a Target.
 # * The returned value contains information about the result per target.
 #
+require 'bolt/error'
+
 Puppet::Functions.create_function(:run_task) do
   local_types do
     type 'TargetOrTargets = Variant[String[1], Target, Array[TargetOrTargets]]'
@@ -14,7 +16,7 @@ Puppet::Functions.create_function(:run_task) do
     param 'String[1]', :task_name
     param 'TargetOrTargets', :targets
     optional_param 'Hash[String[1], Any]', :task_args
-    return_type 'ExecutionResult'
+    return_type 'ResultSet'
   end
 
   # this is used from 'bolt task run'
@@ -22,16 +24,21 @@ Puppet::Functions.create_function(:run_task) do
     param 'String[1]', :task_name
     param 'TargetOrTargets', :targets
     optional_param 'Hash[String[1], Any]', :task_args
+    # return_type 'ResultSet'
     block_param
   end
 
   def run_task(task_name, targets, task_args = nil)
-    Bolt::ExecutionResult.from_bolt(
-      run_task_raw(task_name, targets, task_args)
-    )
+    task_args ||= {}
+    r = run_task_raw(task_name, targets, task_args)
+    if !r.ok && !task_args['_catch_errors']
+      raise Bolt::RunFailure.new(r, 'run_task', task_name)
+    end
+    r
   end
 
   def run_task_raw(task_name, targets, task_args = nil, &block)
+    task_args ||= {}
     unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
         Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'run_task'
@@ -53,7 +60,8 @@ Puppet::Functions.create_function(:run_task) do
       )
     end
 
-    use_args = task_args.nil? ? {} : task_args
+    use_args = task_args.reject { |k, _| k.start_with?('_') }
+
     task_signature.runnable_with?(use_args) do |mismatch|
       raise Puppet::ParseError, mismatch
     end || (raise Puppet::ParseError, 'Task parameters did not match')
@@ -74,18 +82,12 @@ Puppet::Functions.create_function(:run_task) do
 
     # Ensure that that given targets are all Target instances
     targets = [targets] unless targets.is_a?(Array)
-    targets = targets.flatten.map { |t| t.is_a?(String) ? Bolt::Target.new(t) : t }
+    targets = targets.flatten.map { |t| t.is_a?(String) ? Bolt::Target.from_uri(t) : t }
     if targets.empty?
-      call_function('debug', "Simulating run of task #{task.name} - no targets given - no action taken")
-      Puppet::Pops::EMPTY_HASH
+      Bolt::ResultSet.new([])
     else
-      # TODO: Awaits change in the executor, enabling it receive Target instances
-      hosts = targets.map(&:host)
-
-      # TODO: separate handling of default since it's platform specific
-      input_method = task.input_method
-
-      executor.run_task(executor.from_uris(hosts), task.executable, input_method, use_args, &block)
+      # TODO: pass entire task to executor
+      executor.run_task(targets, task.executable, task.input_method, use_args, &block)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-11 00:00:00.000000000 Z
+date: 2018-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -114,14 +114,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: CFPropertyList
   requirement: !ruby/object:Gem::Requirement
@@ -309,9 +323,7 @@ files:
 - lib/bolt/cli.rb
 - lib/bolt/config.rb
 - lib/bolt/error.rb
-- lib/bolt/execution_result.rb
 - lib/bolt/executor.rb
-- lib/bolt/formatter.rb
 - lib/bolt/logger.rb
 - lib/bolt/node.rb
 - lib/bolt/node/errors.rb
@@ -319,15 +331,17 @@ files:
 - lib/bolt/node/output.rb
 - lib/bolt/node/ssh.rb
 - lib/bolt/node/winrm.rb
-- lib/bolt/node_uri.rb
 - lib/bolt/notifier.rb
 - lib/bolt/outputter.rb
 - lib/bolt/outputter/human.rb
 - lib/bolt/outputter/json.rb
+- lib/bolt/pal.rb
 - lib/bolt/result.rb
+- lib/bolt/result_set.rb
 - lib/bolt/target.rb
 - lib/bolt/version.rb
-- modules/boltlib/lib/puppet/datatypes/executionresult.rb
+- modules/boltlib/lib/puppet/datatypes/result.rb
+- modules/boltlib/lib/puppet/datatypes/resultset.rb
 - modules/boltlib/lib/puppet/datatypes/target.rb
 - modules/boltlib/lib/puppet/functions/file_upload.rb
 - modules/boltlib/lib/puppet/functions/run_command.rb
@@ -1578,7 +1592,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Execute commands remotely over SSH and WinRM

data/lib/bolt/execution_result.rb

@@ -1,109 +0,0 @@
-module Bolt
-  class ExecutionResult
-    if Object.const_defined?(:Puppet) && Puppet.const_defined?(:Pops)
-      include Puppet::Pops::Types::Iterable
-      include Puppet::Pops::Types::IteratorProducer
-
-      def iterator
-        tc = Puppet::Pops::Types::TypeFactory
-        Puppet::Pops::Types::Iterable.on(
-          @result_hash,
-          tc.tuple([tc.string, tc.data], Puppet::Pops::Types::PHashType::KEY_PAIR_TUPLE_SIZE)
-        )
-      end
-
-      def to_s
-        @result_hash.to_s
-      end
-    else
-      def iterator
-        @result_hash.each
-      end
-    end
-
-    # Creates a pure Data hash from a result hash returned from the Bolt::Executor
-    # @return [Hash{String => Data}] The data hash
-    def self.from_bolt(result_hash)
-      data_result = {}
-      result_hash.each_pair { |k, v| data_result[k.uri] = v.to_h }
-      new(data_result)
-    end
-
-    attr_reader :result_hash
-
-    def initialize(result_hash, final = false)
-      result_hash = convert_errors(result_hash) unless final
-      @result_hash = result_hash
-    end
-
-    def count
-      @result_hash.size
-    end
-
-    def empty
-      @result_hash.empty?
-    end
-    alias empty? empty
-
-    def error_nodes
-      result = {}
-      @result_hash.each_pair { |k, v| result[k] = v if v.is_a?(Puppet::DataTypes::Error) }
-      self.class.new(result, true)
-    end
-
-    def names
-      @result_hash.keys
-    end
-
-    def ok
-      @result_hash.values.none? { |v| v.is_a?(Puppet::DataTypes::Error) }
-    end
-    alias ok? ok
-
-    def ok_nodes
-      result = {}
-      @result_hash.each_pair { |k, v| result[k] = v unless v.is_a?(Error) }
-      self.class.new(result, true)
-    end
-
-    def [](node_uri)
-      @result_hash[node_uri]
-    end
-
-    def value(node_uri)
-      self[node_uri]
-    end
-
-    def values
-      @result_hash.values
-    end
-
-    def _pcore_init_hash
-      @result_hash
-    end
-
-    def eql?(other)
-      self.class == other.class && @result_hash == other.result_hash
-    end
-
-    def ==(other)
-      eql?(other)
-    end
-
-    private
-
-    def convert_errors(result_hash)
-      converted = {}
-      result_hash.each_pair { |k, v| converted[k] = convert_error(v) }
-      converted
-    end
-
-    def convert_error(value_or_error)
-      e = value_or_error['error']
-      v = value_or_error['value']
-      e.nil? ? v : Puppet::DataTypes::Error.new(e['msg'], e['kind'], e['issue_code'], v, e['details'])
-    end
-
-    EMPTY_RESULT = new({})
-  end
-end

data/lib/bolt/formatter.rb

@@ -1,9 +0,0 @@
-require 'logger'
-
-module Bolt
-  class Formatter < Logger::Formatter
-    def call(severity, time, progname, msg)
-      "#{format_datetime(time)} #{severity} #{progname}: #{msg2str(msg)}\n"
-    end
-  end
-end