puppet 2.7.13 → 2.7.14

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

@@ -1,11 +1,11 @@
 require 'fileutils'
 
-module Puppet::Module::Tool
+module Puppet::ModuleTool
   module Applications
     class Builder < Application
 
       def initialize(path, options = {})
-        @path = File.expand_path(Puppet::Module::Tool.find_module_root(path))
+        @path = File.expand_path(Puppet::ModuleTool.find_module_root(path))
         @pkg_path = File.join(@path, 'pkg')
         super(options)
       end
@@ -61,7 +61,7 @@ module Puppet::Module::Tool
       def create_directory
         FileUtils.mkdir(@pkg_path) rescue nil
         if File.directory?(build_path)
-          FileUtils.rm_rf(build_path)
+          FileUtils.rm_rf(build_path, :secure => true)
         end
         FileUtils.mkdir(build_path)
       end
@@ -69,7 +69,7 @@ module Puppet::Module::Tool
       def copy_contents
         Dir[File.join(@path, '*')].each do |path|
           case File.basename(path)
-          when *Puppet::Module::Tool::ARTIFACTS
+          when *Puppet::ModuleTool::ARTIFACTS
             next
           else
             FileUtils.cp_r path, build_path

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

@@ -1,4 +1,6 @@
-module Puppet::Module::Tool
+require 'puppet/module_tool/checksums'
+
+module Puppet::ModuleTool
   module Applications
     class Checksummer < Application
 
@@ -10,8 +12,15 @@ module Puppet::Module::Tool
       def run
         changes = []
         if metadata_file.exist?
-          sums = Checksums.new(@path)
+          sums = Puppet::ModuleTool::Checksums.new(@path)
           (metadata['checksums'] || {}).each do |child_path, canonical_checksum|
+
+            # Work around an issue where modules built with an older version
+            # of PMT would include the metadata.json file in the list of files
+            # checksummed. This causes metadata.json to always report local
+            # changes.
+            next if File.basename(child_path) == "metadata.json"
+
             path = @path + child_path
             if canonical_checksum != sums.checksum(path)
               changes << child_path
@@ -28,7 +37,7 @@ module Puppet::Module::Tool
         #
         # Example return value:
         #
-        #   [ "REVISION", "metadata.json", "manifests/init.pp"]
+        #   [ "REVISION", "manifests/init.pp"]
         #
         changes
       end

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

@@ -2,7 +2,7 @@ require 'pathname'
 require 'fileutils'
 require 'erb'
 
-module Puppet::Module::Tool
+module Puppet::ModuleTool
   module Applications
     class Generator < Application
 

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

@@ -1,53 +1,182 @@
 require 'open-uri'
 require 'pathname'
 require 'tmpdir'
+require 'semver'
+require 'puppet/forge'
+require 'puppet/module_tool'
+require 'puppet/module_tool/shared_behaviors'
 
-module Puppet::Module::Tool
+module Puppet::ModuleTool
   module Applications
     class Installer < Application
 
+      include Puppet::ModuleTool::Errors
+
       def initialize(name, options = {})
-        @forge = Puppet::Forge::Forge.new
-        @install_params = {}
+        @action              = :install
+        @environment         = Puppet::Node::Environment.new(Puppet.settings[:environment])
+        @force               = options[:force]
+        @ignore_dependencies = options[:force] || options[:ignore_dependencies]
+        @name                = name
+        super(options)
+      end
+
+      def run
+        begin
+          if is_module_package?(@name)
+            @source = :filesystem
+            @filename = File.expand_path(@name)
+            raise MissingPackageError, :requested_package => @filename unless File.exist?(@filename)
 
-        if File.exist?(name)
-          if File.directory?(name)
-            # TODO Unify this handling with that of Unpacker#check_clobber!
-            raise ArgumentError, "Module already installed: #{name}"
+            parsed = parse_filename(@filename)
+            @module_name = parsed[:module_name]
+            @version     = parsed[:version]
+          else
+            @source = :repository
+            @module_name = @name.gsub('/', '-')
+            @version = options[:version]
           end
-          @filename = File.expand_path(name)
-          @install_params[:source] = :filesystem
-          @install_params[:filename] = @filename
-          parse_filename!
-        else
-          @install_params[:source] = :repository
-          begin
-            @install_params[:author], @install_params[:modname] = Puppet::Module::Tool::username_and_modname_from(name)
-          rescue ArgumentError
-            raise "Could not install module with invalid name: #{name}"
+
+          results = {
+            :module_name    => @module_name,
+            :module_version => @version,
+            :install_dir    => options[:target_dir],
+          }
+
+          unless File.directory? options[:target_dir]
+            raise MissingInstallDirectoryError,
+              :requested_module  => @module_name,
+              :requested_version => @version || 'latest',
+              :directory         => options[:target_dir]
           end
-          @install_params[:version_requirement] = options[:version]
+
+          cached_paths = get_release_packages
+
+          unless @graph.empty?
+            Puppet.notice 'Installing -- do not interrupt ...'
+            cached_paths.each do |hash|
+              hash.each do |dir, path|
+                Unpacker.new(path, @options.merge(:target_dir => dir)).run
+              end
+            end
+          end
+        rescue ModuleToolError => err
+          results[:error] = {
+            :oneline   => err.message,
+            :multiline => err.multiline,
+          }
+        else
+          results[:result] = :success
+          results[:installed_modules] = @graph
+        ensure
+          results[:result] ||= :failure
         end
-        super(options)
+
+        results
+      end
+
+      private
+
+      include Puppet::ModuleTool::Shared
+
+      # Return a Pathname object representing the path to the module
+      # release package in the `Puppet.settings[:module_working_dir]`.
+      def get_release_packages
+        get_local_constraints
+
+        if !@force && @installed.include?(@module_name)
+
+          raise AlreadyInstalledError,
+            :module_name       => @module_name,
+            :installed_version => @installed[@module_name].first.version,
+            :requested_version => @version || (@conditions[@module_name].empty? ? :latest : :best),
+            :local_changes     => @installed[@module_name].first.local_changes
+        end
+
+        if @ignore_dependencies && @source == :filesystem
+          @urls   = {}
+          @remote = { "#{@module_name}@#{@version}" => { } }
+          @versions = {
+            @module_name => [
+              { :vstring => @version, :semver => SemVer.new(@version) }
+            ]
+          }
+        else
+          get_remote_constraints
+        end
+
+        @graph = resolve_constraints({ @module_name => @version })
+        @graph.first[:tarball] = @filename if @source == :filesystem
+        resolve_install_conflicts(@graph) unless @force
+
+        # 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
+        download_tarballs(@graph, @graph.last[:path])
       end
 
-      def force?
-        options[:force]
+      #
+      # Resolve installation conflicts by checking if the requested module
+      # or one of it's dependencies conflicts with an installed module.
+      #
+      # Conflicts occur under the following conditions:
+      #
+      # When installing 'puppetlabs-foo' and an existing directory in the
+      # target install path contains a 'foo' directory and we cannot determine
+      # the "full name" of the installed module.
+      #
+      # When installing 'puppetlabs-foo' and 'pete-foo' is already installed.
+      # This is considered a conflict because 'puppetlabs-foo' and 'pete-foo'
+      # install into the same directory 'foo'.
+      #
+      def resolve_install_conflicts(graph, is_dependency = false)
+        graph.each do |release|
+          @environment.modules_by_path[options[:target_dir]].each do |mod|
+            if mod.has_metadata?
+              metadata = {
+                :name    => mod.forge_name.gsub('/', '-'),
+                :version => mod.version
+              }
+              next if release[:module] == metadata[:name]
+            else
+              metadata = nil
+            end
+
+            if release[:module] =~ /-#{mod.name}$/
+              dependency_info = {
+                :name    => release[:module],
+                :version => release[:version][:vstring]
+              }
+              dependency = is_dependency ? dependency_info : nil
+              latest_version = @versions["#{@module_name}"].sort_by { |h| h[:semver] }.last[:vstring]
+
+              raise InstallConflictError,
+                :requested_module  => @module_name,
+                :requested_version => @version || "latest: v#{latest_version}",
+                :dependency        => dependency,
+                :directory         => mod.path,
+                :metadata          => metadata
+            end
+
+            resolve_install_conflicts(release[:dependencies], true)
+          end
+        end
       end
 
-      def run
-        cache_path = @forge.get_release_package(@install_params)
-
-        module_dir = Unpacker.run(cache_path, options)
-        # Return the Pathname object representing the path to the installed
-        # module. This return value is used by the module_tool face install
-        # action, and displayed to on the console.
-        #
-        # Example return value:
-        #
-        #   "/etc/puppet/modules/apache"
-        #
-        module_dir
+      #
+      # Check if a file is a vaild module package.
+      # ---
+      # FIXME: Checking for a valid module package should be more robust and
+      # use the acutal metadata contained in the package. 03132012 - Hightower
+      # +++
+      #
+      def is_module_package?(name)
+        filename = File.expand_path(name)
+        filename =~ /.tar.gz$/
       end
     end
   end

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

@@ -1,15 +1,14 @@
-module Puppet::Module::Tool
+module Puppet::ModuleTool
   module Applications
     class Searcher < Application
 
       def initialize(term, options = {})
         @term = term
-        @forge = Puppet::Forge::Forge.new
         super(options)
       end
 
       def run
-        @forge.search(@term)
+        Puppet::Forge.search(@term)
       end
     end
   end

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

@@ -1,57 +1,105 @@
-module Puppet::Module::Tool
+module Puppet::ModuleTool
   module Applications
     class Uninstaller < Application
+      include Puppet::ModuleTool::Errors
 
       def initialize(name, options)
-        @name = name
-        @options = options
-        @errors = Hash.new {|h, k| h[k] = []}
-        @removed_mods = []
+        @name        = name
+        @options     = options
+        @errors      = Hash.new {|h, k| h[k] = {}}
+        @unfiltered  = []
+        @installed   = []
+        @suggestions = []
         @environment = Puppet::Node::Environment.new(options[:environment])
       end
 
       def run
-        if module_installed?
-          uninstall
-        else
-          @errors[@name] << "Module #{@name} is not installed"
+        results = {
+          :module_name       => @name,
+          :requested_version => @version,
+        }
+
+        begin
+          find_installed_module
+          validate_module
+          FileUtils.rm_rf(@installed.first.path, :secure => true)
+
+          results[:affected_modules] = @installed
+          results[:result] = :success
+        rescue ModuleToolError => err
+          results[:error] = {
+            :oneline   => err.message,
+            :multiline => err.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
-        { :removed_mods => @removed_mods, :errors => @errors, :options => @options }
+
+        results
       end
 
       private
 
-      def version_match?(mod)
-        if @options[:version]
-          mod.version == @options[:version]
-        else
-          true
+      def find_installed_module
+        @environment.modules_by_path.values.flatten.each do |mod|
+          mod_name = (mod.forge_name || mod.name).gsub('/', '-')
+          if mod_name == @name
+            @unfiltered << {
+              :name    => mod_name,
+              :version => mod.version,
+              :path    => mod.modulepath,
+            }
+            if @options[:version] && mod.version
+              next unless SemVer[@options[:version]].include?(SemVer.new(mod.version))
+            end
+            @installed << mod
+          elsif mod_name =~ /#{@name}/
+            @suggestions << mod_name
+          end
         end
-      end
 
-      def module_installed?
-        @environment.module(@name)
+        if @installed.length > 1
+          raise MultipleInstalledError,
+            :action            => :uninstall,
+            :module_name       => @name,
+            :installed_modules => @installed.sort_by { |mod| @environment.modulepath.index(mod.modulepath) }
+        elsif @installed.empty?
+          if @unfiltered.empty?
+            raise NotInstalledError,
+              :action      => :uninstall,
+              :suggestions => @suggestions,
+              :module_name => @name
+          else
+            raise NoVersionMatchesError,
+              :installed_modules => @unfiltered.sort_by { |mod| @environment.modulepath.index(mod[:path]) },
+              :version_range     => @options[:version],
+              :module_name       => @name
+          end
+        end
       end
 
-      def has_changes?
-        Puppet::Module::Tool::Applications::Checksummer.run(@module.path)
-      end
+      def validate_module
+        mod = @installed.first
 
-      def uninstall
-        # TODO: #11803 Check for broken dependencies before uninstalling modules.
-        @environment.modules_by_path.each do |path, modules|
-          modules.each do |mod|
-            if mod.name == @name
-              unless version_match?(mod)
-                @errors[@name] << "Installed version of #{mod.name} (v#{mod.version}) does not match version range"
-              end
-
-              if @errors[@name].empty?
-                FileUtils.rm_rf(mod.path)
-                @removed_mods << mod
-              end
-            end
-          end
+        if !@options[:force] && mod.has_metadata? && mod.has_local_changes?
+          raise LocalChangesError,
+            :action            => :uninstall,
+            :module_name       => (mod.forge_name || mod.name).gsub('/', '-'),
+            :requested_version => @options[:version],
+            :installed_version => mod.version
+        end
+
+        if !@options[:force] && !mod.required_by.empty?
+          raise ModuleIsRequiredError,
+            :module_name       => (mod.forge_name || mod.name).gsub('/', '-'),
+            :required_by       => mod.required_by,
+            :requested_version => @options[:version],
+            :installed_version => mod.version
         end
       end
     end