puppet 2.7.13 → 2.7.14

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

@@ -0,0 +1,45 @@
+module Puppet::ModuleTool::Errors
+
+  class UninstallError < ModuleToolError; end
+
+  class NoVersionMatchesError < UninstallError
+    def initialize(options)
+      @module_name = options[:module_name]
+      @modules     = options[:installed_modules]
+      @version     = options[:version_range]
+      super "Could not uninstall '#{@module_name}'; no installed version matches"
+    end
+
+    def multiline
+      message = []
+      message << "Could not uninstall module '#{@module_name}' (#{v(@version)})"
+      message << "  No installed version of '#{@module_name}' matches (#{v(@version)})"
+      message += @modules.map do |mod|
+        "    '#{mod[:name]}' (#{v(mod[:version])}) is installed in #{mod[:path]}"
+      end
+      message.join("\n")
+    end
+  end
+
+  class ModuleIsRequiredError < UninstallError
+    def initialize(options)
+      @module_name       = options[:module_name]
+      @required_by       = options[:required_by]
+      @requested_version = options[:requested_version]
+      @installed_version = options[:installed_version]
+
+      super "Could not uninstall '#{@module_name}'; installed modules still depend upon it"
+    end
+
+    def multiline
+      message = []
+      message << ("Could not uninstall module '#{@module_name}'" << (@requested_version ? " (#{v(@requested_version)})" : ''))
+      message << "  Other installed modules have dependencies on '#{@module_name}' (#{v(@installed_version)})"
+      message += @required_by.map do |mod|
+        "    '#{mod['name']}' (#{v(mod['version'])}) requires '#{@module_name}' (#{v(mod['version_requirement'])})"
+      end
+      message << "    Use `puppet module uninstall --force` to uninstall this module anyway"
+      message.join("\n")
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Puppet::ModuleTool::Errors
+
+  class UpgradeError < ModuleToolError
+    def initialize(msg)
+      @action = :upgrade
+      super
+    end
+  end
+
+  class VersionAlreadyInstalledError < UpgradeError
+    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}'; module is not installed"
+    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"
+      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])})"
+        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.join("\n")
+    end
+  end
+end

data/lib/puppet/module_tool/metadata.rb

@@ -1,4 +1,4 @@
-module Puppet::Module::Tool
+module Puppet::ModuleTool
 
   # = Metadata
   #
@@ -31,7 +31,7 @@ module Puppet::Module::Tool
     # module +name+.
     def full_module_name=(full_module_name)
       @full_module_name = full_module_name
-      @username, @name = Puppet::Module::Tool::username_and_modname_from(full_module_name)
+      @username, @name = Puppet::ModuleTool::username_and_modname_from(full_module_name)
     end
 
     # Return an array of the module's Dependency objects.

data/lib/puppet/module_tool/modulefile.rb

@@ -1,4 +1,4 @@
-module Puppet::Module::Tool
+module Puppet::ModuleTool
 
   # = Modulefile
   #
@@ -10,13 +10,13 @@ module Puppet::Module::Tool
     # Read the +filename+ and eval its Ruby code to set values in the Metadata
     # +metadata+ instance.
     def self.evaluate(metadata, filename)
-      returning(new(metadata)) do |builder|
-        if File.file?(filename)
-          builder.instance_eval(File.read(filename.to_s), filename.to_s, 1)
-        else
-          Puppet.warning "No Modulefile: #{filename}"
-        end
+      builder = new(metadata)
+      if File.file?(filename)
+        builder.instance_eval(File.read(filename.to_s), filename.to_s, 1)
+      else
+        Puppet.warning "No Modulefile: #{filename}"
       end
+      return builder
     end
 
     # Instantiate with the Metadata +metadata+ instance.

data/lib/puppet/module_tool/shared_behaviors.rb

@@ -0,0 +1,161 @@
+module Puppet::ModuleTool::Shared
+
+  include Puppet::ModuleTool::Errors
+
+  def get_local_constraints
+    @local      = Hash.new { |h,k| h[k] = { } }
+    @conditions = Hash.new { |h,k| h[k] = [] }
+    @installed  = Hash.new { |h,k| h[k] = [] }
+
+    @environment.modules_by_path.values.flatten.each do |mod|
+      mod_name = (mod.forge_name || mod.name).gsub('/', '-')
+      @installed[mod_name] << mod
+      d = @local["#{mod_name}@#{mod.version}"]
+      (mod.dependencies || []).each do |hash|
+        name, conditions = hash['name'], hash['version_requirement']
+        name = name.gsub('/', '-')
+        d[name] = conditions
+        @conditions[name] << {
+          :module => mod_name,
+          :version => mod.version,
+          :dependency => conditions
+        }
+      end
+    end
+  end
+
+  def get_remote_constraints
+    @remote   = Hash.new { |h,k| h[k] = { } }
+    @urls     = {}
+    @versions = Hash.new { |h,k| h[k] = [] }
+
+    Puppet.notice "Downloading from #{Puppet::Forge.repository.uri} ..."
+    author, modname = Puppet::ModuleTool.username_and_modname_from(@module_name)
+    info = Puppet::Forge.remote_dependency_info(author, modname, @options[:version])
+    info.each do |pair|
+      mod_name, releases = pair
+      mod_name = mod_name.gsub('/', '-')
+      releases.each do |rel|
+        semver = SemVer.new(rel['version'] || '0.0.0') rescue SemVer.MIN
+        @versions[mod_name] << { :vstring => rel['version'], :semver => semver }
+        @versions[mod_name].sort! { |a, b| a[:semver] <=> b[:semver] }
+        @urls["#{mod_name}@#{rel['version']}"] = rel['file']
+        d = @remote["#{mod_name}@#{rel['version']}"]
+        (rel['dependencies'] || []).each do |name, conditions|
+          d[name.gsub('/', '-')] = conditions
+        end
+      end
+    end
+  end
+
+  def implicit_version(mod)
+    return :latest if @conditions[mod].empty?
+    if @conditions[mod].all? { |c| c[:queued] || c[:module] == :you }
+      return :latest
+    end
+    return :best
+  end
+
+  def annotated_version(mod, versions)
+    if versions.empty?
+      return implicit_version(mod)
+    else
+      return "#{implicit_version(mod)}: #{versions.last}"
+    end
+  end
+
+  def resolve_constraints(dependencies, source = [{:name => :you}], seen = {}, action = @action)
+    dependencies = dependencies.map do |mod, range|
+      source.last[:dependency] = range
+
+      @conditions[mod] << {
+        :module     => source.last[:name],
+        :version    => source.last[:version],
+        :dependency => range,
+        :queued     => true
+      }
+
+      if @force
+        range = SemVer[@version] rescue SemVer['>= 0.0.0']
+      else
+        range = (@conditions[mod]).map do |r|
+          SemVer[r[:dependency]] rescue SemVer['>= 0.0.0']
+        end.inject(&:&)
+      end
+
+      if @action == :install && seen.include?(mod)
+        next if range === seen[mod][:semver]
+
+        req_module   = @module_name
+        req_versions = @versions["#{@module_name}"].map { |v| v[:semver] }
+        raise InvalidDependencyCycleError,
+          :module_name       => mod,
+          :source            => (source + [{ :name => mod, :version => source.last[:dependency] }]),
+          :requested_module  => req_module,
+          :requested_version => @version || annotated_version(req_module, req_versions),
+          :conditions        => @conditions
+      end
+
+      if !(@force || @installed[mod].empty? || source.last[:name] == :you)
+        next if range === SemVer.new(@installed[mod].first.version)
+        action = :upgrade
+      elsif @installed[mod].empty?
+        action = :install
+      end
+
+      if action == :upgrade
+        @conditions.each { |_, conds| conds.delete_if { |c| c[:module] == mod } }
+      end
+
+      valid_versions = @versions["#{mod}"].select { |h| range === h[:semver] }
+
+      unless version = valid_versions.last
+        req_module   = @module_name
+        req_versions = @versions["#{@module_name}"].map { |v| v[:semver] }
+        raise NoVersionsSatisfyError,
+          :requested_name    => req_module,
+          :requested_version => @version || annotated_version(req_module, req_versions),
+          :installed_version => @installed[@module_name].empty? ? nil : @installed[@module_name].first.version,
+          :dependency_name   => mod,
+          :conditions        => @conditions[mod],
+          :action            => @action
+      end
+
+      seen[mod] = version
+
+      {
+        :module           => mod,
+        :version          => version,
+        :action           => action,
+        :previous_version => @installed[mod].empty? ? nil : @installed[mod].first.version,
+        :file             => @urls["#{mod}@#{version[:vstring]}"],
+        :path             => action == :install ? @options[:target_dir] : (@installed[mod].empty? ? @options[:target_dir] : @installed[mod].first.modulepath),
+        :dependencies     => []
+      }
+    end.compact
+    dependencies.each do |mod|
+      deps = @remote["#{mod[:module]}@#{mod[:version][:vstring]}"].sort_by(&:first)
+      mod[:dependencies] = resolve_constraints(deps, source + [{ :name => mod[:module], :version => mod[:version][:vstring] }], seen, :install)
+    end unless @ignore_dependencies
+    return dependencies
+  end
+
+  def download_tarballs(graph, default_path)
+    graph.map do |release|
+      begin
+        if release[:tarball]
+          cache_path = Pathname(release[:tarball])
+        else
+          cache_path = Puppet::Forge.repository.retrieve(release[:file])
+        end
+      rescue OpenURI::HTTPError => e
+        raise RuntimeError, "Could not download module: #{e.message}"
+      end
+
+      [
+        { (release[:path] ||= default_path) => cache_path},
+        *download_tarballs(release[:dependencies], default_path)
+      ]
+    end.flatten
+  end
+end

data/lib/puppet/module_tool/skeleton.rb

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

data/lib/puppet/node/environment.rb

@@ -127,8 +127,10 @@ class Puppet::Node::Environment
     modules_by_path = {}
     modulepath.each do |path|
       Dir.chdir(path) do
-        module_names = Dir.glob('*').select { |d| FileTest.directory? d }
-        modules_by_path[path] = module_names.map do |name|
+        module_names = Dir.glob('*').select do |d|
+          FileTest.directory?(d) && (File.basename(d) =~ /^[\w]+([-]{1}[\w]+)*$/)
+        end
+        modules_by_path[path] = module_names.sort.map do |name|
           Puppet::Module.new(name, :environment => self, :path => File.join(path, name))
         end
       end

data/lib/puppet/parser/ast/leaf.rb

@@ -202,7 +202,7 @@ class Puppet::Parser::AST
     end
 
     def evaluate_match(value, scope, options = {})
-      value = value.is_a?(String) ? value : value.to_s
+      value = value == :undef ? '' : value.to_s
 
       if matched = @value.match(value)
         scope.ephemeral_from(matched, options[:file], options[:line])

data/lib/puppet/parser/functions/create_resources.rb

@@ -51,14 +51,15 @@ Puppet::Parser::Functions::newfunction(:create_resources, :doc => <<-'ENDHEREDOC
   # iterate through the resources to create
   defaults = args[2] || {}
   args[1].each do |title, params|
-    raise ArgumentError, 'params should not contain title' if(params['title'])
     params = defaults.merge(params)
+    Puppet::Util.symbolizehash!(params)
+    raise ArgumentError, 'params should not contain title' if(params[:title])
     case type_of_resource
     # JJM The only difference between a type and a define is the call to instantiate_resource
     # for a defined type.
     when :type, :define
       p_resource = Puppet::Parser::Resource.new(type_name, title, :scope => self, :source => resource)
-      params.merge(:name => title).each do |k,v|
+      {:name => title}.merge(params).each do |k,v|
         p_resource.set_parameter(k,v)
       end
       if type_of_resource == :define then

data/lib/puppet/parser/scope.rb

@@ -21,7 +21,7 @@ class Puppet::Parser::Scope
   attr_accessor :source, :resource
   attr_accessor :base, :keyword
   attr_accessor :top, :translated, :compiler
-  attr_accessor :parent, :dynamic
+  attr_accessor :parent
   attr_reader :namespaces
 
   # thin wrapper around an ephemeral
@@ -222,13 +222,52 @@ class Puppet::Parser::Scope
 
   private :qualified_scope
 
-  # Look up a variable.  The simplest value search we do.
+  # Look up a variable with traditional scoping and then with new scoping. If
+  # the answers differ then print a deprecation warning.
   def lookupvar(name, options = {})
+    dynamic_value = dynamic_lookupvar(name,options)
+    twoscope_value = twoscope_lookupvar(name,options)
+    if dynamic_value != twoscope_value
+      location = (options[:file] && options[:line]) ? " at #{options[:file]}:#{options[:line]}" : ''
+      Puppet.deprecation_warning("Dynamic lookup of $#{name}#{location} is deprecated. For more information, see http://docs.puppetlabs.com/guides/scope_and_puppet.html. To see the change in behavior, use the --debug flag.")
+      Puppet.debug("Currently $#{name} is #{dynamic_value.inspect}")
+      Puppet.debug("In the future $#{name} will be #{twoscope_value == :undefined ? "undefined" : twoscope_value.inspect}")
+    end
+    dynamic_value
+  end
+
+  # Look up a variable.  The simplest value search we do.
+  def twoscope_lookupvar(name, options = {})
+    # Save the originating scope for the request
+    options[:origin] = self unless options[:origin]
+    table = ephemeral?(name) ? @ephemeral.last : @symtable
+    if name =~ /^(.*)::(.+)$/
+      begin
+        qualified_scope($1).twoscope_lookupvar($2, options.merge({:origin => nil}))
+      rescue RuntimeError => e
+        location = (options[:file] && options[:line]) ? " at #{options[:file]}:#{options[:line]}" : ''
+        warning "Could not look up qualified variable '#{name}'; #{e.message}#{location}"
+        :undefined
+      end
+    # If the value is present and either we are top/node scope or originating scope...
+    elsif (ephemeral_include?(name) or table.include?(name)) and (compiler and self == compiler.topscope or (self.resource and self.resource.type == "Node") or self == options[:origin])
+      table[name]
+    elsif resource and resource.type == "Class" and parent_type = resource.resource_type.parent
+      class_scope(parent_type).twoscope_lookupvar(name,options.merge({:origin => nil}))
+    elsif parent
+      parent.twoscope_lookupvar(name, options)
+    else
+      :undefined
+    end
+  end
+
+  # Look up a variable.  The simplest value search we do.
+  def dynamic_lookupvar(name, options = {})
     table = ephemeral?(name) ? @ephemeral.last : @symtable
     # If the variable is qualified, then find the specified scope and look the variable up there instead.
     if name =~ /^(.*)::(.+)$/
       begin
-        qualified_scope($1).lookupvar($2,options)
+        qualified_scope($1).dynamic_lookupvar($2,options)
       rescue RuntimeError => e
         location = (options[:file] && options[:line]) ? " at #{options[:file]}:#{options[:line]}" : ''
         warning "Could not look up qualified variable '#{name}'; #{e.message}#{location}"
@@ -236,13 +275,9 @@ class Puppet::Parser::Scope
       end
     elsif ephemeral_include?(name) or table.include?(name)
       # We can't use "if table[name]" here because the value might be false
-      if options[:dynamic] and self != compiler.topscope
-        location = (options[:file] && options[:line]) ? " at #{options[:file]}:#{options[:line]}" : ''
-        Puppet.deprecation_warning "Dynamic lookup of $#{name}#{location} is deprecated.  Support will be removed in Puppet 2.8.  Use a fully-qualified variable name (e.g., $classname::variable) or parameterized classes."
-      end
       table[name]
     elsif parent
-      parent.lookupvar(name,options.merge(:dynamic => (dynamic || options[:dynamic])))
+      parent.dynamic_lookupvar(name,options)
     else
       :undefined
     end
@@ -374,7 +409,7 @@ class Puppet::Parser::Scope
 
   # check if name exists in one of the ephemeral scope.
   def ephemeral_include?(name)
-    @ephemeral.reverse.each do |eph|
+    @ephemeral.reverse_each do |eph|
       return true if eph.include?(name)
     end
     false