bolt 1.18.0 → 1.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa6e4eb68e71946db22097bb174c21cfd49be4541980b8e0690a52e72a7a9330
-  data.tar.gz: 6e8cc701adcc4c3351e907e9d8550844bb014e3ab96d92afdca2115ed1b9ca41
+  metadata.gz: d56ec91fb5d2a032a164f87f30ece4f103b93e3957dbff221ea775e5c52af0e1
+  data.tar.gz: cad130dc12fcba0d3fa39feb61603b9fe801373c04c62a9306958dff7bac13cd
 SHA512:
-  metadata.gz: 6f7a793488438e0fb03700c536e1dbd680604eed52ea51ae03d1d7aa4da55203be5f4bb19bd481aceef92d0cbd30d531adf3e139a8cb36b9706e33afc249fe4f
-  data.tar.gz: a16943eac6c51d4e06df6bba47b81786053c3c1127ce26c3bbb5308ac88459c789ff3a327c24b192794f7e0c42222e5354b25faa4b8564d52e8bd1a7605b1abb
+  metadata.gz: 566a3c7f134067783fb458db050eee4058c43d97ac44f87caf598589f9a6761b68e6150b65bac8cb8f63e65708d1c73a9391501244f87732ae89802f9a169302
+  data.tar.gz: c69f7762b1f76c311526ac63ed01c60d993b2b638acc84e76920fb4971edc41aec1bb7a227cc4475c35189733fe50748d9c1c556d2dd7e290d35df7bd7141f99

data/lib/bolt/bolt_option_parser.rb

@@ -27,6 +27,7 @@ Available subcommands:
   bolt task show                   Show list of available tasks
   bolt task show <task>            Show documentation for task
   bolt task run <task> [params]    Run a Puppet task
+  bolt plan convert <plan_path>    Convert a YAML plan to a Puppet plan
   bolt plan show                   Show list of available plans
   bolt plan show <plan>            Show details for plan
   bolt plan run <plan> [params]    Run a Puppet task plan
@@ -77,6 +78,7 @@ Available options are:
 Usage: bolt plan <action> <plan> [options] [parameters]
 
 Available actions are:
+  convert <plan_path>              Convert a YAML plan to a Puppet plan
   show                             Show list of available plans
   show <plan>                      Show details for plan
   run                              Run a Puppet task plan

data/lib/bolt/cli.rb

@@ -30,7 +30,7 @@ module Bolt
     COMMANDS = { 'command' => %w[run],
                  'script' => %w[run],
                  'task' => %w[show run],
-                 'plan' => %w[show run],
+                 'plan' => %w[show run convert],
                  'file' => %w[upload],
                  'puppetfile' => %w[install show-modules],
                  'apply' => %w[] }.freeze
@@ -119,7 +119,10 @@ module Bolt
       # After this step
       # options[:target_args] will contain a string/array version of the targetting options this is passed to plans
       # options[:targets] will contain a resolved set of Target objects
-      unless options[:subcommand] == 'puppetfile' || options[:action] == 'show'
+      unless options[:subcommand] == 'puppetfile' ||
+             options[:action] == 'show' ||
+             options[:action] == 'convert'
+
         update_targets(options)
       end
 
@@ -204,6 +207,10 @@ module Bolt
       if options[:subcommand] == 'apply' && (!options[:object] && !options[:code])
         raise Bolt::CLIError, "a manifest file or --execute is required"
       end
+
+      if options[:subcommand] == 'command' && (!options[:object] || options[:object].empty?)
+        raise Bolt::CLIError, "Must specify a command to run"
+      end
     end
 
     def handle_parser_errors
@@ -240,6 +247,11 @@ module Bolt
         exit!
       end
 
+      if options[:action] == 'convert'
+        convert_plan(options[:object])
+        return 0
+      end
+
       @analytics = Bolt::Analytics.build_client
       @analytics.bundled_content = bundled_content
 
@@ -452,6 +464,10 @@ module Bolt
       @pal ||= Bolt::PAL.new(config.modulepath, config.hiera_config, config.compile_concurrency)
     end
 
+    def convert_plan(plan)
+      pal.convert_plan(plan)
+    end
+
     def validate_file(type, path, allow_dir = false)
       if path.nil?
         raise Bolt::CLIError, "A #{type} must be specified"

data/lib/bolt/pal.rb

@@ -37,6 +37,8 @@ module Bolt
       end
     end
 
+    attr_reader :modulepath
+
     def initialize(modulepath, hiera_config, max_compiles = Etc.nprocessors)
       # Nothing works without initialized this global state. Reinitializing
       # is safe and in practice only happen in tests
@@ -83,6 +85,7 @@ module Bolt
       require 'bolt/pal/logging'
       require 'bolt/pal/issues'
       require 'bolt/pal/yaml_plan/loader'
+      require 'bolt/pal/yaml_plan/transpiler'
 
       # Now that puppet is loaded we can include puppet mixins in data types
       Bolt::ResultSet.include_iterable
@@ -294,6 +297,12 @@ module Bolt
       plan_info
     end
 
+    def convert_plan(plan_path)
+      Puppet[:tasks] = true
+      transpiler = YamlPlan::Transpiler.new
+      transpiler.transpile(plan_path)
+    end
+
     # Returns a mapping of all modules available to the Bolt compiler
     #
     # @return [Hash{String => Array<Hash{Symbol => String,nil}>}]

data/lib/bolt/pal/yaml_plan.rb

@@ -1,47 +1,13 @@
 # frozen_string_literal: true
 
+require 'bolt/pal/yaml_plan/parameter'
+require 'bolt/pal/yaml_plan/step'
+
 module Bolt
   class PAL
     class YamlPlan
       PLAN_KEYS = Set['parameters', 'steps', 'return', 'version']
-      PARAMETER_KEYS = Set['type', 'default', 'description']
-      COMMON_STEP_KEYS = %w[name description target].freeze
-      STEP_KEYS = {
-        'command' => {
-          'allowed_keys' => Set['command'].merge(COMMON_STEP_KEYS),
-          'required_keys' => Set['target']
-        },
-        'script' => {
-          'allowed_keys' => Set['script', 'parameters', 'arguments'].merge(COMMON_STEP_KEYS),
-          'required_keys' => Set['target']
-        },
-        'task' => {
-          'allowed_keys' => Set['task', 'parameters'].merge(COMMON_STEP_KEYS),
-          'required_keys' => Set['target']
-        },
-        'plan' => {
-          'allowed_keys' => Set['plan', 'parameters'].merge(COMMON_STEP_KEYS),
-          'required_keys' => Set.new
-        },
-        'source' => {
-          'allowed_keys' => Set['source', 'destination'].merge(COMMON_STEP_KEYS),
-          'required_keys' => Set['target', 'source', 'destination']
-        },
-        'destination' => {
-          'allowed_keys' => Set['source', 'destination'].merge(COMMON_STEP_KEYS),
-          'required_keys' => Set['target', 'source', 'destination']
-        },
-        'eval' => {
-          'allowed_keys' => Set['eval', 'name', 'description'],
-          'required_keys' => Set.new
-        }
-      }.freeze
-
-      Parameter = Struct.new(:name, :value, :type_expr) do
-        def captures_rest
-          false
-        end
-      end
+      VAR_NAME_PATTERN = /\A[a-z_][a-z0-9_]*\z/.freeze
 
       attr_reader :name, :parameters, :steps, :return
 
@@ -51,14 +17,18 @@ module Bolt
         plan = Bolt::Util.walk_keys(plan) { |key| stringify(key) }
         @name = name.freeze
 
-        # Nothing in parameters is allowed to be code, since no variables are defined yet
         params_hash = stringify(plan.fetch('parameters', {}))
-
         # Ensure params is a hash
         unless params_hash.is_a?(Hash)
           raise Bolt::Error.new("Plan parameters must be a Hash", "bolt/invalid-plan")
         end
 
+        # Munge parameters into an array of Parameter objects, which is what
+        # the Puppet API expects
+        @parameters = params_hash.map do |param, definition|
+          Parameter.new(param, definition)
+        end.freeze
+
         # Validate top level plan keys
         top_level_keys = plan.keys.to_set
         unless PLAN_KEYS.superset?(top_level_keys)
@@ -67,75 +37,31 @@ module Bolt
                                 "bolt/invalid-plan")
         end
 
-        # Munge parameters into an array of Parameter objects, which is what
-        # the Puppet API expects
-        @parameters = params_hash.map do |param, definition|
-          definition ||= {}
-          definition_keys = definition.keys.to_set
-          unless PARAMETER_KEYS.superset?(definition_keys)
-            invalid_keys = definition_keys - PARAMETER_KEYS
-            raise Bolt::Error.new("Plan parameter #{param.inspect} contains illegal key(s)" \
-                                  " #{invalid_keys.to_a.inspect}",
-                                  "bolt/invalid-plan")
-          end
-          type = Puppet::Pops::Types::TypeParser.singleton.parse(definition['type']) if definition.key?('type')
-          Parameter.new(param, definition['default'], type)
-        end.freeze
+        unless plan['steps'].is_a?(Array)
+          raise Bolt::Error.new("Plan must specify an array of steps", "bolt/invalid-plan")
+        end
 
-        @steps = plan['steps']&.map do |step|
+        used_names = Set.new(@parameters.map(&:name))
+
+        @steps = plan['steps'].each_with_index.map do |step, index|
           # Step keys also aren't allowed to be code and neither is the value of "name"
           stringified_step = Bolt::Util.walk_keys(step) { |key| stringify(key) }
           stringified_step['name'] = stringify(stringified_step['name']) if stringified_step.key?('name')
-          stringified_step
-        end.freeze
 
+          step = Step.new(stringified_step, index + 1)
+          # Send object instead of just name so that step number is printed
+          duplicate_check(used_names, step)
+          used_names << stringified_step['name'] if stringified_step['name']
+          step
+        end.freeze
         @return = plan['return']
-
-        validate
       end
 
-      VAR_NAME_PATTERN = /\A[a-z_][a-z0-9_]*\z/.freeze
-
-      def validate
-        unless @steps.is_a?(Array)
-          raise Bolt::Error.new("Plan must specify an array of steps", "bolt/invalid-plan")
-        end
-
-        used_names = Set.new
-        step_number = 1
-
-        # Parameters come in a hash, so they must be unique
-        @parameters.each do |param|
-          unless param.name.is_a?(String) && param.name.match?(VAR_NAME_PATTERN)
-            raise Bolt::Error.new("Invalid parameter name #{param.name.inspect}", "bolt/invalid-plan")
-          end
-
-          used_names << param.name
-        end
-
-        @steps.each do |step|
-          validate_step_keys(step, step_number)
-
-          begin
-            step.each { |k, v| validate_puppet_code(k, v) }
-          rescue Bolt::Error => e
-            raise Bolt::Error.new(step_err_msg(step_number, step['name'], e.msg), 'bolt/invalid-plan')
-          end
-
-          if step.key?('name')
-            unless step['name'].is_a?(String) && step['name'].match?(VAR_NAME_PATTERN)
-              error_message = "Invalid step name: #{step['name'].inspect}"
-              raise Bolt::Error.new(step_err_msg(step_number, step['name'], error_message), "bolt/invalid-plan")
-            end
-
-            if used_names.include?(step['name'])
-              error_message = "Duplicate step name or parameter detected: #{step['name'].inspect}"
-              raise Bolt::Error.new(step_err_msg(step_number, step['name'], error_message), "bolt/invalid-plan")
-            end
-
-            used_names << step['name']
-          end
-          step_number += 1
+      def duplicate_check(used_names, step)
+        if used_names.include?(step.name)
+          error_message = "Duplicate step name or parameter detected: #{step.name.inspect}"
+          err = step.step_err_msg(error_message)
+          raise Bolt::Error.new(err, "bolt/invalid-plan")
         end
       end
 
@@ -143,6 +69,10 @@ module Bolt
         self
       end
 
+      def return_type
+        Puppet::Pops::Types::TypeParser.singleton.parse('Boltlib::PlanResult')
+      end
+
       # Turn all "potential" strings in the object into actual strings.
       # Because we interpret bare strings as potential Puppet code, even in
       # places where Puppet code isn't allowed (like some hash keys), we need
@@ -163,88 +93,6 @@ module Bolt
         end
       end
 
-      def return_type
-        Puppet::Pops::Types::TypeParser.singleton.parse('Boltlib::PlanResult')
-      end
-
-      def step_err_msg(step_number, step_name, message)
-        if step_name
-          "Parse error in step number #{step_number} with name #{step_name.inspect}: \n #{message}"
-        else
-          "Parse error in step number #{step_number}: \n #{message}"
-        end
-      end
-
-      def validate_step_keys(step, step_number)
-        step_keys = step.keys.to_set
-        action = step_keys.intersection(STEP_KEYS.keys.to_set).to_a
-        unless action.count == 1
-          if action.count > 1
-            # Upload step is special in that it is identified by both `source` and `destination`
-            unless action.to_set == Set['source', 'destination']
-              error_message = "Multiple action keys detected: #{action.inspect}"
-              raise Bolt::Error.new(step_err_msg(step_number, step['name'], error_message), "bolt/invalid-plan")
-            end
-          else
-            error_message = "No valid action detected"
-            raise Bolt::Error.new(step_err_msg(step_number, step['name'], error_message), "bolt/invalid-plan")
-          end
-        end
-
-        # For validated step action, ensure only valid keys
-        unless STEP_KEYS[action.first]['allowed_keys'].superset?(step_keys)
-          illegal_keys = step_keys - STEP_KEYS[action.first]['allowed_keys']
-          error_message = "The #{action.first.inspect} step does not support: #{illegal_keys.to_a.inspect} key(s)"
-          raise Bolt::Error.new(step_err_msg(step_number, step['name'], error_message), "bolt/invalid-plan")
-        end
-
-        # Ensure all required keys are present
-        STEP_KEYS[action.first]['required_keys'].each do |k|
-          next if step_keys.include?(k)
-          missing_keys = STEP_KEYS[action.first]['required_keys'] - step_keys
-          error_message = "The #{action.first.inspect} step requires: #{missing_keys.to_a.inspect} key(s)"
-          raise Bolt::Error.new(step_err_msg(step_number, step['name'], error_message), "bolt/invalid-plan")
-        end
-      end
-
-      # Recursively ensure all puppet code can be parsed
-      def validate_puppet_code(step_key, value)
-        case value
-        when Array
-          value.map { |element| validate_puppet_code(step_key, element) }
-        when Hash
-          value.each_with_object({}) do |(k, v), o|
-            key = k.is_a?(EvaluableString) ? k.value : k
-            o[key] = validate_puppet_code(key, v)
-          end
-        # CodeLiterals can be parsed directly
-        when CodeLiteral
-          parse_code_string(value.value)
-        # BareString is parsed directly if it starts with '$'
-        when BareString
-          if value.value.start_with?('$')
-            parse_code_string(value.value)
-          else
-            parse_code_string(value.value, true)
-          end
-        when EvaluableString
-          # Must quote parsed strings to evaluate them
-          parse_code_string(value.value, true)
-        end
-      rescue Puppet::Error => e
-        raise Bolt::Error.new("Error parsing #{step_key.inspect}: #{e.basic_message}", "bolt/invalid-plan")
-      end
-
-      # Parses the an evaluable string, optionally quote it before parsing
-      def parse_code_string(code, quote = false)
-        if quote
-          quoted = Puppet::Pops::Parser::EvaluatingParser.quote(code)
-          Puppet::Pops::Parser::EvaluatingParser.new.parse_string(quoted)
-        else
-          Puppet::Pops::Parser::EvaluatingParser.new.parse_string(code)
-        end
-      end
-
       # This class wraps a value parsed from YAML which may be Puppet code.
       # That includes double-quoted strings and string literals, each of which
       # subclasses this parent class in order to implement its own evaluation

data/lib/bolt/pal/yaml_plan/evaluator.rb

@@ -12,26 +12,23 @@ module Bolt
           @evaluator = Puppet::Pops::Parser::EvaluatingParser.new
         end
 
-        STEP_KEYS = %w[task command eval script source plan].freeze
-
         def dispatch_step(scope, step)
-          step = evaluate_code_blocks(scope, step)
-
-          step_type = STEP_KEYS.find { |key| step.key?(key) }
+          step_type = step.type
+          step_body = evaluate_code_blocks(scope, step.body)
 
           case step_type
           when 'task'
-            task_step(scope, step)
+            task_step(scope, step_body)
           when 'command'
-            command_step(scope, step)
+            command_step(scope, step_body)
           when 'plan'
-            plan_step(scope, step)
+            plan_step(scope, step_body)
           when 'script'
-            script_step(scope, step)
+            script_step(scope, step_body)
           when 'source'
-            upload_file_step(scope, step)
+            upload_file_step(scope, step_body)
           when 'eval'
-            eval_step(scope, step)
+            eval_step(scope, step_body)
           end
         end
 
@@ -107,7 +104,7 @@ module Bolt
             plan.steps.each do |step|
               step_result = dispatch_step(scope, step)
 
-              scope.setvar(step['name'], step_result) if step.key?('name')
+              scope.setvar(step.name, step_result) if step.name
             end
 
             evaluate_code_blocks(scope, plan.return)

data/lib/bolt/pal/yaml_plan/parameter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Parameter
+        attr_reader :name, :value, :type_expr
+
+        PARAMETER_KEYS = Set['type', 'default', 'description']
+
+        def initialize(param, definition)
+          definition ||= {}
+          validate_param(param, definition)
+
+          @name = param
+          @value = definition['default']
+          @type_expr = Puppet::Pops::Types::TypeParser.singleton.parse(definition['type']) if definition['type']
+        end
+
+        def validate_param(param, definition)
+          unless param.is_a?(String) && param.match?(Bolt::PAL::YamlPlan::VAR_NAME_PATTERN)
+            raise Bolt::Error.new("Invalid parameter name #{param.inspect}", "bolt/invalid-plan")
+          end
+
+          definition_keys = definition.keys.to_set
+          unless PARAMETER_KEYS.superset?(definition_keys)
+            invalid_keys = definition_keys - PARAMETER_KEYS
+            raise Bolt::Error.new("Plan parameter #{param.inspect} contains illegal key(s)" \
+                                  " #{invalid_keys.to_a.inspect}",
+                                  "bolt/invalid-plan")
+          end
+        end
+
+        def captures_rest
+          false
+        end
+
+        def transpile
+          result = String.new
+          result << "\n\s\s"
+
+          # Param type
+          if @type_expr.respond_to?(:type_string)
+            result << @type_expr.type_string + " "
+          elsif !@type_expr.nil?
+            result << @type_expr.to_s + " "
+          end
+
+          # Param name
+          result << "$#{@name}"
+
+          # Param default
+          if @value
+            default = @type_expr.to_s =~ /String/ ? "'#{@value}'" : @value
+            result << " = #{default}"
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/bolt/pal/yaml_plan/step.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require 'bolt/util'
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        attr_reader :name, :type, :body, :target
+
+        COMMON_STEP_KEYS = %w[name description target].freeze
+        STEP_KEYS = {
+          'command' => {
+            'allowed_keys' => Set['command'].merge(COMMON_STEP_KEYS),
+            'required_keys' => Set['target']
+          },
+          'script' => {
+            'allowed_keys' => Set['script', 'parameters', 'arguments'].merge(COMMON_STEP_KEYS),
+            'required_keys' => Set['target']
+          },
+          'task' => {
+            'allowed_keys' => Set['task', 'parameters'].merge(COMMON_STEP_KEYS),
+            'required_keys' => Set['target']
+          },
+          'plan' => {
+            'allowed_keys' => Set['plan', 'parameters'].merge(COMMON_STEP_KEYS),
+            'required_keys' => Set.new
+          },
+          'source' => {
+            'allowed_keys' => Set['source', 'destination'].merge(COMMON_STEP_KEYS),
+            'required_keys' => Set['target', 'source', 'destination']
+          },
+          'destination' => {
+            'allowed_keys' => Set['source', 'destination'].merge(COMMON_STEP_KEYS),
+            'required_keys' => Set['target', 'source', 'destination']
+          },
+          'eval' => {
+            'allowed_keys' => Set['eval', 'name', 'description'],
+            'required_keys' => Set.new
+          }
+        }.freeze
+
+        def initialize(step_body, step_number)
+          @body = step_body
+          @name = @body['name']
+          # For error messages
+          @step_number = step_number
+          validate_step
+
+          @type = STEP_KEYS.keys.find { |key| @body.key?(key) }
+          @target = @body['target']
+        end
+
+        def transpile(plan_path)
+          result = String.new("  ")
+          result << "$#{@name} = " if @name
+
+          description = body.fetch('description', nil)
+          parameters = body.fetch('parameters', {})
+          if @type == 'script' && body.key?('arguments')
+            parameters['arguments'] = body['arguments']
+          end
+
+          case @type
+          when 'command', 'task', 'script', 'plan'
+            result << "run_#{@type}(#{Bolt::Util.to_code(body[@type])}"
+            result << ", #{Bolt::Util.to_code(@target)}" if @target
+            result << ", #{Bolt::Util.to_code(description)}" if description && type != 'plan'
+            result << ", #{Bolt::Util.to_code(parameters)}" unless parameters.empty?
+            result << ")"
+          when 'source'
+            result << "upload_file(#{Bolt::Util.to_code(body['source'])}, #{Bolt::Util.to_code(body['destination'])}"
+            result << ", #{Bolt::Util.to_code(@target)}" if @target
+            result << ", #{Bolt::Util.to_code(description)}" if description
+            result << ")"
+          when 'eval'
+            # We have to do a little extra parsing here, since we only need
+            # with() for eval blocks
+            code = Bolt::Util.to_code(body['eval'])
+            if @name && code.include?("\n")
+              # A little indented niceness
+              indented = code.gsub(/\n/, "\n    ").chomp("  ")
+              result << "with() || {\n    #{indented}}"
+            else
+              result << code
+            end
+          else
+            # We should never get here
+            raise Bolt::YamlTranspiler::ConvertError.new("Can't convert unsupported step type #{@name}", plan_path)
+          end
+          result << "\n"
+          result
+        end
+
+        def validate_step
+          validate_step_keys
+
+          begin
+            @body.each { |k, v| validate_puppet_code(k, v) }
+          rescue Bolt::Error => e
+            err = step_err_msg(e.msg)
+            raise Bolt::Error.new(err, 'bolt/invalid-plan')
+          end
+
+          unless body.fetch('parameters', {}).is_a?(Hash)
+            msg = "Parameters key must be a hash"
+            raise Bolt::Error.new(step_err_msg(msg), "bolt/invalid-plan")
+          end
+
+          if @name
+            unless @name.is_a?(String) && @name.match?(Bolt::PAL::YamlPlan::VAR_NAME_PATTERN)
+              error_message = "Invalid step name: #{@name.inspect}"
+              err = step_err_msg(error_message)
+              raise Bolt::Error.new(err, "bolt/invalid-plan")
+            end
+          end
+        end
+
+        def validate_step_keys
+          step_keys = @body.keys.to_set
+          action = step_keys.intersection(STEP_KEYS.keys.to_set).to_a
+          unless action.count == 1
+            if action.count > 1
+              # Upload step is special in that it is identified by both `source` and `destination`
+              unless action.to_set == Set['source', 'destination']
+                error_message = "Multiple action keys detected: #{action.inspect}"
+                err = step_err_msg(error_message)
+                raise Bolt::Error.new(err, "bolt/invalid-plan")
+              end
+            else
+              error_message = "No valid action detected"
+              err = step_err_msg(error_message)
+              raise Bolt::Error.new(err, "bolt/invalid-plan")
+            end
+          end
+
+          # For validated step action, ensure only valid keys
+          unless STEP_KEYS[action.first]['allowed_keys'].superset?(step_keys)
+            illegal_keys = step_keys - STEP_KEYS[action.first]['allowed_keys']
+            error_message = "The #{action.first.inspect} step does not support: #{illegal_keys.to_a.inspect} key(s)"
+            err = step_err_msg(error_message)
+            raise Bolt::Error.new(err, "bolt/invalid-plan")
+          end
+
+          # Ensure all required keys are present
+          STEP_KEYS[action.first]['required_keys'].each do |k|
+            next if step_keys.include?(k)
+            missing_keys = STEP_KEYS[action.first]['required_keys'] - step_keys
+            error_message = "The #{action.first.inspect} step requires: #{missing_keys.to_a.inspect} key(s)"
+            err = step_err_msg(error_message)
+            raise Bolt::Error.new(err, "bolt/invalid-plan")
+          end
+        end
+
+        # Recursively ensure all puppet code can be parsed
+        def validate_puppet_code(step_key, value)
+          case value
+          when Array
+            value.map { |element| validate_puppet_code(step_key, element) }
+          when Hash
+            value.each_with_object({}) do |(k, v), o|
+              key = k.is_a?(Bolt::PAL::YamlPlan::EvaluableString) ? k.value : k
+              o[key] = validate_puppet_code(key, v)
+            end
+            # CodeLiterals can be parsed directly
+          when Bolt::PAL::YamlPlan::CodeLiteral
+            parse_code_string(value.value)
+            # BareString is parsed directly if it starts with '$'
+          when Bolt::PAL::YamlPlan::BareString
+            if value.value.start_with?('$')
+              parse_code_string(value.value)
+            else
+              parse_code_string(value.value, true)
+            end
+          when Bolt::PAL::YamlPlan::EvaluableString
+            # Must quote parsed strings to evaluate them
+            parse_code_string(value.value, true)
+          end
+        rescue Puppet::Error => e
+          raise Bolt::Error.new("Error parsing #{step_key.inspect}: #{e.basic_message}", "bolt/invalid-plan")
+        end
+
+        def step_err_msg(message)
+          if @name
+            "Parse error in step number #{@step_number} with name #{@name.inspect}: \n #{message}"
+          else
+            "Parse error in step number #{@step_number}: \n #{message}"
+          end
+        end
+
+        # Parses the an evaluable string, optionally quote it before parsing
+        def parse_code_string(code, quote = false)
+          if quote
+            quoted = Puppet::Pops::Parser::EvaluatingParser.quote(code)
+            Puppet::Pops::Parser::EvaluatingParser.new.parse_string(quoted)
+          else
+            Puppet::Pops::Parser::EvaluatingParser.new.parse_string(code)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bolt/pal/yaml_plan/transpiler.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+require 'bolt/pal/yaml_plan/loader'
+require 'bolt/util'
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Transpiler
+        class ConvertError < Bolt::Error
+          def initialize(msg, plan_path)
+            super(msg, 'bolt/convert-error', { "plan_path" => plan_path })
+          end
+        end
+
+        def transpile(relative_path)
+          @plan_path = File.expand_path(relative_path)
+          @modulename = Bolt::Util.module_name(@plan_path)
+          @filename = @plan_path.split(File::SEPARATOR)[-1]
+          validate_path
+
+          plan_object = parse_plan
+
+          plan_string = String.new("# WARNING: This is an autogenerated plan. " \
+                                   "It may not behave as expected.\n" \
+                                   "plan #{plan_object.name}(")
+          # Parameters are Bolt::PAL::YamlPlan::Parameter
+          plan_object.parameters&.each_with_index do |param, i|
+            plan_string << param.transpile
+
+            # If it's the last parameter add a newline and no comma
+            last = i + 1 == plan_object.parameters.length ? "\n" : ","
+            # This encodes strangely if we << directly to plan_string
+            plan_string << last
+          end
+          plan_string << ") {\n"
+
+          plan_object.steps&.each do |step|
+            # This only needs the plan path for raising errors
+            plan_string << step.transpile(@plan_path)
+          end
+
+          plan_string << "\n  return #{Bolt::Util.to_code(plan_object.return)}\n" if plan_object.return
+          plan_string << "}"
+          # We always print the plan, even if there's an error
+          puts plan_string
+          validate_plan(plan_string)
+          plan_string
+        end
+
+        # Save me from all these rescue statements...
+        def parse_plan
+          begin
+            file_contents = File.read(@plan_path)
+          rescue Errno::ENOENT
+            msg = "Could not read yaml plan file: #{@plan_path}"
+            raise Bolt::FileError.new(msg, @plan_path)
+          end
+
+          begin
+            result = Bolt::PAL::YamlPlan::Loader.parse_plan(file_contents, @plan_path)
+          rescue Error => e
+            raise ConvertError.new("Failed to convert yaml plan: #{e.message}", @plan_path)
+          end
+
+          unless result.is_a?(Hash)
+            type = result.class.name
+            raise ArgumentError, "The data loaded from #{source_ref} does not contain an object - its type is #{type}"
+          end
+
+          Bolt::PAL::YamlPlan.new(@modulename, result).freeze
+        end
+
+        def validate_path
+          unless File.extname(@filename) == ".yaml"
+            raise ConvertError.new("You can only convert plans written in yaml", @plan_path)
+          end
+        end
+
+        def validate_plan(plan)
+          Puppet::Pops::Parser::EvaluatingParser.new.parse_string(plan)
+        rescue Puppet::Error => e
+          $stderr.puts "The converted puppet plan contains invalid puppet code: #{e.message}"
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/bolt/util.rb

@@ -35,6 +35,70 @@ module Bolt
         raise Bolt::FileError.new("Could not read #{file_name} file: #{path}", path)
       end
 
+      # Accepts a path with either 'plans' or 'tasks' in it and determines
+      # the name of the module
+      def module_name(path)
+        # Remove extra dots and slashes
+        path = Pathname.new(path).cleanpath.to_s
+        fs = File::SEPARATOR
+        regex = Regexp.new("#{fs}plans#{fs}|#{fs}tasks#{fs}")
+
+        # Only accept paths with '/plans/' or '/tasks/'
+        unless path.match?(regex)
+          msg = "Could not determine module from #{path}. "\
+            "The path must include 'plans' or 'tasks' directory"
+          raise Bolt::Error.new(msg, 'bolt/modulepath-error')
+        end
+
+        # Split the path on the first instance of /plans/ or /tasks/
+        parts = path.split(regex, 2)
+        # Module name is the last entry before 'plans' or 'tasks'
+        modulename = parts[0].split(fs)[-1]
+        filename = File.basename(path).split('.')[0]
+        # Remove "/init.*" if filename is init or just remove the file
+        # extension
+        if filename == 'init'
+          parts[1].chomp!(File.basename(path))
+        else
+          parts[1].chomp!(File.extname(path))
+        end
+
+        # The plan or task name is the rest of the path
+        [modulename, parts[1].split(fs)].flatten.join('::')
+      end
+
+      def to_code(string)
+        case string
+        when Bolt::PAL::YamlPlan::DoubleQuotedString
+          string.value.inspect
+        when Bolt::PAL::YamlPlan::BareString
+          if string.value.start_with?('$')
+            string.value.to_s
+          else
+            "'#{string.value}'"
+          end
+        when Bolt::PAL::YamlPlan::EvaluableString, Bolt::PAL::YamlPlan::CodeLiteral
+          string.value.to_s
+        when String
+          "'#{string}'"
+        when Hash
+          formatted = String.new("{")
+          string.each do |k, v|
+            formatted << "#{to_code(k)} => #{to_code(v)}, "
+          end
+          formatted.chomp!(", ")
+          formatted << "}"
+          formatted
+        when Array
+          formatted = String.new("[")
+          formatted << string.map { |str| to_code(str) }.join(', ')
+          formatted << "]"
+          formatted
+        else
+          string
+        end
+      end
+
       def deep_merge(hash1, hash2)
         recursive_merge = proc do |_key, h1, h2|
           if h1.is_a?(Hash) && h2.is_a?(Hash)

data/lib/bolt/version.rb

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

data/lib/plan_executor/app.rb

@@ -92,9 +92,15 @@ module PlanExecutor
       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)
-
+      # We need to wrap all calls to @pal (not just plan_run) in a future
+      # to ensure that the process always uses the SingleThreadExecutor
+      # worker and forces one call to @pal at a time regardless of the number
+      # of concurrent calls to POST /plan_run
+      result = Concurrent::Future.execute(executor: @worker) do
+        @pal.get_plan_info(name)
+      end
+      # .value! will fail if the internal process of the thread fails
+      result.value!
       executor = PlanExecutor::Executor.new(body['job_id'], @http_client)
       applicator = PlanExecutor::Applicator.new(@inventory, executor, nil)
       params = body['params']
@@ -104,7 +110,6 @@ module PlanExecutor
         executor.finish_plan(pal_result)
         pal_result
       end
-
       [200, { status: 'running' }.to_json]
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 1.18.0
+  version: 1.19.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-25 00:00:00.000000000 Z
+date: 2019-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -380,6 +380,9 @@ files:
 - lib/bolt/pal/yaml_plan.rb
 - lib/bolt/pal/yaml_plan/evaluator.rb
 - lib/bolt/pal/yaml_plan/loader.rb
+- lib/bolt/pal/yaml_plan/parameter.rb
+- lib/bolt/pal/yaml_plan/step.rb
+- lib/bolt/pal/yaml_plan/transpiler.rb
 - lib/bolt/plan_result.rb
 - lib/bolt/plugin.rb
 - lib/bolt/plugin/puppetdb.rb