puppet 2.7.13 → 2.7.14

data/lib/puppet/module_tool/applications/unpacker.rb

@@ -1,20 +1,19 @@
 require 'pathname'
 require 'tmpdir'
 
-module Puppet::Module::Tool
+module Puppet::ModuleTool
   module Applications
     class Unpacker < Application
 
       def initialize(filename, options = {})
         @filename = Pathname.new(filename)
-        parse_filename!
+        parsed = parse_filename(filename)
         super(options)
-        @module_dir = Pathname.new(options[:install_dir]) + @module_name
+        @module_dir = Pathname.new(options[:target_dir]) + parsed[:dir_name]
       end
 
       def run
         extract_module_to_install_dir
-        tag_revision
 
         # Return the Pathname object representing the directory where the
         # module release archive was unpacked the to, and the module release
@@ -23,23 +22,12 @@ module Puppet::Module::Tool
       end
 
       private
-
-      def tag_revision
-        File.open("#{@module_dir}/REVISION", 'w') do |f|
-          f.puts "module: #{@username}/#{@module_name}"
-          f.puts "version: #{@version}"
-          f.puts "url: file://#{@filename.expand_path}"
-          f.puts "installed: #{Time.now}"
-        end
-      end
-
       def extract_module_to_install_dir
         delete_existing_installation_or_abort!
 
         build_dir = Puppet::Forge::Cache.base_path + "tmp-unpacker-#{Digest::SHA1.hexdigest(@filename.basename.to_s)}"
         build_dir.mkpath
         begin
-          Puppet.notice "Installing #{@filename.basename} to #{@module_dir.expand_path}"
           unless system "tar xzf #{@filename} -C #{build_dir}"
             raise RuntimeError, "Could not extract contents of module archive."
           end
@@ -53,17 +41,7 @@ module Puppet::Module::Tool
 
       def delete_existing_installation_or_abort!
         return unless @module_dir.exist?
-
-        if !options[:force]
-          Puppet.warning "Existing module '#{@module_dir.expand_path}' found"
-          response = prompt "Overwrite module installed at #{@module_dir.expand_path}? [y/N]"
-          unless response =~ /y/i
-            raise RuntimeError, "Aborted installation."
-          end
-        end
-
-        Puppet.warning "Deleting #{@module_dir.expand_path}"
-        FileUtils.rm_rf @module_dir
+        FileUtils.rm_rf(@module_dir, :secure => true)
       end
     end
   end

data/lib/puppet/module_tool/applications/upgrader.rb

@@ -0,0 +1,109 @@
+module Puppet::ModuleTool
+  module Applications
+    class Upgrader < Application
+
+      include Puppet::ModuleTool::Errors
+
+      def initialize(name, options)
+        @action              = :upgrade
+        @environment         = Puppet::Node::Environment.new(Puppet.settings[:environment])
+        @module_name         = name
+        @options             = options
+        @force               = options[:force]
+        @ignore_dependencies = options[:force] || options[:ignore_dependencies]
+        @version             = options[:version]
+      end
+
+      def run
+        begin
+          results = { :module_name => @module_name }
+
+          get_local_constraints
+
+          if @installed[@module_name].length > 1
+            raise MultipleInstalledError,
+              :action            => :upgrade,
+              :module_name       => @module_name,
+              :installed_modules => @installed[@module_name].sort_by { |mod| @environment.modulepath.index(mod.modulepath) }
+          elsif @installed[@module_name].empty?
+            raise NotInstalledError,
+              :action      => :upgrade,
+              :module_name => @module_name
+          end
+
+          @module = @installed[@module_name].last
+          results[:installed_version] = @module.version ? @module.version.sub(/^(?=\d)/, 'v') : nil
+          results[:requested_version] = @version || (@conditions[@module_name].empty? ? :latest : :best)
+          dir = @module.modulepath
+
+          Puppet.notice "Found '#{@module_name}' (#{colorize(:cyan, results[:installed_version] || '???')}) in #{dir} ..."
+          if !@options[:force] && @module.has_metadata? && @module.has_local_changes?
+            raise LocalChangesError,
+              :action            => :upgrade,
+              :module_name       => @module_name,
+              :requested_version => @version || (@conditions[@module_name].empty? ? :latest : :best),
+              :installed_version => @module.version
+          end
+
+          begin
+            get_remote_constraints
+          rescue => e
+            raise UnknownModuleError, results.merge(:repository => Puppet::Forge.repository.uri)
+          else
+            raise UnknownVersionError, results.merge(:repository => Puppet::Forge.repository.uri) if @remote.empty?
+          end
+
+          if !@options[:force] && @versions["#{@module_name}"].last[:vstring].sub(/^(?=\d)/, 'v') == (@module.version || '0.0.0').sub(/^(?=\d)/, 'v')
+            raise VersionAlreadyInstalledError,
+              :module_name       => @module_name,
+              :requested_version => @version || ((@conditions[@module_name].empty? ? 'latest' : 'best') + ": #{@versions["#{@module_name}"].last[:vstring].sub(/^(?=\d)/, 'v')}"),
+              :installed_version => @installed[@module_name].last.version,
+              :conditions        => @conditions[@module_name] + [{ :module => :you, :version => @version }]
+          end
+
+          @graph = resolve_constraints({ @module_name => @version })
+
+          # This clean call means we never "cache" the module we're installing, but this
+          # is desired since module authors can easily rerelease modules different content but the same
+          # version number, meaning someone with the old content cached will be very confused as to why
+          # they can't get new content.
+          # Long term we should just get rid of this caching behavior and cleanup downloaded modules after they install
+          # but for now this is a quick fix to disable caching
+          Puppet::Forge::Cache.clean
+          tarballs = download_tarballs(@graph, @graph.last[:path])
+
+          unless @graph.empty?
+            Puppet.notice 'Upgrading -- do not interrupt ...'
+            tarballs.each do |hash|
+              hash.each do |dir, path|
+                Unpacker.new(path, @options.merge(:target_dir => dir)).run
+              end
+            end
+          end
+
+          results[:result] = :success
+          results[:base_dir] = @graph.first[:path]
+          results[:affected_modules] = @graph
+        rescue VersionAlreadyInstalledError => e
+          results[:result] = :noop
+          results[:error] = {
+            :oneline   => e.message,
+            :multiline => e.multiline
+          }
+        rescue => e
+          results[:error] = {
+            :oneline => e.message,
+            :multiline => e.respond_to?(:multiline) ? e.multiline : [e.to_s, e.backtrace].join("\n")
+          }
+        ensure
+          results[:result] ||= :failure
+        end
+
+        return results
+      end
+
+      private
+      include Puppet::ModuleTool::Shared
+    end
+  end
+end

data/lib/puppet/module_tool/checksums.rb

@@ -1,6 +1,6 @@
 require 'digest/md5'
 
-module Puppet::Module::Tool
+module Puppet::ModuleTool
 
   # = Checksums
   #
@@ -25,7 +25,7 @@ module Puppet::Module::Tool
       unless @data
         @data = {}
         @path.find do |descendant|
-          if Puppet::Module::Tool.artifact?(descendant)
+          if Puppet::ModuleTool.artifact?(descendant)
             Find.prune
           elsif descendant.file?
             path = descendant.relative_path_from(@path)

data/lib/puppet/module_tool/contents_description.rb

@@ -1,4 +1,4 @@
-module Puppet::Module::Tool
+module Puppet::ModuleTool
 
   # = ContentsDescription
   #

data/lib/puppet/module_tool/dependency.rb

@@ -1,4 +1,4 @@
-module Puppet::Module::Tool
+module Puppet::ModuleTool
 
   class Dependency
 
@@ -8,7 +8,7 @@ module Puppet::Module::Tool
     def initialize(full_module_name, version_requirement = nil, repository = nil)
       @full_module_name = full_module_name
       # TODO: add error checking, the next line raises ArgumentError when +full_module_name+ is invalid
-      @username, @name = Puppet::Module::Tool.username_and_modname_from(full_module_name)
+      @username, @name = Puppet::ModuleTool.username_and_modname_from(full_module_name)
       @version_requirement = version_requirement
       @repository = repository ? Puppet::Forge::Repository.new(repository) : nil
     end

data/lib/puppet/module_tool/errors.rb

@@ -0,0 +1,9 @@
+module Puppet::ModuleTool
+  module Errors
+    require 'puppet/module_tool/errors/base'
+    require 'puppet/module_tool/errors/installer'
+    require 'puppet/module_tool/errors/uninstaller'
+    require 'puppet/module_tool/errors/upgrader'
+    require 'puppet/module_tool/errors/shared'
+  end
+end

data/lib/puppet/module_tool/errors/base.rb

@@ -0,0 +1,15 @@
+module Puppet::ModuleTool::Errors
+  class ModuleToolError < StandardError
+    def v(version)
+      (version || '???').to_s.sub(/^(?=\d)/, 'v')
+    end
+
+    def vstring
+      if @action == :upgrade
+        "#{v(@installed_version)} -> #{v(@requested_version)}"
+      else
+        "#{v(@installed_version || @requested_version)}"
+      end
+    end
+  end
+end

data/lib/puppet/module_tool/errors/installer.rb

@@ -0,0 +1,90 @@
+module Puppet::ModuleTool::Errors
+
+  class InstallError < ModuleToolError; end
+
+  class AlreadyInstalledError < InstallError
+    def initialize(options)
+      @module_name       = options[:module_name]
+      @installed_version = v(options[:installed_version])
+      @requested_version = v(options[:requested_version])
+      @local_changes     = options[:local_changes]
+      super "'#{@module_name}' (#{@requested_version}) requested; '#{@module_name}' (#{@installed_version}) already installed"
+    end
+
+    def multiline
+      message = []
+      message << "Could not install module '#{@module_name}' (#{@requested_version})"
+      message << "  Module '#{@module_name}' (#{@installed_version}) is already installed"
+      message << "    Installed module has had changes made locally" unless @local_changes.empty?
+      message << "    Use `puppet module upgrade` to install a different version"
+      message << "    Use `puppet module install --force` to re-install only this module"
+      message.join("\n")
+    end
+  end
+
+  class InstallConflictError < InstallError
+    def initialize(options)
+      @requested_module  = options[:requested_module]
+      @requested_version = v(options[:requested_version])
+      @dependency        = options[:dependency]
+      @directory         = options[:directory]
+      @metadata          = options[:metadata]
+      super "'#{@requested_module}' (#{@requested_version}) requested; Installation conflict"
+    end
+
+    def multiline
+      message = []
+      message << "Could not install module '#{@requested_module}' (#{@requested_version})"
+
+      if @dependency
+        message << "  Dependency '#{@dependency[:name]}' (#{v(@dependency[:version])}) would overwrite #{@directory}"
+      else
+        message << "  Installation would overwrite #{@directory}"
+      end
+
+      if @metadata
+        message << "    Currently, '#{@metadata[:name]}' (#{v(@metadata[:version])}) is installed to that directory"
+      end
+
+      message << "    Use `puppet module install --dir <DIR>` to install modules elsewhere"
+
+      if @dependency
+        message << "    Use `puppet module install --ignore-dependencies` to install only this module"
+      else
+        message << "    Use `puppet module install --force` to install this module anyway"
+      end
+
+      message.join("\n")
+    end
+  end
+
+  class MissingPackageError < InstallError
+    def initialize(options)
+      @requested_package = options[:requested_package]
+      super "#{@requested_package} requested; Package #{@requested_package} does not exist"
+    end
+
+    def multiline
+      <<-MSG.strip
+Could not install package #{@requested_package}
+  Package #{@requested_package} does not exist
+      MSG
+    end
+  end
+
+  class MissingInstallDirectoryError < InstallError
+    def initialize(options)
+      @requested_module  = options[:requested_module]
+      @requested_version = options[:requested_version]
+      @directory         = options[:directory]
+      super "'#{@requested_module}' (#{@requested_version}) requested; Directory #{@directory} does not exist"
+    end
+
+    def multiline
+      <<-MSG.strip
+Could not install module '#{@requested_module}' (#{@requested_version})
+  Directory #{@directory} does not exist
+      MSG
+    end
+  end
+end

data/lib/puppet/module_tool/errors/shared.rb

@@ -0,0 +1,115 @@
+module Puppet::ModuleTool::Errors
+
+  class NoVersionsSatisfyError < ModuleToolError
+    def initialize(options)
+      @requested_name    = options[:requested_name]
+      @requested_version = options[:requested_version]
+      @installed_version = options[:installed_version]
+      @dependency_name   = options[:dependency_name]
+      @conditions        = options[:conditions]
+      @action            = options[:action]
+
+      super "Could not #{@action} '#{@requested_name}' (#{vstring}); module '#{@dependency_name}' cannot satisfy dependencies"
+    end
+
+    def multiline
+      same_mod = @requested_name == @dependency_name
+
+      message = []
+      message << "Could not #{@action} module '#{@requested_name}' (#{vstring})"
+      message << "  No version of '#{@dependency_name}' will satisfy dependencies"
+      message << "    You specified '#{@requested_name}' (#{v(@requested_version)})" if same_mod
+      message += @conditions.select { |c| c[:module] != :you }.sort_by { |c| c[:module] }.map do |c|
+        "    '#{c[:module]}' (#{v(c[:version])}) requires '#{@dependency_name}' (#{v(c[:dependency])})"
+      end
+      message << "    Use `puppet module #{@action} --force` to #{@action} this module anyway" if same_mod
+      message << "    Use `puppet module #{@action} --ignore-dependencies` to #{@action} only this module" unless same_mod
+
+      message.join("\n")
+    end
+  end
+
+  class InvalidDependencyCycleError < ModuleToolError
+    def initialize(options)
+      @module_name       = options[:module_name]
+      @requested_module  = options[:requested_module]
+      @requested_version = options[:requested_version]
+      @conditions        = options[:conditions]
+      @source            = options[:source][1..-1]
+
+      super "'#{@requested_module}' (#{v(@requested_version)}) requested; Invalid dependency cycle"
+    end
+
+    def multiline
+      trace = []
+      trace << "You specified '#{@source.first[:name]}' (#{v(@requested_version)})"
+      trace += @source[1..-1].map { |m| "which depends on '#{m[:name]}' (#{v(m[:version])})" }
+
+      message = []
+      message << "Could not install module '#{@requested_module}' (#{v(@requested_version)})"
+      message << "  No version of '#{@module_name}' will satisfy dependencies"
+      message << trace.map { |s| "    #{s}" }.join(",\n")
+      message << "    Use `puppet module install --force` to install this module anyway"
+
+      message.join("\n")
+    end
+  end
+
+  class NotInstalledError < ModuleToolError
+    def initialize(options)
+      @module_name = options[:module_name]
+      @suggestions = options[:suggestions] || []
+      @action      = options[:action]
+      super "Could not #{@action} '#{@module_name}'; module is not installed"
+    end
+
+    def multiline
+      message = []
+      message << "Could not #{@action} module '#{@module_name}'"
+      message << "  Module '#{@module_name}' is not installed"
+      message += @suggestions.map do |suggestion|
+        "    You may have meant `puppet module #{@action} #{suggestion}`"
+      end
+      message << "    Use `puppet module install` to install this module" if @action == :upgrade
+      message.join("\n")
+    end
+  end
+
+  class MultipleInstalledError < ModuleToolError
+    def initialize(options)
+      @module_name = options[:module_name]
+      @modules     = options[:installed_modules]
+      @action      = options[:action]
+      super "Could not #{@action} '#{@module_name}'; module appears in multiple places in the module path"
+    end
+
+    def multiline
+      message = []
+      message << "Could not #{@action} module '#{@module_name}'"
+      message << "  Module '#{@module_name}' appears multiple places in the module path"
+      message += @modules.map do |mod|
+        "    '#{@module_name}' (#{v(mod.version)}) was found in #{mod.modulepath}"
+      end
+      message << "    Use the `--modulepath` option to limit the search to specific directories"
+      message.join("\n")
+    end
+  end
+
+  class LocalChangesError < ModuleToolError
+    def initialize(options)
+      @module_name       = options[:module_name]
+      @requested_version = options[:requested_version]
+      @installed_version = options[:installed_version]
+      @action            = options[:action]
+      super "Could not #{@action} '#{@module_name}'; module is not installed"
+    end
+
+    def multiline
+      message = []
+      message << "Could not #{@action} module '#{@module_name}' (#{vstring})"
+      message << "  Installed module has had changes made locally"
+      message << "    Use `puppet module #{@action} --force` to #{@action} this module anyway"
+      message.join("\n")
+    end
+  end
+end