akerl-r10k 3.14.2.1

data/lib/r10k/settings.rb

@@ -0,0 +1,312 @@
+require 'etc'
+
+module R10K
+  module Settings
+    require 'r10k/settings/container'
+    require 'r10k/settings/mixin'
+
+    require 'r10k/settings/collection'
+    require 'r10k/settings/definition'
+    require 'r10k/settings/list'
+
+    class << self
+      # Path to puppet executable
+      attr_accessor :puppet_path
+      # Path to puppet.conf
+      attr_accessor :puppet_conf
+    end
+
+    def self.git_settings
+      R10K::Settings::Collection.new(:git, [
+
+        EnumDefinition.new(:provider, {
+          :desc => "The Git provider to use. Valid values: 'shellgit', 'rugged'",
+          :normalize => lambda { |input| input.to_sym },
+          :enum => [:shellgit, :rugged],
+        }),
+
+        Definition.new(:username, {
+          :desc => "The username to use for Git SSH remotes that do not specify a user.
+                    Only used by the 'rugged' Git provider.
+                    Default: the current user",
+          :default => lambda { Etc.getlogin },
+        }),
+
+        Definition.new(:private_key, {
+          :desc => "The path to the SSH private key for Git SSH remotes.
+                    Only used by the 'rugged' Git provider.",
+        }),
+
+        Definition.new(:oauth_token, {
+          :desc => "The path to a token file for Git OAuth remotes.
+                    Only used by the 'rugged' Git provider."
+        }),
+
+        Definition.new(:github_app_id, {
+          :desc => "The Github App id for Git SSL remotes.
+                    Only used by the 'rugged' Git provider."
+        }),
+
+        Definition.new(:github_app_key, {
+          :desc => "The Github App private key for Git SSL remotes.
+                    Only used by the 'rugged' Git provider."
+        }),
+
+        Definition.new(:github_app_ttl, {
+          :desc => "The ttl expiration for SSL tokens.
+                    Only used by the 'rugged' Git provider.",
+          :default => "120",
+        }),
+
+        URIDefinition.new(:proxy, {
+          :desc => "An optional proxy server to use when interacting with Git sources via HTTP(S).",
+          :default => :inherit,
+        }),
+
+        List.new(:repositories, lambda {
+          R10K::Settings::Collection.new(nil, [
+            Definition.new(:remote, {
+              :desc => "Remote source that repository-specific settings should apply to.",
+            }),
+
+            Definition.new(:private_key, {
+              :desc => "The path to the SSH private key for Git SSH remotes.
+                        Only used by the 'rugged' Git provider.",
+              :default => :inherit,
+            }),
+
+            Definition.new(:oauth_token, {
+              :desc => "The path to a token file for Git OAuth remotes.
+                        Only used by the 'rugged' Git provider.",
+              :default => :inherit
+            }),
+
+            Definition.new(:github_app_id, {
+              :desc => "The Github App id for Git SSL remotes.
+                        Only used by the 'rugged' Git provider.",
+              :default => :inherit
+            }),
+
+            Definition.new(:github_app_key, {
+              :desc => "The Github App private key for Git SSL remotes.
+                        Only used by the 'rugged' Git provider.",
+              :default => :inherit
+            }),
+
+            Definition.new(:github_app_ttl, {
+              :desc => "The ttl expiration for Git SSL tokens.
+                        Only used by the 'rugged' Git provider.",
+              :default => :inherit
+            }),
+
+            URIDefinition.new(:proxy, {
+              :desc => "An optional proxy server to use when interacting with Git sources via HTTP(S).",
+              :default => :inherit,
+            }),
+
+            Definition.new(:ignore_branch_prefixes, {
+              :desc => "Array of strings used to prefix branch names that will not be deployed as environments.",
+            }),
+          ])
+        },
+        {
+          :desc => "Repository specific configuration.",
+          :default => [],
+        }),
+      ])
+    end
+
+    def self.forge_settings
+      R10K::Settings::Collection.new(:forge, [
+        URIDefinition.new(:proxy, {
+          :desc => "An optional proxy server to use when downloading modules from the forge.",
+          :default => :inherit,
+        }),
+
+        URIDefinition.new(:baseurl, {
+          :desc => "The URL to the Puppet Forge to use for downloading modules."
+        }),
+
+        Definition.new(:authorization_token, {
+          :desc => "The token for Puppet Forge authorization. Leave blank for unauthorized or license-based connections."
+        }),
+
+        Definition.new(:allow_puppetfile_override, {
+          :desc => "Whether to use `forge` declarations in the Puppetfile as an override of `baseurl`.",
+          :default => false,
+          :validate => lambda do |value|
+            unless !!value == value
+              raise ArgumentError, "`allow_puppetfile_override` can only be a boolean value, not '#{value}'"
+            end
+          end
+        })
+      ])
+    end
+
+    def self.deploy_settings
+      R10K::Settings::Collection.new(:deploy, [
+        Definition.new(:write_lock, {
+          :desc => "Whether r10k deploy actions should be locked out in case r10k is being managed
+          by another application. The value should be a string containing the reason for the write lock.",
+          :validate => lambda do |value|
+            if value && !value.is_a?(String)
+              raise ArgumentError, "The write_lock setting should be a string containing the reason for the write lock, not a #{value.class}"
+            end
+          end
+        }),
+
+        EnumDefinition.new(:purge_levels, {
+          :desc => "Controls how aggressively r10k will purge unmanaged content from the target directory. Should be a list of values indicating at what levels unmanaged content should be purged. Options are 'deployment', 'environment', and 'puppetfile'. For backwards compatibility, the default is ['deployment', 'puppetfile'].",
+          :multi => true,
+          :enum => [:deployment, :environment, :puppetfile],
+          :default => [:deployment, :puppetfile],
+          :normalize => lambda do |input|
+            if input.respond_to?(:collect)
+              input.collect { |val| val.to_sym }
+            else
+              # Convert single values to a list of one symbolized value.
+              [input.to_sym]
+            end
+          end,
+        }),
+
+        Definition.new(:purge_allowlist, {
+          :desc => "A list of filename patterns to be excluded from any purge operations. Patterns are matched relative to the root of each deployed environment, if you want a pattern to match recursively you need to use the '**' glob in your pattern. Basic shell style globs are supported.",
+          :default => [],
+        }),
+
+        Definition.new(:purge_whitelist, {
+          :desc => "Deprecated; please use purge_allowlist instead. This setting will be removed in a future version.",
+          :default => [],
+        }),
+
+        Definition.new(:generate_types, {
+          :desc => "Controls whether to generate puppet types after deploying an environment. Defaults to false.",
+          :default => false,
+          :normalize => lambda do |input|
+            input.to_s == 'true'
+          end,
+        }),
+
+        Definition.new(:puppet_path, {
+          :desc => "Path to puppet executable. Defaults to /opt/puppetlabs/bin/puppet.",
+          :default => '/opt/puppetlabs/bin/puppet',
+          :validate => lambda do |value|
+            unless File.executable? value
+              raise ArgumentError, "The specified puppet executable #{value} is not executable"
+            end
+          end
+        }),
+        Definition.new(:puppet_conf, {
+          :desc => "Path to puppet.conf. Defaults to /etc/puppetlabs/puppet/puppet.conf.",
+          :default => '/etc/puppetlabs/puppet/puppet.conf',
+          :validate => lambda do |value|
+            unless File.readable? value
+              raise ArgumentError, "The specified puppet.conf #{value} is not readable"
+            end
+          end
+        }),
+        Definition.new(:exclude_spec, {
+          :desc => "Whether or not to deploy the spec dir of a module. Defaults to false.",
+          :default => false,
+          :validate => lambda do |value|
+            unless !!value == value
+              raise ArgumentError, "`exclude_spec` can only be a boolean value, not '#{value}'"
+            end
+          end
+        })])
+    end
+
+    def self.logging_settings
+      R10K::Settings::Collection.new(:logging, [
+        Definition.new(:level, {
+          desc: 'What logging level should R10k run on if not specified at runtime.',
+          validate: lambda do |value|
+            if R10K::Logging.parse_level(value).nil?
+              raise ArgumentError, "`level` must be a valid log level.
+                                    Valid levels are #{R10K::Logging::LOG_LEVELS.map(&:downcase).inspect}"
+            end
+          end
+        }),
+
+        Definition.new(:outputs, {
+          desc: 'Additional log outputs to use.',
+          validate: lambda do |value|
+            unless value.is_a?(Array)
+              raise ArgumentError, "The `outputs` setting should be an array of outputs, not a #{value.class}"
+            end
+          end
+        }),
+
+        Definition.new(:disable_default_stderr, {
+          desc: 'Disable the default stderr logging output',
+          default: false,
+          validate: lambda do |value|
+            unless !!value == value
+              raise ArgumentError, "`disable_default_stderr` can only be a boolean value, not '#{value}'"
+            end
+          end
+        })
+      ])
+    end
+
+    def self.global_settings
+      R10K::Settings::Collection.new(:global, [
+        Definition.new(:sources, {
+          :desc => "Where r10k should retrieve sources when deploying environments.
+                    Only used for r10k environment deployment.",
+        }),
+
+        Definition.new(:purgedirs, {
+          :desc => "The purgedirs setting was deprecated in r10k 1.0.0 and is no longer respected.",
+        }),
+
+        Definition.new(:cachedir, {
+          :desc => "Where r10k should store cached Git repositories.",
+        }),
+
+        Definition.new(:postrun, {
+          :desc => "The command r10k should run after deploying environments or modules.",
+          :validate => lambda do |value|
+            if !value.is_a?(Array)
+              raise ArgumentError, "The postrun setting should be an array of strings, not a #{value.class}"
+            end
+          end
+        }),
+
+        Definition.new(:pool_size, {
+          :desc => "The amount of threads used to concurrently install modules. The default value is 1: install one module at a time.",
+          :default => 4,
+          :validate => lambda do |value|
+            if !value.is_a?(Integer)
+              raise ArgumentError, "The pool_size setting should be an integer, not a #{value.class}"
+            end
+            if !(value > 0)
+              raise ArgumentError, "The pool_size setting should be greater than zero."
+            end
+          end
+        }),
+
+        URIDefinition.new(:proxy, {
+          :desc => "Proxy to use for all r10k operations which occur over HTTP(S).",
+          :default => lambda {
+            [
+              ENV['HTTPS_PROXY'],
+              ENV['https_proxy'],
+              ENV['HTTP_PROXY'],
+              ENV['http_proxy']
+            ].find { |value| value }
+          },
+        }),
+
+        R10K::Settings.forge_settings,
+
+        R10K::Settings.git_settings,
+
+        R10K::Settings.deploy_settings,
+
+        R10K::Settings.logging_settings
+      ])
+    end
+  end
+end

data/lib/r10k/source/base.rb

@@ -0,0 +1,93 @@
+require 'r10k/logging'
+
+# This class defines a common interface for source implementations.
+#
+# @since 1.3.0
+class R10K::Source::Base
+
+  include R10K::Logging
+
+  # @!attribute [r] basedir
+  #   @return [String] The path this source will place environments in
+  attr_reader :basedir
+
+  # @!attribute [r] name
+  #   @return [String] The short name for this environment source
+  attr_reader :name
+
+  # @!attribute [r] prefix
+  #   @return [String, nil] The prefix for the environments basedir.
+  #     Defaults to nil.
+  attr_reader :prefix
+
+  # @!attribute [r] puppetfile_name
+  #   @return [String, nil] The Name of the puppetfile
+  #     Defaults to nil.
+  attr_reader :puppetfile_name
+
+  # Initialize the given source.
+  #
+  # @param name [String] The identifier for this source.
+  # @param basedir [String] The base directory where the generated environments will be created.
+  # @param options [Hash] An additional set of options for this source. The
+  #   semantics of this hash may depend on the source implementation.
+  #
+  # @option options [Boolean, String] :prefix If a String this becomes the prefix.
+  #   If true, will use the source name as the prefix. All sources should respect this option.
+  #   Defaults to false for no environment prefix.
+  # @option options [String] :strip_component If a string, this value will be
+  #   removed from the beginning of each generated environment's name, if
+  #   present. If the string is contained within two "/" characters, it will
+  #   be treated as a regular expression.
+  def initialize(name, basedir, options = {})
+    @name    = name
+    @basedir = Pathname.new(basedir).cleanpath.to_s
+    @prefix  = options.delete(:prefix)
+    @strip_component = options.delete(:strip_component)
+    @puppetfile_name = options.delete(:puppetfile_name)
+    @options = options
+  end
+
+  # Perform any actions needed for loading environments that may have side
+  # effects.
+  #
+  # Actions done during preloading may include things like updating caches or
+  # performing network queries. If an environment has not been preloaded but
+  # {#environments} is invoked, it should return the best known state of
+  # environments or return an empty list.
+  #
+  # @api public
+  # @abstract
+  # @return [void]
+  def preload!
+
+  end
+
+  # Perform actions to reload environments after the `preload!`. Similar
+  # to preload!, and likely to include network queries and rerunning
+  # environment generation.
+  #
+  # @api public
+  # @abstract
+  # @return [void]
+  def reload!
+  end
+
+  # Enumerate the environments associated with this SVN source.
+  #
+  # @api public
+  # @abstract
+  # @return [Array<R10K::Environment::Base>] An array of environments created
+  #   from this source.
+  def environments
+    raise NotImplementedError, _("%{class} has not implemented method %{method}") % {class: self.class, method: __method__}
+  end
+
+  def accept(visitor)
+    visitor.visit(:source, self) do
+      environments.each do |env|
+        env.accept(visitor)
+      end
+    end
+  end
+end

data/lib/r10k/source/exec.rb

@@ -0,0 +1,51 @@
+require 'r10k/util/subprocess'
+require 'json'
+require 'yaml'
+
+class R10K::Source::Exec < R10K::Source::Hash
+  R10K::Source.register(:exec, self)
+
+  def initialize(name, basedir, options = {})
+    unless @command = options[:command]
+      raise ConfigError, _('Environment source %{name} missing required parameter: command') % {name: name}
+    end
+
+    # We haven't set the environments option yet. We will do that by
+    # overloading the #environments method.
+    super(name, basedir, options)
+  end
+
+  def environments_hash
+    @environments_hash ||= set_environments_hash(run_environments_command)
+  end
+
+  private
+
+  def run_environments_command
+    subproc = R10K::Util::Subprocess.new([@command])
+    subproc.raise_on_fail = true
+    subproc.logger = self.logger
+    procresult = subproc.execute
+
+    begin
+      environments = JSON.parse(procresult.stdout)
+    rescue JSON::ParserError => json_err
+      begin
+        environments = YAML.safe_load(procresult.stdout)
+      rescue Psych::SyntaxError => yaml_err
+        raise R10K::Error, _("Error parsing command output for exec source %{name}:\n" \
+                             "Not valid JSON: %{j_msg}\n" \
+                             "Not valid YAML: %{y_msg}\n" \
+                             "Stdout:\n%{out}") % {name: name, j_msg: json_err.message, y_msg: yaml_err.message, out: procresult.stdout}
+      end
+    end
+
+    unless R10K::Source::Hash.valid_environments_hash?(environments)
+      raise R10K::Error, _("Environment source %{name} command %{cmd} did not return valid environment data.\n" \
+                           'Returned: %{data}') % {name: name, cmd: @command, data: environments}
+    end
+
+    # Return the resulting environments hash
+    environments
+  end
+end

data/lib/r10k/source/git.rb

@@ -0,0 +1,178 @@
+require 'r10k/git'
+require 'r10k/environment'
+require 'r10k/environment/name'
+
+# This class implements a source for Git environments.
+#
+# A Git source generates environments by locally caching the given Git
+# repository and enumerating the branches for the Git repository. Branches
+# are mapped to environments without modification.
+#
+# @since 1.3.0
+class R10K::Source::Git < R10K::Source::Base
+
+  R10K::Source.register(:git, self)
+  # Register git as the default source
+  R10K::Source.register(nil, self)
+
+  # @!attribute [r] remote
+  #   @return [String] The URL to the remote git repository
+  attr_reader :remote
+
+  # @!attribute [r] cache
+  #   @api private
+  #   @return [R10K::Git::Cache] The git cache associated with this source
+  attr_reader :cache
+
+  # @!attribute [r] settings
+  #   @return [Hash<Symbol, Object>] Additional settings that configure how
+  #     the source should behave.
+  attr_reader :settings
+
+  # @!attribute [r] invalid_branches
+  #   @return [String] How Git branch names that cannot be cleanly mapped to
+  #     Puppet environments will be handled.
+  attr_reader :invalid_branches
+
+  # @!attribute [r] ignore_branch_prefixes
+  #   @return [Array<String>] Array of strings used to remove repository branches
+  #     that will be deployed as environments.
+  attr_reader :ignore_branch_prefixes
+
+  # @!attribute [r] filter_command
+  #   @return [String] Command to run to filter branches
+  attr_reader :filter_command
+
+  # Initialize the given source.
+  #
+  # @param name [String] The identifier for this source.
+  # @param basedir [String] The base directory where the generated environments will be created.
+  # @param options [Hash] An additional set of options for this source.
+  #
+  # @option options [Boolean, String] :prefix If a String this becomes the prefix.
+  #   If true, will use the source name as the prefix.
+  #   Defaults to false for no environment prefix.
+  # @option options [String] :remote The URL to the base directory of the SVN repository
+  # @option options [Hash] :remote Additional settings that configure how the
+  #   source should behave.
+  def initialize(name, basedir, options = {})
+    super
+
+    @environments = []
+
+    @remote = options[:remote]
+    @invalid_branches = (options[:invalid_branches] || 'correct_and_warn')
+    @ignore_branch_prefixes = options[:ignore_branch_prefixes]
+    @filter_command = options[:filter_command]
+
+    @cache  = R10K::Git.cache.generate(@remote)
+  end
+
+  # Update the git cache for this git source to get the latest list of environments.
+  #
+  # @return [void]
+  def preload!
+    logger.debug _("Fetching '%{remote}' to determine current branches.") % {remote: @remote}
+    @cache.sync
+  rescue => e
+    raise R10K::Error.wrap(e, _("Unable to determine current branches for Git source '%{name}' (%{basedir})") % {name: @name, basedir: @basedir})
+  end
+  alias fetch_remote preload!
+
+  # Load the git remote and create environments for each branch. If the cache
+  # has not been fetched, this will return an empty list.
+  #
+  # @return [Array<R10K::Environment::Git>]
+  def environments
+    if not @cache.cached?
+      []
+    elsif @environments.empty?
+      @environments = generate_environments()
+    else
+      @environments
+    end
+  end
+
+  def reload!
+    @cache.sync!
+    @environments = generate_environments()
+  end
+
+  def generate_environments
+    envs = []
+    environment_names.each do |en|
+      if en.valid?
+        envs << R10K::Environment::Git.new(en.name,
+                                           @basedir,
+                                           en.dirname,
+                                           {remote: remote,
+                                            ref: en.original_name,
+                                            puppetfile_name: puppetfile_name,
+                                            overrides: @options[:overrides]})
+      elsif en.correct?
+       logger.warn _("Environment %{env_name} contained non-word characters, correcting name to %{corrected_env_name}") % {env_name: en.name.inspect, corrected_env_name: en.dirname}
+        envs << R10K::Environment::Git.new(en.name,
+                                           @basedir,
+                                           en.dirname,
+                                           {remote: remote,
+                                            ref: en.original_name,
+                                            puppetfile_name: puppetfile_name,
+                                            overrides: @options[:overrides]})
+      elsif en.validate?
+       logger.error _("Environment %{env_name} contained non-word characters, ignoring it.") % {env_name: en.name.inspect}
+      end
+    end
+
+    envs
+  end
+
+  # List all environments that should exist in the basedir for this source
+  # @note This is required by {R10K::Util::Basedir}
+  # @return [Array<String>]
+  def desired_contents
+    environments.map {|env| env.dirname }
+  end
+
+  def filter_branches_by_regexp(branches, ignore_prefixes)
+    filter = Regexp.new("^#{Regexp.union(ignore_prefixes)}")
+    branches = branches.reject do |branch|
+      result = filter.match(branch)
+      if result
+        logger.warn _("Branch %{branch} filtered out by ignore_branch_prefixes %{ibp}") % {branch: branch, ibp: @ignore_branch_prefixes}
+      end
+      result
+    end
+    branches
+  end
+
+  def filter_branches_by_command(branches, command)
+    branches.select do |branch|
+      result = system({'GIT_DIR' => @cache.git_dir.to_s, 'R10K_BRANCH' => branch, 'R10K_NAME' => @name.to_s}, command)
+      unless result
+        logger.warn _("Branch `%{name}:%{branch}` filtered out by filter_command %{cmd}") % {name: @name, branch: branch, cmd: command}
+      end
+      result
+    end
+  end
+
+  private
+
+  def environment_names
+    opts = {prefix: @prefix,
+            invalid: @invalid_branches,
+            source: @name,
+            strip_component: @strip_component}
+    branch_names = @cache.branches
+    if @ignore_branch_prefixes && !@ignore_branch_prefixes.empty?
+      branch_names = filter_branches_by_regexp(branch_names, @ignore_branch_prefixes)
+    end
+
+    if @filter_command && !@filter_command.empty?
+      branch_names = filter_branches_by_command(branch_names, @filter_command)
+    end
+
+    branch_names.map do |branch_name|
+      R10K::Environment::Name.new(branch_name, opts)
+    end
+  end
+end