puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

data/lib/puppet/module_tool/checksums.rb

@@ -1,4 +1,5 @@
 require 'digest/md5'
+require 'puppet/network/format_support'
 
 module Puppet::ModuleTool
 
@@ -7,6 +8,7 @@ module Puppet::ModuleTool
   # This class proides methods for generating checksums for data and adding
   # them to +Metadata+.
   class Checksums
+    include Puppet::Network::FormatSupport
     include Enumerable
 
     # Instantiate object with string +path+ to create checksums from.
@@ -36,17 +38,12 @@ module Puppet::ModuleTool
       return @data
     end
 
+    alias :to_data_hash :data
+    alias :to_hash :data
+
     # TODO: Why?
     def each(&block)
       data.each(&block)
     end
-
-    # Update +Metadata+'s checksums with this object's.
-    def annotate(metadata)
-      metadata.checksums.replace(data)
-    end
-
-    # TODO: Move the Checksummer#run checksum checking to here?
-
   end
 end

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

@@ -22,56 +22,25 @@ module Puppet::ModuleTool::Errors
     end
   end
 
-  class InstallConflictError < InstallError
+  class MissingPackageError < 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"
+      @requested_package = options[:requested_package]
+      @source = options[:source]
+
+      super "Could not install '#{@requested_package}'; no releases are available from #{@source}"
     end
 
     def multiline
       message = []
-      message << "Could not install module '#{@requested_module}' (#{@requested_version})"
+      message << "Could not install '#{@requested_package}'"
 
-      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 --target-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 << "  No releases are available from #{@source}"
+      message << "    Does '#{@requested_package}' have at least one published release?"
 
       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 InstallPathExistsNotDirectoryError < InstallError
     def initialize(original, options)
       @requested_module  = options[:requested_module]
@@ -110,16 +79,15 @@ Could not install module '#{@requested_module}' (#{@requested_version})
 
   class InvalidPathInPackageError < InstallError
     def initialize(options)
-      @requested_package = options[:requested_package]
-      @entry_path        = options[:entry_path]
-      @directory         = options[:directory]
+      @entry_path = options[:entry_path]
+      @directory  = options[:directory]
       super "Attempt to install file into #{@entry_path.inspect} under #{@directory.inspect}"
     end
 
     def multiline
       <<-MSG.strip
-Could not install package #{@requested_package}
-  Package #{@requested_package} attempted to install file into
+Could not install package
+  Package attempted to install file into
   #{@entry_path.inspect} under #{@directory.inspect}.
       MSG
     end

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

@@ -5,25 +5,81 @@ module Puppet::ModuleTool::Errors
       @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"
+      super "Could not #{@action} '#{@requested_name}' (#{vstring}); no version satisfies all 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])})"
+      message << "  No version of '#{@requested_name}' can satisfy all dependencies"
+      message << "    Use `puppet module #{@action} --ignore-dependencies` to #{@action} only this module"
+
+      message.join("\n")
+    end
+  end
+
+  class NoCandidateReleasesError < ModuleToolError
+    def initialize(options)
+      @module_name       = options[:module_name]
+      @requested_version = options[:requested_version]
+      @installed_version = options[:installed_version]
+      @source            = options[:source]
+      @action            = options[:action]
+
+      if @requested_version == :latest
+        super "Could not #{@action} '#{@module_name}'; no releases are available from #{@source}"
+      else
+        super "Could not #{@action} '#{@module_name}'; no releases matching '#{@requested_version}' are available from #{@source}"
+      end
+    end
+
+    def multiline
+      message = []
+      message << "Could not #{@action} '#{@module_name}' (#{vstring})"
+
+      if @requested_version == :latest
+        message << "  No releases are available from #{@source}"
+        message << "    Does '#{@module_name}' have at least one published release?"
+      else
+        message << "  No releases matching '#{@requested_version}' are available from #{@source}"
+      end
+
+      message.join("\n")
+    end
+  end
+
+  class InstallConflictError < ModuleToolError
+    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
+
+      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 << "    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
@@ -101,7 +157,7 @@ module Puppet::ModuleTool::Errors
       @requested_version = options[:requested_version]
       @installed_version = options[:installed_version]
       @action            = options[:action]
-      super "Could not #{@action} '#{@module_name}'; module is not installed"
+      super "Could not #{@action} '#{@module_name}'; module has had changes made locally"
     end
 
     def multiline
@@ -112,4 +168,21 @@ module Puppet::ModuleTool::Errors
       message.join("\n")
     end
   end
+
+  class InvalidModuleError < ModuleToolError
+    def initialize(name, options)
+      @name   = name
+      @action = options[:action]
+      @error  = options[:error]
+      super "Could not #{@action} '#{@name}'; #{@error.message}"
+    end
+
+    def multiline
+      message = []
+      message << "Could not #{@action} module '#{@name}'"
+      message << "  Failure trying to parse metadata"
+      message << "    Original message was: #{@error.message}"
+      message.join("\n")
+    end
+  end
 end

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

@@ -8,64 +8,35 @@ module Puppet::ModuleTool::Errors
   end
 
   class VersionAlreadyInstalledError < UpgradeError
+    attr_reader :newer_versions
+
     def initialize(options)
       @module_name       = options[:module_name]
       @requested_version = options[:requested_version]
       @installed_version = options[:installed_version]
       @dependency_name   = options[:dependency_name]
-      @conditions        = options[:conditions]
-      super "Could not upgrade '#{@module_name}';"
+      @newer_versions    = options[:newer_versions]
+      @possible_culprits = options[:possible_culprits]
+      super "Could not upgrade '#{@module_name}'; more recent versions not found"
     end
 
     def multiline
       message = []
       message << "Could not upgrade module '#{@module_name}' (#{vstring})"
-      if @conditions.length == 1 && @conditions.last[:version].nil?
-        message << "  The installed version is already the latest version"
+      if @newer_versions.empty?
+        message << "  The installed version is already the latest version matching #{vstring}"
       else
-        message << "  The installed version is already the best fit for the current dependencies"
-        message += @conditions.select { |c| c[:module] == :you && c[:version] }.map do |c|
-          "    You specified '#{@module_name}' (#{v(c[:version])})"
-        end
-        message += @conditions.select { |c| c[:module] != :you }.sort_by { |c| c[:module] }.map do |c|
-           "    '#{c[:module]}' (#{v(c[:version])}) requires '#{@module_name}' (#{v(c[:dependency])})"
+        message << "  There are #{@newer_versions.length} newer versions"
+        message << "    No combination of dependency upgrades would satisfy all dependencies"
+        unless @possible_culprits.empty?
+          message << "    Dependencies will not be automatically upgraded across major versions"
+          message << "    Upgrading one or more of these modules may permit the upgrade to succeed:"
+          @possible_culprits.each do |name|
+            message << "    - #{name}"
+          end
         end
       end
-      message << "    Use `puppet module install --force` to re-install this module"
-      message.join("\n")
-    end
-  end
-
-  class UnknownModuleError < UpgradeError
-    def initialize(options)
-      @module_name       = options[:module_name]
-      @installed_version = options[:installed_version]
-      @requested_version = options[:requested_version]
-      @repository        = options[:repository]
-      super "Could not upgrade '#{@module_name}'; module is unknown to #{@repository}"
-    end
-
-    def multiline
-      message = []
-      message << "Could not upgrade module '#{@module_name}' (#{vstring})"
-      message << "  Module '#{@module_name}' does not exist on #{@repository}"
-      message.join("\n")
-    end
-  end
-
-  class UnknownVersionError < UpgradeError
-    def initialize(options)
-      @module_name       = options[:module_name]
-      @installed_version = options[:installed_version]
-      @requested_version = options[:requested_version]
-      @repository        = options[:repository]
-      super "Could not upgrade '#{@module_name}' (#{vstring}); module has no versions #{ @requested_version && "matching #{v(@requested_version)} "}published on #{@repository}"
-    end
-
-    def multiline
-      message = []
-      message << "Could not upgrade module '#{@module_name}' (#{vstring})"
-      message << "  No version matching '#{@requested_version || ">= 0.0.0"}' exists on #{@repository}"
+      message << "    Use `puppet module upgrade --force` to upgrade only this module"
       message.join("\n")
     end
   end

data/lib/puppet/module_tool/install_directory.rb

@@ -7,18 +7,19 @@ module Puppet
     class InstallDirectory
       include Puppet::ModuleTool::Errors
 
-      def initialize(target_directory)
-        @target_directory = target_directory
+      attr_reader :target
+      def initialize(target)
+        @target = target
       end
 
       # prepare the module install location. This will create the location if
       # needed.
       def prepare(module_name, version)
-        return if @target_directory.directory?
+        return if @target.directory?
 
         begin
-          @target_directory.mkpath
-          Puppet.notice "Created target directory #{@target_directory}"
+          @target.mkpath
+          Puppet.notice "Created target directory #{@target}"
         rescue SystemCallError => orig_error
           raise converted_to_friendly_error(module_name, version, orig_error)
         end
@@ -37,7 +38,7 @@ module Puppet
         ERROR_MAPPINGS[orig_error.class].new(orig_error,
           :requested_module  => module_name,
           :requested_version => version,
-          :directory         => @target_directory.to_s)
+          :directory         => @target.to_s)
       end
     end
   end

data/lib/puppet/module_tool/installed_modules.rb

@@ -0,0 +1,92 @@
+require 'pathname'
+
+require 'puppet/forge'
+require 'puppet/module_tool'
+
+module Puppet::ModuleTool
+  class InstalledModules < Semantic::Dependency::Source
+    attr_reader :modules, :by_name
+
+    def priority
+      10
+    end
+
+    def initialize(env)
+      @env = env
+      modules = env.modules_by_path
+
+      @fetched = []
+      @modules = {}
+      @by_name = {}
+      env.modulepath.each do |path|
+        modules[path].each do |mod|
+          @by_name[mod.name] = mod
+          next unless mod.has_metadata?
+          release = ModuleRelease.new(self, mod)
+          @modules[release.name] ||= release
+        end
+      end
+
+      @modules.freeze
+    end
+
+    # Fetches {ModuleRelease} entries for each release of the named module.
+    #
+    # @param name [String] the module name to look up
+    # @return [Array<Semantic::Dependency::ModuleRelease>] a list of releases for
+    #         the given name
+    # @see Semantic::Dependency::Source#fetch
+    def fetch(name)
+      name = name.tr('/', '-')
+
+      if @modules.key? name
+        @fetched << name
+        [ @modules[name] ]
+      else
+        [ ]
+      end
+    end
+
+    def fetched
+      @fetched
+    end
+
+    class ModuleRelease < Semantic::Dependency::ModuleRelease
+      attr_reader :mod, :metadata
+
+      def initialize(source, mod)
+        @mod = mod
+        @metadata = mod.metadata
+        name = mod.forge_name.tr('/', '-')
+        version = Semantic::Version.parse(mod.version)
+
+        super(source, name, version, {})
+
+        if mod.dependencies
+          mod.dependencies.each do |dep|
+            range = dep['version_requirement'] || dep['versionRequirement'] || '>=0'
+            range = Semantic::VersionRange.parse(range) rescue Semantic::VersionRange::EMPTY_RANGE
+
+            dep.tap do |dep|
+              add_constraint('initialize', dep['name'].tr('/', '-'), range.to_s) do |node|
+                range === node.version
+              end
+            end
+          end
+        end
+      end
+
+      def install_dir
+        Pathname.new(@mod.path).dirname
+      end
+
+      def install(dir)
+        # If we're already installed, there's no need for us to faff about.
+      end
+
+      def prepare
+        # We're already installed; what preparation remains?
+      end
+    end
+  end
+end