bolt 0.11.0 → 0.12.0

data/lib/bolt/executor.rb

@@ -7,12 +7,15 @@ require 'bolt/notifier'
 
 module Bolt
   class Executor
-    def initialize(config = Bolt::Config.new)
+    attr_reader :noop
+
+    def initialize(config = Bolt::Config.new, noop = nil)
       @config = config
       @logger = Logger.new(config[:log_destination])
       @logger.progname = 'executor'
       @logger.level = config[:log_level]
       @logger.formatter = Bolt::Formatter.new
+      @noop = noop
       @notifier = Bolt::Notifier.new
     end
 

data/lib/bolt/node.rb

@@ -3,6 +3,7 @@ require 'bolt/node_uri'
 require 'bolt/formatter'
 require 'bolt/result'
 require 'bolt/config'
+require 'bolt/target'
 
 module Bolt
   class Node
@@ -29,7 +30,7 @@ module Bolt
 
     def self.initialize_transport(_logger); end
 
-    attr_reader :logger, :host, :uri, :user, :password, :connect_timeout
+    attr_reader :logger, :host, :port, :uri, :user, :password, :connect_timeout
 
     def initialize(host, port = nil, user = nil, password = nil, uri: nil,
                    config: Bolt::Config.new)
@@ -41,6 +42,7 @@ module Bolt
       @user = user || transport_conf[:user]
       @password = password || transport_conf[:password]
       @key = transport_conf[:key]
+      @cacert = transport_conf[:cacert]
       @tty = transport_conf[:tty]
       @insecure = transport_conf[:insecure]
       @connect_timeout = transport_conf[:connect_timeout]
@@ -48,6 +50,9 @@ module Bolt
       @sudo_password = transport_conf[:sudo_password]
       @run_as = transport_conf[:run_as]
       @tmpdir = transport_conf[:tmpdir]
+      @service_url = transport_conf[:service_url]
+      @token_file = transport_conf[:token_file]
+      @orch_task_environment = transport_conf[:orch_task_environment]
 
       @logger = init_logger(config[:log_destination], config[:log_level])
       @transport_logger = init_logger(config[:log_destination], Logger::WARN)

data/lib/bolt/node/orch.rb

@@ -16,7 +16,11 @@ module Bolt
     end
 
     def make_client
-      OrchestratorClient.new({}, true)
+      opts = {}
+      opts["service-url"] = @service_url if @service_url
+      opts["token-file"] = @token_file if @token_file
+      opts["cacert"] = @cacert if @cacert
+      OrchestratorClient.new(opts, true)
     end
 
     def client
@@ -41,7 +45,9 @@ module Bolt
 
     def _run_task(task, _input_method, arguments)
       body = { task: task_name_from_path(task),
-               params: arguments,
+               environment: @orch_task_environment,
+               noop: arguments['_noop'],
+               params: arguments.reject { |k, _| k == '_noop' },
                scope: {
                  nodes: [@host]
                } }
@@ -53,6 +59,18 @@ module Bolt
 
       if state == 'finished'
         exit_code = 0
+      elsif state == 'skipped'
+        return Bolt::TaskResult.new(
+          JSON.dump(
+            '_error' => {
+              'kind' => 'puppetlabs.tasks/skipped-node',
+              'msg' => "Node #{@host} was skipped",
+              'details' => {}
+            }
+          ),
+          nil,
+          nil
+        )
       else
         # Try to extract the exit_code from _error
         begin

data/lib/bolt/node/winrm.rb

@@ -9,40 +9,52 @@ module Bolt
       'winrm'
     end
 
-    def initialize(host, port, user, password, shell: :powershell, **kwargs)
-      super(host, port, user, password, **kwargs)
+    def port
+      default_port = @insecure ? 5985 : 5986
+      @port || default_port
+    end
 
-      @shell = shell
-      @endpoint = "http://#{host}:#{port}/wsman"
+    def initialize(host, port, user, password, **kwargs)
+      super(host, port, user, password, **kwargs)
     end
 
     def connect
-      options = { endpoint: @endpoint,
+      if @insecure
+        scheme = 'http'
+        transport = :negotiate
+      else
+        scheme = 'https'
+        transport = :ssl
+      end
+      endpoint = "#{scheme}://#{host}:#{port}/wsman"
+      options = { endpoint: endpoint,
                   user: @user,
                   password: @password,
-                  retry_limit: 1 }
+                  retry_limit: 1,
+                  transport: transport,
+                  ca_trust_path: @cacert }
 
       Timeout.timeout(@connect_timeout) do
         @connection = ::WinRM::Connection.new(options)
         @connection.logger = @transport_logger
 
-        @session = @connection.shell(@shell)
+        @session = @connection.shell(:powershell)
         @session.run('$PSVersionTable.PSVersion')
         @logger.debug { "Opened session" }
       end
     rescue Timeout::Error
       raise Bolt::Node::ConnectError.new(
-        "Timeout after #{@connect_timeout} seconds connecting to #{@endpoint}",
+        "Timeout after #{@connect_timeout} seconds connecting to #{endpoint}",
         'CONNECT_ERROR'
       )
     rescue ::WinRM::WinRMAuthorizationError
       raise Bolt::Node::ConnectError.new(
-        "Authentication failed for #{@endpoint}",
+        "Authentication failed for #{endpoint}",
         'AUTH_ERROR'
       )
     rescue StandardError => e
       raise Bolt::Node::ConnectError.new(
-        "Failed to connect to #{@endpoint}: #{e.message}",
+        "Failed to connect to #{endpoint}: #{e.message}",
         'CONNECT_ERROR'
       )
     end

data/lib/bolt/node_uri.rb

@@ -7,13 +7,11 @@ module Bolt
     end
 
     def parse(string, transport)
-      uri = if string =~ %r{^[^:]+://}
-              Addressable::URI.parse(string)
-            else
-              Addressable::URI.parse("#{transport}://#{string}")
-            end
-      uri.port ||= 5985 if uri.scheme == 'winrm'
-      uri
+      if string =~ %r{^[^:]+://}
+        Addressable::URI.parse(string)
+      else
+        Addressable::URI.parse("#{transport}://#{string}")
+      end
     end
     private :parse
 

data/lib/bolt/outputter/human.rb

@@ -1,3 +1,4 @@
+require 'terminal-table'
 module Bolt
   class Outputter
     class Human < Bolt::Outputter
@@ -77,11 +78,69 @@ module Bolt
                             elapsed_time)
       end
 
+      def print_table(results)
+        @stream.puts Terminal::Table.new(
+          rows: results,
+          style: {
+            border_x: '',
+            border_y: '',
+            border_i: '',
+            padding_left: 0,
+            padding_right: 3,
+            border_top: false,
+            border_bottom: false
+          }
+        )
+      end
+
+      # @param [Hash] A hash representing the task
+      def print_task_info(task)
+        # Building lots of strings...
+        pretty_params = ""
+        task_info = ""
+        usage = "bolt task run --nodes, -n <node-name> #{task['name']}"
+
+        if task['parameters']
+          task['parameters'].each do |k, v|
+            pretty_params << "- #{k}: #{v['type']}\n"
+            pretty_params << "    #{v['description']}\n" if v['description']
+            usage << if !v['type'].to_s.include? "Optional"
+                       " #{k}=<value>"
+                     else
+                       " [#{k}=<value>]"
+                     end
+          end
+        end
+
+        usage << " [--noop]" if task['supports_noop']
+
+        task_info << "\n#{task['name']}"
+        task_info << " - #{task['description']}" if task['description']
+        task_info << "\n\n"
+        task_info << "USAGE:\n#{usage}\n\n"
+        task_info << "PARAMETERS:\n#{pretty_params}\n" if task['parameters']
+        @stream.puts(task_info)
+      end
+
       def print_plan(result)
-        @stream.puts result
+        # If a hash or array, pretty-print as JSON
+        if result.is_a?(Hash) || result.is_a?(Array)
+          if result.empty?
+            # Avoids extra lines for an empty result
+            @stream.puts(result.to_json)
+          else
+            @stream.puts(::JSON.pretty_generate(result))
+          end
+        else
+          @stream.puts result.to_s
+        end
       end
 
       def fatal_error(e); end
     end
+
+    def print_message(message)
+      @stream.puts(message)
+    end
   end
 end

data/lib/bolt/outputter/json.rb

@@ -43,7 +43,16 @@ module Bolt
                             elapsed_time)
       end
 
+      def print_table(results)
+        @stream.puts results.to_json
+      end
+
+      def print_task_info(task)
+        @stream.puts task.to_json
+      end
+
       def print_plan(result)
+        # Ruby JSON patches most objects to have a to_json method.
         @stream.puts result.to_json
       end
 
@@ -53,6 +62,8 @@ module Bolt
         @stream.puts e.to_json
         @stream.puts '}' if @object_open
       end
+
+      def print_message(message); end
     end
   end
 end

data/lib/bolt/target.rb

@@ -0,0 +1,32 @@
+module Bolt
+  class Target
+    attr_reader :host, :options
+
+    def self.from_asserted_hash(hash)
+      new(hash['host'], hash['options'])
+    end
+
+    def initialize(host, options = {})
+      @host = host
+      @options = options
+    end
+
+    def eql?(other)
+      self.class.equal?(other.class) && @host == other.host && @options == other.options
+    end
+    alias == eql?
+
+    def hash
+      @host.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
+    end
+  end
+end

data/lib/bolt/version.rb

@@ -1,3 +1,3 @@
 module Bolt
-  VERSION = '0.11.0'.freeze
+  VERSION = '0.12.0'.freeze
 end

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

@@ -0,0 +1,30 @@
+Puppet::DataTypes.create_type('ExecutionResult') do
+  interface <<-PUPPET
+    attributes => {
+      'result_hash' => Hash[
+        String[1],
+        Struct[
+          Optional[value] => Data,
+          Optional[error] => Struct[
+            msg => String[1],
+            Optional[kind] => String[1],
+            Optional[issue_code] => String[1],
+            Optional[details] => Hash[String[1], Data]]]]
+    },
+    functions => {
+      count => Callable[[], Integer],
+      empty => Callable[[], Boolean],
+      error_nodes => Callable[[], ExecutionResult],
+      names => Callable[[], Array[String[1]]],
+      ok => Callable[[], Boolean],
+      ok_nodes => Callable[[], ExecutionResult],
+      value => Callable[[String[1]], Variant[Error, Data]],
+      values => Callable[[], Array[Variant[Error,Data]]],
+      '[]' => Callable[[String[1]], Variant[Error, Data]]
+    }
+  PUPPET
+
+  load_file('bolt/executionresult')
+
+  implementation_class Bolt::ExecutionResult
+end

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

@@ -0,0 +1,12 @@
+Puppet::DataTypes.create_type('Target') do
+  interface <<-PUPPET
+    attributes => {
+      host => String[1],
+      options => { type => Hash[String[1], Data], value => {} }
+    }
+    PUPPET
+
+  load_file('bolt/target')
+
+  implementation_class Bolt::Target
+end

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

@@ -39,15 +39,15 @@ 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) ? Puppet::Pops::Types::TypeFactory.target.create(t) : t }
+    targets = targets.flatten.map { |t| t.is_a?(String) ? Bolt::Target.new(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
+      Bolt::ExecutionResult::EMPTY_RESULT
     else
       # Awaits change in the executor, enabling it receive Target instances
       hosts = targets.map(&:host)
 
-      Puppet::Pops::Types::ExecutionResult.from_bolt(
+      Bolt::ExecutionResult.from_bolt(
         executor.file_upload(executor.from_uris(hosts), found, destination)
       )
     end

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

@@ -30,16 +30,16 @@ 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) ? Puppet::Pops::Types::TypeFactory.target.create(t) : t }
+    targets = targets.flatten.map { |t| t.is_a?(String) ? Bolt::Target.new(t) : t }
 
     if targets.empty?
       call_function('debug', "Simulating run_command('#{command}') - no targets given - no action taken")
-      Puppet::Pops::Types::ExecutionResult::EMPTY_RESULT
+      Bolt::ExecutionResult::EMPTY_RESULT
     else
       # Awaits change in the executor, enabling it receive Target instances
       hosts = targets.map(&:host)
 
-      Puppet::Pops::Types::ExecutionResult.from_bolt(executor.run_command(executor.from_uris(hosts), command))
+      Bolt::ExecutionResult.from_bolt(executor.run_command(executor.from_uris(hosts), command))
     end
   end
 end

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

@@ -54,15 +54,15 @@ 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) ? Puppet::Pops::Types::TypeFactory.target.create(t) : t }
+    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")
-      Puppet::Pops::Types::ExecutionResult::EMPTY_RESULT
+      Bolt::ExecutionResult::EMPTY_RESULT
     else
       # Awaits change in the executor, enabling it receive Target instances
       hosts = targets.map(&:host)
 
-      Puppet::Pops::Types::ExecutionResult.from_bolt(
+      Bolt::ExecutionResult.from_bolt(
         executor.run_script(executor.from_uris(hosts), found, args_hash['arguments'])
       )
     end

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

@@ -25,7 +25,7 @@ Puppet::Functions.create_function(:run_task) do
   end
 
   def run_task(task_name, targets, task_args = nil)
-    Puppet::Pops::Types::ExecutionResult.from_bolt(
+    Bolt::ExecutionResult.from_bolt(
       run_task_raw(task_name, targets, task_args)
     )
   end
@@ -58,9 +58,17 @@ Puppet::Functions.create_function(:run_task) do
     end || (raise Puppet::ParseError, 'Task parameters did not match')
     task = task_signature.task
 
+    if executor.noop
+      if task.supports_noop
+        use_args['_noop'] = true
+      else
+        raise Puppet::ParseError, 'Task does not support noop'
+      end
+    end
+
     # 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) ? Puppet::Pops::Types::TypeFactory.target.create(t) : t }
+    targets = targets.flatten.map { |t| t.is_a?(String) ? Bolt::Target.new(t) : t }
     if targets.empty?
       call_function('debug', "Simulating run of task #{task.name} - no targets given - no action taken")
       Puppet::Pops::EMPTY_HASH