bolt 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8afdc9d66e35557fd6dee9433d0c5dd62f9620fb111a7b56d3ba11e7a0b66e73
-  data.tar.gz: d2ea3502f583cfa8cd136f8e04eaebac50364c822f892595eb0782c8e6c6f175
+  metadata.gz: 59ccedf25067dbbeb8769b4cb77178679c6b5a7a312dcecba80841af2d472ffe
+  data.tar.gz: 358e3ce1e0e4e3241eb9442fac18b80b9e36bec98b3e3d1dbbd039c5708d458b
 SHA512:
-  metadata.gz: 3c15b22e1ab464ba249372b62161da08c69e31db4c55ff2a89b590fde7abccde114dc0559e1b3b32eae3fcae69ef09afd1f142fe89e1976d682247f4e1e16bdc
-  data.tar.gz: d1b82c13cb0faf8b80e5b37bf6800a24a7837e4ed572690257163fcf95da6dcd2a14f25a0f23e7fd33c7e797683e00eda3f0f2933a319785ce92a40f5bdfcc01
+  metadata.gz: 42734205200d757dd20e82aeed34f61734b4688fd8e72de40b5f5341fdd1f452537de9db1277b585a9cf274abb0dad0ba20cc2a5822e4769d40c505ca42da4f5
+  data.tar.gz: 6c906fafb671ab787e79fbcdb3bfbd544b31eeb2ade0f9937be4c3ebe7472dc9d7a399ed5ae8e357d2582e93250371a15beadf08d93cd9a68762e85e91dc9088

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

@@ -3,7 +3,18 @@
 require 'fileutils'
 require 'bolt/task'
 
+# Installs the puppet-agent package on targets if needed then collects facts, including any custom
+# facts found in Bolt's modulepath.
+#
+# Agent detection will be skipped if the target includes the 'puppet-agent' feature, either as a
+# property of its transport (PCP) or by explicitly setting it as a feature in Bolt's inventory.
+#
+# If no agent is detected on the target using the 'puppet_agent::version' task, it's installed
+# using 'puppet_agent::install' and the puppet service is stopped/disabled using the 'service' task.
 Puppet::Functions.create_function(:apply_prep) do
+  # @param targets A pattern or array of patterns identifying a set of targets.
+  # @example Prepare targets by name.
+  #   apply_prep('target1,target2')
   dispatch :apply_prep do
     param 'Boltlib::TargetSpec', :targets
   end
@@ -22,6 +33,12 @@ Puppet::Functions.create_function(:apply_prep) do
     results
   end
 
+  # Returns true if the target has the puppet-agent feature defined, either from inventory or transport.
+  def agent?(target, executor, inventory)
+    inventory.features(target).include?('puppet-agent') ||
+      executor.transport(target.protocol).provided_features.include?('puppet-agent')
+  end
+
   def apply_prep(target_spec)
     applicator = Puppet.lookup(:apply_executor) { nil }
     executor = Puppet.lookup(:bolt_executor) { nil }
@@ -38,20 +55,25 @@ Puppet::Functions.create_function(:apply_prep) do
 
     executor.log_action('install puppet and gather facts', targets) do
       executor.without_default_logging do
-        # Ensure Puppet is installed
-        versions = run_task(executor, targets, 'puppet_agent::version')
-        need_install, installed = versions.partition { |r| r['version'].nil? }
-        installed.each do |r|
-          Puppet.info "Puppet Agent #{r['version']} installed on #{r.target.name}"
-        end
+        # Skip targets that include the puppet-agent feature, as we know an agent will be available.
+        agent_targets, unknown_targets = targets.partition { |target| agent?(target, executor, inventory) }
+        agent_targets.each { |target| Puppet.debug "Puppet Agent feature declared for #{target.name}" }
+        unless unknown_targets.empty?
+          # Ensure Puppet is installed
+          versions = run_task(executor, unknown_targets, 'puppet_agent::version')
+          need_install, installed = versions.partition { |r| r['version'].nil? }
+          installed.each do |r|
+            Puppet.debug "Puppet Agent #{r['version']} installed on #{r.target.name}"
+          end
 
-        unless need_install.empty?
-          need_install_targets = need_install.map(&:target)
-          run_task(executor, need_install_targets, 'puppet_agent::install')
+          unless need_install.empty?
+            need_install_targets = need_install.map(&:target)
+            run_task(executor, need_install_targets, 'puppet_agent::install')
 
-          # Ensure the Puppet service is stopped after new install
-          run_task(executor, need_install_targets, 'service', 'action' => 'stop', 'name' => 'puppet')
-          run_task(executor, need_install_targets, 'service', 'action' => 'disable', 'name' => 'puppet')
+            # Ensure the Puppet service is stopped after new install
+            run_task(executor, need_install_targets, 'service', 'action' => 'stop', 'name' => 'puppet')
+            run_task(executor, need_install_targets, 'service', 'action' => 'disable', 'name' => 'puppet')
+          end
         end
         targets.each { |target| inventory.set_feature(target, 'puppet-agent') }
 

data/lib/bolt/catalog.rb

@@ -23,6 +23,10 @@ module Bolt
           cli << "--#{setting}" << dir
         end
         Puppet.settings.send(:clear_everything_for_tests)
+        # Override module locations, Bolt includes vendored modules in its internal modulepath.
+        Puppet.settings.override_default(:basemodulepath, '')
+        Puppet.settings.override_default(:vendormoduledir, '')
+
         Puppet.initialize_settings(cli)
         Puppet.settings[:hiera_config] = hiera_config
 

data/lib/bolt/cli.rb

@@ -378,7 +378,7 @@ module Bolt
       executor.start_plan(plan_context)
       result = pal.run_plan(plan_name, plan_arguments, executor, inventory, puppetdb_client)
 
-      # If a non-bolt exeception bubbles up the plan won't get finished
+      # If a non-bolt exception bubbles up the plan won't get finished
       executor.finish_plan(result)
       outputter.print_plan_result(result)
       result.ok? ? 0 : 1

data/lib/bolt/inventory.rb

@@ -13,9 +13,9 @@ module Bolt
     class ValidationError < Bolt::Error
       attr_accessor :path
       def initialize(message, offending_group)
-        super(msg, 'bolt.inventory/validation-error')
+        super(message, 'bolt.inventory/validation-error')
         @_message = message
-        @path = offending_group ? [offending_group] : []
+        @path = [offending_group].compact
       end
 
       def details
@@ -27,7 +27,11 @@ module Bolt
       end
 
       def message
-        "#{@_message} for group at #{path}"
+        if path.empty?
+          @_message
+        else
+          "#{@_message} for group at #{path}"
+        end
       end
     end
 
@@ -63,6 +67,8 @@ module Bolt
       @target_vars = target_vars
       @target_facts = target_facts
       @target_features = target_features
+
+      @groups.resolve_aliases(@groups.node_aliases)
       collect_groups
     end
 
@@ -194,27 +200,26 @@ module Bolt
     private :update_target
 
     # If target is a group name, expand it to the members of that group.
-    # If a wildcard string, match against nodes in inventory (or error if none found).
-    # Else return [target].
+    # Else match against nodes in inventory by name or alias.
+    # If a wildcard string, error if no matches are found.
+    # Else fall back to [target] if no matches are found.
     def resolve_name(target)
       if (group = @group_lookup[target])
         group.node_names
-      elsif target.include?('*')
+      else
         # Try to wildcard match nodes in inventory
         # Ignore case because hostnames are generally case-insensitive
         regexp = Regexp.new("^#{Regexp.escape(target).gsub('\*', '.*?')}$", Regexp::IGNORECASE)
 
-        nodes = []
-        @groups.node_names.each do |node|
-          if node =~ regexp
-            nodes << node
-          end
-        end
+        nodes = @groups.node_names.select { |node| node =~ regexp }
+        nodes += @groups.node_aliases.select { |target_alias, _node| target_alias =~ regexp }.values
 
-        raise(WildcardError, target) if nodes.empty?
-        nodes
-      else
-        [target]
+        if nodes.empty?
+          raise(WildcardError, target) if target.include?('*')
+          [target]
+        else
+          nodes
+        end
       end
     end
     private :resolve_name

data/lib/bolt/inventory/group.rb

@@ -5,24 +5,20 @@ module Bolt
     # Group is a specific implementation of Inventory based on nested
     # structured data.
     class Group
-      attr_accessor :name, :nodes, :groups, :config, :rest, :facts, :vars, :features
+      attr_accessor :name, :nodes, :aliases, :name_or_alias, :groups, :config, :rest, :facts, :vars, :features
+
+      # Regex used to validate group names and target aliases.
+      NAME_REGEX = /\A[a-z0-9_]+\Z/.freeze
 
       def initialize(data)
         @logger = Logging.logger[self]
 
-        unless data.is_a?(Hash)
-          raise ValidationError.new("Expected group to be a Hash, not #{data.class}", nil)
-        end
+        raise ValidationError.new("Expected group to be a Hash, not #{data.class}", nil) unless data.is_a?(Hash)
+        raise ValidationError.new("Group does not have a name", nil) unless data.key?('name')
 
-        if data.key?('name')
-          if data['name'].is_a?(String)
-            @name = data['name']
-          else
-            raise ValidationError.new("Group name must be a String, not #{data['name'].inspect}", nil)
-          end
-        else
-          raise ValidationError.new("Group does not have a name", nil)
-        end
+        @name = data['name']
+        raise ValidationError.new("Group name must be a String, not #{@name.inspect}", nil) unless @name.is_a?(String)
+        raise ValidationError.new("Invalid group name #{@name}", @name) unless @name =~ NAME_REGEX
 
         @vars = fetch_value(data, 'vars', Hash)
         @facts = fetch_value(data, 'facts', Hash)
@@ -33,25 +29,50 @@ module Bolt
         groups = fetch_value(data, 'groups', Array)
 
         @nodes = {}
-        nodes.each do |node|
-          node = { 'name' => node } if node.is_a? String
+        @aliases = {}
+        nodes.reject { |node| node.is_a?(String) }.each do |node|
           unless node.is_a?(Hash)
             raise ValidationError.new("Node entry must be a String or Hash, not #{node.class}", @name)
           end
-          if @nodes.include? node['name']
+
+          if @nodes.include?(node['name'])
             @logger.warn("Ignoring duplicate node in #{@name}: #{node}")
-          else
-            @nodes[node['name']] = node
+            next
+          end
+
+          raise ValidationError.new("Node #{node} does not have a name", @name) unless node['name']
+          @nodes[node['name']] = node
+
+          next unless node.include?('alias')
+
+          aliases = node['alias']
+          aliases = [aliases] if aliases.is_a?(String)
+          unless aliases.is_a?(Array)
+            msg = "Alias entry on #{node['name']} must be a String or Array, not #{aliases.class}"
+            raise ValidationError.new(msg, @name)
+          end
+
+          aliases.each do |alia|
+            raise ValidationError.new("Invalid alias #{alia}", @name) unless alia =~ NAME_REGEX
+
+            if (found = @aliases[alia])
+              raise ValidationError.new(alias_conflict(alia, found, node['name']), @name)
+            end
+            @aliases[alia] = node['name']
           end
         end
 
+        # If node is a string, it can refer to either a node name or alias. Which can't be determined
+        # until all groups have been resolved, and requires a depth-first traversal to categorize them.
+        @name_or_alias = nodes.select { |node| node.is_a?(String) }
+
         @groups = groups.map { |g| Group.new(g) }
 
         # this allows arbitrary info for the top level
         @rest = data.reject { |k, _| %w[name nodes config groups vars facts features].include? k }
       end
 
-      def fetch_value(data, key, type)
+      private def fetch_value(data, key, type)
         value = data.fetch(key, type.new)
         unless value.is_a?(type)
           raise ValidationError.new("Expected #{key} to be of type #{type}, not #{value.class}", @name)
@@ -59,38 +80,76 @@ module Bolt
         value
       end
 
-      def validate(used_names = Set.new, node_names = Set.new, depth = 0)
-        if used_names.include?(@name)
-          raise ValidationError.new("Tried to redefine group #{@name}", @name)
-        end
-        raise ValidationError.new("Invalid group name #{@name}", @name) unless @name =~ /\A[a-z0-9_]+\Z/
+      def resolve_aliases(aliases)
+        @name_or_alias.each do |name_or_alias|
+          # If an alias is found, insert the name into this group. Otherwise use the name as a new node.
+          node_name = aliases[name_or_alias] || name_or_alias
 
-        if node_names.include?(@name)
-          raise ValidationError.new("Group #{@name} conflicts with node of the same name", @name)
+          if @nodes.include?(node_name)
+            @logger.warn("Ignoring duplicate node in #{@name}: #{node_name}")
+          else
+            @nodes[node_name] = { 'name' => node_name }
+          end
         end
 
+        @groups.each { |g| g.resolve_aliases(aliases) }
+      end
+
+      private def alias_conflict(name, node1, node2)
+        "Alias #{name} refers to multiple targets: #{node1} and #{node2}"
+      end
+
+      private def group_alias_conflict(name)
+        "Group #{name} conflicts with alias of the same name"
+      end
+
+      private def group_node_conflict(name)
+        "Group #{name} conflicts with node of the same name"
+      end
+
+      private def alias_node_conflict(name)
+        "Node name #{name} conflicts with alias of the same name"
+      end
+
+      def validate(used_names = Set.new, node_names = Set.new, aliased = {}, depth = 0)
+        # Test if this group name conflicts with anything used before.
+        raise ValidationError.new("Tried to redefine group #{@name}", @name) if used_names.include?(@name)
+        raise ValidationError.new(group_node_conflict(@name), @name) if node_names.include?(@name)
+        raise ValidationError.new(group_alias_conflict(@name), @name) if aliased.include?(@name)
+
         used_names << @name
 
-        @nodes.each_value do |n|
+        # Collect node names and aliases into a list used to validate that subgroups don't conflict.
+        # Used names validate that previously used group names don't conflict with new node names/aliases.
+        @nodes.each_key do |n|
           # Require nodes to be parseable as a Target.
           begin
-            Target.new(n['name'])
+            Target.new(n)
           rescue Addressable::URI::InvalidURIError => e
             @logger.debug(e)
-            raise ValidationError.new("Invalid node name #{n['name']}", n['name'])
+            raise ValidationError.new("Invalid node name #{n}", @name)
           end
 
-          raise ValidationError.new("Node #{n['name']} does not have a name", n['name']) unless n['name']
-          if used_names.include?(n['name'])
-            raise ValidationError.new("Group #{n['name']} conflicts with node of the same name", n['name'])
+          raise ValidationError.new(group_node_conflict(n), @name) if used_names.include?(n)
+          raise ValidationError.new(alias_node_conflict(n), @name) if aliased.include?(n)
+
+          node_names << n
+        end
+
+        @aliases.each do |n, target|
+          raise ValidationError.new(group_alias_conflict(n), @name) if used_names.include?(n)
+          raise ValidationError.new(alias_node_conflict(n), @name) if node_names.include?(n)
+
+          if aliased.include?(n) && aliased[n] != target
+            raise ValidationError.new(alias_conflict(n, target, aliased[n]), @name)
           end
 
-          node_names << n['name']
+          aliased[n] = target
         end
 
         @groups.each do |g|
           begin
-            g.validate(used_names, node_names, depth + 1)
+            g.validate(used_names, node_names, aliased, depth + 1)
           rescue ValidationError => e
             e.add_parent(@name)
             raise e
@@ -157,6 +216,13 @@ module Bolt
         end
       end
 
+      # Returns a mapping of aliases to nodes contained within the group, which includes subgroups.
+      def node_aliases
+        @groups.inject(@aliases) do |acc, g|
+          acc.merge(g.node_aliases)
+        end
+      end
+
       # Return a mapping of group names to group.
       def collect_groups
         @groups.inject(name => self) do |acc, g|

data/lib/bolt/transport/base.rb

@@ -68,6 +68,10 @@ module Bolt
         result
       end
 
+      def provided_features
+        []
+      end
+
       def filter_options(target, options)
         if target.options['run-as']
           options.reject { |k, _v| k == '_run_as' }

data/lib/bolt/transport/docker.rb

@@ -11,7 +11,9 @@ module Bolt
         %w[service-url service-options tmpdir]
       end
 
-      PROVIDED_FEATURES = ['shell'].freeze
+      def provided_features
+        ['shell']
+      end
 
       def self.validate(options)
         if (url = options['service-url'])
@@ -75,7 +77,7 @@ module Bolt
       end
 
       def run_task(target, task, arguments, _options = {})
-        implementation = task.select_implementation(target, PROVIDED_FEATURES)
+        implementation = task.select_implementation(target, provided_features)
         executable = implementation['path']
         input_method = implementation['input_method']
         extra_files = implementation['files']

data/lib/bolt/transport/local.rb

@@ -13,7 +13,9 @@ module Bolt
         %w[tmpdir]
       end
 
-      PROVIDED_FEATURES = ['shell'].freeze
+      def provided_features
+        ['shell']
+      end
 
       def self.validate(_options); end
 
@@ -82,7 +84,7 @@ module Bolt
       end
 
       def run_task(target, task, arguments, _options = {})
-        implementation = task.select_implementation(target, PROVIDED_FEATURES)
+        implementation = task.select_implementation(target, provided_features)
         executable = implementation['path']
         input_method = implementation['input_method'] || 'both'
         extra_files = implementation['files']

data/lib/bolt/transport/orch.rb

@@ -29,7 +29,9 @@ module Bolt
         %w[service-url cacert token-file task-environment]
       end
 
-      PROVIDED_FEATURES = ['puppet-agent'].freeze
+      def provided_features
+        ['puppet-agent']
+      end
 
       def self.validate(options); end
 

data/lib/bolt/transport/ssh.rb

@@ -12,7 +12,9 @@ module Bolt
         %w[port user password sudo-password private-key host-key-check connect-timeout tmpdir run-as tty run-as-command]
       end
 
-      PROVIDED_FEATURES = ['shell'].freeze
+      def provided_features
+        ['shell']
+      end
 
       def self.validate(options)
         logger = Logging.logger[self]
@@ -119,7 +121,7 @@ module Bolt
       end
 
       def run_task(target, task, arguments, options = {})
-        implementation = task.select_implementation(target, PROVIDED_FEATURES)
+        implementation = task.select_implementation(target, provided_features)
         executable = implementation['path']
         input_method = implementation['input_method']
         extra_files = implementation['files']

data/lib/bolt/transport/winrm.rb

@@ -14,7 +14,9 @@ module Bolt
         %w[port user password connect-timeout ssl ssl-verify tmpdir cacert extensions]
       end
 
-      PROVIDED_FEATURES = ['powershell'].freeze
+      def provided_features
+        ['powershell']
+      end
 
       def self.validate(options)
         ssl_flag = options['ssl']
@@ -108,7 +110,7 @@ catch
       end
 
       def run_task(target, task, arguments, _options = {})
-        implementation = task.select_implementation(target, PROVIDED_FEATURES)
+        implementation = task.select_implementation(target, provided_features)
         executable = implementation['path']
         input_method = implementation['input_method']
         extra_files = implementation['files']

data/lib/bolt/version.rb

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

data/lib/bolt_server/file_cache.rb

@@ -106,7 +106,7 @@ module BoltServer
 
     def serial_execute(&block)
       promise = Concurrent::Promise.new(executor: @executor, &block).execute.wait
-      raise promise.reason if promise.state == :rejected
+      raise promise.reason if promise.rejected?
       promise.value
     end
 

data/lib/bolt_spec/plans.rb

@@ -202,7 +202,6 @@ module BoltSpec
     end
 
     def allow_apply_prep
-      allow_task('puppet_agent::version').always_return('version' => '6.0')
       allow_task('apply_helpers::custom_facts')
       nil
     end

data/lib/bolt_spec/plans/mock_executor.rb

@@ -148,6 +148,17 @@ module BoltSpec
         Bolt::ResultSet.new(promises.map { |target| Bolt::ApplyResult.new(target) })
       end
       # End Apply mocking
+
+      # Mocked for apply_prep
+      def transport(_protocol)
+        # Always return a transport that includes the puppet-agent feature so version/install are skipped.
+        Class.new do
+          def provided_features
+            ['puppet-agent']
+          end
+        end.new
+      end
+      # End apply_prep mocking
     end
   end
 end

data/lib/plan_executor/app.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'sinatra'
+require 'bolt'
+require 'bolt/error'
+require 'bolt/executor'
+require 'bolt/inventory'
+require 'bolt/pal'
+require 'bolt/puppetdb'
+require 'concurrent'
+require 'json'
+require 'json-schema'
+
+module PlanExecutor
+  class App < Sinatra::Base
+    # This disables Sinatra's error page generation
+    set :show_exceptions, false
+    # Global var to capture output for testing
+    result = nil
+
+    helpers do
+      def puppetdb_client
+        return @puppetdb_client if @puppetdb_client
+        @puppetdb_client = Bolt::PuppetDB::Client.new({})
+      end
+    end
+
+    def initialize(modulepath, executor = nil)
+      @schema = JSON.parse(File.read(File.join(__dir__, 'schemas', 'run_plan.json')))
+      @worker = Concurrent::SingleThreadExecutor.new
+
+      # Create a basic executor, leave concurrency up to Orchestrator.
+      @executor = executor || Bolt::Executor.new(0, load_config: false)
+      # Use an empty inventory until we figure out where this data comes from.
+      @inventory = Bolt::Inventory.new(nil)
+      # TODO: what should max compiles be set to for apply?
+      @pal = Bolt::PAL.new(modulepath, nil)
+
+      super(nil)
+    end
+
+    def validate_schema(schema, body)
+      schema_error = JSON::Validator.fully_validate(schema, body)
+      if schema_error.any?
+        Bolt::Error.new("There was an error validating the request body.",
+                        'boltserver/schema-error',
+                        schema_error)
+      end
+    end
+
+    get '/' do
+      200
+    end
+
+    if ENV['RACK_ENV'] == 'dev'
+      get '/admin/gc' do
+        GC.start
+        200
+      end
+
+      get '/admin/gc_stat' do
+        [200, GC.stat.to_json]
+      end
+    end
+
+    get '/500_error' do
+      raise 'Unexpected error'
+    end
+
+    post '/plan/run' do
+      content_type :json
+
+      body = JSON.parse(request.body.read)
+      error = validate_schema(@schema, body)
+      return [400, error.to_json] unless error.nil?
+
+      name = body['plan_name']
+      # Errors if plan is not found
+      @pal.get_plan_info(name)
+
+      params = body['params']
+      # This provides a wait function, which promise doesn't
+      result = Concurrent::Future.execute(executor: @worker) do
+        # Stores result in result for testing
+        @pal.run_plan(name, params, @executor, @inventory, puppetdb_client)
+      end
+
+      [200, { status: 'running' }.to_json]
+    end
+
+    # Provided for testing
+    get '/plan/result' do
+      result.wait_or_cancel(20)
+      if result.fulfilled?
+        return [200, result.value.to_json]
+      elsif result.rejected?
+        raise result.reason.to_s
+      else
+        return [200, result.state.to_s]
+      end
+    end
+
+    error 404 do
+      err = Bolt::Error.new("Could not find route #{request.path}",
+                            'boltserver/not-found')
+      [404, err.to_json]
+    end
+
+    error 500 do
+      e = env['sinatra.error']
+      err = Bolt::Error.new("500: Unknown error: #{e.message}",
+                            'boltserver/server-error')
+      [500, err.to_json]
+    end
+  end
+end

data/lib/plan_executor/schemas/run_plan.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "run_plan request",
+  "description": "POST plan/run request schema",
+  "type": "object",
+  "properties": {
+    "plan_name": {
+      "type": "string",
+      "description": "Name of the plan"
+    },
+    "job_id": {
+      "type": "string",
+      "description": "The job ID initialized in Orchestrator"
+    },
+    "environment": {
+      "type": "string",
+      "description": "Environment used for plan execution"
+    },
+    "description": {
+      "type": "string",
+      "description": "Describes this execution of the plan"
+    },
+    "params": {
+      "type": "object",
+      "description": "JSON formatted parameters to be provided to plan"
+    }
+  },
+  "required": ["plan_name", "job_id", "params"]
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-30 00:00:00.000000000 Z
+date: 2018-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -368,6 +368,8 @@ files:
 - lib/bolt_spec/plans/action_stubs/upload_stub.rb
 - lib/bolt_spec/plans/mock_executor.rb
 - lib/bolt_spec/run.rb
+- lib/plan_executor/app.rb
+- lib/plan_executor/schemas/run_plan.json
 - libexec/apply_catalog.rb
 - libexec/bolt_catalog
 - libexec/custom_facts.rb