puppet 2.7.13 → 2.7.14

data/lib/puppet/forge/cache.rb

@@ -39,7 +39,7 @@ module Puppet::Forge
 
     # Return Pathname for repository's cache directory, create it if needed.
     def path
-      return @path ||= (self.class.base_path + @repository.cache_key).tap{ |o| o.mkpath }
+      (self.class.base_path + @repository.cache_key).tap{ |o| o.mkpath }
     end
 
     # Return the base Pathname for all the caches.

data/lib/puppet/forge/repository.rb

@@ -2,26 +2,18 @@ require 'net/http'
 require 'digest/sha1'
 require 'uri'
 
-require 'puppet/module_tool/utils'
-
 module Puppet::Forge
-  # Directory names that should not be checksummed.
-  ARTIFACTS = ['pkg', /^\./, /^~/, /^#/, 'coverage']
-  FULL_MODULE_NAME_PATTERN = /\A([^-\/|.]+)[-|\/](.+)\z/
-  REPOSITORY_URL = Puppet.settings[:module_repository]
-
   # = Repository
   #
   # This class is a file for accessing remote repositories with modules.
   class Repository
-    include Puppet::Module::Tool::Utils::Interrogation
 
     attr_reader :uri, :cache
 
     # Instantiate a new repository instance rooted at the optional string
     # +url+, else an instance of the default Puppet modules repository.
     def initialize(url=Puppet[:module_repository])
-      @uri = url.is_a?(::URI) ? url : ::URI.parse(url)
+      @uri = url.is_a?(::URI) ? url : ::URI.parse(url.sub(/^(?!https?:\/\/)/, 'http://'))
       @cache = Cache.new(self)
     end
 
@@ -62,13 +54,7 @@ module Puppet::Forge
     end
 
     # Return a Net::HTTPResponse read for this +request+.
-    #
-    # Options:
-    # * :authenticate => Request authentication on the terminal. Defaults to false.
     def make_http_request(request, options = {})
-      if options[:authenticate]
-        authenticate(request)
-      end
       if ! @uri.user.nil? && ! @uri.password.nil?
         request.basic_auth(@uri.user, @uri.password)
       end
@@ -85,19 +71,14 @@ module Puppet::Forge
           http.request(request)
         end
       rescue Errno::ECONNREFUSED, SocketError
-        raise RuntimeError, "Could not reach remote repository"
+        msg = "Error: Could not connect to #{@uri}\n"
+        msg << "  There was a network communications problem\n"
+        msg << "    Check your network connection and try again\n"
+        Puppet.err msg
+        exit(1)
       end
     end
 
-    # Set the HTTP Basic Authentication parameters for the Net::HTTPRequest
-    # +request+ by asking the user for input on the console.
-    def authenticate(request)
-      Puppet.notice "Authenticating for #{@uri}"
-      email = prompt('Email Address')
-      password = prompt('Password', true)
-      request.basic_auth(email, password)
-    end
-
     # Return the local file name containing the data downloaded from the
     # repository at +release+ (e.g. "myuser-mymodule").
     def retrieve(release)

data/lib/puppet/indirector/facts/network_device.rb

@@ -22,4 +22,4 @@ class Puppet::Node::Facts::NetworkDevice < Puppet::Indirector::Code
   def save(facts)
     raise Puppet::DevError, "You cannot save facts to the code store; it is only used for getting facts from a remote device"
   end
-end
+end

data/lib/puppet/interface/action.rb

@@ -212,7 +212,7 @@ WRAPPER
 
     if @face.is_a?(Class)
       @face.class_eval do eval wrapper, nil, file, line end
-      @face.define_method(internal_name, &block)
+      @face.send(:define_method, internal_name, &block)
       @when_invoked = @face.instance_method(name)
     else
       @face.instance_eval do eval wrapper, nil, file, line end

data/lib/puppet/module.rb

@@ -119,6 +119,18 @@ class Puppet::Module
           raise MissingMetadata, "No #{attr} module metadata provided for #{self.name}"
         end
       end
+
+      # NOTICE: The fallback to `versionRequirement` is something we'd like to
+      # not have to support, but we have a reasonable number of releases that
+      # don't use `version_requirement`. When we can deprecate this, we should.
+      if attr == :dependencies
+        value.tap do |dependencies|
+          dependencies.each do |dep|
+            dep['version_requirement'] ||= dep['versionRequirement'] || '>= 0.0.0'
+          end
+        end
+      end
+
       send(attr.to_s + "=", value)
     end
   end
@@ -144,6 +156,10 @@ class Puppet::Module
     @path ||= environment.modulepath.collect { |path| File.join(path, name) }.find { |d| FileTest.directory?(d) }
   end
 
+  def modulepath
+    File.dirname(path) if path
+  end
+
   # Find all plugin directories.  This is used by the Plugins fileserving mount.
   def plugin_directory
     subpath("plugins")
@@ -176,55 +192,90 @@ class Puppet::Module
   end
 
   def has_local_changes?
-    changes = Puppet::Module::Tool::Applications::Checksummer.run(path)
+    changes = Puppet::ModuleTool::Applications::Checksummer.run(path)
     !changes.empty?
   end
 
-  def unmet_dependencies
-    return [] unless dependencies
+  def local_changes
+    Puppet::ModuleTool::Applications::Checksummer.run(path)
+  end
 
+  # Identify and mark unmet dependencies.  A dependency will be marked unmet
+  # for the following reasons:
+  #
+  #   * not installed and is thus considered missing
+  #   * installed and does not meet the version requirements for this module
+  #   * installed and doesn't use semantic versioning
+  #
+  # Returns a list of hashes representing the details of an unmet dependency.
+  #
+  # Example:
+  #
+  #   [
+  #     {
+  #       :reason => :missing,
+  #       :name   => 'puppetlabs-mysql',
+  #       :version_constraint => 'v0.0.1',
+  #       :mod_details => {
+  #         :installed_version => '0.0.1'
+  #       }
+  #       :parent => {
+  #         :name    => 'puppetlabs-bacula',
+  #         :version => 'v1.0.0'
+  #       }
+  #     }
+  #   ]
+  #
+  def unmet_dependencies
     unmet_dependencies = []
+    return unmet_dependencies unless dependencies
 
     dependencies.each do |dependency|
       forge_name = dependency['name']
-      author, dep_name = forge_name.split('/')
-      version_string = dependency['version_requirement']
+      version_string = dependency['version_requirement'] || '>= 0.0.0'
 
-      equality, dep_version = version_string ? version_string.split("\s") : [nil, nil]
-
-      unless dep_mod = environment.module(dep_name)
-        msg =  "Missing dependency `#{dep_name}`:\n"
-        msg += "  `#{self.name}` (#{self.version}) requires `#{forge_name}` (#{version_string})\n"
-        unmet_dependencies << { :name => forge_name, :error => msg }
-        next
+      dep_mod = begin
+        environment.module_by_forge_name(forge_name)
+      rescue => e
+        nil
       end
 
-      if dep_version && !dep_mod.version
-        msg =  "Unversioned dependency `#{dep_mod.name}`:\n"
-        msg += "  `#{self.name}` (#{self.version}) requires `#{forge_name}` (#{version_string})\n"
-        unmet_dependencies << { :name => forge_name, :error => msg }
+      error_details = {
+        :name => forge_name,
+        :version_constraint => version_string.gsub(/^(?=\d)/, "v"),
+        :parent => {
+          :name => self.forge_name,
+          :version => self.version.gsub(/^(?=\d)/, "v")
+        },
+        :mod_details => {
+          :installed_version => dep_mod.nil? ? nil : dep_mod.version
+        }
+      }
+
+      unless dep_mod
+        error_details[:reason] = :missing
+        unmet_dependencies << error_details
         next
       end
 
-      if dep_version
+      if version_string
         begin
-          required_version_semver = SemVer.new(dep_version)
+          required_version_semver_range = SemVer[version_string]
           actual_version_semver = SemVer.new(dep_mod.version)
         rescue ArgumentError
-          msg =  "Non semantic version dependency `#{dep_mod.name}` (#{dep_mod.version}):\n"
-          msg += "  `#{self.name}` (#{self.version}) requires `#{forge_name}` (#{version_string})\n"
-          unmet_dependencies << { :name => forge_name, :error => msg }
+          error_details[:reason] = :non_semantic_version
+          unmet_dependencies << error_details
           next
         end
 
-        if !actual_version_semver.send(equality, required_version_semver)
-          msg =  "Version dependency mismatch `#{dep_mod.name}` (#{dep_mod.version}):\n"
-          msg += "  `#{self.name}` (#{self.version}) requires `#{forge_name}` (#{version_string})\n"
-          unmet_dependencies << { :name => forge_name, :error => msg }
+        unless required_version_semver_range.include? actual_version_semver
+          error_details[:reason] = :version_mismatch
+          unmet_dependencies << error_details
           next
         end
       end
     end
+
     unmet_dependencies
   end
 
@@ -256,8 +307,8 @@ class Puppet::Module
 
   def ==(other)
     self.name == other.name &&
-      self.version == other.version &&
-      self.path == other.path &&
-      self.environment == other.environment
+    self.version == other.version &&
+    self.path == other.path &&
+    self.environment == other.environment
   end
 end

data/lib/puppet/module_tool.rb

@@ -1,55 +1,93 @@
+# encoding: UTF-8
 # Load standard libraries
 require 'pathname'
 require 'fileutils'
-require 'puppet/module_tool/utils'
+require 'puppet/util/colors'
 
 # Define tool
 module Puppet
-  class Module
-    module Tool
-
-      # Directory names that should not be checksummed.
-      ARTIFACTS = ['pkg', /^\./, /^~/, /^#/, 'coverage']
-      FULL_MODULE_NAME_PATTERN = /\A([^-\/|.]+)[-|\/](.+)\z/
-      REPOSITORY_URL = Puppet.settings[:module_repository]
-
-      # Is this a directory that shouldn't be checksummed?
-      #
-      # TODO: Should this be part of Checksums?
-      # TODO: Rename this method to reflect it's purpose?
-      # TODO: Shouldn't this be used when building packages too?
-      def self.artifact?(path)
-        case File.basename(path)
-        when *ARTIFACTS
-          true
-        else
-          false
-        end
+  module ModuleTool
+    extend Puppet::Util::Colors
+
+    # Directory and names that should not be checksummed.
+    ARTIFACTS = ['pkg', /^\./, /^~/, /^#/, 'coverage', 'metadata.json', 'REVISION']
+    FULL_MODULE_NAME_PATTERN = /\A([^-\/|.]+)[-|\/](.+)\z/
+    REPOSITORY_URL = Puppet.settings[:module_repository]
+
+    # Is this a directory that shouldn't be checksummed?
+    #
+    # TODO: Should this be part of Checksums?
+    # TODO: Rename this method to reflect it's purpose?
+    # TODO: Shouldn't this be used when building packages too?
+    def self.artifact?(path)
+      case File.basename(path)
+      when *ARTIFACTS
+        true
+      else
+        false
+      end
+    end
+
+    # Return the +username+ and +modname+ for a given +full_module_name+, or raise an
+    # ArgumentError if the argument isn't parseable.
+    def self.username_and_modname_from(full_module_name)
+      if matcher = full_module_name.match(FULL_MODULE_NAME_PATTERN)
+        return matcher.captures
+      else
+        raise ArgumentError, "Not a valid full name: #{full_module_name}"
       end
+    end
 
-      # Return the +username+ and +modname+ for a given +full_module_name+, or raise an
-      # ArgumentError if the argument isn't parseable.
-      def self.username_and_modname_from(full_module_name)
-        if matcher = full_module_name.match(FULL_MODULE_NAME_PATTERN)
-          return matcher.captures
-        else
-          raise ArgumentError, "Not a valid full name: #{full_module_name}"
+    def self.find_module_root(path)
+      for dir in [path, Dir.pwd].compact
+        if File.exist?(File.join(dir, 'Modulefile'))
+          return dir
         end
       end
+      raise ArgumentError, "Could not find a valid module at #{path ? path.inspect : 'current directory'}"
+    end
+
+    # Builds a formatted tree from a list of node hashes containing +:text+
+    # and +:dependencies+ keys.
+    def self.format_tree(nodes, level = 0)
+      str = ''
+      nodes.each_with_index do |node, i|
+        last_node = nodes.length - 1 == i
+        deps = node[:dependencies] || []
+
+        str << (indent = "  " * level)
+        str << (last_node ? "└" : "├")
+        str << "─"
+        str << (deps.empty? ? "─" : "┬")
+        str << " #{node[:text]}\n"
+
+        branch = format_tree(deps, level + 1)
+        branch.gsub!(/^#{indent} /, indent + '│') unless last_node
+        str << branch
+      end
 
-      def self.find_module_root(path)
-        for dir in [path, Dir.pwd].compact
-          if File.exist?(File.join(dir, 'Modulefile'))
-            return dir
-          end
+      return str
+    end
+
+    def self.build_tree(mods, dir)
+      mods.each do |mod|
+        version_string = mod[:version][:vstring].sub(/^(?!v)/, 'v')
+
+        if mod[:action] == :upgrade
+          previous_version = mod[:previous_version].sub(/^(?!v)/, 'v')
+          version_string = "#{previous_version} -> #{version_string}"
         end
-        raise ArgumentError, "Could not find a valid module at #{path ? path.inspect : 'current directory'}"
+
+        mod[:text] = "#{mod[:module]} (#{colorize(:cyan, version_string)})"
+        mod[:text] += " [#{mod[:path]}]" unless mod[:path] == dir
+        build_tree(mod[:dependencies], dir)
       end
     end
   end
 end
 
 # Load remaining libraries
+require 'puppet/module_tool/errors'
 require 'puppet/module_tool/applications'
 require 'puppet/module_tool/checksums'
 require 'puppet/module_tool/contents_description'

data/lib/puppet/module_tool/applications.rb

@@ -1,17 +1,15 @@
-require 'puppet/module'
+require 'puppet/module_tool'
 
-class Puppet::Module
-  module Tool
-    module Applications
-      require 'puppet/module_tool/applications/application'
-      require 'puppet/module_tool/applications/builder'
-      require 'puppet/module_tool/applications/checksummer'
-      require 'puppet/module_tool/applications/cleaner'
-      require 'puppet/module_tool/applications/generator'
-      require 'puppet/module_tool/applications/installer'
-      require 'puppet/module_tool/applications/searcher'
-      require 'puppet/module_tool/applications/unpacker'
-      require 'puppet/module_tool/applications/uninstaller'
-    end
+module Puppet::ModuleTool
+  module Applications
+    require 'puppet/module_tool/applications/application'
+    require 'puppet/module_tool/applications/builder'
+    require 'puppet/module_tool/applications/checksummer'
+    require 'puppet/module_tool/applications/generator'
+    require 'puppet/module_tool/applications/installer'
+    require 'puppet/module_tool/applications/searcher'
+    require 'puppet/module_tool/applications/unpacker'
+    require 'puppet/module_tool/applications/uninstaller'
+    require 'puppet/module_tool/applications/upgrader'
   end
 end

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

@@ -1,11 +1,11 @@
 require 'net/http'
 require 'semver'
-require 'puppet/module_tool/utils/interrogation'
+require 'puppet/util/colors'
 
-module Puppet::Module::Tool
+module Puppet::ModuleTool
   module Applications
     class Application
-      include Puppet::Module::Tool::Utils::Interrogation
+      include Puppet::Util::Colors
 
       def self.run(*args)
         new(*args).run
@@ -14,6 +14,9 @@ module Puppet::Module::Tool
       attr_accessor :options
 
       def initialize(options = {})
+        if Puppet.features.microsoft_windows?
+          raise Puppet::Error, "`puppet module` actions are currently not supported on Microsoft Windows"
+        end
         @options = options
       end
 
@@ -36,14 +39,14 @@ module Puppet::Module::Tool
           unless @path
             raise ArgumentError, "Could not determine module path"
           end
-          @metadata = Puppet::Module::Tool::Metadata.new
+          @metadata = Puppet::ModuleTool::Metadata.new
           contents = ContentsDescription.new(@path)
           contents.annotate(@metadata)
           checksums = Checksums.new(@path)
           checksums.annotate(@metadata)
           modulefile_path = File.join(@path, 'Modulefile')
           if File.file?(modulefile_path)
-            Puppet::Module::Tool::ModulefileReader.evaluate(@metadata, modulefile_path)
+            Puppet::ModuleTool::ModulefileReader.evaluate(@metadata, modulefile_path)
           elsif require_modulefile
             raise ArgumentError, "No Modulefile found."
           end
@@ -56,24 +59,23 @@ module Puppet::Module::Tool
         metadata(true)
       end
 
-      # Use to extract and validate a module name and version from a
-      # filename
-      # Note: Must have @filename set to use this
-      def parse_filename!
-        @release_name = File.basename(@filename,'.tar.gz')
-        match = /^(.*?)-(.*?)-(\d+\.\d+\.\d+.*?)$/.match(@release_name)
-        if match then
-          @username, @module_name, @version = match.captures
+      def parse_filename(filename)
+        if match = /^((.*?)-(.*?))-(\d+\.\d+\.\d+.*?)$/.match(File.basename(filename,'.tar.gz'))
+          module_name, author, shortname, version = match.captures
         else
           raise ArgumentError, "Could not parse filename to obtain the username, module name and version.  (#{@release_name})"
         end
-        @full_module_name = [@username, @module_name].join('-')
-        unless @username && @module_name
-          raise ArgumentError, "Username and Module name not provided"
-        end
-        unless SemVer.valid?(@version)
-          raise ArgumentError, "Invalid version format: #{@version} (Semantic Versions are acceptable: http://semver.org)"
+
+        unless SemVer.valid?(version)
+          raise ArgumentError, "Invalid version format: #{version} (Semantic Versions are acceptable: http://semver.org)"
         end
+
+        return {
+          :module_name => module_name,
+          :author      => author,
+          :dir_name    => shortname,
+          :version     => version
+        }
       end
     end
   end