openbolt 5.0.0.rc1

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Parameter
+        attr_reader :name, :value, :type_expr, :description
+
+        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']
+          @description = definition['description']
+        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/command.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Command < Step
+          def self.option_keys
+            Set['catch_errors', 'env_vars', 'run_as']
+          end
+
+          def self.required_keys
+            Set['command', 'targets']
+          end
+
+          def self.validate_step_keys(body, number)
+            super
+
+            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
+
+          # Returns an array of arguments to pass to the step's function call
+          #
+          private def format_args(body)
+            opts = format_options(body)
+
+            args = [body['command'], body['targets']]
+            args << body['description'] if body['description']
+            args << opts if opts.any?
+
+            args
+          end
+
+          # Returns the function corresponding to the step
+          #
+          private def function
+            'run_command'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Download < Step
+          def self.option_keys
+            Set['catch_errors', 'run_as']
+          end
+
+          def self.required_keys
+            Set['download', 'destination', 'targets']
+          end
+
+          # Returns an array of arguments to pass to the step's function call
+          #
+          private def format_args(body)
+            opts = format_options(body)
+
+            args = [body['download'], body['destination'], body['targets']]
+            args << body['description'] if body['description']
+            args << opts if opts.any?
+
+            args
+          end
+
+          # Returns the function corresponding to the step
+          #
+          private def function
+            'download_file'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Eval < Step
+          def self.required_keys
+            Set['eval']
+          end
+
+          # 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 << "$#{body['name']} = " if body['name']
+
+            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 body['name'] && code_body.lines.count > 1
+              indented = code_body.gsub(/\n/, "\n    ").chomp("  ")
+              code << "with() || {\n    #{indented}}"
+            else
+              code << code_body
+            end
+
+            code << "\n"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Message < Step
+          def self.allowed_keys
+            super + Set['message']
+          end
+
+          def self.required_keys
+            Set['message']
+          end
+
+          # 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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Plan < Step
+          def self.allowed_keys
+            super + Set['parameters']
+          end
+
+          def self.option_keys
+            Set['catch_errors', 'run_as']
+          end
+
+          def self.required_keys
+            Set['plan']
+          end
+
+          # 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)
+
+            args = [body['plan']]
+            args << body['targets'] if body['targets']
+            args << params if params.any?
+
+            args
+          end
+
+          # Returns the function corresponding to the step
+          #
+          private def function
+            'run_plan'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Resources < Step
+          def self.option_keys
+            Set['catch_errors', 'description', 'noop', 'run_as']
+          end
+
+          def self.required_keys
+            Set['resources', 'targets']
+          end
+
+          def initialize(body)
+            super
+            @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)
+            super
+
+            body['resources'].each do |resource|
+              if resource['type'] || resource['title']
+                if !resource['type']
+                  err = "Resource declaration must include type key if title key is set"
+                  raise StepError.new(err, body['name'], step_number)
+                elsif !resource['title']
+                  err = "Resource declaration must include title key if type key is set"
+                  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 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 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?
+          #
+          private def normalize_resources(resources)
+            resources.map do |resource|
+              if resource['type'] && resource['title']
+                type = resource['type']
+                title = resource['title']
+              else
+                type, = (resource.keys - ['parameters'])
+                title = resource[type]
+              end
+
+              { 'type' => type, 'title' => title, 'parameters' => resource['parameters'] || {} }
+            end
+          end
+
+          def transpile
+            code = StringIO.new
+
+            code.print "  "
+            code << function_call('apply_prep', [body['targets']])
+            code.print "\n"
+
+            code.print "  "
+            code.print "$#{body['name']} = " if body['name']
+
+            code << function_call('apply', format_args(body))
+
+            code.print " {\n"
+
+            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|
+                Bolt::Util.to_code(val)
+              end
+
+              resource_str = StringIO.new
+              if parameters.empty?
+                resource_str.puts "    #{type} { #{title}: }"
+              else
+                resource_str.puts "    #{type} { #{title}:"
+                parameters.each do |key, val|
+                  resource_str.puts "      #{key} => #{val},"
+                end
+                resource_str.puts "    }"
+              end
+              resource_str.string
+            end
+
+            code.puts declarations.join("    ->\n")
+
+            code.puts "  }\n"
+            code.string
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Script < Step
+          def self.allowed_keys
+            super + Set['arguments', 'pwsh_params']
+          end
+
+          def self.option_keys
+            Set['catch_errors', 'env_vars', 'run_as']
+          end
+
+          def self.required_keys
+            Set['script', 'targets']
+          end
+
+          def self.validate_step_keys(body, number)
+            super
+
+            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
+
+          # 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'] || {}
+
+            opts = format_options(body)
+            opts = opts.merge('arguments' => args) if args.any?
+            opts = opts.merge('pwsh_params' => pwsh_params) if pwsh_params.any?
+
+            args = [body['script'], body['targets']]
+            args << body['description'] if body['description']
+            args << opts if opts.any?
+
+            args
+          end
+
+          # Returns the function corresponding to the step
+          #
+          private def function
+            'run_script'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Task < Step
+          def self.allowed_keys
+            super + Set['parameters']
+          end
+
+          def self.option_keys
+            Set['catch_errors', 'noop', 'run_as']
+          end
+
+          def self.required_keys
+            Set['targets', 'task']
+          end
+
+          # 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)
+
+            args = [body['task'], body['targets']]
+            args << body['description'] if body['description']
+            args << params if params.any?
+
+            args
+          end
+
+          # Returns the function corresponding to the step
+          #
+          private def function
+            'run_task'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Upload < Step
+          def self.option_keys
+            Set['catch_errors', 'run_as']
+          end
+
+          def self.required_keys
+            Set['destination', 'targets', 'upload']
+          end
+
+          # Returns an array of arguments to pass to the step's function call
+          #
+          private def format_args(body)
+            opts = format_options(body)
+
+            args = [body['upload'], body['destination'], body['targets']]
+            args << body['description'] if body['description']
+            args << opts if opts.any?
+
+            args
+          end
+
+          # Returns the function corresponding to the step
+          #
+          private def function
+            'upload_file'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Verbose < Step
+          def self.allowed_keys
+            super + Set['verbose']
+          end
+
+          def self.required_keys
+            Set['verbose']
+          end
+
+          # Returns an array of arguments to pass to the step's function call
+          #
+          private def format_args(body)
+            [body['verbose']]
+          end
+
+          # Returns the function corresponding to the step
+          #
+          private def function
+            'out::verbose'
+          end
+        end
+      end
+    end
+  end
+end