r10k 2.3.1 → 2.4.0

data/lib/r10k/puppetfile.rb

@@ -29,30 +29,39 @@ class Puppetfile
   #   @return [String] The path to the Puppetfile
   attr_reader :puppetfile_path
 
+  # @!attribute [rw] environment
+  #   @return [R10K::Environment] Optional R10K::Environment that this Puppetfile belongs to.
+  attr_accessor :environment
+
   # @param [String] basedir
-  # @param [String] puppetfile The path to the Puppetfile, default to #{basedir}/Puppetfile
-  def initialize(basedir, moduledir = nil, puppetfile = nil)
+  # @param [String] moduledir The directory to install the modules, default to #{basedir}/modules
+  # @param [String] puppetfile_path The path to the Puppetfile, default to #{basedir}/Puppetfile
+  def initialize(basedir, moduledir = nil, puppetfile_path = nil)
     @basedir         = basedir
     @moduledir       = moduledir  || File.join(basedir, 'modules')
-    @puppetfile_path = puppetfile || File.join(basedir, 'Puppetfile')
+    @puppetfile_path = puppetfile_path || File.join(basedir, 'Puppetfile')
 
     @modules = []
+    @managed_content = {}
     @forge   = 'forgeapi.puppetlabs.com'
+
+    @loaded = false
   end
 
   def load
     if File.readable? @puppetfile_path
       self.load!
     else
-      logger.debug "Puppetfile #{@puppetfile_path.inspect} missing or unreadable"
+      logger.debug _("Puppetfile %{path} missing or unreadable") % {path: @puppetfile_path.inspect}
     end
   end
 
   def load!
     dsl = R10K::Puppetfile::DSL.new(self)
     dsl.instance_eval(puppetfile_contents, @puppetfile_path)
+    @loaded = true
   rescue SyntaxError, LoadError, ArgumentError => e
-    raise R10K::Error.wrap(e, "Failed to evaluate #{@puppetfile_path}")
+    raise R10K::Error.wrap(e, _("Failed to evaluate %{path}") % {path: @puppetfile_path})
   end
 
   # @param [String] forge
@@ -72,20 +81,49 @@ class Puppetfile
   # @param [String] name
   # @param [*Object] args
   def add_module(name, args)
-    @modules << R10K::Module.new(name, @moduledir, args)
+    if args.is_a?(Hash) && install_path = args.delete(:install_path)
+      install_path = resolve_install_path(install_path)
+      validate_install_path(install_path, name)
+    else
+      install_path = @moduledir
+    end
+
+    # Keep track of all the content this Puppetfile 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, @environment)
+
+    @managed_content[install_path] << mod.name
+    @modules << mod
   end
 
   include R10K::Util::Purgeable
 
-  def managed_directory
-    @moduledir
+  def managed_directories
+    self.load unless @loaded
+
+    @managed_content.keys
   end
 
-  # List all modules that should exist in the module directory
+  # 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
-    @modules.map { |mod| mod.name }
+    self.load unless @loaded
+
+    @managed_content.flat_map do |install_path, modnames|
+      modnames.collect { |name| File.join(install_path, name) }
+    end
+  end
+
+  def purge_exclusions
+    exclusions = managed_directories
+
+    if environment && environment.respond_to?(:desired_contents)
+      exclusions += environment.desired_contents
+    end
+
+    exclusions
   end
 
   def accept(visitor)
@@ -102,6 +140,29 @@ class Puppetfile
     File.read(@puppetfile_path)
   end
 
+  def resolve_install_path(path)
+    pn = Pathname.new(path)
+
+    unless pn.absolute?
+      pn = Pathname.new(File.join(basedir, path))
+    end
+
+    # .cleanpath is as good as we can do without touching the filesystem.
+    # The .realpath methods will also choke if some of the intermediate
+    # paths are missing, even though we will create them later as needed.
+    pn.cleanpath.to_s
+  end
+
+  def validate_install_path(path, modname)
+    real_basedir = Pathname.new(basedir).cleanpath.to_s
+
+    unless /^#{Regexp.escape(real_basedir)}.*/ =~ path
+      raise R10K::Error.new("Puppetfile cannot manage content '#{modname}' outside of containing environment: #{path} is not within #{real_basedir}")
+    end
+
+    true
+  end
+
   class DSL
     # A barebones implementation of the Puppetfile DSL
     #
@@ -124,7 +185,7 @@ class Puppetfile
     end
 
     def method_missing(method, *args)
-      raise NoMethodError, "unrecognized declaration '#{method}'"
+      raise NoMethodError, _("unrecognized declaration '%{method}'") % {method: method}
     end
   end
 end

data/lib/r10k/settings.rb

@@ -84,6 +84,26 @@ module R10K
             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 => [],
+        }),
       ])
     end
 

data/lib/r10k/settings/collection.rb

@@ -74,9 +74,9 @@ module R10K
 
         if !errors.empty?
           if @name
-            msg = "Validation failed for '#{@name}' settings group"
+            msg = _("Validation failed for '%{name}' settings group") % {name: @name}
           else
-            msg = "Validation failed for settings group"
+            msg = _("Validation failed for settings group")
           end
 
           raise ValidationError.new(msg, :errors => errors)

data/lib/r10k/settings/container.rb

@@ -84,7 +84,7 @@ class R10K::Settings::Container
 
   def validate_key!(key)
     unless valid_key?(key)
-      raise InvalidKey, "Key #{key} is not a valid key"
+      raise InvalidKey, _("Key %{key} is not a valid key") % {key: key}
     end
   end
 

data/lib/r10k/settings/enum_definition.rb

@@ -6,8 +6,16 @@ module R10K
 
       def validate
         if @value
-          if !@enum.include?(@value)
-            raise ArgumentError, "Setting #{@name} should be one of #{@enum.inspect}, not '#{@value}'"
+          if @multi && @value.respond_to?(:select)
+            invalid = @value.select { |val| !@enum.include?(val) }
+
+            if invalid.size > 0
+              raise ArgumentError, _("Setting %{name} may only contain %{enums}; the disallowed values %{invalid} were present") % {name: @name, enums: @enum.inspect, invalid: invalid.inspect}
+            end
+          else
+            if !@enum.include?(@value)
+              raise ArgumentError, _("Setting %{name} should be one of %{enums}, not '%{value}'") % {name: @name, enums: @enum.inspect, value: @value}
+            end
           end
         end
       end
@@ -15,7 +23,7 @@ module R10K
       private
 
       def allowed_initialize_opts
-        super.merge({:enum => true})
+        super.merge({:enum => true, :multi => true})
       end
     end
   end

data/lib/r10k/settings/helpers.rb

@@ -16,11 +16,11 @@ module R10K
         # @param new_parent [R10K::Settings::Collection] Parent collection
         def parent=(new_parent)
           unless @parent.nil?
-            raise R10K::Error.new("#{self.class} instances cannot be reassigned to a new parent.")
+            raise R10K::Error.new(_("%{class} instances cannot be reassigned to a new parent.") % {class: self.class} )
           end
 
           unless new_parent.is_a?(R10K::Settings::Collection) || new_parent.is_a?(R10K::Settings::List)
-            raise R10K::Error.new("#{self.class} instances may only belong to a settings collection or list.")
+            raise R10K::Error.new(_("%{class} instances may only belong to a settings collection or list.") % {class: self.class} )
           end
 
           @parent = new_parent

data/lib/r10k/settings/list.rb

@@ -63,7 +63,7 @@ module R10K
         end
 
         if !errors.empty?
-          raise ValidationError.new("Validation failed for '#{@name}' settings list", :errors => errors)
+          raise ValidationError.new(_("Validation failed for '%{name}' settings list") % {name: @name}, :errors => errors)
         end
       end
 

data/lib/r10k/settings/loader.rb

@@ -42,15 +42,15 @@ module R10K
 
         # If both default files are present, issue a warning.
         if (File.file? DEFAULT_LOCATION) && (File.file? OLD_DEFAULT_LOCATION)
-          logger.warn "Both #{DEFAULT_LOCATION} and #{OLD_DEFAULT_LOCATION} configuration files exist."
-          logger.warn "#{DEFAULT_LOCATION} will be used."
+          logger.warn _("Both %{default_path} and %{old_default_path} configuration files exist.") % {default_path: DEFAULT_LOCATION, old_default_path: OLD_DEFAULT_LOCATION}
+          logger.warn _("%{default_path} will be used.") % {default_path: DEFAULT_LOCATION}
         end
 
         path = @loadpath.find {|filename| File.file? filename}
 
         if path == OLD_DEFAULT_LOCATION
-          logger.warn "The r10k configuration file at #{OLD_DEFAULT_LOCATION} is deprecated."
-          logger.warn "Please move your r10k configuration to #{DEFAULT_LOCATION}."
+          logger.warn _("The r10k configuration file at %{old_default_path} is deprecated.") % {old_default_path: OLD_DEFAULT_LOCATION}
+          logger.warn _("Please move your r10k configuration to %{default_path}.") % {default_path: DEFAULT_LOCATION}
         end
 
         path
@@ -60,13 +60,13 @@ module R10K
         path = search(override)
 
         if path.nil?
-          raise ConfigError, "No configuration file given, no config file found in current directory, and no global config present"
+          raise ConfigError, _("No configuration file given, no config file found in current directory, and no global config present")
         end
 
         begin
           contents = ::YAML.load_file(path)
         rescue => e
-          raise ConfigError, "Couldn't load config file: #{e.message}"
+          raise ConfigError, _("Couldn't load config file: %{error_msg}") % {error_msg: e.message}
         end
 
         R10K::Util::SymbolizeKeys.symbolize_keys!(contents, true)

data/lib/r10k/settings/uri_definition.rb

@@ -9,7 +9,7 @@ module R10K
           begin
             URI.parse(@value)
           rescue URI::Error
-            raise ArgumentError, "Setting #{@name} requires a URL but '#{@value}' could not be parsed as a URL"
+            raise ArgumentError, _("Setting %{name} requires a URL but '%{value}' could not be parsed as a URL") % {name: @name, value: @value}
           end
         end
         super

data/lib/r10k/source/base.rb

@@ -28,7 +28,7 @@ class R10K::Source::Base
   #   Defaults to false for no environment prefix.
   def initialize(name, basedir, options = {})
     @name    = name
-    @basedir = basedir
+    @basedir = Pathname.new(basedir).cleanpath.to_s
     @prefix  = options.delete(:prefix)
     @options = options
   end
@@ -55,7 +55,7 @@ class R10K::Source::Base
   # @return [Array<R10K::Environment::Base>] An array of environments created
   #   from this source.
   def environments
-    raise NotImplementedError, "#{self.class} has not implemented method #{__method__}"
+    raise NotImplementedError, _("%{class} has not implemented method %{method}") % {class: self.class, method: __method__}
   end
 
   def accept(visitor)

data/lib/r10k/source/git.rb

@@ -63,10 +63,10 @@ class R10K::Source::Git < R10K::Source::Base
   #
   # @return [void]
   def preload!
-    logger.debug "Fetching '#{@remote}' to determine current branches."
+    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})")
+    raise R10K::Error.wrap(e, _("Unable to determine current branches for Git source '%{name}' (%{basedir})") % {name: @name, basedir: @basedir})
   end
   alias fetch_remote preload!
 
@@ -91,11 +91,11 @@ class R10K::Source::Git < R10K::Source::Base
         envs << R10K::Environment::Git.new(bn.name, @basedir, bn.dirname,
                                        {:remote => remote, :ref => bn.name})
       elsif bn.correct?
-       logger.warn "Environment #{bn.name.inspect} contained non-word characters, correcting name to #{bn.dirname}"
+       logger.warn _("Environment %{env_name} contained non-word characters, correcting name to %{corrected_env_name}") % {env_name: bn.name.inspect, corrected_env_name: bn.dirname}
         envs << R10K::Environment::Git.new(bn.name, @basedir, bn.dirname,
                                        {:remote => remote, :ref => bn.name})
       elsif bn.validate?
-       logger.error "Environment #{bn.name.inspect} contained non-word characters, ignoring it."
+       logger.error _("Environment %{env_name} contained non-word characters, ignoring it.") % {env_name: bn.name.inspect}
       end
     end
 

data/lib/r10k/svn/working_dir.rb

@@ -40,7 +40,7 @@ module R10K
         setopts(opts, {:username => :self, :password => :self})
 
         if !!(@username) ^ !!(@password)
-          raise ArgumentError, "Both username and password must be specified"
+          raise ArgumentError, _("Both username and password must be specified")
         end
       end
 

data/lib/r10k/util/basedir.rb

@@ -31,7 +31,7 @@ module R10K
       # @param sources [Array<#desired_contents>] A list of objects that may create filesystem entries
       def initialize(path, sources)
         if sources.is_a? R10K::Deployment
-          raise ArgumentError, "Expected Array<#desired_contents>, got R10K::Deployment"
+          raise ArgumentError, _("Expected Array<#desired_contents>, got R10K::Deployment")
         end
         @path    = path
         @sources = sources
@@ -39,25 +39,25 @@ module R10K
 
       # Return the path of the basedir
       # @note This implements a required method for the Purgeable mixin
-      # @return [String]
-      def managed_directory
-        @path
+      # @return [Array]
+      def managed_directories
+        [@path]
       end
 
       # List all environments that should exist in this basedir
       # @note This implements a required method for the Purgeable mixin
       # @return [Array<String>]
       def desired_contents
-        @sources.map(&:desired_contents).flatten
+        @sources.flat_map do |src|
+          src.desired_contents.collect { |env| File.join(@path, env) }
+        end
       end
 
       def purge!
         @sources.each do |source|
-          logger.debug1 "Source #{source.name} in #{@path} manages contents #{source.desired_contents.inspect}"
-        end
-        if !stale_contents.empty?
-          logger.debug "The path #{@path} has unmanaged contents #{stale_contents.inspect}"
+          logger.debug1 _("Source %{source_name} in %{path} manages contents %{contents}") % {source_name: source.name, path: @path, contents: source.desired_contents.inspect}
         end
+
         super
       end
     end

data/lib/r10k/util/license.rb

@@ -8,14 +8,14 @@ module R10K
 
       def self.load
         if R10K::Features.available?(:pe_license)
-          logger.debug2 "pe_license feature is available, loading PE license key"
+          logger.debug2 _("pe_license feature is available, loading PE license key")
           begin
             return PELicense.load_license_key
           rescue PELicense::InvalidLicenseError => e
-            raise R10K::Error.wrap(e, "Invalid PE license detected: #{e.message}")
+            raise R10K::Error.wrap(e, _("Invalid PE license detected: %{error_msg}") % {error_msg: e.message} )
           end
         else
-          logger.debug2 "pe_license feature is not available, PE only Puppet modules will not be downloadable."
+          logger.debug2 _("pe_license feature is not available, PE only Puppet modules will not be downloadable.")
           nil
         end
       end

data/lib/r10k/util/purgeable.rb

@@ -15,43 +15,69 @@ module R10K
 
       # @!method desired_contents
       #   @abstract Including classes must implement this method to list the
-      #     expected filenames of managed_directory
-      #   @return [Array<String>] A list of directory contents that should be present
+      #     expected filenames of managed_directories
+      #   @return [Array<String>] The full paths to all the content this object is managing
 
-      # @!method managed_directory
-      #   @abstract Including classes must implement this method to return the
-      #     path to the directory that can be purged
-      #   @return [String] The path to the directory to be purged
+      # @!method managed_directories
+      #   @abstract Including classes must implement this method to return an array of
+      #     paths that can be purged
+      #   @return [Array<String>] The paths to the directories to be purged
 
-      # @return [Array<String>] The present directory entries in `self.managed_directory`
-      def current_contents
-        dir = self.managed_directory
-        glob_exp = File.join(dir, '*')
+      # @return [Array<String>] The present directory entries in `self.managed_directories`
+      def current_contents(recurse)
+        dirs = self.managed_directories
 
-        Dir.glob(glob_exp).map do |fname|
-          File.basename(fname)
+        dirs.flat_map do |dir|
+          if recurse
+            glob_exp = File.join(dir, '**', '{*,.[^.]*}')
+          else
+            glob_exp = File.join(dir, '*')
+          end
+
+          Dir.glob(glob_exp)
         end
       end
 
       # @return [Array<String>] Directory contents that are expected but not present
-      def pending_contents
-        desired_contents - current_contents
+      def pending_contents(recurse)
+        desired_contents - current_contents(recurse)
       end
 
       # @return [Array<String>] Directory contents that are present but not expected
-      def stale_contents
-        current_contents - desired_contents
+      def stale_contents(recurse, exclusions, whitelist)
+        (current_contents(recurse) - desired_contents).reject do |item|
+          if exclusion_match = exclusions.find { |ex_item| File.fnmatch?(ex_item, item, File::FNM_PATHNAME | File::FNM_DOTMATCH) }
+            logger.debug2 _("Not purging %{item} due to internal exclusion match: %{exclusion_match}") % {item: item, exclusion_match: exclusion_match}
+          elsif whitelist_match = whitelist.find { |wl_item| File.fnmatch?(wl_item, item, File::FNM_PATHNAME | File::FNM_DOTMATCH) }
+            logger.debug _("Not purging %{item} due to whitelist match: %{whitelist_match}") % {item: item, whitelist_match: whitelist_match}
+          end
+
+          !!exclusion_match || !!whitelist_match
+        end
       end
 
-      # Forcibly remove all unmanaged content in `self.managed_directory`
-      def purge!
-        if stale_contents.empty?
-          logger.debug1 "No unmanaged contents in #{managed_directory}, nothing to purge"
+      # Forcibly remove all unmanaged content in `self.managed_directories`
+      def purge!(opts={})
+        recurse = opts[:recurse] || false
+        whitelist = opts[:whitelist] || []
+
+        exclusions = self.respond_to?(:purge_exclusions) ? purge_exclusions : []
+
+        stale = stale_contents(recurse, exclusions, whitelist)
+
+        if stale.empty?
+          logger.debug1 _("No unmanaged contents in %{managed_dirs}, nothing to purge") % {managed_dirs: managed_directories.join(', ')}
         else
-          stale_contents.each do |fname|
-            fpath = File.join(self.managed_directory, fname)
-            logger.info "Removing unmanaged path #{fpath}"
-            FileUtils.rm_rf(fpath, :secure => true)
+          stale.each do |fpath|
+            begin
+              FileUtils.rm_r(fpath, :secure => true)
+              logger.info _("Removing unmanaged path %{path}") % {path: fpath}
+            rescue Errno::ENOENT
+              # Don't log on ENOENT since we may encounter that from recursively deleting
+              # this item's parent earlier in the purge.
+            rescue
+              logger.debug1 _("Unable to remove unmanaged path: %{path}") % {path: fpath}
+            end
           end
         end
       end