bolt 2.44.0 → 3.4.0

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

@@ -5,30 +5,38 @@ module Bolt
     class YamlPlan
       class Step
         class Command < Step
-          def self.allowed_keys
-            super + Set['command']
+          def self.option_keys
+            Set['catch_errors', 'env_vars', 'run_as']
           end
 
           def self.required_keys
-            Set['targets']
+            Set['command', 'targets']
           end
 
-          def initialize(step_body)
+          def self.validate_step_keys(body, number)
             super
-            @command = step_body['command']
+
+            if body.key?('env_vars') && ![Hash, String].include?(body['env_vars'].class)
+              raise StepError.new('env_vars key must be a hash or evaluable string', body['name'], number)
+            end
           end
 
-          def transpile
-            code = String.new("  ")
-            code << "$#{@name} = " if @name
+          # Returns an array of arguments to pass to the step's function call
+          #
+          private def format_args(body)
+            opts = format_options(body)
 
-            fn = 'run_command'
-            args = [@command, @targets]
-            args << @description if @description
+            args = [body['command'], body['targets']]
+            args << body['description'] if body['description']
+            args << opts if opts.any?
 
-            code << function_call(fn, args)
+            args
+          end
 
-            code << "\n"
+          # Returns the function corresponding to the step
+          #
+          private def function
+            'run_command'
           end
         end
       end

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

@@ -5,31 +5,30 @@ module Bolt
     class YamlPlan
       class Step
         class Download < Step
-          def self.allowed_keys
-            super + Set['download', 'destination']
+          def self.option_keys
+            Set['catch_errors', 'run_as']
           end
 
           def self.required_keys
             Set['download', 'destination', 'targets']
           end
 
-          def initialize(step_body)
-            super
-            @source = step_body['download']
-            @destination = step_body['destination']
-          end
-
-          def transpile
-            code = String.new("  ")
-            code << "$#{@name} = " if @name
+          # Returns an array of arguments to pass to the step's function call
+          #
+          private def format_args(body)
+            opts = format_options(body)
 
-            fn = 'download_file'
-            args = [@source, @destination, @targets]
-            args << @description if @description
+            args = [body['download'], body['destination'], body['targets']]
+            args << body['description'] if body['description']
+            args << opts if opts.any?
 
-            code << function_call(fn, args)
+            args
+          end
 
-            code << "\n"
+          # Returns the function corresponding to the step
+          #
+          private def function
+            'download_file'
           end
         end
       end

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

@@ -5,28 +5,28 @@ module Bolt
     class YamlPlan
       class Step
         class Eval < Step
-          def self.allowed_keys
-            super + Set['eval']
-          end
-
           def self.required_keys
-            Set.new
+            Set['eval']
           end
 
-          def initialize(step_body)
-            super
-            @eval = step_body['eval']
+          # Evaluates the step
+          #
+          def evaluate(scope, evaluator)
+            evaluated = evaluator.evaluate_code_blocks(scope, body)
+            evaluated['eval']
           end
 
+          # Transpiles the step into the plan language
+          #
           def transpile
             code = String.new("  ")
-            code << "$#{@name} = " if @name
+            code << "$#{body['name']} = " if body['name']
 
-            code_body = Bolt::Util.to_code(@eval)
+            code_body = Bolt::Util.to_code(body['eval']) || 'undef'
 
             # If we're trying to assign the result of a multi-line eval to a name
             # variable, we need to wrap it in `with()`.
-            if @name && code_body.lines.count > 1
+            if body['name'] && code_body.lines.count > 1
               indented = code_body.gsub(/\n/, "\n    ").chomp("  ")
               code << "with() || {\n    #{indented}}"
             else

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

@@ -13,14 +13,23 @@ module Bolt
             Set['message']
           end
 
-          def initialize(step_body)
-            super
-            @message = step_body['message']
+          # Returns an array of arguments to pass to the step's function call
+          #
+          private def format_args(body)
+            [body['message']]
           end
 
+          # Returns the function corresponding to the step
+          #
+          private def function
+            'out::message'
+          end
+
+          # Transpiles the step into the plan language
+          #
           def transpile
             code = String.new("  ")
-            code << function_call('out::message', [@message])
+            code << function_call(function, format_args(body))
             code << "\n"
           end
         end

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

@@ -6,30 +6,34 @@ module Bolt
       class Step
         class Plan < Step
           def self.allowed_keys
-            super + Set['plan', 'parameters']
+            super + Set['parameters']
           end
 
-          def self.required_keys
-            Set.new
+          def self.option_keys
+            Set['catch_errors', 'run_as']
           end
 
-          def initialize(step_body)
-            super
-            @plan = step_body['plan']
-            @parameters = step_body.fetch('parameters', {})
+          def self.required_keys
+            Set['plan']
           end
 
-          def transpile
-            code = String.new("  ")
-            code << "$#{@name} = " if @name
+          # Returns an array of arguments to pass to the step's function call
+          #
+          private def format_args(body)
+            opts   = format_options(body)
+            params = (body['parameters'] || {}).merge(opts)
 
-            fn = 'run_plan'
-            args = [@plan]
-            args << @parameters unless @parameters.empty?
+            args = [body['plan']]
+            args << body['targets'] if body['targets']
+            args << params if params.any?
 
-            code << function_call(fn, args)
+            args
+          end
 
-            code << "\n"
+          # Returns the function corresponding to the step
+          #
+          private def function
+            'run_plan'
           end
         end
       end

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

@@ -5,18 +5,81 @@ module Bolt
     class YamlPlan
       class Step
         class Resources < Step
-          def self.allowed_keys
-            super + Set['resources']
+          def self.option_keys
+            Set['catch_errors', 'description', 'noop', 'run_as']
           end
 
           def self.required_keys
-            Set['targets']
+            Set['resources', 'targets']
           end
 
-          def initialize(step_body)
+          def initialize(body)
             super
-            @resources = step_body['resources']
-            @normalized_resources = normalize_resources(@resources)
+            @body['resources'] = normalize_resources(@body['resources'])
+          end
+
+          # Returns an array of arguments to pass to the apply function call
+          #
+          private def format_args(body)
+            opts = format_options(body)
+
+            args = [body['targets']]
+            args << opts if opts.any?
+
+            args
+          end
+
+          def evaluate(scope, evaluator)
+            evaluated = evaluator.evaluate_code_blocks(scope, body)
+
+            scope.call_function('apply_prep', evaluated['targets'])
+
+            apply_args = format_args(evaluated)
+            manifest   = generate_manifest(evaluated['resources'])
+            apply_manifest(scope, apply_args, manifest)
+          end
+
+          # Generates a manifest from the resources
+          #
+          private def generate_manifest(resources)
+            # inspect returns the Ruby representation of the resource hashes,
+            # which happens to be the same as the Puppet representation
+            puppet_resources = resources.inspect
+
+            # Because the :tasks setting globally controls which mode the parser
+            # is in, we need to make this snippet of non-tasks manifest code
+            # parseable in tasks mode. The way to do that is by putting it in an
+            # apply statement and taking the body.
+            <<~MANIFEST
+            apply('placeholder') {
+              $resources = #{puppet_resources}
+              $resources.each |$res| {
+                Resource[$res['type']] { $res['title']:
+                  * => $res['parameters'],
+                }
+              }
+  
+              # Add relationships if there is more than one resource
+              if $resources.length > 1 {
+                ($resources.length - 1).each |$index| {
+                  $lhs = $resources[$index]
+                  $rhs = $resources[$index+1]
+                  $lhs_resource = Resource[$lhs['type'] , $lhs['title']]
+                  $rhs_resource = Resource[$rhs['type'] , $rhs['title']]
+                  $lhs_resource -> $rhs_resource
+                }
+              }
+            }
+            MANIFEST
+          end
+
+          # Applies the manifest block on the targets
+          #
+          private def apply_manifest(scope, args, manifest)
+            ast = self.class.parse_code_string(manifest)
+            apply_block = ast.body.body
+            applicator = Puppet.lookup(:apply_executor)
+            applicator.apply(args, apply_block, scope)
           end
 
           def self.validate(body, step_number)
@@ -26,26 +89,28 @@ module Bolt
               if resource['type'] || resource['title']
                 if !resource['type']
                   err = "Resource declaration must include type key if title key is set"
-                  raise step_error(err, body['name'], step_number)
+                  raise StepError.new(err, body['name'], step_number)
                 elsif !resource['title']
                   err = "Resource declaration must include title key if type key is set"
-                  raise step_error(err, body['name'], step_number)
+                  raise StepError.new(err, body['name'], step_number)
                 end
               else
                 type_keys = (resource.keys - ['parameters'])
                 if type_keys.empty?
                   err = "Resource declaration is missing a type"
-                  raise step_error(err, body['name'], step_number)
+                  raise StepError.new(err, body['name'], step_number)
                 elsif type_keys.length > 1
                   err = "Resource declaration has ambiguous type: could be #{type_keys.join(' or ')}"
-                  raise step_error(err, body['name'], step_number)
+                  raise StepError.new(err, body['name'], step_number)
                 end
               end
             end
           end
 
+          # Normalizes the resources so they are in a format compatible with apply blocks
           # What if this comes from a code block?
-          def normalize_resources(resources)
+          #
+          private def normalize_resources(resources)
             resources.map do |resource|
               if resource['type'] && resource['title']
                 type = resource['type']
@@ -59,25 +124,21 @@ module Bolt
             end
           end
 
-          def body
-            @body.merge('resources' => @normalized_resources)
-          end
-
           def transpile
             code = StringIO.new
 
             code.print "  "
-            fn = 'apply_prep'
-            args = [@targets]
-            code << function_call(fn, args)
+            code << function_call('apply_prep', [body['targets']])
             code.print "\n"
 
             code.print "  "
-            code.print "$#{@name} = " if @name
+            code.print "$#{body['name']} = " if body['name']
+
+            code << function_call('apply', format_args(body))
 
-            code.puts "apply(#{Bolt::Util.to_code(@targets)}) {"
+            code.print " {\n"
 
-            declarations = @normalized_resources.map do |resource|
+            declarations = body['resources'].map do |resource|
               type = resource['type'].is_a?(EvaluableString) ? resource['type'].value : resource['type']
               title = Bolt::Util.to_code(resource['title'])
               parameters = resource['parameters'].transform_values do |val|

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

@@ -6,35 +6,54 @@ module Bolt
       class Step
         class Script < Step
           def self.allowed_keys
-            super + Set['script', 'parameters', 'arguments']
+            super + Set['arguments', 'pwsh_params']
+          end
+
+          def self.option_keys
+            Set['catch_errors', 'env_vars', 'run_as']
           end
 
           def self.required_keys
-            Set['targets']
+            Set['script', 'targets']
           end
 
-          def initialize(step_body)
+          def self.validate_step_keys(body, number)
             super
-            @script = step_body['script']
-            @parameters = step_body.fetch('parameters', {})
-            @arguments = step_body.fetch('arguments', [])
+
+            if body.key?('arguments') && !body['arguments'].nil? && !body['arguments'].is_a?(Array)
+              raise StepError.new('arguments key must be an array', body['name'], number)
+            end
+
+            if body.key?('pwsh_params') && !body['pwsh_params'].nil? && !body['pwsh_params'].is_a?(Hash)
+              raise StepError.new('pwsh_params key must be a hash', body['name'], number)
+            end
+
+            if body.key?('env_vars') && ![Hash, String].include?(body['env_vars'].class)
+              raise StepError.new('env_vars key must be a hash or evaluable string', body['name'], number)
+            end
           end
 
-          def transpile
-            code = String.new("  ")
-            code << "$#{@name} = " if @name
+          # Returns an array of arguments to pass to the step's function call
+          #
+          private def format_args(body)
+            args        = body['arguments'] || []
+            pwsh_params = body['pwsh_params'] || {}
 
-            options = @parameters.dup
-            options['arguments'] = @arguments unless @arguments.empty?
+            opts = format_options(body)
+            opts = opts.merge('arguments' => args) if args.any?
+            opts = opts.merge('pwsh_params' => pwsh_params) if pwsh_params.any?
 
-            fn = 'run_script'
-            args = [@script, @targets]
-            args << @description if @description
-            args << options unless options.empty?
+            args = [body['script'], body['targets']]
+            args << body['description'] if body['description']
+            args << opts if opts.any?
 
-            code << function_call(fn, args)
+            args
+          end
 
-            code << "\n"
+          # Returns the function corresponding to the step
+          #
+          private def function
+            'run_script'
           end
         end
       end

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

@@ -6,31 +6,34 @@ module Bolt
       class Step
         class Task < Step
           def self.allowed_keys
-            super + Set['task', 'parameters']
+            super + Set['parameters']
           end
 
-          def self.required_keys
-            Set['targets']
+          def self.option_keys
+            Set['catch_errors', 'noop', 'run_as']
           end
 
-          def initialize(step_body)
-            super
-            @task = step_body['task']
-            @parameters = step_body.fetch('parameters', {})
+          def self.required_keys
+            Set['targets', 'task']
           end
 
-          def transpile
-            code = String.new("  ")
-            code << "$#{@name} = " if @name
+          # Returns an array of arguments to pass to the step's function call
+          #
+          private def format_args(body)
+            opts   = format_options(body)
+            params = (body['parameters'] || {}).merge(opts)
 
-            fn = 'run_task'
-            args = [@task, @targets]
-            args << @description if @description
-            args << @parameters unless @parameters.empty?
+            args = [body['task'], body['targets']]
+            args << body['description'] if body['description']
+            args << params if params.any?
 
-            code << function_call(fn, args)
+            args
+          end
 
-            code << "\n"
+          # Returns the function corresponding to the step
+          #
+          private def function
+            'run_task'
           end
         end
       end