r10k 3.5.2

data/lib/r10k/settings.rb

@@ -0,0 +1,194 @@
+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
+    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.",
+        }),
+
+        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,
+            }),
+
+            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."
+        }),
+      ])
+    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_whitelist, {
+          :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(: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
+        }),
+      ])
+    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.",
+          :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 => 1,
+          :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,
+      ])
+    end
+  end
+end

data/lib/r10k/settings/collection.rb

@@ -0,0 +1,123 @@
+require 'r10k/settings/helpers'
+require 'r10k/settings/definition'
+require 'r10k/util/setopts'
+require 'r10k/util/symbolize_keys'
+require 'r10k/errors'
+
+module R10K
+  module Settings
+
+    # Define a group of settings, which can be single definitions or nested
+    # collections.
+    class Collection
+      include R10K::Settings::Helpers
+
+      # @!attribute [r] name
+      #   @return [String] The name of this collection
+      attr_reader :name
+
+      # @param name [Symbol] The name of the collection
+      # @param settings [Array] All settings in this collection
+      def initialize(name, settings)
+        @name = name
+
+        @settings = {}
+
+        # iterate through settings and adopt them
+        settings.each do |s|
+          s.parent = self
+          @settings[s.name] = s
+        end
+      end
+
+      # Assign new values, perform validation checks, and return the final
+      # values for this collection
+      def evaluate(newvalues)
+        assign(newvalues)
+        validate
+        resolve
+      end
+
+      # Assign a hash of values to the settings in this collection.
+      #
+      # If the passed hash contains any invalid settings values, the names
+      # of those settings are stored for use in the {#validate} method.
+      #
+      # @param newvalues [Hash]
+      # @return [void]
+      def assign(newvalues)
+        return if newvalues.nil?
+
+        R10K::Util::SymbolizeKeys.symbolize_keys!(newvalues)
+
+        @settings.each_pair do |name, setting|
+          if newvalues.key?(name)
+            setting.assign(newvalues[name])
+          end
+        end
+      end
+
+      # Validate all settings and return validation errors
+      #
+      # @return [nil, Hash] If all validation passed nil will be returned; if
+      #   validation failed then a hash of those errors will be returned.
+      def validate
+        errors = {}
+
+        @settings.each_pair do |name, setting|
+          begin
+            setting.validate
+          rescue => error
+            errors[name] = error
+          end
+        end
+
+        if !errors.empty?
+          if @name
+            msg = _("Validation failed for '%{name}' settings group") % {name: @name}
+          else
+            msg = _("Validation failed for settings group")
+          end
+
+          raise ValidationError.new(msg, :errors => errors)
+        end
+      end
+
+      # Evaluate all settings and return a frozen hash of the final values.
+      # @return [Hash]
+      def resolve
+        rv = {}
+
+        @settings.each_pair do |name, setting|
+          rv[name] = setting.resolve
+        end
+
+        rv.freeze
+      end
+
+      # Access individual settings via a Hash-like interface.
+      def [](name)
+        @settings[name]
+      end
+
+      class ValidationError < R10K::Error
+
+        attr_reader :errors
+
+        def initialize(mesg, options = {})
+          super
+          @errors = options[:errors]
+        end
+
+        def format
+          struct = []
+          struct << "#{message}:"
+          @errors.each_pair do |name, nested|
+            struct << indent(structure_exception(name, nested))
+          end
+          struct.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/r10k/settings/container.rb

@@ -0,0 +1,97 @@
+# Defines a collection for application settings
+#
+# This implements a hierarchical interface to application settings. Containers
+# can define an optional parent container that will be used for default options
+# if those options aren't set on the given container.
+class R10K::Settings::Container
+
+  # @!attribute [r] valid_keys
+  #   @return [Set<Symbol>] All valid keys defined on the container or parent container.
+  attr_accessor :valid_keys
+
+  # @param parent [R10K::Settings::Container] An optional parent container
+  def initialize(parent = nil)
+    @parent = parent
+
+    @valid_keys = Set.new
+    @settings = {}
+  end
+
+  # Look up a value in the container. The lookup checks the current container,
+  # and then falls back to the parent container if it's given.
+  #
+  # @param key [Symbol] The lookup key
+  #
+  # @return [Object, nil] The retrieved value if present.
+  #
+  # @raise [R10K::Settings::Container::InvalidKey] If the looked up key isn't
+  #   a valid key.
+  def [](key)
+    validate_key! key
+
+    if @settings[key]
+      @settings[key]
+    elsif @parent && (pkey = @parent[key])
+      begin
+        @settings[key] = pkey.dup
+      rescue TypeError
+        @settings[key] = pkey
+      end
+      @settings[key]
+    end
+  end
+
+  # Set a value on the container
+  #
+  # @param key [Symbol] The lookup key
+  # @param value [Object] The value to store in the container
+  #
+  # @raise [R10K::Settings::Container::InvalidKey] If the looked up key isn't
+  #   a valid key.
+  def []=(key, value)
+    validate_key! key
+
+    @settings[key] = value
+  end
+
+  # Define a valid container key
+  #
+  # @note This should only be used by {#R10K::Settings::ClassSettings}
+  #
+  # @param key [Symbol]
+  # @return [void]
+  def add_valid_key(key)
+    @valid_keys.add(key)
+  end
+
+  # Determine if a key is a valid setting.
+  #
+  # @param key [Symbol]
+  #
+  # @return [true, false]
+  def valid_key?(key)
+    if @valid_keys.include?(key)
+      true
+    elsif @parent and @parent.valid_key?(key)
+      @valid_keys.add(key)
+      true
+    end
+  end
+
+  # Clear all existing settings in this container. Valid settings are left alone.
+  # @return [void]
+  def reset!
+    @settings = {}
+  end
+
+  private
+
+  def validate_key!(key)
+    unless valid_key?(key)
+      raise InvalidKey, _("Key %{key} is not a valid key") % {key: key}
+    end
+  end
+
+  # @api private
+  class InvalidKey < StandardError; end
+end

data/lib/r10k/settings/definition.rb

@@ -0,0 +1,124 @@
+require 'r10k/settings/helpers'
+require 'r10k/util/setopts'
+
+module R10K
+  module Settings
+
+    # Define a single setting and additional attributes like descriptions,
+    # default values, and validation.
+    class Definition
+      require 'r10k/settings/uri_definition'
+      require 'r10k/settings/enum_definition'
+
+      include R10K::Settings::Helpers
+      include R10K::Util::Setopts
+
+      # @!attribute [r] name
+      #   @return [String] The name of this setting
+      attr_reader :name
+
+      # @!attribute [r] value
+      #   @return [Object] An explicitly set value. This should only be used if
+      #     an optional default value should not be used; otherwise use {#resolve}.
+      attr_reader :value
+
+      # @!attribute [r] desc
+      #   @return [String] An optional documentation string for this setting.
+      attr_reader :desc
+
+      # @param name [Symbol] The name of the setting for this definition.
+      # @param opts [Hash] Additional options for this definition to control
+      #   validation, normalization, and the like.
+      #
+      # @option opts [Proc, Object] :default An optional proc or object for
+      #   this setting. If no value has been set and the default is a Proc then
+      #   it will be called and the result will be returned, otherwise if the
+      #   value is not set the default value itself is returned.
+      #
+      # @options opts [Proc] :validate An optional proc that can be used to
+      #   validate an assigned value. Default values are not assigned.
+      #
+      # @options opts [Proc] :normalize An optional proc that can be used to
+      #   normalize an explicitly assigned value.
+      def initialize(name, opts = {})
+        @name = name
+        setopts(opts, allowed_initialize_opts)
+      end
+
+      # Assign new values, perform validation checks, and return the final
+      # values for this collection
+      def evaluate(newvalue)
+        assign(newvalue)
+        validate
+        resolve
+      end
+
+      # Store an explicit value for this definition
+      #
+      # If a :normalize hook has been given then it will be called with the
+      # new value and the returned value will be stored.
+      #
+      # @param newvalue [Object] The value to store for this setting
+      # @return [void]
+      def assign(newvalue)
+        if @normalize
+          @value = @normalize.call(newvalue)
+        else
+          @value = newvalue
+        end
+      end
+
+      # Call any validation hooks for this definition.
+      #
+      # The :validate hook will be called if the hook has been set and an
+      # explicit value has been assigned to this definition. Validation
+      # failures should be indicated by the :validate hook raising an exception.
+      #
+      # @raise [Exception] An exception class indicating that validation failed.
+      # @return [nil]
+      def validate
+        if @value && @validate
+          @validate.call(@value)
+        end
+        nil
+      end
+
+      # Compute the final value of this setting. If a value has not been
+      # assigned the default value will be used.
+      #
+      # @return [Object] The final value of this definition.
+      def resolve
+        if !@value.nil?
+          @value
+        elsif @default
+          if @default == :inherit
+            # walk all the way up to root, starting with grandparent
+            ancestor = parent
+
+            while ancestor = ancestor.parent
+              return ancestor[@name].resolve if ancestor.respond_to?(:[]) && ancestor[@name]
+            end
+          elsif @default.is_a?(Proc)
+            @default.call
+          else
+            @default
+          end
+        end
+      end
+
+      private
+
+      # Subclasses may define additional params that are accepted at
+      # initialization; they should override this method to add any
+      # additional fields that should be respected.
+      def allowed_initialize_opts
+        {
+          :desc      => true,
+          :default   => true,
+          :validate  => true,
+          :normalize => true,
+        }
+      end
+    end
+  end
+end