bolt 0.19.0 → 0.19.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a2227748b6143c5d3515d1c9f24faaf212eb30b7
-  data.tar.gz: 5547e32cf4a0d588a201c4b011bb2c9fffae983f
+  metadata.gz: 67a9420306d6fd8eabb25f62ef540cd54105c9c4
+  data.tar.gz: 7247ca058c6d039f19a7967614c776b4d6fbaf09
 SHA512:
-  metadata.gz: 4c628c28a11c9779918352684e2ce04ab3ff078ede27694f669312d63ac9329e1538ee870bb8238efb1cc81a8b2ef1e6d44af92f550173fe16f2d274cd1d0de1
-  data.tar.gz: c0fdcf6f47139a80565fe393f9ad079dac585dab2cc5b490ea1db5e526be898878e0e544d0704504ca09a5ecfa9471611764f0089ea9610b2e64f2f0c49d11e5
+  metadata.gz: bbb8e273a0eb95d656003813d2b785043008edc828494663bf784111079e3065e2389e03c45b2ba9a4fe15c7536a1f59f4ed473b6d30634cec982b3c6c31af75
+  data.tar.gz: 4ae498d40e34ae98de03190b23099181f62db5fe02db1da84a34b591176d46828249aad0b6f8084448eb2d35f56c6e98f334c72d33845b4a64a2ed7e099c6fca

data/bolt-modules/boltlib/lib/puppet/functions/run_plan.rb

@@ -39,43 +39,44 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
     # 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))
-      # TODO: Add profiling around this
-      if (run_as = named_args['_run_as'])
-        old_run_as = executor.run_as
-        executor.run_as = run_as
-      end
 
-      begin
-        # If the plan does not throw :return by calling the return function it's result is
-        # undef/nil
-        result = catch(:return) do
-          func.class.dispatcher.dispatchers[0].call_by_name_with_scope(scope, params, true)
-          nil
-        end&.value
-        # Validate the result is a PlanResult
-        unless Puppet::Pops::Types::TypeParser.singleton.parse('Boltlib::PlanResult').instance?(result)
-          raise Bolt::InvalidPlanResult.new(plan_name, result.to_s)
-        end
-        result
-      rescue Puppet::PreformattedError => err
-        if named_args['_catch_errors'] && err.cause.is_a?(Bolt::Error)
-          result = err.cause.to_puppet_error
-        else
-          raise err
-        end
-      ensure
-        if run_as
-          executor.run_as = old_run_as
-        end
-      end
+    # TODO: Why would we not have a private_environment_loader?
+    unless loader && (func = loader.load(:plan, plan_name))
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues.issue(:UNKNOWN_PLAN) { Bolt::Error.unknown_plan(plan_name) }
+      )
+    end
 
-      return result
+    # TODO: Add profiling around this
+    if (run_as = named_args['_run_as'])
+      old_run_as = executor.run_as
+      executor.run_as = run_as
+    end
+    result = nil
+    begin
+      # If the plan does not throw :return by calling the return function it's result is
+      # undef/nil
+      result = catch(:return) do
+        func.class.dispatcher.dispatchers[0].call_by_name_with_scope(scope, params, true)
+        nil
+      end&.value
+      # Validate the result is a PlanResult
+      unless Puppet::Pops::Types::TypeParser.singleton.parse('Boltlib::PlanResult').instance?(result)
+        raise Bolt::InvalidPlanResult.new(plan_name, result.to_s)
+      end
+      result
+    rescue Puppet::PreformattedError => err
+      if named_args['_catch_errors'] && err.cause.is_a?(Bolt::Error)
+        result = err.cause.to_puppet_error
+      else
+        raise err
+      end
+    ensure
+      if run_as
+        executor.run_as = old_run_as
+      end
     end
 
-    # Could not find plan
-    raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-      Puppet::Pops::Issues.issue(:UNKNOWN_PLAN) { Bolt::Error.unknown_plan(plan_name) }
-    )
+    result
   end
 end

data/lib/bolt/cli.rb

@@ -243,6 +243,9 @@ Available options are:
         define('--format FORMAT', 'Output format to use: human or json') do |format|
           @options[:format] = format
         end
+        define('--[no-]color', 'Whether to show output in color') do |color|
+          @options[:color] = color
+        end
         define('-h', '--help', 'Display help') do |_|
           @options[:help] = true
         end
@@ -529,11 +532,20 @@ Available options are:
           end
           options[:task_options]['nodes'] = options[:nodes].join(',')
         end
-        executor = Bolt::Executor.new(config, options[:noop], true)
+        params = options[:noop] ? options[:task_options].merge("_noop" => true) : options[:task_options]
+        plan_context = { plan_name: options[:object],
+                         params: params }
+        plan_context[:description] = options[:description] if options[:description]
+
+        executor = Bolt::Executor.new(config, options[:noop])
+        executor.start_plan(plan_context)
         result = pal.run_plan(options[:object], options[:task_options], executor, inventory, puppetdb_client)
+
+        # If a non-bolt exeception bubbles up the plan won't get finished
+        # TODO: finish the plan once ORCH-2224
+        # executor.finish_plan(result)
         outputter.print_plan_result(result)
-        # An exception would have been raised if the plan failed
-        code = 0
+        code = result.ok? ? 0 : 1
       else
         executor = Bolt::Executor.new(config, options[:noop])
         targets = options[:targets]
@@ -614,7 +626,7 @@ Available options are:
     end
 
     def outputter
-      @outputter ||= Bolt::Outputter.for_format(config[:format])
+      @outputter ||= Bolt::Outputter.for_format(config[:format], config[:color])
     end
   end
 end

data/lib/bolt/config.rb

@@ -30,6 +30,7 @@ module Bolt
     :log,
     :modulepath,
     :puppetdb,
+    :color,
     :transport,
     :transports
   ) do
@@ -39,7 +40,8 @@ module Bolt
       transport: 'ssh',
       format: 'human',
       modulepath: [],
-      puppetdb: {}
+      puppetdb: {},
+      color: true
     }.freeze
 
     TRANSPORT_OPTIONS = %i[password run-as sudo-password extensions
@@ -129,8 +131,8 @@ module Bolt
         self[:modulepath] = data['modulepath'].split(File::PATH_SEPARATOR)
       end
 
-      %w[inventoryfile concurrency format puppetdb].each do |key|
-        if data[key]
+      %w[inventoryfile concurrency format puppetdb color].each do |key|
+        if data.key?(key)
           self[key.to_sym] = data[key]
         end
       end
@@ -150,8 +152,8 @@ module Bolt
     end
 
     def update_from_cli(options)
-      %i[concurrency transport format modulepath inventoryfile].each do |key|
-        self[key] = options[key] if options[key]
+      %i[concurrency transport format modulepath inventoryfile color].each do |key|
+        self[key] = options[key] if options.key?(key)
       end
 
       if options[:debug]

data/lib/bolt/error.rb

@@ -65,10 +65,6 @@ module Bolt
   end
 
   class PuppetError < Error
-    def self.convert_puppet_errors(result)
-      Bolt::Util.walk_vals(result) { |v| v.is_a?(Puppet::DataTypes::Error) ? from_error(v) : v }
-    end
-
     def self.from_error(err)
       new(err.msg, err.kind, err.details, err.issue_code)
     end

data/lib/bolt/executor.rb

@@ -16,10 +16,10 @@ module Bolt
     attr_reader :noop, :transports
     attr_accessor :run_as
 
-    def initialize(config = Bolt::Config.new, noop = nil, plan_logging = false)
+    def initialize(config = Bolt::Config.new, noop = nil)
       @config = config
       @logger = Logging.logger[self]
-      @plan_logging = plan_logging
+      @plan_logging = false
 
       @transports = Bolt::TRANSPORTS.each_with_object({}) do |(key, val), coll|
         coll[key.to_s] = Concurrent::Delay.new { val.new }
@@ -34,19 +34,12 @@ module Bolt
 
     def transport(transport)
       impl = @transports[transport || 'ssh']
+      raise(Bolt::UnknownTransportError, transport) unless impl
       # If there was an error creating the transport, ensure it gets thrown
       impl.no_error!
       impl.value
     end
 
-    def summary(description, result)
-      fc = result.error_set.length
-      npl = result.length == 1 ? '' : 's'
-      fpl = fc == 1 ? '' : 's'
-      "Finished: #{description} on #{result.length} node#{npl} with #{fc} failure#{fpl}"
-    end
-    private :summary
-
     # Execute the given block on a list of nodes in parallel, one thread per "batch".
     #
     # This is the main driver of execution on a list of targets. It first
@@ -93,9 +86,27 @@ module Bolt
       ResultSet.new(promises.map(&:value))
     end
 
-    # When running a plan, info messages like starting a task are promoted to notice.
-    def log_action(msg)
-      @plan_logging ? @logger.notice(msg) : @logger.info(msg)
+    def log_action(description, targets)
+      # When running a plan, info messages like starting a task are promoted to notice.
+      log_method = @plan_logging ? :notice : :info
+      target_str = if targets.length > 5
+                     "#{targets.count} targets"
+                   else
+                     targets.map(&:uri).join(', ')
+                   end
+
+      @logger.send(log_method, "Starting: #{description} on #{target_str}")
+
+      start_time = Time.now
+      results = yield
+      duration = Time.now - start_time
+
+      failures = results.error_set.length
+      plural = failures == 1 ? '' : 's'
+
+      @logger.send(log_method, "Finished: #{description} with #{failures} failure#{plural} in #{duration.round(2)} sec")
+
+      results
     end
     private :log_action
 
@@ -109,72 +120,89 @@ module Bolt
 
     def run_command(targets, command, options = {}, &callback)
       description = options.fetch('_description', "command '#{command}'")
-      log_action("Starting: #{description} on #{targets.map(&:uri)}")
-      notify = proc { |event| @notifier.notify(callback, event) if callback }
-      options = { '_run_as' => run_as }.merge(options) if run_as
+      log_action(description, targets) do
+        notify = proc { |event| @notifier.notify(callback, event) if callback }
+        options = { '_run_as' => run_as }.merge(options) if run_as
 
-      results = batch_execute(targets) do |transport, batch|
-        with_node_logging("Running command '#{command}'", batch) do
-          transport.batch_command(batch, command, options, &notify)
+        results = batch_execute(targets) do |transport, batch|
+          with_node_logging("Running command '#{command}'", batch) do
+            transport.batch_command(batch, command, options, &notify)
+          end
         end
-      end
 
-      log_action(summary(description, results))
-      @notifier.shutdown
-      results
+        @notifier.shutdown
+        results
+      end
     end
 
     def run_script(targets, script, arguments, options = {}, &callback)
       description = options.fetch('_description', "script #{script}")
-      log_action("Starting: #{description} on #{targets.map(&:uri)}")
+      log_action(description, targets) do
+        notify = proc { |event| @notifier.notify(callback, event) if callback }
+        options = { '_run_as' => run_as }.merge(options) if run_as
 
-      notify = proc { |event| @notifier.notify(callback, event) if callback }
-      options = { '_run_as' => run_as }.merge(options) if run_as
-
-      results = batch_execute(targets) do |transport, batch|
-        with_node_logging("Running script #{script} with '#{arguments}'", batch) do
-          transport.batch_script(batch, script, arguments, options, &notify)
+        results = batch_execute(targets) do |transport, batch|
+          with_node_logging("Running script #{script} with '#{arguments}'", batch) do
+            transport.batch_script(batch, script, arguments, options, &notify)
+          end
         end
-      end
 
-      log_action(summary(description, results))
-      @notifier.shutdown
-      results
+        @notifier.shutdown
+        results
+      end
     end
 
     def run_task(targets, task, arguments, options = {}, &callback)
       description = options.fetch('_description', "task #{task.name}")
-      log_action("Starting: #{description} on #{targets.map(&:uri)}")
+      log_action(description, targets) do
+        notify = proc { |event| @notifier.notify(callback, event) if callback }
+        options = { '_run_as' => run_as }.merge(options) if run_as
 
-      notify = proc { |event| @notifier.notify(callback, event) if callback }
-      options = { '_run_as' => run_as }.merge(options) if run_as
-
-      results = batch_execute(targets) do |transport, batch|
-        with_node_logging("Running task #{task.name} with '#{arguments}' via #{task.input_method}", batch) do
-          transport.batch_task(batch, task, arguments, options, &notify)
+        results = batch_execute(targets) do |transport, batch|
+          with_node_logging("Running task #{task.name} with '#{arguments}' via #{task.input_method}", batch) do
+            transport.batch_task(batch, task, arguments, options, &notify)
+          end
         end
-      end
 
-      log_action(summary(description, results))
-      @notifier.shutdown
-      results
+        @notifier.shutdown
+        results
+      end
     end
 
     def file_upload(targets, source, destination, options = {}, &callback)
       description = options.fetch('_description', "file upload from #{source} to #{destination}")
-      log_action("Starting: #{description} on #{targets.map(&:uri)}")
-      notify = proc { |event| @notifier.notify(callback, event) if callback }
-      options = { '_run_as' => run_as }.merge(options) if run_as
+      log_action(description, targets) do
+        notify = proc { |event| @notifier.notify(callback, event) if callback }
+        options = { '_run_as' => run_as }.merge(options) if run_as
 
-      results = batch_execute(targets) do |transport, batch|
-        with_node_logging("Uploading file #{source} to #{destination}", batch) do
-          transport.batch_upload(batch, source, destination, options, &notify)
+        results = batch_execute(targets) do |transport, batch|
+          with_node_logging("Uploading file #{source} to #{destination}", batch) do
+            transport.batch_upload(batch, source, destination, options, &notify)
+          end
         end
+
+        @notifier.shutdown
+        results
       end
+    end
 
-      log_action(summary(description, results))
-      @notifier.shutdown
-      results
+    # Plan context doesn't make sense for most transports but it is tightly
+    # coupled with the orchestrator transport since the transport behaves
+    # differently when a plan is running. In order to limit how much this
+    # pollutes the transport API we only handle the orchestrator transport here.
+    # Since we callt this function without resolving targets this will result
+    # in the orchestrator transport always being initialized during plan runs.
+    # For now that's ok.
+    #
+    # In the future if other transports need this or if we want a plan stack
+    # we'll need to refactor.
+    def start_plan(plan_context)
+      transport('pcp').plan_context = plan_context
+      @plan_logging = true
+    end
+
+    def finish_plan(plan_result)
+      transport('pcp').finish_plan(plan_result)
     end
   end
 end

data/lib/bolt/logger.rb

@@ -16,19 +16,29 @@ module Bolt
 
       Logging.init :debug, :info, :notice, :warn, :error, :fatal, :any
 
+      Logging.color_scheme(
+        'bolt',
+        lines: {
+          notice: :green,
+          warn: :yellow,
+          error: :red,
+          fatal: %i[white on_red]
+        }
+      )
+    end
+
+    def self.configure(config)
       root_logger = Logging.logger[:root]
+
       root_logger.add_appenders Logging.appenders.stderr(
         'console',
-        layout: default_layout,
+        layout: console_layout(config[:color]),
         level: default_level
       )
+
       # We set the root logger's level so that it logs everything but we do
       # limit what's actually logged in every appender individually.
       root_logger.level = :all
-    end
-
-    def self.configure(config)
-      root_logger = Logging.logger[:root]
 
       config[:log].each_pair do |name, params|
         appender = Logging.appenders[name]
@@ -56,8 +66,16 @@ module Bolt
       end
     end
 
+    def self.console_layout(color)
+      color_scheme = :bolt if color
+      Logging.layouts.pattern(
+        pattern: '%m\n',
+        color_scheme: color_scheme
+      )
+    end
+
     def self.default_layout
-      @default_layout ||= Logging.layouts.pattern(
+      Logging.layouts.pattern(
         pattern: '%d %-6l %c: %m\n',
         date_pattern: '%Y-%m-%dT%H:%M:%S.%6N'
       )

data/lib/bolt/outputter.rb

@@ -2,18 +2,19 @@
 
 module Bolt
   class Outputter
-    def self.for_format(format)
+    def self.for_format(format, color)
       case format
       when 'human'
-        Bolt::Outputter::Human.new
+        Bolt::Outputter::Human.new(color)
       when 'json'
-        Bolt::Outputter::JSON.new
+        Bolt::Outputter::JSON.new(color)
       when nil
         raise "Cannot use outputter before parsing."
       end
     end
 
-    def initialize(stream = $stdout)
+    def initialize(color, stream = $stdout)
+      @color = color
       @stream = stream
     end
 

data/lib/bolt/outputter/human.rb

@@ -11,7 +11,7 @@ module Bolt
       def print_head; end
 
       def colorize(color, string)
-        if @stream.isatty
+        if @color && @stream.isatty
           "\033[#{COLORS[color]}m#{string}\033[0m"
         else
           string

data/lib/bolt/outputter/json.rb

@@ -3,11 +3,11 @@
 module Bolt
   class Outputter
     class JSON < Bolt::Outputter
-      def initialize(stream = $stdout)
+      def initialize(color, stream = $stdout)
         @items_open = false
         @object_open = false
         @preceding_item = false
-        super(stream)
+        super(color, stream)
       end
 
       def print_head

data/lib/bolt/pal.rb

@@ -2,6 +2,7 @@
 
 require 'bolt/executor'
 require 'bolt/error'
+require 'bolt/plan_result'
 
 module Bolt
   class PAL
@@ -12,7 +13,7 @@ module Bolt
       # Nothing works without initialized this global state. Reinitializing
       # is safe and in practice only happen in tests
       self.class.load_puppet
-      self.class.configure_logging
+
       # This makes sure we don't accidentally create puppet dirs
       with_puppet_settings { |_| nil }
 
@@ -21,7 +22,10 @@ module Bolt
 
     # Puppet logging is global so this is class method to avoid confusion
     def self.configure_logging
-      Puppet::Util::Log.newdestination(:console)
+      Puppet::Util::Log.newdestination(Logging.logger['Puppet'])
+      # Defer all log level decisions to the Logging library by telling Puppet
+      # to log everything
+      Puppet.settings[:log_level] = 'debug'
     end
 
     def self.load_puppet
@@ -39,6 +43,8 @@ module Bolt
         raise Bolt::CLIError, "Puppet must be installed to execute tasks"
       end
 
+      require 'bolt/pal/logging'
+
       # Now that puppet is loaded we can include puppet mixins in data types
       Bolt::ResultSet.include_iterable
     end
@@ -130,6 +136,7 @@ module Bolt
         end
         Puppet.settings.send(:clear_everything_for_tests)
         Puppet.initialize_settings(cli)
+        self.class.configure_logging
         yield
       end
     end
@@ -229,8 +236,10 @@ module Bolt
     def run_plan(plan_name, params, executor = nil, inventory = nil, pdb_client = nil)
       in_plan_compiler(executor, inventory, pdb_client) do |compiler|
         r = compiler.call_function('run_plan', plan_name, params)
-        Bolt::PuppetError.convert_puppet_errors(r)
+        Bolt::PlanResult.from_pcore(r, 'success')
       end
+    rescue Bolt::Error => e
+      Bolt::PlanResult.new(e, 'failure')
     end
   end
 end

data/lib/bolt/pal/logging.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+Puppet::Util::Log.newdesttype :logging do
+  match "Logging::Logger"
+
+  # Bolt log levels don't match exactly with Puppet log levels, so we use
+  # an explicit mapping.
+  def initialize(logger)
+    @external_logger = logger
+
+    @log_level_map = {
+      debug: :debug,
+      info: :info,
+      notice: :notice,
+      warning: :warn,
+      err: :error,
+      # Nothing in Puppet actually uses alert, emerg or crit, so it's hard to say
+      # what they indicate, but they sound pretty bad.
+      alert: :error,
+      emerg: :fatal,
+      crit: :fatal
+    }
+  end
+
+  def handle(log)
+    @external_logger.send(@log_level_map[log.level], log.to_s)
+  end
+end

data/lib/bolt/plan_result.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'bolt/error'
+require 'bolt/util'
+
+module Bolt
+  class PlanResult
+    attr_accessor :value, :status
+
+    # This must be called from inside a compiler
+    def self.from_pcore(result, status)
+      result = Bolt::Util.walk_vals(result) do |v|
+        if v.is_a?(Puppet::DataTypes::Error)
+          Bolt::PuppetError.from_error(v)
+        else
+          v
+        end
+      end
+      new(result, status)
+    end
+
+    def initialize(value, status)
+      @value = value
+      @status = status
+    end
+
+    def ok?
+      @status == 'success'
+    end
+
+    def ==(other)
+      value == other.value && status == other.status
+    end
+
+    def to_json(*args)
+      @value.to_json(*args)
+    end
+  end
+end

data/lib/bolt/transport/orch.rb

@@ -5,6 +5,7 @@ require 'concurrent'
 require 'json'
 require 'orchestrator_client'
 require 'bolt/transport/base'
+require 'bolt/transport/orch/connection'
 require 'bolt/result'
 
 module Bolt
@@ -15,6 +16,8 @@ module Bolt
       BOLT_SCRIPT_TASK = Struct.new(:name).new('bolt_shim::script').freeze
       BOLT_UPLOAD_TASK = Struct.new(:name).new('bolt_shim::upload').freeze
 
+      attr_writer :plan_context
+
       def self.options
         %w[service-url cacert token-file task-environment local-validation]
       end
@@ -26,30 +29,31 @@ module Bolt
         end
       end
 
-      def create_client(opts)
-        client_keys = %i[service-url token-file cacert]
-        client_opts = opts.reduce({}) do |acc, (k, v)|
-          if client_keys.include?(k)
-            acc.merge(k.to_s => v)
-          else
-            acc
+      def initialize(*args)
+        @connections = {}
+        super
+      end
+
+      def finish_plan(result)
+        if result.is_a? Bolt::PlanResult
+          @connections.each_value do |conn|
+            begin
+              conn.finish_plan(result)
+            rescue StandardError => e
+              @logger.error("Failed to finish plan on #{conn.key}: #{e.message}")
+            end
           end
         end
-        logger.debug("Creating orchestrator client for #{client_opts}")
-
-        OrchestratorClient.new(client_opts, true)
       end
 
-      def build_request(targets, task, arguments, description = nil)
-        body = { task: task.name,
-                 environment: targets.first.options["task-environment"],
-                 noop: arguments['_noop'],
-                 params: arguments.reject { |k, _| k == '_noop' },
-                 scope: {
-                   nodes: targets.map(&:host)
-                 } }
-        body[:description] = description if description
-        body
+      # It's safe to create connections here for now because the
+      # batches/threads are per connection.
+      def get_connection(conn_opts)
+        key = Connection.get_key(conn_opts)
+        unless (conn = @connections[key])
+          conn = @connections[key] = Connection.new(conn_opts, @plan_context, logger)
+        end
+        conn
       end
 
       def process_run_results(targets, results)
@@ -134,22 +138,16 @@ module Bolt
       end
 
       def batches(targets)
-        targets.group_by do |target|
-          [target.options['task-environment'],
-           target.options['service-url'],
-           target.options['token-file']]
-        end.values
+        targets.group_by { |target| Connection.get_key(target.options) }.values
       end
 
       def run_task_job(targets, task, arguments, options)
-        body = build_request(targets, task, arguments, options['_description'])
-
         targets.each do |target|
           yield(type: :node_start, target: target) if block_given?
         end
 
         begin
-          results = create_client(targets.first.options).run_task(body)
+          results = get_connection(targets.first.options).run_task(targets, task, arguments, options)
 
           process_run_results(targets, results)
         rescue OrchestratorClient::ApiError => e

data/lib/bolt/transport/orch/connection.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Bolt
+  module Transport
+    class Orch < Base
+      class Connection
+        attr_reader :logger, :key
+
+        CONTEXT_KEYS = Set.new(%i[plan_name description params]).freeze
+
+        def self.get_key(opts)
+          [
+            opts['service-url'],
+            opts['task-environment'],
+            opts['token-file']
+          ].join('-')
+        end
+
+        def initialize(opts, plan_context, logger)
+          @logger = logger
+          @key = self.class.get_key(opts)
+          client_keys = %w[service-url token-file cacert]
+          client_opts = client_keys.each_with_object({}) do |k, acc|
+            acc[k] = opts[k] if opts.include?(k)
+          end
+          logger.debug("Creating orchestrator client for #{client_opts}")
+
+          @client = OrchestratorClient.new(client_opts, true)
+          @plan_job = start_plan(plan_context)
+
+          @environment = opts["task-environment"]
+        end
+
+        def start_plan(plan_context)
+          if plan_context
+            begin
+              opts = plan_context.select { |k, _| CONTEXT_KEYS.include? k }
+              @client.command.plan_start(opts)['name']
+            rescue OrchestratorClient::ApiError => e
+              if e.code == '404'
+                @logger.debug("Orchestrator #{key} does not support plans")
+              else
+                @logger.error("Failed to start a plan with orchestrator #{key}: #{e.message}")
+              end
+              nil
+            end
+          end
+        end
+
+        def finish_plan(plan_result)
+          if @plan_job
+            @client.command.plan_finish(
+              plan_job: @plan_job,
+              result: plan_result.value,
+              status: plan_result.status
+            )
+          end
+        end
+
+        def build_request(targets, task, arguments, description = nil)
+          body = { task: task.name,
+                   environment: @environment,
+                   noop: arguments['_noop'],
+                   params: arguments.reject { |k, _| k == '_noop' },
+                   scope: {
+                     nodes: targets.map(&:host)
+                   } }
+          body[:description] = description if description
+          body[:plan_job] = @plan_job if @plan_job
+          body
+        end
+
+        def run_task(targets, task, arguments, options)
+          body = build_request(targets, task, arguments, options['_description'])
+          @client.run_task(body)
+        end
+      end
+    end
+  end
+end

data/lib/bolt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bolt
-  VERSION = '0.19.0'
+  VERSION = '0.19.1'
 end

data/modules/apply/tasks/resource.json

@@ -0,0 +1,18 @@
+{
+  "description": "Apply a single Puppet resource",
+  "input_method": "stdin",
+  "parameters": {
+    "type": {
+      "description": "The type of resource to apply",
+      "type": "String[1]"
+    },
+    "title": {
+      "description": "The title of the resource to apply",
+      "type": "String[1]"
+    },
+    "params": {
+      "description": "A map of parameter names and values to apply",
+      "type": "Optional[Hash[String[1], Data]]"
+    }
+  }
+}

data/modules/apply/tasks/resource.rb

@@ -0,0 +1,98 @@
+#!/opt/puppetlabs/puppet/bin/ruby
+# frozen_string_literal: true
+
+require 'json'
+require 'puppet'
+
+def apply_resource(type, title, params)
+  result = {
+    type: type,
+    title: title,
+    changed: false,
+  }
+
+  resource = Puppet::Resource.new(type, title, parameters: params)
+
+  # Configure the indirection to manage the resource locally and not cache it anywhere else
+  Puppet::Resource.indirection.terminus_class = :ral
+  Puppet::Resource.indirection.cache_class = nil
+
+  _saved_resource, report = Puppet::Resource.indirection.save(resource)
+
+  # This step is necessary to compute the report "status"
+  report.finalize_report
+
+  resource_status = report.resource_statuses.values.first
+
+  # Non-existent resource types and strange built-in types like Whit and Stage
+  # cause no resource to be managed.
+  unless resource_status
+    result[:_error] = { msg: "Invalid resource type #{type}",
+                        kind: 'apply/type-not-found',
+                        details: {} }
+    return result
+  end
+
+  # XXX currently ignoring noop and audit events
+  failures = resource_status.events.select { |event| event.status == 'failure' }
+  changes = resource_status.events.select { |event| event.status == 'success' }
+
+  if failures.any?
+    result[:failures] = failures.map do |event|
+      {
+        property: event.property,
+        previous_value: event.previous_value,
+        desired_value: event.desired_value,
+        message: event.message,
+      }
+    end
+  end
+
+  if changes.any?
+    result[:changes] = changes.map do |event|
+      {
+        property: event.property,
+        previous_value: event.previous_value,
+        desired_value: event.desired_value,
+        message: event.message,
+      }
+    end
+  end
+
+  result[:changed] = true if resource_status.changed?
+
+  if report.status == 'failed'
+    error_message = failures.map(&:message).join("\n").strip
+
+    result[:_error] = { msg: error_message,
+                        kind: 'apply/resource-failure',
+                        details: {} }
+  end
+
+  result
+rescue StandardError => e
+  result[:_error] = {
+    msg: "Could not manage resource: #{e}",
+    kind: 'apply/unknown-error',
+    details: {},
+  }
+  result
+end
+
+args = JSON.parse(STDIN.read)
+
+type = args['type']
+title = args['title']
+params = args['params'] || {}
+
+# Required to find pluginsync'd plugins
+Puppet.initialize_settings
+
+Puppet[:noop] = false
+
+result = apply_resource(type, title, params)
+exitcode = result.key?(:_error) ? 1 : 0
+
+puts result.to_json
+
+exit exitcode

data/modules/service/tasks/linux.json

@@ -0,0 +1,14 @@
+{
+  "description": "Manage the state of services (without a puppet agent)",
+  "input_method": "environment",
+  "parameters": {
+    "action": {
+      "description": "The operation (start, stop) to perform on the service",
+      "type": "Enum[start, stop, restart]"
+    },
+    "name": {
+      "description": "The name of the service to operate on.",
+      "type": "String[1]"
+    }
+  }
+}

data/modules/service/tasks/linux.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+
+action="$PT_action"
+name="$PT_name"
+service_managers[0]="systemctl"
+service_managers[1]="service"
+service_managers[2]="initctl"
+
+# example cli /opt/puppetlabs/puppet/bin/bolt  task run service::linux action=stop name=ntp --nodes localhost --modulepath /etc/puppetlabs/code/modules --password puppet --user root
+
+check_command_exists() {
+  (which "$1") > /dev/null 2>&1
+  command_exists=$?
+  return $command_exists
+}
+
+for service_manager in "${service_managers[@]}"
+do
+  check_command_exists "$service_manager"
+  command_exists=$?
+  if [ $command_exists -eq 0 ]; then
+    command_line="$service_manager $action $name"
+    if [ $service_manager == "service" ]; then
+      command_line="$service_manager $name $action"
+    fi
+    output=$($command_line 2>&1)
+    status_from_command=$?
+    # set up our status and exit code
+    if [ $status_from_command -eq 0 ]; then
+      echo "{ \"status\": \"$name $action\" }"
+      exit 0
+    else
+      # initd is special, starting an already started service is an error
+      if [[ $service_manager == "service" && "$output" == *"Job is already running"* ]]; then
+        echo "{ \"status\": \"$name $action\" }"
+        exit 0
+      fi
+      echo "{ \"status\": \"unable to run command '$command_line'\" }"
+      exit $status_from_command
+    fi
+  fi
+done
+
+echo "{ \"status\": \"No service managers found\" }"
+exit 255

data/modules/service/tasks/windows.json

@@ -0,0 +1,14 @@
+{
+  "description": "Manage the state of Windows services (without a puppet agent)",
+  "input_method": "powershell",
+  "parameters": {
+    "action": {
+      "description": "The operation (start, stop, restart, status) to perform on the service",
+      "type": "Enum[start, stop, restart, status]"
+    },
+    "name": {
+      "description": "The short name of the Windows service to operate on.",
+      "type": "String[1]"
+    }
+  }
+}

data/modules/service/tasks/windows.ps1

@@ -0,0 +1,85 @@
+[CmdletBinding()]
+param(
+  # NOTE: init.json cannot yet be shared, so must have windows.json / windows.ps1
+  [Parameter(Mandatory = $true)]
+  [String]
+  $Name,
+
+  [Parameter(Mandatory = $true)]
+  [ValidateSet('start', 'stop', 'restart', 'status')]
+  [String]
+  $Action
+)
+
+$ErrorActionPreference = 'Stop'
+
+function Invoke-ServiceAction($Service, $Action)
+{
+  $inSyncStatus = 'in_sync'
+  $status = $null
+
+  switch ($Action)
+  {
+    'start'
+    {
+      if ($Service.Status -eq 'Running') { $status = $InSyncStatus }
+      else { Start-Service $Service }
+    }
+    'stop'
+    {
+      if ($Service.Status -eq 'Stopped') { $status = $InSyncStatus }
+      else { Stop-Service $Service }
+    }
+    'restart'
+    {
+      Restart-Service $Service
+      $status = 'restarted'
+    }
+    # no-op since status always returned
+    'status' { }
+  }
+
+  # user action
+  if ($status -eq $null)
+  {
+    # https://msdn.microsoft.com/en-us/library/system.serviceprocess.servicecontrollerstatus(v=vs.110).aspx
+    # ContinuePending, Paused, PausePending, Running, StartPending, Stopped, StopPending
+    $status = $Service.Status
+    if ($status -eq 'Running') { $status = 'started' }
+  }
+
+  return $status
+}
+
+try
+{
+  $service = Get-Service -Name $Name
+  $status = Invoke-ServiceAction -Service $service -Action $action
+
+# TODO: could use ConvertTo-Json, but that requires PS3
+# if embedding in literal, should make sure Name / Status doesn't need escaping
+Write-Host @"
+{
+  "name"        : "$($service.Name)",
+  "action"      : "$Action",
+  "displayName" : "$($service.DisplayName)",
+  "status"      : "$status",
+  "startType"   : "$($service.StartType)"
+}
+"@
+}
+catch
+{
+  Write-Host @"
+  {
+    "status"  : "failure",
+    "name"    : "$Name",
+    "action"  : "$Action",
+    "_error"  : {
+      "msg" : "Unable to perform '$Action' on '$Name': $($_.Exception.Message)",
+      "kind": "powershell_error",
+      "details" : {}
+    }
+  }
+"@
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.19.1
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-04-11 00:00:00.000000000 Z
+date: 2018-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: 0.2.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: 0.2.4
 - !ruby/object:Gem::Dependency
   name: terminal-table
   requirement: !ruby/object:Gem::Requirement
@@ -347,6 +347,8 @@ files:
 - lib/bolt/outputter/human.rb
 - lib/bolt/outputter/json.rb
 - lib/bolt/pal.rb
+- lib/bolt/pal/logging.rb
+- lib/bolt/plan_result.rb
 - lib/bolt/puppetdb.rb
 - lib/bolt/puppetdb/client.rb
 - lib/bolt/puppetdb/config.rb
@@ -357,6 +359,7 @@ files:
 - lib/bolt/transport/local.rb
 - lib/bolt/transport/local/shell.rb
 - lib/bolt/transport/orch.rb
+- lib/bolt/transport/orch/connection.rb
 - lib/bolt/transport/ssh.rb
 - lib/bolt/transport/ssh/connection.rb
 - lib/bolt/transport/winrm.rb
@@ -369,6 +372,8 @@ files:
 - modules/aggregate/lib/puppet/functions/aggregate/nodes.rb
 - modules/aggregate/plans/count.pp
 - modules/aggregate/plans/nodes.pp
+- modules/apply/tasks/resource.json
+- modules/apply/tasks/resource.rb
 - modules/canary/lib/puppet/functions/canary/merge.rb
 - modules/canary/lib/puppet/functions/canary/random_split.rb
 - modules/canary/lib/puppet/functions/canary/skip.rb
@@ -387,6 +392,10 @@ files:
 - modules/puppetdb_fact/plans/init.pp
 - modules/service/tasks/init.json
 - modules/service/tasks/init.rb
+- modules/service/tasks/linux.json
+- modules/service/tasks/linux.sh
+- modules/service/tasks/windows.json
+- modules/service/tasks/windows.ps1
 - vendored/facter/lib/facter.rb
 - vendored/facter/lib/facter/Cfkey.rb
 - vendored/facter/lib/facter/application.rb