bolt 2.30.0 → 2.34.0

data/lib/bolt/puppetfile/module.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require 'bolt/error'
-
-# This class represents a module specification. It used by the Bolt::Puppetfile
-# class to have a consistent API for accessing a module's attributes.
-#
-module Bolt
-  class Puppetfile
-    class Module
-      attr_reader :owner, :name, :version
-
-      def initialize(owner, name, version = nil)
-        @owner   = owner
-        @name    = name
-        @version = version unless version == :latest
-      end
-
-      # Creates a new module from a hash.
-      #
-      def self.from_hash(mod)
-        unless mod['name'].is_a?(String)
-          raise Bolt::ValidationError,
-                "Module name must be a String, not #{mod['name'].inspect}"
-        end
-
-        owner, name = mod['name'].tr('/', '-').split('-', 2)
-
-        unless owner && name
-          raise Bolt::ValidationError, "Module name #{mod['name']} must include both the owner and module name."
-        end
-
-        new(owner, name, mod['version_requirement'])
-      end
-
-      # Returns the module's title.
-      #
-      def title
-        "#{@owner}-#{@name}"
-      end
-      alias to_s title
-
-      # Checks two modules for equality.
-      #
-      def eql?(other)
-        self.class == other.class &&
-          @owner == other.owner &&
-          @name == other.name &&
-          versions_intersect?(other)
-      end
-      alias == eql?
-
-      # Returns true if the versions of two modules intersect. Used to determine
-      # if an installed module satisfies the version requirement of another.
-      #
-      def versions_intersect?(other)
-        range       = ::SemanticPuppet::VersionRange.parse(@version || '')
-        other_range = ::SemanticPuppet::VersionRange.parse(other.version || '')
-
-        range.intersection(other_range) != ::SemanticPuppet::VersionRange::EMPTY_RANGE
-      end
-
-      # Hashes the module.
-      #
-      def hash
-        [@owner, @name].hash
-      end
-
-      # Returns a hash representation similar to the module
-      # declaration.
-      #
-      def to_hash
-        {
-          'name'                => title,
-          'version_requirement' => version
-        }.compact
-      end
-
-      # Returns the Puppetfile specification for the module.
-      #
-      def to_spec
-        if @version
-          "mod #{title.inspect}, #{@version.inspect}"
-        else
-          "mod #{title.inspect}"
-        end
-      end
-    end
-  end
-end

data/lib/bolt_server/pe/pal.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require 'bolt/pal'
-require 'bolt/util'
-
-module BoltServer
-  module PE
-    class PAL < Bolt::PAL
-      # PE_BOLTLIB_PATH is intended to function exactly like the BOLTLIB_PATH used
-      # in Bolt::PAL. Paths and variable names are similar to what exists in
-      # Bolt::PAL, but with a 'PE' prefix.
-      PE_BOLTLIB_PATH = '/opt/puppetlabs/server/apps/bolt-server/pe-bolt-modules'
-
-      # For now at least, we maintain an entirely separate codedir from
-      # puppetserver by default, so that filesync can work properly. If filesync
-      # is not used, this can instead match the usual puppetserver codedir.
-      # See the `orchestrator.bolt.codedir` tk config setting.
-      DEFAULT_BOLT_CODEDIR = '/opt/puppetlabs/server/data/orchestration-services/code'
-
-      # This function is nearly identical to Bolt::Pal's `with_puppet_settings` with the
-      # one difference that we set the codedir to point to actual code, rather than the
-      # tmpdir. We only use this funtion inside the PEBolt::PAL initializer so that Puppet
-      # is correctly configured to pull environment configuration correctly. If we don't
-      # set codedir in this way: when we try to load and interpolate the modulepath it
-      # won't correctly load.
-      def with_pe_pal_init_settings(codedir, environmentpath, basemodulepath)
-        Dir.mktmpdir('pe-bolt') do |dir|
-          cli = []
-          Puppet::Settings::REQUIRED_APP_SETTINGS.each do |setting|
-            dir = setting == :codedir ? codedir : dir
-            cli << "--#{setting}" << dir
-          end
-          cli << "--environmentpath" << environmentpath
-          cli << "--basemodulepath" << basemodulepath
-          Puppet.settings.send(:clear_everything_for_tests)
-          Puppet.initialize_settings(cli)
-          yield
-          # Ensure the puppet settings go back to what bolt expects after
-          # we finish with the settings we need for PEBolt::PAL init.
-          with_puppet_settings { |_| nil }
-        end
-      end
-
-      def initialize(plan_executor_config, environment_name, hiera_config = nil, max_compiles = nil)
-        # Bolt::PAL#initialize takes the modulepath as its first argument, but we
-        # want to customize it later, so we pass an empty value:
-        super([], hiera_config, max_compiles)
-
-        codedir = plan_executor_config['codedir'] || DEFAULT_BOLT_CODEDIR
-        environmentpath = plan_executor_config['environmentpath'] || "#{codedir}/environments"
-        basemodulepath = plan_executor_config['basemodulepath'] || "#{codedir}/modules:/opt/puppetlabs/puppet/modules"
-
-        with_pe_pal_init_settings(codedir, environmentpath, basemodulepath) do
-          environment = Puppet.lookup(:environments).get!(environment_name)
-          # A new modulepath is created from scratch (rather than using super's @modulepath)
-          # so that we can have full control over all the entries in modulepath. In the future
-          # it's likely we will need to preceed _both_ Bolt::PAL::BOLTLIB_PATH _and_
-          # Bolt::PAL::MODULES_PATH which would be more complex if we tried to use @modulepath since
-          # we need to append our modulepaths and exclude modules shiped in bolt gem code
-          modulepath_dirs = environment.modulepath
-          @user_modulepath = modulepath_dirs
-          @modulepath = [PE_BOLTLIB_PATH, Bolt::PAL::BOLTLIB_PATH, *modulepath_dirs]
-        end
-      end
-    end
-  end
-end

data/modules/secure_env_vars/plans/init.pp

@@ -1,20 +0,0 @@
-plan secure_env_vars(
-  TargetSpec $targets,
-  Optional[String] $command = undef,
-  Optional[String] $script = undef
-) {
-  $env_vars = parsejson(system::env('BOLT_ENV_VARS'))
-  unless type($command) == Undef or type($script) == Undef {
-      fail_plan('Cannot specify both script and command for secure_env_vars')
-  }
-
-  return if $command {
-           run_command($command, $targets, '_env_vars' => $env_vars)
-         }
-         elsif $script {
-           run_script($script, $targets, '_env_vars' => $env_vars)
-         }
-         else {
-           fail_plan('Must specify either script or command for secure_env_vars')
-         }
-}