openbolt 5.0.0.rc1

data/lib/bolt/catalog/logging.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+Puppet::Util::Log.newdesttype :stderr do
+  def initialize
+    # Flush output immediately.
+    $stderr.sync = true
+  end
+
+  # Emits message as a single line of JSON mapping level to message string.
+  def handle(msg)
+    str = msg.respond_to?(:multiline) ? msg.multiline : msg.to_s
+    str = msg.source == "Puppet" ? str : "#{msg.source}: #{str}"
+    warn({ level: msg.level, message: str }.to_json)
+  end
+end

data/lib/bolt/catalog.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative '../bolt/apply_inventory'
+require_relative '../bolt/apply_target'
+require_relative '../bolt/config'
+require_relative '../bolt/error'
+require_relative '../bolt/inventory'
+require_relative '../bolt/pal'
+require_relative '../bolt/puppetdb'
+require_relative '../bolt/util'
+
+Bolt::PAL.load_puppet
+
+require_relative 'catalog/logging'
+
+module Bolt
+  class Catalog
+    def initialize(log_level = 'debug')
+      @log_level = log_level
+    end
+
+    def with_puppet_settings(overrides = {})
+      Dir.mktmpdir('bolt') do |dir|
+        cli = []
+        Puppet::Settings::REQUIRED_APP_SETTINGS.each do |setting|
+          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)
+        overrides.each do |setting, value|
+          Puppet.settings[setting] = value
+        end
+
+        # Use a special logdest that serializes all log messages and their level to stderr.
+        Puppet::Util::Log.newdestination(:stderr)
+        Puppet.settings[:log_level] = @log_level
+        yield
+      end
+    end
+
+    def generate_ast(code, filename = nil)
+      with_puppet_settings do
+        Puppet::Pal.in_tmp_environment("bolt_parse") do |pal|
+          pal.with_catalog_compiler do |compiler|
+            ast = compiler.parse_string(code, filename)
+            Puppet::Pops::Serialization::ToDataConverter.convert(ast,
+                                                                 rich_data: true,
+                                                                 symbol_to_string: true)
+          end
+        end
+      end
+    end
+
+    def compile_catalog(request)
+      pdb_client = Bolt::PuppetDB::Client.new(config: request['pdb_config'])
+      project = request['project']
+      bolt_project = Struct.new(:name, :path, :load_as_module?).new(project['name'],
+                                                                    project['path'],
+                                                                    project['load_as_module?'])
+      inv = Bolt::ApplyInventory.new(request['config'])
+      puppet_overrides = {
+        bolt_pdb_client: pdb_client,
+        bolt_inventory: inv,
+        bolt_project: bolt_project
+      }
+
+      # Facts will be set by the catalog compiler, so we need to ensure
+      # that any plan or target variables with the same name are not
+      # passed into the apply block to avoid a redefinition error.
+      # Filter out plan and target vars separately and raise a Puppet
+      # warning if there are any collisions for either. Puppet warning
+      # is the only way to log a message that will make it back to Bolt
+      # to be printed.
+      target = request['target']
+
+      variables = {
+        variables:        request['plan_vars'],
+        target_variables: target['variables']
+      }
+
+      env_conf = {
+        modulepath: request['modulepath'],
+        facts:      target['facts']
+      }
+
+      puppet_settings = {
+        node_name_value: target['name'],
+        hiera_config:    request['hiera_config']
+      }
+
+      with_puppet_settings(puppet_settings) do
+        Puppet::Pal.in_tmp_environment('bolt_catalog', **env_conf) do |pal|
+          Puppet.override(puppet_overrides) do
+            Puppet.lookup(:pal_current_node).trusted_data = target['trusted']
+            pal.with_catalog_compiler(**variables) do |compiler|
+              options = request['puppet_config'] || {}
+              # Configure language strictness in the CatalogCompiler. We want Bolt to be able
+              # to compile most Puppet 4+ manifests, so we default to allowing deprecated functions.
+              Puppet[:strict] = options['strict'] || :warning
+              Puppet[:strict_variables] = options['strict_variables'] || false
+
+              pal_main = request['code_ast'] || request['code_string']
+              ast = build_program(pal_main)
+              compiler.evaluate(ast)
+              compiler.evaluate_ast_node
+              compiler.compile_additions
+              compiler.with_json_encoding(&:encode)
+            end
+          end
+        end
+      end
+    end
+
+    def build_program(code)
+      ast = Puppet::Pops::Serialization::FromDataConverter.convert(code)
+
+      # This will be a Program when running via `bolt apply`, but will
+      # only be a subset of the AST when compiling an apply block in a
+      # plan. In that case, we need to discover the definitions (which
+      # would ordinarily be stored on the Program) and construct a Program object.
+      if ast.is_a?(Puppet::Pops::Model::Program)
+        ast
+      else
+        # Node definitions must be at the top level of the apply block.
+        # That means the apply body either a) consists of just a
+        # NodeDefinition, b) consists of a BlockExpression which may
+        # contain NodeDefinitions, or c) doesn't contain NodeDefinitions.
+        definitions = case ast
+                      when Puppet::Pops::Model::BlockExpression
+                        ast.statements.select { |st| st.is_a?(Puppet::Pops::Model::NodeDefinition) }
+                      when Puppet::Pops::Model::NodeDefinition
+                        [ast]
+                      else
+                        []
+                      end
+        Puppet::Pops::Model::Factory.PROGRAM(ast, definitions, ast.locator).model
+      end
+    end
+  end
+end