akerl-r10k 3.14.2.1

data/lib/r10k/environment/name.rb

@@ -0,0 +1,109 @@
+module R10K
+  module Environment
+    # Handle environment name validation and modification.
+    #
+    # @api private
+    class Name
+
+      # @!attribute [r] name
+      #   @return [String] The functional name of the environment derived from inputs and options.
+      attr_reader :name
+
+      # @!attribute [r] original_name
+      #   @return [String] The unmodified name originally given to create the object.
+      attr_reader :original_name
+
+      INVALID_CHARACTERS = %r[\W]
+
+      def initialize(original_name, opts)
+        @source  = opts[:source]
+        @prefix  = opts[:prefix]
+        @invalid = opts[:invalid]
+
+        @name = derive_name(original_name, opts[:strip_component])
+        @original_name = original_name
+        @opts = opts
+
+        case @invalid
+        when 'correct_and_warn'
+          @validate = true
+          @correct  = true
+        when 'correct'
+          @validate = false
+          @correct  = true
+        when 'error'
+          @validate = true
+          @correct  = false
+        when NilClass
+          @validate = opts[:validate]
+          @correct = opts[:correct]
+        end
+      end
+
+      # Should the environment name have invalid characters removed?
+      def correct?
+        @correct
+      end
+
+      def validate?
+        @validate
+      end
+
+      def valid?
+        if @validate
+          ! @name.match(INVALID_CHARACTERS)
+        else
+          true
+        end
+      end
+
+      # The directory name for the environment, modified as necessary to remove
+      # invalid characters.
+      #
+      # @return [String]
+      def dirname
+        dir = @name.dup
+
+        prefix = derive_prefix(@source,@prefix)
+
+        if @correct
+          dir.gsub!(INVALID_CHARACTERS, '_')
+        end
+
+        "#{prefix}#{dir}"
+      end
+
+
+      private
+
+      def derive_name(original_name, strip_component)
+        return original_name unless strip_component
+
+        unless strip_component.is_a?(String)
+          raise _('Improper configuration value given for strip_component setting in %{src} source. ' \
+                  'Value must be a string, a /regex/, false, or omitted. Got "%{val}" (%{type})' \
+                  % {src: @source, val: strip_component, type: strip_component.class})
+        end
+
+        if %r{^/.*/$}.match(strip_component)
+          regex = Regexp.new(strip_component[1..-2])
+          original_name.gsub(regex, '')
+        elsif original_name.start_with?(strip_component)
+          original_name[strip_component.size..-1]
+        else
+          original_name
+        end
+      end
+
+      def derive_prefix(source,prefix)
+        if prefix == true
+          "#{source}_"
+        elsif prefix.is_a? String
+          "#{prefix}_"
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/r10k/environment/plain.rb

@@ -0,0 +1,16 @@
+class R10K::Environment::Plain < R10K::Environment::WithModules
+
+  R10K::Environment.register(:plain, self)
+
+  def sync
+    path.mkpath
+  end
+
+  def status
+    :not_applicable
+  end
+
+  def signature
+    'plain-default'
+  end
+end

data/lib/r10k/environment/svn.rb

@@ -0,0 +1,98 @@
+require 'r10k/puppetfile'
+require 'r10k/svn/working_dir'
+require 'r10k/util/setopts'
+
+# This class implements an environment based on an SVN branch.
+#
+# @since 1.3.0
+class R10K::Environment::SVN < R10K::Environment::Base
+
+  R10K::Environment.register(:svn, self)
+
+  # @!attribute [r] remote
+  #   @return [String] The URL to the remote SVN branch to check out
+  attr_reader :remote
+
+  # @!attribute [r] working_dir
+  #   @api private
+  #   @return [R10K::SVN::WorkingDir] The SVN working directory backing this environment
+  attr_reader :working_dir
+
+  # @!attribute [r] username
+  #   @return [String, nil] The SVN username to be passed to the underlying SVN commands
+  #   @api private
+  attr_reader :username
+
+  # @!attribute [r] password
+  #   @return [String, nil] The SVN password to be passed to the underlying SVN commands
+  #   @api private
+  attr_reader :password
+
+  include R10K::Util::Setopts
+
+  # Initialize the given SVN environment.
+  #
+  # @param name [String] The unique name describing this environment.
+  # @param basedir [String] The base directory where this environment will be created.
+  # @param dirname [String] The directory name for this environment.
+  # @param options [Hash] An additional set of options for this environment.
+  #
+  # @option options [String] :remote The URL to the remote SVN branch to check out
+  # @option options [String] :username The SVN username
+  # @option options [String] :password The SVN password
+  def initialize(name, basedir, dirname, options = {})
+    super
+    setopts(options, {
+      # Standard option interface
+      :source   => :remote,
+      :version  => :expected_revision,
+      :type     => ::R10K::Util::Setopts::Ignore,
+
+      # Type-specific options
+      :remote   => :self,
+      :username => :self,
+      :password => :self,
+    })
+
+    @working_dir = R10K::SVN::WorkingDir.new(Pathname.new(@full_path), :username => @username, :password => @password)
+  end
+
+  # Perform an initial checkout of the SVN repository or update the repository.
+  #
+  # If the environment is being created for the first time, it will
+  # automatically update all modules to ensure that the environment is complete.
+  #
+  # @api public
+  # @return [void]
+  def sync
+    if @working_dir.is_svn?
+      @working_dir.update
+    else
+      @working_dir.checkout(@remote, @expected_revision)
+    end
+    @synced = true
+  end
+
+  # Return a sting which uniquely identifies (per source) the current state of the
+  # environment.
+  #
+  # @api public
+  # @return [String]
+  def signature
+    @working_dir.revision
+  end
+
+  def status
+    if !@path.exist?
+      :absent
+    elsif !@working_dir.is_svn?
+      :mismatched
+    elsif !(@remote == @working_dir.url)
+      :mismatched
+    elsif !@synced
+      :outdated
+    else
+      :insync
+    end
+  end
+end

data/lib/r10k/environment/tarball.rb

@@ -0,0 +1,78 @@
+require 'r10k/util/setopts'
+require 'r10k/tarball'
+require 'r10k/environment'
+
+class R10K::Environment::Tarball < R10K::Environment::WithModules
+
+  R10K::Environment.register(:tarball, self)
+
+  # @!attribute [r] tarball
+  #   @api private
+  #   @return [R10K::Tarball]
+  attr_reader :tarball
+
+  include R10K::Util::Setopts
+
+  # Initialize the given tarball environment.
+  #
+  # @param name [String] The unique name describing this environment.
+  # @param basedir [String] The base directory where this environment will be created.
+  # @param dirname [String] The directory name for this environment.
+  # @param options [Hash] An additional set of options for this environment.
+  #
+  # @param options [String] :source Where to get the tarball from
+  # @param options [String] :version The sha256 digest of the tarball
+  def initialize(name, basedir, dirname, options = {})
+    super
+    setopts(options, {
+      # Standard option interface
+      :type      => ::R10K::Util::Setopts::Ignore,
+      :source    => :self,
+      :version   => :checksum,
+
+      # Type-specific options
+      :checksum => :self,
+    })
+
+    @tarball = R10K::Tarball.new(name, @source, checksum: @checksum)
+  end
+
+  def path
+    @path ||= Pathname.new(File.join(@basedir, @dirname))
+  end
+
+  def sync
+    tarball.get unless tarball.cache_valid?
+    case status
+    when :absent, :mismatched
+      tarball.unpack(path.to_s)
+      # Untracked files left behind from previous extractions are expected to
+      # be deleted by r10k's purge facility.
+    end
+  end
+
+  def status
+    if not path.exist?
+      :absent
+    elsif not (tarball.cache_valid? && tarball.insync?(path.to_s, ignore_untracked_files: true))
+      :mismatched
+    else
+      :insync
+    end
+  end
+
+  def signature
+    @checksum || @tarball.cache_checksum
+  end
+
+  include R10K::Util::Purgeable
+
+  # Returns an array of the full paths to all the content being managed.
+  # @note This implements a required method for the Purgeable mixin
+  # @return [Array<String>]
+  def desired_contents
+    desired = []
+    desired += @tarball.paths.map { |entry| File.join(@full_path, entry) }
+    desired += super
+  end
+end

data/lib/r10k/environment/with_modules.rb

@@ -0,0 +1,174 @@
+require 'r10k/util/purgeable'
+
+# This abstract base class implements an environment that can include module
+# content
+#
+# @since 3.4.0
+class R10K::Environment::WithModules < R10K::Environment::Base
+
+  # @!attribute [r] moduledir
+  #   @return [String] The directory to install environment-defined modules
+  #     into (default: #{basedir}/modules)
+  attr_reader :moduledir
+
+  # Initialize the given environment.
+  #
+  # @param name [String] The unique name describing this environment.
+  # @param basedir [String] The base directory where this environment will be created.
+  # @param dirname [String] The directory name for this environment.
+  # @param options [Hash] An additional set of options for this environment.
+  #
+  # @param options [String] :moduledir The path to install modules to
+  # @param options [Hash] :modules Modules to add to the environment
+  def initialize(name, basedir, dirname, options = {})
+    super
+
+    @all_modules = nil
+    @managed_content = {}
+    @modules = []
+    @moduledir = case options[:moduledir]
+                 when nil
+                   File.join(@basedir, @dirname, 'modules')
+                 when File.absolute_path(options[:moduledir])
+                   options.delete(:moduledir)
+                 else
+                   File.join(@basedir, @dirname, options.delete(:moduledir))
+                 end
+
+    modhash = options.delete(:modules)
+    load_modules(modhash) unless modhash.nil?
+  end
+
+  # @return [Array<R10K::Module::Base>] All modules associated with this environment.
+  #   Modules may originate from either:
+  #     - The r10k environment object
+  #     - A Puppetfile in the environment's content
+  def modules
+    if @all_modules.nil?
+      puppetfile_modules = super()
+      @all_modules = @modules + puppetfile_modules
+    end
+
+    @all_modules
+  end
+
+  def module_conflicts?(mod_b)
+    conflict = @modules.any? { |mod_a| mod_a.name == mod_b.name }
+    return false unless conflict
+
+    msg_vars = {src: mod_b.origin, name: mod_b.name}
+    msg_error = _('Environment and %{src} both define the "%{name}" module' % msg_vars)
+    msg_continue = _("#{msg_error}. The %{src} definition will be ignored" % msg_vars)
+
+    case conflict_opt = @options[:module_conflicts]
+    when 'override_and_warn', nil
+      logger.warn msg_continue
+    when 'override'
+      logger.debug msg_continue
+    when 'error'
+      raise R10K::Error, msg_error
+    else
+      raise R10K::Error, _('Unexpected value for `module_conflicts` setting in %{env} ' \
+                           'environment: %{val}' % {env: self.name, val: conflict_opt})
+    end
+
+    true
+  end
+
+  def accept(visitor)
+    visitor.visit(:environment, self) do
+      @modules.each do |mod|
+        mod.sync
+      end
+
+      puppetfile.accept(visitor)
+    end
+  end
+
+  def deploy
+    @modules.each do |mod|
+      mod.sync
+    end
+
+    super
+  end
+
+  def load_modules(module_hash)
+    module_hash.each do |name, args|
+      if !args.is_a?(Hash)
+        args = { type: 'forge', version: args }
+      end
+
+      add_module(name, args)
+    end
+  end
+
+  def resolve_path(base, dirname, path)
+    if Pathname.new(path).absolute?
+      cleanpath(path)
+    else
+      cleanpath(File.join(base, dirname, path))
+    end
+  end
+
+  # .cleanpath is as good as we can do without touching the filesystem.
+  # The .realpath methods will choke if some of the intermediate paths
+  # are missing, even though in some cases we will create them later as
+  # needed.
+  def cleanpath(path)
+    Pathname.new(path).cleanpath.to_s
+  end
+
+  def validate_install_path(path, modname)
+    unless /^#{Regexp.escape(@basedir)}.*/ =~ path
+      raise R10K::Error.new("Environment cannot manage content '#{modname}' outside of containing environment: #{path} is not within #{@basedir}")
+    end
+    true
+  end
+
+  # @param [String] name
+  # @param [Hash] args
+  def add_module(name, args)
+    # symbolize keys in the args hash
+    args = args.inject({}) { |memo,(k,v)| memo[k.to_sym] = v; memo }
+    args[:overrides] = @overrides
+
+    if install_path = args.delete(:install_path)
+      install_path = resolve_path(@basedir, @dirname, install_path)
+      validate_install_path(install_path, name)
+    else
+      install_path = @moduledir
+    end
+
+    # Keep track of all the content this environment is managing to enable purging.
+    @managed_content[install_path] = Array.new unless @managed_content.has_key?(install_path)
+
+    mod = R10K::Module.new(name, install_path, args, self.name)
+    mod.origin = :environment
+
+    @managed_content[install_path] << mod.name
+    @modules << mod
+  end
+
+  include R10K::Util::Purgeable
+
+  # Returns an array of the full paths of filenames that should exist. Files
+  # inside managed_directories that are not listed in desired_contents will
+  # be purged.
+  # @note This implements a required method for the Purgeable mixin
+  # @return [Array<String>]
+  def desired_contents
+    list = @managed_content.keys
+    list += @managed_content.flat_map do |install_path, modnames|
+      modnames.collect { |name| File.join(install_path, name) }
+    end
+  end
+
+  def purge_exclusions
+    super + @managed_content.flat_map do |install_path, modnames|
+      modnames.map do |name|
+        File.join(install_path, name, '**', '*')
+      end
+    end
+  end
+end

data/lib/r10k/environment.rb

@@ -0,0 +1,39 @@
+module R10K
+  module Environment
+    def self.factory
+      @factory ||= R10K::KeyedFactory.new
+    end
+
+    def self.register(key, klass)
+      factory.register(key, klass)
+    end
+
+    def self.retrieve(key)
+      factory.retrieve(key)
+    end
+
+    def self.generate(type, name, basedir, dirname, options = {})
+      factory.generate(type, name, basedir, dirname, options)
+    end
+
+    def self.from_hash(name, hash)
+      R10K::Util::SymbolizeKeys.symbolize_keys!(hash)
+
+      basedir = hash.delete(:basedir)
+      dirname = hash.delete(:dirname) || name
+
+      type = hash.delete(:type)
+      type = type.is_a?(String) ? type.to_sym : type
+
+      generate(type, name, basedir, dirname, hash)
+    end
+
+    require 'r10k/environment/base'
+    require 'r10k/environment/with_modules'
+    require 'r10k/environment/plain'
+    require 'r10k/environment/bare'
+    require 'r10k/environment/git'
+    require 'r10k/environment/svn'
+    require 'r10k/environment/tarball'
+  end
+end

data/lib/r10k/errors/formatting.rb

@@ -0,0 +1,28 @@
+require 'r10k/errors'
+
+module R10K
+  module Errors
+    module Formatting
+      module_function
+
+      # Format this exception for displaying to the user
+      #
+      # @param exc [Exception] The exception to format
+      # @param with_backtrace [true, false] Whether the backtrace should be
+      #   included with this exception
+      # @return [String]
+      def format_exception(exc, with_backtrace = false)
+        lines = []
+        lines << exc.message
+        if with_backtrace
+          lines.concat(exc.backtrace)
+        end
+        if exc.respond_to?(:original) && exc.original
+          lines << "Original exception:"
+          lines<< format_exception(exc.original, with_backtrace)
+        end
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/r10k/errors.rb

@@ -0,0 +1,66 @@
+require 'r10k'
+
+module R10K
+
+  # An error class that accepts an optional hash and wrapped error message
+  #
+  class Error < StandardError
+    attr_accessor :original
+
+    # Generate a wrapped exception
+    #
+    # @param original [Exception] The exception to wrap
+    # @param mesg [String]
+    # @param options [Hash]
+    #
+    # @return [R10K::Error]
+    def self.wrap(original, mesg, options = {})
+      new(mesg, options).tap do |e|
+        e.set_backtrace(caller(4))
+        e.original = original
+      end
+    end
+
+    # @overload initialize(mesg)
+    #   @param mesg [String] The exception mesg
+    #
+    # @overload initialize(mesg, options)
+    #   @param mesg [String] The exception mesg
+    #   @param options [Hash] A set of options to store on the exception
+    #
+    # @options options [Array<String>] :backtrace
+    def initialize(mesg, options = {})
+      super(mesg)
+
+      bt = options.delete(:backtrace)
+      if bt
+        set_backtrace(bt)
+      end
+
+      @options = options
+    end
+
+    protected
+
+    def structure_exception(name, exc)
+      struct = []
+      struct << "#{name}:"
+      if exc.respond_to?(:format)
+        struct << indent(exc.format)
+      else
+        struct << indent(exc.message)
+      end
+      struct.join("\n")
+    end
+
+    def indent(str, level = 4)
+      prefix = ' ' * level
+      str.gsub(/^/, prefix)
+    end
+  end
+
+  # An error class for configuration errors
+  #
+  class ConfigError < Error
+  end
+end

data/lib/r10k/feature/collection.rb

@@ -0,0 +1,23 @@
+require 'r10k/feature'
+
+# Store all features and indicate if they're available.
+class R10K::Feature::Collection
+  def initialize
+    @features = {}
+  end
+
+  # @param name [Symbol] The feature to add
+  # @param opts [Hash] Additional options for the feature, see {R10K::Feature}
+  # @param block [Proc] An optional block to detect if this feature is present
+  # @return [void]
+  def add(name, opts = {}, &block)
+    @features[name] = R10K::Feature.new(name, opts, &block)
+  end
+
+  # @return [true, false] Does a feature by this name exist and is it available?
+  def available?(name)
+    if @features.key?(name)
+      @features[name].available?
+    end
+  end
+end

data/lib/r10k/feature.rb

@@ -0,0 +1,56 @@
+require 'r10k/logging'
+
+module R10K
+  # Detect whether a given feature is present or absent
+  class Feature
+
+    include R10K::Logging
+
+    # @attribute [r] name
+    #   @return [Symbol] The name of this feature
+    attr_reader :name
+
+    # @param name [Symbol] The name of this feature
+    # @param opts [Hash]
+    # @param block [Proc] An optional block to detect if this feature is available
+    #
+    # @option opts [String, Array<String>] :libraries One or more libraries to
+    #   require to make sure this feature is present.
+    def initialize(name, opts = {}, &block)
+      @name      = name
+      @libraries = Array(opts.delete(:libraries))
+      @block     = block
+    end
+
+    # @return [true, false] Is this feature available?
+    def available?
+      logger.debug1 { _("Testing to see if feature %{name} is available.") % {name: @name} }
+      rv = @libraries.all? { |lib| library_available?(lib) } && proc_available?
+      msg = rv ? "is" : "is not"
+      logger.debug1 { _("Feature %{name} %{message} available.") % {name: @name, message: msg} }
+      rv
+    end
+
+    private
+
+    def library_available?(lib)
+      logger.debug2 { _("Attempting to load library '%{lib}' for feature %{name}") % {lib: lib, name: @name} }
+      require lib
+      true
+    rescue ScriptError => e
+      logger.debug2 { _("Error while loading library %{lib} for feature %{name}: %{error_msg}") % {lib: lib, name: @name, error_msg: e.message} }
+      false
+    end
+
+    def proc_available?
+      if @block
+        logger.debug2 { _("Evaluating proc %{block} to test for feature %{name}") % {block: @block.inspect, name: @name} }
+        output = @block.call
+        logger.debug2 { _("Proc %{block} for feature %{name} returned %{output}") % {block: @block.inspect, name: @name, output: output.inspect } }
+        !!output
+      else
+        true
+      end
+    end
+  end
+end