bolt 1.11.0 → 1.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29c062ea69471f56b51b9cef6ea2a3ba820773161753a13145879b7b941d2a32
-  data.tar.gz: 0f237d5aa389dee5e8a908f4fd52268d9fd397af25894a25adeeff0bc96d2ccc
+  metadata.gz: 05e284722c10c61a2fe08a01b920b18739b8cc31486762db9dfadba82288f6d6
+  data.tar.gz: 59e57d3df534fcbae81f2f5f44000e1f1930aec4029c8d664696e156a715a922
 SHA512:
-  metadata.gz: 79a0c7e11a5998175df643ed639f197f3e05c78895713562b220338b8c0df5f2fa1a506d5d4a7e063b38e314d4c046816cf7d4fd084296f313b3193b04b91c12
-  data.tar.gz: b92c3bb6f4e0fcc95895d22907c7c98e7cf5b4fef4385354dfd6a53c09817306d6d99aed1266beb1c0a65cbfb804567599c29c69a08790c3ba1d04ac5e3c7392
+  metadata.gz: ea83de65334823f418383868b21cb5f23f501e11fbb525e5d9b9ebc8fac9f818322f56e4069f2697e9de48ce5631a349e5673cf16c0b5437e0f4799e654c6b39
+  data.tar.gz: b1d95304ae24c3f792ee9fecf9fe42073efc73f7fbd309654f78112886e5e55a2541913e1a1aa705c8e123113f53ba136f18731b39344d3b9bdd0ac31a96f496

data/lib/bolt/bolt_option_parser.rb

@@ -32,6 +32,7 @@ Available subcommands:
   bolt plan run <plan> [params]    Run a Puppet task plan
   bolt apply <manifest>            Apply Puppet manifest code
   bolt puppetfile install          Install modules from a Puppetfile into a Boltdir
+  bolt puppetfile show-modules     List modules available to Bolt
 
 Run `bolt <subcommand> --help` to view specific examples.
 
@@ -101,6 +102,7 @@ Usage: bolt puppetfile <action> [options]
 
 Available actions are:
   install                          Install modules from a Puppetfile into a Boltdir
+  show-modules                     List modules available to Bolt
 
 Install modules into the local Boltdir
   bolt puppetfile install

data/lib/bolt/boltdir.rb

@@ -33,7 +33,7 @@ module Bolt
       @path = Pathname.new(path).expand_path
       @config_file = @path + 'bolt.yaml'
       @inventory_file = @path + 'inventory.yaml'
-      @modulepath = [(@path + 'modules').to_s, (@path + 'site').to_s]
+      @modulepath = [(@path + 'modules').to_s, (@path + 'site-modules').to_s, (@path + 'site').to_s]
       @hiera_config = @path + 'hiera.yaml'
       @puppetfile = @path + 'Puppetfile'
     end

data/lib/bolt/cli.rb

@@ -30,7 +30,7 @@ module Bolt
                  'task' => %w[show run],
                  'plan' => %w[show run],
                  'file' => %w[upload],
-                 'puppetfile' => %w[install],
+                 'puppetfile' => %w[install show-modules],
                  'apply' => %w[] }.freeze
 
     attr_reader :config, :options
@@ -259,6 +259,9 @@ module Bolt
           end
         end
         return 0
+      elsif options[:action] == 'show-modules'
+        list_modules
+        return 0
       end
 
       message = 'There may be processes left executing on some nodes.'
@@ -400,6 +403,10 @@ module Bolt
       results.ok ? 0 : 1
     end
 
+    def list_modules
+      outputter.print_module_list(pal.list_modules)
+    end
+
     def install_puppetfile(puppetfile, modulepath)
       require 'r10k/action/puppetfile/install'
       require 'bolt/r10k_log_proxy'

data/lib/bolt/outputter/human.rb

@@ -191,6 +191,34 @@ module Bolt
                         "details and parameters for a specific plan.")
       end
 
+      def print_module_list(module_list)
+        module_list.each do |path, modules|
+          if (mod = modules.find { |m| m[:internal_module_group] })
+            @stream.puts(mod[:internal_module_group])
+          else
+            @stream.puts(path)
+          end
+
+          if modules.empty?
+            @stream.puts('(no modules installed)')
+          else
+            module_info = modules.map do |m|
+              version = if m[:version].nil?
+                          m[:internal_module_group].nil? ? '(no metadata)' : '(built-in)'
+                        else
+                          m[:version]
+                        end
+
+              [m[:name], version]
+            end
+
+            print_table(module_info)
+          end
+
+          @stream.write("\n")
+        end
+      end
+
       # @param [Bolt::ResultSet] apply_result A ResultSet object representing the result of a `bolt apply`
       def print_apply_result(apply_result)
         apply_result.each { |result| print_result(result) }

data/lib/bolt/outputter/json.rb

@@ -42,6 +42,7 @@ module Bolt
       def print_table(results)
         @stream.puts results.to_json
       end
+      alias print_module_list print_table
 
       def print_task_info(task)
         path = task['files'][0]['path'].chomp("/tasks/#{task['files'][0]['name']}")

data/lib/bolt/pal.rb

@@ -284,6 +284,36 @@ module Bolt
       plan_info
     end
 
+    # Returns a mapping of all modules available to the Bolt compiler
+    #
+    # @return [Hash{String => Array<Hash{Symbol => String,nil}>}]
+    #   A hash that associates each directory on the module path with an array
+    #   containing a hash of information for each module in that directory.
+    #   The information hash provides the name, version, and a string
+    #   indicating whether the module belongs to an internal module group.
+    def list_modules
+      internal_module_groups = { BOLTLIB_PATH => 'Plan Language Modules',
+                                 MODULES_PATH => 'Packaged Modules' }
+
+      in_bolt_compiler do
+        # NOTE: Can replace map+to_h with transform_values when Ruby 2.4
+        #       is the minimum supported version.
+        Puppet.lookup(:current_environment).modules_by_path.map do |path, modules|
+          module_group = internal_module_groups[path]
+
+          values = modules.map do |mod|
+            mod_info = { name: (mod.forge_name || mod.name),
+                         version: mod.version }
+            mod_info[:internal_module_group] = module_group unless module_group.nil?
+
+            mod_info
+          end
+
+          [path, values]
+        end.to_h
+      end
+    end
+
     def run_task(task_name, targets, params, executor, inventory, description = nil, &eventblock)
       in_task_compiler(executor, inventory) do |compiler|
         params = params.merge('_bolt_api_call' => true)

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

@@ -58,7 +58,8 @@ module Bolt
           # If we're using the default port with SSL, a timeout probably means the
           # host doesn't support SSL.
           if target.options['ssl'] && @port == HTTPS_PORT
-            the_problem = "\nUse --no-ssl if this host isn't configured to use SSL for WinRM"
+            the_problem = "\nVerify that required WinRM ports are open, " \
+                          "or use --no-ssl if this host isn't configured to use SSL for WinRM."
           end
           raise Bolt::Node::ConnectError.new(
             "Timeout after #{target.options['connect-timeout']} seconds connecting to #{endpoint}#{the_problem}",

data/lib/bolt/version.rb

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

data/lib/bolt_server/schemas/task.json

@@ -50,19 +50,39 @@
         "properties": {
           "uri": {
             "type": "object",
-            "description": "Where is the file"
+            "description": "Information on how to request the file contents",
+            "properties": {
+              "path": {
+                "description": "Relative URI for accessing task contents",
+                "type": "string"
+              },
+              "params": {
+                "description": "Map of query params when requesting task content",
+                "type": "object",
+                "properties": {
+                  "environment": {
+                    "description": "Environment the task is in",
+                    "type": "string"
+                  }
+                },
+                "required": ["environment"],
+                "additionalProperties": true
+              }
+            },
+            "required": ["path", "params"],
+            "additionalProperties": true
           },
           "sha256": {
             "type": "string",
-            "description": "checksum of file"
+            "description": "Checksum of file"
           },
           "filename": {
             "type": "string",
-            "description": "Name of file"
+            "description": "Name of file including extension"
           },
           "size": {
             "type": "number",
-            "description": "Size of file"
+            "description": "Size of file in bytes"
           }
         }
       },

data/lib/bolt_spec/run.rb

@@ -11,36 +11,35 @@ require 'bolt/util'
 # This is intended to provide a relatively stable method of executing bolt in process from tests.
 module BoltSpec
   module Run
-    def run_task(task_name, targets, params = nil, config: nil, inventory: nil)
+    def run_task(task_name, targets, params, config: nil, inventory: nil)
       result = BoltRunner.with_runner(config, inventory) do |runner|
-        runner.run_task(task_name, targets, params || {})
+        runner.run_task(task_name, targets, params)
       end
       result = result.to_a
       Bolt::Util.walk_keys(result, &:to_s)
     end
 
-    def run_plan(plan_name, params = nil, config: nil, inventory: nil)
+    def run_plan(plan_name, params, config: nil, inventory: nil)
       # Users copying code from run_task may forget that targets is not a parameter for run plan
-      params ||= {}
       raise ArgumentError, "params must be a hash" unless params.is_a?(Hash)
 
       result = BoltRunner.with_runner(config, inventory) do |runner|
-        runner.run_plan(plan_name, params || {})
+        runner.run_plan(plan_name, params)
       end
 
       { "status" => result.status,
         "value" => JSON.parse(result.value.to_json) }
     end
 
-    def run_command(command, targets, params = nil, config: nil, inventory: nil)
+    def run_command(command, targets, options: {}, config: nil, inventory: nil)
       result = BoltRunner.with_runner(config, inventory) do |runner|
-        runner.run_command(command, targets, params)
+        runner.run_command(command, targets, options)
       end
       result = result.to_a
       Bolt::Util.walk_keys(result, &:to_s)
     end
 
-    def run_script(script, targets, arguments = nil, options = {}, config: nil, inventory: nil)
+    def run_script(script, targets, arguments, options: {}, config: nil, inventory: nil)
       result = BoltRunner.with_runner(config, inventory) do |runner|
         runner.run_script(script, targets, arguments, options)
       end
@@ -116,13 +115,13 @@ module BoltSpec
         pal.run_plan(plan_name, params, executor, inventory, puppetdb_client)
       end
 
-      def run_command(command, targets, params = nil)
+      def run_command(command, targets, options)
         executor = Bolt::Executor.new(config.concurrency, @analytics)
         targets = inventory.get_targets(targets)
-        executor.run_command(targets, command, params || {})
+        executor.run_command(targets, command, options)
       end
 
-      def run_script(script, targets, arguments = nil, options = {})
+      def run_script(script, targets, arguments, options = {})
         executor = Bolt::Executor.new(config.concurrency, @analytics)
         targets = inventory.get_targets(targets)
         executor.run_script(targets, script, arguments, options)

data/lib/plan_executor/app.rb

@@ -28,10 +28,7 @@ module PlanExecutor
     end
 
     def initialize(config)
-      conn_opts = { 'service-url' => config['orchestrator-url'],
-                    'cacert' => config['ssl-ca-cert'],
-                    'User-Agent' => "Bolt/#{Bolt::VERSION}" }
-      @client = OrchestratorClient.new(conn_opts, false)
+      @http_client = create_http(config)
 
       # Use an empty inventory until we figure out where this data comes from.
       @inventory = Bolt::Inventory.new(nil)
@@ -49,6 +46,15 @@ module PlanExecutor
       super(nil)
     end
 
+    def create_http(config)
+      base_url = config['orchestrator-url'].chomp('/') + '/orchestrator/v1/'
+      agent_name = "Bolt/#{Bolt::VERSION}"
+      http = JSONClient.new(base_url: base_url, agent_name: agent_name)
+      http.ssl_config.set_client_cert_file(config['ssl-cert'], config['ssl-key'])
+      http.ssl_config.add_trust_ca(config['ssl-ca-cert'])
+      http
+    end
+
     def validate_schema(schema, body)
       schema_error = JSON::Validator.fully_validate(schema, body)
       if schema_error.any?
@@ -87,7 +93,7 @@ module PlanExecutor
       # Errors if plan is not found
       @pal.get_plan_info(name)
 
-      executor = PlanExecutor::Executor.new(body['job_id'], @client)
+      executor = PlanExecutor::Executor.new(body['job_id'], @http_client)
       applicator = PlanExecutor::Applicator.new(@inventory, executor, nil)
       params = body['params']
       # This provides a wait function, which promise doesn't

data/lib/plan_executor/executor.rb

@@ -14,14 +14,14 @@ require 'plan_executor/orch_client'
 module PlanExecutor
   class Executor
     attr_reader :noop, :logger
-    attr_accessor :transport
+    attr_accessor :orch_client
 
-    def initialize(job_id, client, noop = nil)
+    def initialize(job_id, http_client, noop = nil)
       @logger = Logging.logger[self]
       @plan_logging = false
       @noop = noop
       @logger.debug { "Started" }
-      @transport = PlanExecutor::OrchClient.new(job_id, client, @logger)
+      @orch_client = PlanExecutor::OrchClient.new(job_id, http_client, @logger)
     end
 
     # This handles running the job, catching errors, and turning the result
@@ -82,7 +82,7 @@ module PlanExecutor
       description = options.fetch('_description', "command '#{command}'")
       log_action(description, targets) do
         results = as_resultset(targets) do
-          @transport.run_command(targets, command, options)
+          @orch_client.run_command(targets, command, options)
         end
 
         results
@@ -93,7 +93,7 @@ module PlanExecutor
       description = options.fetch('_description', "script #{script}")
       log_action(description, targets) do
         results = as_resultset(targets) do
-          @transport.run_script(targets, script, arguments, options)
+          @orch_client.run_script(targets, script, arguments, options)
         end
 
         results
@@ -106,7 +106,7 @@ module PlanExecutor
         arguments['_task'] = task.name
 
         results = as_resultset(targets) do
-          @transport.run_task(targets, task, arguments, options)
+          @orch_client.run_task(targets, task, arguments, options)
         end
 
         results
@@ -117,7 +117,7 @@ module PlanExecutor
       description = options.fetch('_description', "file upload from #{source} to #{destination}")
       log_action(description, targets) do
         results = as_resultset(targets) do
-          @transport.file_upload(targets, source, destination, options)
+          @orch_client.file_upload(targets, source, destination, options)
         end
 
         results
@@ -132,7 +132,7 @@ module PlanExecutor
                              retry_interval: 1)
       log_action(description, targets) do
         begin
-          wait_until(wait_time, retry_interval) { @transport.connected?(targets) }
+          wait_until(wait_time, retry_interval) { @orch_client.connected?(targets) }
           targets.map { |target| Bolt::Result.new(target) }
         rescue TimeoutError => e
           targets.map { |target| Bolt::Result.from_exception(target, e) }
@@ -149,7 +149,7 @@ module PlanExecutor
     end
 
     def finish_plan(plan_result)
-      @transport.finish_plan(plan_result)
+      @orch_client.finish_plan(plan_result)
     end
 
     def without_default_logging

data/lib/plan_executor/orch_client.rb

@@ -1,30 +1,31 @@
 # frozen_string_literal: true
 
+require 'jsonclient'
+
 module PlanExecutor
   class OrchClient
-    attr_reader :plan_job, :client
+    attr_reader :plan_job, :http
 
     BOLT_COMMAND_TASK = Struct.new(:name).new('bolt_shim::command').freeze
     BOLT_SCRIPT_TASK = Struct.new(:name).new('bolt_shim::script').freeze
     BOLT_UPLOAD_TASK = Struct.new(:name).new('bolt_shim::upload').freeze
 
-    def initialize(plan_job, client, logger)
+    def initialize(plan_job, http_client, logger)
       @plan_job = plan_job
-      @client = client
       @logger = logger
-      @client_url = client.config['service-url']
-      logger.debug("Creating orchestrator client for #{@client_url}")
+      @http = http_client
       @environment = 'production'
     end
 
     def finish_plan(plan_result)
-      result = @client.command.plan_finish(
+      body = {
         plan_job: @plan_job,
         result: plan_result.value || '',
         status: plan_result.status
-      )
+      }
+      post_command('internal/plan_finish', body)
     rescue StandardError => e
-      @logger.debug("Failed to finish plan on #{@client_url}: #{e.message}\nResult: #{result.to_json}")
+      @logger.error("Failed to finish plan #{plan_job}: #{e.message}")
     end
 
     def run_task_job(targets, task, arguments, options)
@@ -43,6 +44,22 @@ module PlanExecutor
       end
     end
 
+    def get(url)
+      response = @http.get(url)
+      if response.status != 200
+        raise Bolt::Error.new(response.body['msg'], response.body['kind'], response.body['details'])
+      end
+      response.body
+    end
+
+    def post_command(url, body)
+      response = @http.post(url, body)
+      if response.status != 202
+        raise Bolt::Error.new(response.body['msg'], response.body['kind'], response.body['details'])
+      end
+      response.body
+    end
+
     def send_request(targets, task, arguments, options = {})
       description = options['_description']
       body = { task: task.name,
@@ -55,7 +72,15 @@ module PlanExecutor
       body[:description] = description if description
       body[:plan_job] = @plan_job if @plan_job
 
-      @client.run_task(body)
+      url = post_command('internal/plan_task', body).dig('job', 'id')
+
+      job = get(url)
+      until %w[stopped finished failed].include?(job['state'])
+        sleep 1
+        job = get(url)
+      end
+
+      get(job.dig('nodes', 'id'))['items']
     end
 
     def process_run_results(targets, results)
@@ -99,7 +124,8 @@ module PlanExecutor
       content = Base64.encode64(content)
       params = {
         'content' => content,
-        'arguments' => arguments
+        'arguments' => arguments,
+        'name' => Pathname(script).basename.to_s
       }
       callback ||= proc {}
       results = run_task_job(targets, BOLT_SCRIPT_TASK, params, options, &callback)
@@ -204,8 +230,8 @@ module PlanExecutor
     end
 
     def connected?(targets)
-      nodes = @client.post('inventory', nodes: targets.map(&:host))
-      nodes['items'].all? { |node| node['connected'] }
+      response = @http.post('inventory', nodes: targets.map(&:host))
+      response.body['items'].all? { |node| node['connected'] }
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 1.11.0
+  version: 1.12.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-02-08 00:00:00.000000000 Z
+date: 2019-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable