bolt 0.14.0 → 0.15.0

data/lib/bolt/result.rb

@@ -3,9 +3,9 @@ require 'bolt/error'
 
 module Bolt
   class Result
-    attr_reader :message, :error
+    attr_reader :target, :value
 
-    def self.from_exception(exception)
+    def self.from_exception(target, exception)
       @exception = exception
       if @exception.is_a?(Bolt::Error)
         error = @exception.to_h
@@ -18,121 +18,124 @@ module Bolt
         }
         error['details']['stack_trace'] = exception.backtrace.join('\n') if exception.backtrace
       end
-      Result.new(error)
+      Result.new(target, error: error)
     end
 
-    def initialize(error = nil, message = nil)
-      @error = error
-      @message = message
+    def self.for_command(target, stdout, stderr, exit_code)
+      value = {
+        'stdout' => stdout,
+        'stderr' => stderr,
+        'exit_code' => exit_code
+      }
+      unless exit_code == 0
+        value['_error'] = {
+          'kind' => 'puppetlabs.tasks/command-error',
+          'issue_code' => 'COMMAND_ERROR',
+          'msg' => "The command failed with exit code #{exit_code}",
+          'details' => { 'exit_code' => exit_code }
+        }
+      end
+      new(target, value: value)
     end
 
-    def value
-      nil
+    def self.for_task(target, stdout, stderr, exit_code)
+      begin
+        value = JSON.parse(stdout)
+        unless value.is_a? Hash
+          value = nil
+        end
+      rescue JSON::ParserError
+        value = nil
+      end
+      value ||= { '_output' => stdout }
+      if exit_code != 0 && value['_error'].nil?
+        msg = if stdout.empty?
+                "The task failed with exit code #{exit_code}:\n#{stderr}"
+              else
+                "The task failed with exit code #{exit_code}"
+              end
+        value['_error'] = { 'kind' => 'puppetlabs.tasks/task-error',
+                            'issue_code' => 'TASK_ERROR',
+                            'msg' => msg,
+                            'details' => { 'exit_code' => exit_code } }
+      end
+      new(target, value: value)
+    end
+
+    def self.for_upload(target, source, destination)
+      new(target, message: "Uploaded '#{source}' to '#{target.host}:#{destination}'")
     end
 
-    def to_h
-      h = {}
-      if value
-        h['value'] = value
-        h['value']['_output'] = message if message
-      elsif message
-        h['value'] = { '_output' => message }
+    def initialize(target, error: nil, message: nil, value: nil)
+      @target = target
+      @value = value || {}
+      @value_set = !value.nil?
+      if error && !error.is_a?(Hash)
+        raise "TODO: how did we get a string error"
       end
-      h['error'] = error if error
-      h
+      @value['_error'] = error if error
+      @value['_output'] = message if message
     end
 
-    def to_result
-      # TODO: This should be to_h but we need to update the plan functions to
-      # use this hash instead
-      special_keys = {}
-      special_keys['_error'] = error if error
-      special_keys['_output'] = message if message
-      val = value || {}
-      val.merge(special_keys)
+    def message
+      @value['_output']
     end
 
-    def success?
-      error.nil?
+    def status_hash
+      { node: @target.name,
+        status: ok? ? 'success' : 'failure',
+        result: @value }
     end
-  end
 
-  class CommandResult < Result
-    attr_reader :stdout, :stderr, :exit_code
+    # TODO: what to call this it's the value minus special keys
+    # This should be {} if a value was set otherwise it's nil
+    def generic_value
+      if @value_set
+        value.reject { |k, _| %w[_error _output].include? k }
+      end
+    end
 
-    def self.from_output(output)
-      new(output.stdout.string,
-          output.stderr.string,
-          output.exit_code)
+    def eql?(other)
+      self.class == other.class &&
+        target == other.target &&
+        value == other.value
     end
 
-    def initialize(stdout, stderr, exit_code)
-      @stdout = stdout || ""
-      @stderr = stderr || ""
-      @exit_code = exit_code
+    def [](key)
+      value[key]
     end
 
-    def value
-      {
-        'stdout' => @stdout,
-        'stderr' => @stderr,
-        'exit_code' => @exit_code
-      }
+    def ==(other)
+      eql?(other)
     end
 
+    # TODO: remove in favor of ok?
     def success?
-      @exit_code == 0
+      ok?
     end
 
-    def error
-      unless success?
-        {
-          'kind' => 'puppetlabs.tasks/command-error',
-          'issue_code' => 'COMMAND_ERROR',
-          'msg' => "The command failed with exit code #{@exit_code}",
-          'details' => { 'exit_code' => @exit_code }
-        }
-      end
+    def ok?
+      error_hash.nil?
     end
-  end
-
-  class TaskResult < CommandResult
-    attr_reader :value
+    alias ok ok?
 
-    def initialize(stdout, stderr, exit_code)
-      super(stdout, stderr, exit_code)
-      @value = parse_output(stdout)
-      @message = @value.delete('_output')
-      @error = @value.delete('_error')
+    # This allows access to errors outside puppet compilation
+    # it should be prefered over error in bolt code
+    def error_hash
+      value['_error']
     end
 
+    # Warning: This will fail outside of a compilation.
+    # Use error_hash inside bolt.
+    # Is it crazy for this to behave differently outside a compiler?
     def error
-      unless success?
-        return @error if @error
-        msg = if !@stdout.empty?
-                "The task failed with exit code #{@exit_code}"
-              else
-                "The task failed with exit code #{@exit_code}:\n#{@stderr}"
-              end
-        { 'kind' => 'puppetlabs.tasks/task-error',
-          'issue_code' => 'TASK_ERROR',
-          'msg' => msg,
-          'details' => { 'exit_code' => @exit_code } }
-      end
-    end
+      if error_hash
+        Puppet::DataTypes::Error.new(error_hash['msg'],
+                                     error_hash['kind'],
+                                     nil, nil,
+                                     error_hash['details'])
 
-    private
-
-    def parse_output(output)
-      begin
-        obj = JSON.parse(output)
-        unless obj.is_a? Hash
-          obj = nil
-        end
-      rescue JSON::ParserError
-        obj = nil
       end
-      obj || { '_output' => output }
     end
   end
 end

data/lib/bolt/result_set.rb

@@ -0,0 +1,94 @@
+module Bolt
+  class ResultSet
+    attr_reader :results
+
+    include Enumerable
+
+    # We only want want to include these when puppet is loaded
+    def self.include_iterable
+      include(Puppet::Pops::Types::Iterable)
+      include(Puppet::Pops::Types::IteratorProducer)
+    end
+
+    def iterator
+      if Object.const_defined?(:Puppet) && Puppet.const_defined?(:Pops) &&
+         self.class.included_modules.include?(Puppet::Pops::Types::Iterable)
+        Puppet::Pops::Types::Iterable.on(@results, Bolt::Result)
+      else
+        raise NotImplementedError, "iterator requires puppet code to be loaded."
+      end
+    end
+
+    def initialize(results)
+      @results = results
+    end
+
+    def each
+      @results.each { |r| yield r }
+    end
+
+    def result_hash
+      @result_hash ||= @results.each_with_object({}) do |result, acc|
+        acc[result.target.name] = result
+      end
+    end
+
+    def count
+      @results.size
+    end
+    alias length count
+    alias size count
+
+    def empty
+      @results.empty?
+    end
+    alias empty? empty
+
+    def targets
+      results.map(&:target)
+    end
+
+    def names
+      @results.map { |r| r.target.name }
+    end
+
+    def ok
+      @results.all?(&:ok?)
+    end
+    alias ok? ok
+
+    def error_set
+      filtered = @results.reject(&:ok?)
+      ResultSet.new(filtered)
+    end
+
+    def ok_set
+      filtered = @results.select(&:success?)
+      self.class.new(filtered)
+    end
+
+    def find(target_name)
+      result_hash[target_name]
+    end
+
+    def first
+      @results.first
+    end
+
+    def eql?(other)
+      self.class == other.class && @results == other.results
+    end
+
+    def to_json(opts = nil)
+      @results.map(&:status_hash).to_json(opts)
+    end
+
+    def to_s
+      to_json
+    end
+
+    def ==(other)
+      eql?(other)
+    end
+  end
+end

data/lib/bolt/target.rb

@@ -1,32 +1,80 @@
+require 'addressable/uri'
+require 'bolt/error'
+
 module Bolt
   class Target
-    attr_reader :host, :options
+    attr_reader :uri, :options
 
+    # Satisfies the Puppet datatypes API
     def self.from_asserted_hash(hash)
-      new(hash['host'], hash['options'])
+      new(hash['uri'], hash['options'])
+    end
+
+    def self.from_uri(uri)
+      new(uri)
+    end
+
+    def self.parse_urls(urls)
+      urls.split(/[[:space:],]+/).reject(&:empty?).uniq.map { |url| from_uri(url) }
+    end
+
+    def initialize(uri, options = nil)
+      @uri = uri
+      @uri_obj = parse(uri)
+      @options = options || {}
     end
 
-    def initialize(host, options = {})
-      @host = host
-      @options = options
+    def parse(string)
+      if string =~ %r{^[^:]+://}
+        Addressable::URI.parse(string)
+      else
+        # Initialize with an empty scheme to ensure we parse the hostname correctly
+        Addressable::URI.parse("//#{string}")
+      end
     end
+    private :parse
 
     def eql?(other)
-      self.class.equal?(other.class) && @host == other.host && @options == other.options
+      self.class.equal?(other.class) && @uri == other.uri && @options == other.options
     end
     alias == eql?
 
     def hash
-      @host.hash ^ @options.hash
+      @uri.hash ^ @options.hash
     end
 
     def to_s
-      # Use Puppet::Pops::Types::StringConverter if it is available
-      if Object.const_defined?(:Puppet) && Puppet.const_defined?(:Pops)
-        Puppet::Pops::Types::StringConverter.singleton.convert(self)
-      else
-        "Target('#{@host}', #{@options})"
-      end
+      "Target('#{@uri}', #{@options})"
+    end
+
+    def host
+      @uri_obj.hostname
+    end
+
+    def port
+      @uri_obj.port
+    end
+
+    # name is currently just uri but should be be used instead to identify the
+    # Target ouside the transport or uri options.
+    def name
+      uri
+    end
+
+    def user
+      Addressable::URI.unencode_component(
+        @uri_obj.user
+      )
+    end
+
+    def password
+      Addressable::URI.unencode_component(
+        @uri_obj.password
+      )
+    end
+
+    def protocol
+      @uri_obj.scheme
     end
   end
 end

data/lib/bolt/version.rb

@@ -1,3 +1,3 @@
 module Bolt
-  VERSION = '0.14.0'.freeze
+  VERSION = '0.15.0'.freeze
 end

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

@@ -0,0 +1,18 @@
+Puppet::DataTypes.create_type('Result') do
+  interface <<-PUPPET
+    attributes => {
+      'value' => Hash[String[1], Data],
+      'target' => Target
+    },
+    functions => {
+      error => Callable[[], Optional[Error]],
+      message => Callable[[], Optional[String]],
+      ok => Callable[[], Boolean],
+      '[]' => Callable[[String[1]], Data]
+    }
+  PUPPET
+
+  load_file('bolt/result')
+
+  implementation_class Bolt::Result
+end

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

@@ -0,0 +1,22 @@
+Puppet::DataTypes.create_type('ResultSet') do
+  interface <<-PUPPET
+    attributes => {
+      'results' => Array[Result],
+    },
+    functions => {
+      count => Callable[[], Integer],
+      empty => Callable[[], Boolean],
+      error_set => Callable[[], ResultSet],
+      find => Callable[[String[1]], Optional[Result]],
+      first => Callable[[], Optional[Result]],
+      names => Callable[[], Array[String[1]]],
+      ok => Callable[[], Boolean],
+      ok_set => Callable[[], ResultSet],
+      targets => Callable[[], Array[Target]],
+    }
+  PUPPET
+
+  load_file('bolt/result_set')
+
+  implementation_class Bolt::ResultSet
+end