puppet 2.7.3 → 2.7.4

data/lib/puppet/node/environment.rb

@@ -95,7 +95,7 @@ class Puppet::Node::Environment
 
   # Cache the modulepath, so that we aren't searching through
   # all known directories all the time.
-  cached_attr(:modulepath, :ttl => Puppet[:filetimeout]) do
+  cached_attr(:modulepath, Puppet[:filetimeout]) do
     dirs = self[:modulepath].split(File::PATH_SEPARATOR)
     dirs = ENV["PUPPETLIB"].split(File::PATH_SEPARATOR) + dirs if ENV["PUPPETLIB"]
     validate_dirs(dirs)
@@ -103,7 +103,7 @@ class Puppet::Node::Environment
 
   # Return all modules from this environment.
   # Cache the list, because it can be expensive to create.
-  cached_attr(:modules, :ttl => Puppet[:filetimeout]) do
+  cached_attr(:modules, Puppet[:filetimeout]) do
     module_names = modulepath.collect { |path| Dir.entries(path) }.flatten.uniq
     module_names.collect do |path|
       begin
@@ -114,12 +114,6 @@ class Puppet::Node::Environment
     end.compact
   end
 
-  # Cache the manifestdir, so that we aren't searching through
-  # all known directories all the time.
-  cached_attr(:manifestdir, :ttl => Puppet[:filetimeout]) do
-    validate_dirs(self[:manifestdir].split(File::PATH_SEPARATOR))
-  end
-
   def to_s
     name.to_s
   end
@@ -136,14 +130,18 @@ class Puppet::Node::Environment
   end
 
   def validate_dirs(dirs)
+    dir_regex = Puppet.features.microsoft_windows? ? /^[A-Za-z]:#{File::SEPARATOR}/ : /^#{File::SEPARATOR}/
+    # REMIND: Dir.getwd on windows returns a path containing backslashes, which when joined with
+    # dir containing forward slashes, breaks our regex matching. In general, path validation needs
+    # to be refactored which will be handled in a future commit.
     dirs.collect do |dir|
-      if dir !~ /^#{File::SEPARATOR}/
-        File.join(Dir.getwd, dir)
+      if dir !~ dir_regex
+        File.expand_path(File.join(Dir.getwd, dir))
       else
         dir
       end
     end.find_all do |p|
-      p =~ /^#{File::SEPARATOR}/ && FileTest.directory?(p)
+      p =~ dir_regex && FileTest.directory?(p)
     end
   end
 

data/lib/puppet/parameter/path.rb

@@ -17,11 +17,7 @@ class Puppet::Parameter::Path < Puppet::Parameter
     absolute = "[/#{::Regexp.quote(::File::SEPARATOR)}]"
     win32    = Puppet.features.microsoft_windows?
 
-    Array(paths).each do |path|
-      next if path =~ %r{^#{absolute}}
-      next if win32 and path =~ %r{^(?:[a-zA-Z]:)?#{absolute}}
-      fail("#{name} must be a fully qualified path")
-    end
+    fail("#{name} must be a fully qualified path") unless Array(paths).all? {|path| absolute_path?(path)}
 
     paths
   end

data/lib/puppet/parameter.rb

@@ -2,7 +2,6 @@ require 'puppet/util/methodhelper'
 require 'puppet/util/log_paths'
 require 'puppet/util/logging'
 require 'puppet/util/docs'
-require 'puppet/util/cacher'
 
 class Puppet::Parameter
   include Puppet::Util
@@ -10,7 +9,6 @@ class Puppet::Parameter
   include Puppet::Util::LogPaths
   include Puppet::Util::Logging
   include Puppet::Util::MethodHelper
-  include Puppet::Util::Cacher
 
   require 'puppet/parameter/value_collection'
 
@@ -75,7 +73,7 @@ class Puppet::Parameter
       define_method(:unsafe_munge, &block)
     end
 
-    # Does the parameter supports reverse munge?
+    # Does the parameter support reverse munging?
     # This will be called when something wants to access the parameter
     # in a canonical form different to what the storage form is.
     def unmunge(&block)
@@ -150,10 +148,6 @@ class Puppet::Parameter
     self.fail(Puppet::DevError, msg)
   end
 
-  def expirer
-    resource.catalog
-  end
-
   def fail(*args)
     type = nil
     if args[0].is_a?(Class)

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

@@ -13,11 +13,11 @@ class Puppet::Parser::AST
 
     # We return an object that does a late-binding evaluation.
     def evaluate(scope)
-      str, code = query && query.safeevaluate(scope)
+      match, code = query && query.safeevaluate(scope)
 
       resource_type = scope.find_resource_type(@type)
       fail "Resource type #{@type} doesn't exist" unless resource_type
-      newcoll = Puppet::Parser::Collector.new(scope, resource_type.name, str, code, self.form)
+      newcoll = Puppet::Parser::Collector.new(scope, resource_type.name, match, code, self.form)
 
       scope.compiler.add_collection(newcoll)
 

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

@@ -19,8 +19,8 @@ class CollExpr < AST::Branch
     end
 
     # The code is only used for virtual lookups
-    str1, code1 = @test1.safeevaluate scope
-    str2, code2 = @test2.safeevaluate scope
+    match1, code1 = @test1.safeevaluate scope
+    match2, code2 = @test2.safeevaluate scope
 
     # First build up the virtual code.
     # If we're a conjunction operator, then we're calling code.  I did
@@ -31,50 +31,21 @@ class CollExpr < AST::Branch
       when "and"; code1.call(resource) and code2.call(resource)
       when "or"; code1.call(resource) or code2.call(resource)
       when "=="
-        if str1 == "tag"
-          resource.tagged?(str2)
+        if match1 == "tag"
+          resource.tagged?(match2)
         else
-          if resource[str1].is_a?(Array)
-            resource[str1].include?(str2)
+          if resource[match1].is_a?(Array)
+            resource[match1].include?(match2)
           else
-            resource[str1] == str2
+            resource[match1] == match2
           end
         end
-      when "!="; resource[str1] != str2
+      when "!="; resource[match1] != match2
       end
     end
 
-    # Now build up the rails conditions code
-    if self.parens and self.form == :exported
-      Puppet.warning "Parentheses are ignored in Rails searches"
-    end
-
-    case @oper
-    when "and", "or"
-      if form == :exported
-        raise Puppet::ParseError, "Puppet does not currently support collecting exported resources with more than one condition"
-      end
-      oper = @oper.upcase
-    when "=="; oper = "="
-    else
-      oper = @oper
-    end
-
-    if oper == "=" or oper == "!="
-      # Add the rails association info where necessary
-      case str1
-      when "title"
-        str = "title #{oper} '#{str2}'"
-      when "tag"
-        str = "puppet_tags.name #{oper} '#{str2}'"
-      else
-        str = "param_values.value #{oper} '#{str2}' and param_names.name = '#{str1}'"
-      end
-    else
-      str = "(#{str1}) #{oper} (#{str2})"
-    end
-
-    return str, code
+    match = [match1, @oper, match2]
+    return match, code
   end
 
   def initialize(hash = {})

data/lib/puppet/parser/collector.rb

@@ -3,10 +3,11 @@
 class Puppet::Parser::Collector
   attr_accessor :type, :scope, :vquery, :equery, :form, :resources, :overrides, :collected
 
-  # Call the collection method, mark all of the returned objects as non-virtual,
-  # optionally applying parameter overrides. The collector can also delete himself
-  # from the compiler if there is no more resources to collect (valid only for resource fixed-set collector
-  # which get their resources from +collect_resources+ and not from the catalog)
+  # Call the collection method, mark all of the returned objects as
+  # non-virtual, optionally applying parameter overrides. The collector can
+  # also delete himself from the compiler if there is no more resources to
+  # collect (valid only for resource fixed-set collector which get their
+  # resources from +collect_resources+ and not from the catalog)
   def evaluate
     # Shortcut if we're not using storeconfigs and they're trying to collect
     # exported resources.
@@ -29,7 +30,6 @@ class Puppet::Parser::Collector
 
     # we have an override for the collected resources
     if @overrides and !objects.empty?
-
       # force the resource to be always child of any other resource
       overrides[:source].meta_def(:child_of?) do
         true
@@ -39,23 +39,20 @@ class Puppet::Parser::Collector
       # overrided those resources
       objects.each do |res|
         unless @collected.include?(res.ref)
-
-                newres = Puppet::Parser::Resource.new(
-        res.type, res.title,
-            :parameters => overrides[:parameters],
-            :file => overrides[:file],
-            :line => overrides[:line],
-            :source => overrides[:source],
-        
-            :scope => overrides[:scope]
-          )
+          newres = Puppet::Parser::Resource.
+            new(res.type, res.title,
+                :parameters => overrides[:parameters],
+                :file       => overrides[:file],
+                :line       => overrides[:line],
+                :source     => overrides[:source],
+                :scope      => overrides[:scope])
 
           scope.compiler.add_override(newres)
         end
       end
     end
 
-    # filter out object that already have been collected by ourself
+    # filter out object that this collector has previously found.
     objects.reject! { |o| @collected.include?(o.ref) }
 
     return false if objects.empty?
@@ -68,17 +65,19 @@ class Puppet::Parser::Collector
   end
 
   def initialize(scope, type, equery, vquery, form)
-    @scope = scope
+    @scope  = scope
+    @vquery = vquery
+    @equery = equery
 
     # initialisation
     @collected = {}
 
     # Canonize the type
     @type = Puppet::Resource.new(type, "whatever").type
-    @equery = equery
-    @vquery = vquery
 
-    raise(ArgumentError, "Invalid query form #{form}") unless [:exported, :virtual].include?(form)
+    unless [:exported, :virtual].include?(form)
+      raise ArgumentError, "Invalid query form #{form}"
+    end
     @form = form
   end
 
@@ -92,65 +91,36 @@ class Puppet::Parser::Collector
 
   private
 
-  # Create our active record query.
-  def build_active_record_query
-    Puppet::Rails.init unless ActiveRecord::Base.connected?
-
-    raise Puppet::DevError, "Cannot collect resources for a nil host" unless @scope.host
-    host = Puppet::Rails::Host.find_by_name(@scope.host)
-
-    search = "(exported=? AND restype=?)"
-    values = [true, @type]
-
-    search += " AND (#{@equery})" if @equery
-
-    # note:
-    # we're not eagerly including any relations here because
-    # it can creates so much objects we'll throw out later.
-    # We used to eagerly include param_names/values but the way
-    # the search filter is built ruined those efforts and we
-    # were eagerly loading only the searched parameter and not
-    # the other ones.
-    query = {}
-    case search
-    when /puppet_tags/
-      query = {:joins => {:resource_tags => :puppet_tag}}
-    when /param_name/
-      query = {:joins => {:param_values => :param_name}}
-    end
-
-    # We're going to collect objects from rails, but we don't want any
-    # objects from this host.
-    search = ("host_id != ? AND #{search}") and values.unshift(host.id) if host
-
-    query[:conditions] = [search, *values]
-
-    query
-  end
-
   # Collect exported objects.
   def collect_exported
-    # First get everything from the export table.  Just reuse our
-    # collect_virtual method but tell it to use 'exported? for the test.
-    resources = collect_virtual(true).reject { |r| ! r.virtual? }
-
-    count = resources.length
-
-    query = build_active_record_query
+    resources = []
 
-    # Now look them up in the rails db.  When we support attribute comparison
-    # and such, we'll need to vary the conditions, but this works with no
-    # attributes, anyway.
     time = Puppet::Util.thinmark do
-      Puppet::Rails::Resource.find(:all, query).each do |obj|
-        if resource = exported_resource(obj)
-          count += 1
-          resources << resource
+      # First get everything from the export table.  Just reuse our
+      # collect_virtual method but tell it to use 'exported? for the test.
+      resources = collect_virtual(true).reject { |r| ! r.virtual? }
+
+      # key is '#{type}/#{name}', and host and filter.
+      found = Puppet::Resource.indirection.
+        search(@type, :host => @scope.host, :filter => @equery)
+
+      found.map {|x| x.to_resource(@scope) }.each do |item|
+        if existing = @scope.findresource(item.type, item.title)
+          unless existing.collector_id == item.collector_id
+            # unless this is the one we've already collected
+            raise Puppet::ParseError,
+              "Exported resource #{item.ref} cannot override local resource"
+          end
+        else
+          item.exported = false
+          @scope.compiler.add_resource(@scope, item)
+          resources << item
         end
       end
     end
 
-    scope.debug("Collected %s %s resource%s in %.2f seconds" % [count, @type, count == 1 ? "" : "s", time])
+    scope.debug("Collected %s %s resource%s in %.2f seconds" %
+                [resources.length, @type, resources.length == 1 ? "" : "s", time])
 
     resources
   end
@@ -192,25 +162,6 @@ class Puppet::Parser::Collector
     end
   end
 
-  # Seek a specific exported resource.
-  def exported_resource(obj)
-    if existing = @scope.findresource(obj.restype, obj.title)
-      # Next see if we've already collected this resource
-      return nil if existing.rails_id == obj.id
-
-      # This is the one we've already collected
-      raise Puppet::ParseError, "Exported resource #{obj.ref} cannot override local resource"
-    end
-
-    resource = obj.to_resource(self.scope)
-
-    resource.exported = false
-
-    scope.compiler.add_resource(scope, resource)
-
-    resource
-  end
-
   # Does the resource match our tests?  We don't yet support tests,
   # so it's always true at the moment.
   def match?(resource)

data/lib/puppet/parser/compiler.rb

@@ -1,6 +1,3 @@
-#  Created by Luke A. Kanies on 2007-08-13.
-#  Copyright (c) 2007. All rights reserved.
-
 require 'puppet/node'
 require 'puppet/resource/catalog'
 require 'puppet/util/errors'

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

@@ -1,12 +1,24 @@
-Puppet::Parser::Functions::newfunction(:create_resources, :doc => '
-Converts a hash into a set of resources and adds them to the catalog.
-Takes two parameters:
-  create_resource($type, $resources)
-    Creates resources of type $type from the $resources hash. Assumes that
-    hash is in the following form:
-     {title=>{parameters}}
-  This is currently tested for defined resources, classes, as well as native types
-') do |args|
+Puppet::Parser::Functions::newfunction(:create_resources, :doc => <<-'ENDHEREDOC') do |args|
+    Converts a hash into a set of resources and adds them to the catalog.
+
+    This function takes two arguments: a resource type, and a hash describing
+    a set of resources. The hash should be in the form `{title => {parameters} }`:
+
+        # A hash of user resources:
+        $myusers = {
+          'nick' => { uid    => '1330',
+                      group  => allstaff,
+                      groups => ['developers', 'operations', 'release'], }
+          'dan'  => { uid    => '1308',
+                      group  => allstaff,
+                      groups => ['developers', 'prosvc', 'release'], }
+        }
+
+        create_resource(user, $myusers)
+
+    This function can be used to create defined resources and classes, as well
+    as native resources.
+  ENDHEREDOC
   raise ArgumentError, ("create_resources(): wrong number of arguments (#{args.length}; must be 2)") if args.length != 2
   #raise ArgumentError, 'requires resource type and param hash' if args.size < 2
   # figure out what kind of resource we are
@@ -19,7 +31,7 @@ Takes two parameters:
       type_of_resource = :type
     elsif resource = find_definition(type_name.downcase)
       type_of_resource = :define
-    else 
+    else
       raise ArgumentError, "could not create resource of unknown type #{type_name}"
     end
   end

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

@@ -4,19 +4,19 @@ require 'puppet/util/package'
       Puppet::Parser::Functions::newfunction(
         :versioncmp, :type => :rvalue,
 
-  :doc => "Compares two versions
+  :doc => "Compares two version numbers.
 
 Prototype:
 
     \$result = versioncmp(a, b)
 
-Where a and b are arbitrary version strings
+Where a and b are arbitrary version strings.
 
-This functions returns a number:
+This function returns:
 
-* Greater than 0 if version a is greater than version b
-* Equal to 0 if both version are equals
-* Less than 0 if version a is less than version b
+* `1` if version a is greater than version b
+* `0` if the versions are equal
+* `-1` if version a is less than version b
 
 Example:
 
@@ -24,6 +24,9 @@ Example:
         notice('2.6-1 is > than 2.4.5')
     }
 
+This function uses the same version comparison algorithm used by Puppet's
+`package` type.
+
 ") do |args|
 
   unless args.length == 2

data/lib/puppet/parser/resource.rb

@@ -20,7 +20,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   include Puppet::Util::Tagging
   include Puppet::Parser::YamlTrimmer
 
-  attr_accessor :source, :scope, :rails_id
+  attr_accessor :source, :scope, :collector_id
   attr_accessor :virtual, :override, :translated, :catalog, :evaluated
 
   attr_reader :exported, :parameters

data/lib/puppet/parser/type_loader.rb

@@ -80,7 +80,8 @@ class Puppet::Parser::TypeLoader
 
     loaded_asts = []
     files.each do |file|
-      unless file =~ /^#{File::SEPARATOR}/
+      regex = Puppet.features.microsoft_windows? ? /^[A-Za-z]:#{File::SEPARATOR}/ : /^#{File::SEPARATOR}/
+      unless file =~ regex
         file = File.join(dir, file)
       end
       @loading_helper.do_once(file) do

data/lib/puppet/provider/augeas/augeas.rb

@@ -290,8 +290,10 @@ Puppet::Type.type(:augeas).provide(:augeas) do
           set_augeas_save_mode(SAVE_NEWFILE)
           do_execute_changes
           save_result = @aug.save
+          fail("Save failed with return code #{save_result}") unless save_result
+
           saved_files = @aug.match("/augeas/events/saved")
-          if save_result and saved_files.size > 0
+          if saved_files.size > 0
             root = resource[:root].sub(/^\/$/, "")
             saved_files.each do |key|
               saved_file = @aug.get(key).to_s.sub(/^\/files/, root)
@@ -305,13 +307,13 @@ Puppet::Type.type(:augeas).provide(:augeas) do
             debug("Files changed, should execute")
             return_value = true
           else
-            debug("Skipping because no files were changed or save failed")
+            debug("Skipping because no files were changed")
             return_value = false
           end
         end
       end
     ensure
-      if not return_value or resource.noop?
+      if not return_value or resource.noop? or not save_result
         close_augeas
       end
     end

data/lib/puppet/provider/cron/crontab.rb

@@ -14,13 +14,13 @@ tab = case Facter.value(:operatingsystem)
 Puppet::Type.type(:cron).provide(:crontab, :parent => Puppet::Provider::ParsedFile, :default_target => ENV["USER"] || "root", :filetype => tab) do
   commands :crontab => "crontab"
 
-  text_line :comment, :match => %r{^#}, :post_parse => proc { |record|
+  text_line :comment, :match => %r{^\s*#}, :post_parse => proc { |record|
     record[:name] = $1 if record[:line] =~ /Puppet Name: (.+)\s*$/
   }
 
   text_line :blank, :match => %r{^\s*$}
 
-  text_line :environment, :match => %r{^\w+=}
+  text_line :environment, :match => %r{^\s*\w+=}
 
   record_line :freebsd_special, :fields => %w{special command},
     :match => %r{^@(\w+)\s+(.+)$}, :pre_gen => proc { |record|

data/lib/puppet/provider/exec/posix.rb

@@ -1,112 +1,39 @@
-Puppet::Type.type(:exec).provide :posix do
-  include Puppet::Util::Execution
+require 'puppet/provider/exec'
 
+Puppet::Type.type(:exec).provide :posix, :parent => Puppet::Provider::Exec do
   confine :feature => :posix
   defaultfor :feature => :posix
 
-  desc "Execute external binaries directly, on POSIX systems.
-This does not pass through a shell, or perform any interpolation, but
-only directly calls the command with the arguments given."
-
-  def run(command, check = false)
-    output = nil
-    status = nil
-    dir = nil
-
-    checkexe(command)
-
-    if dir = resource[:cwd]
-      unless File.directory?(dir)
-        if check
-          dir = nil
-        else
-          self.fail "Working directory '#{dir}' does not exist"
-        end
-      end
-    end
-
-    dir ||= Dir.pwd
-
-    debug "Executing#{check ? " check": ""} '#{command}'"
-    begin
-      # Do our chdir
-      Dir.chdir(dir) do
-        environment = {}
-
-        environment[:PATH] = resource[:path].join(":") if resource[:path]
-
-        if envlist = resource[:environment]
-          envlist = [envlist] unless envlist.is_a? Array
-          envlist.each do |setting|
-            if setting =~ /^(\w+)=((.|\n)+)$/
-              env_name = $1
-              value = $2
-              if environment.include?(env_name) || environment.include?(env_name.to_sym)
-                warning "Overriding environment setting '#{env_name}' with '#{value}'"
-              end
-              environment[env_name] = value
-            else
-              warning "Cannot understand environment setting #{setting.inspect}"
-            end
-          end
-        end
-
-        withenv environment do
-          Timeout::timeout(resource[:timeout]) do
-            output, status = Puppet::Util::SUIDManager.
-              run_and_capture([command], resource[:user], resource[:group])
-          end
-          # The shell returns 127 if the command is missing.
-          if status.exitstatus == 127
-            raise ArgumentError, output
-          end
-        end
-      end
-    rescue Errno::ENOENT => detail
-      self.fail detail.to_s
-    end
-
-    return output, status
-  end
+  desc <<-EOT
+    Executes external binaries directly, without passing through a shell or
+    performing any interpolation. This is a safer and more predictable way
+    to execute most commands, but prevents the use of globbing and shell
+    built-ins (including control logic like "for" and "if" statements).
+  EOT
 
   # Verify that we have the executable
   def checkexe(command)
     exe = extractexe(command)
 
-    if resource[:path]
-      if Puppet.features.posix? and !File.exists?(exe)
-        withenv :PATH => resource[:path].join(File::PATH_SEPARATOR) do
-          exe = which(exe) || raise(ArgumentError,"Could not find command '#{exe}'")
-        end
-      elsif Puppet.features.microsoft_windows? and !File.exists?(exe)
-        resource[:path].each do |path|
-          [".exe", ".ps1", ".bat", ".com", ""].each do |extension|
-            file = File.join(path, exe+extension)
-            return if File.exists?(file)
-          end
-        end
+    if File.expand_path(exe) == exe
+      if !File.exists?(exe)
+        raise ArgumentError, "Could not find command '#{exe}'"
+      elsif !File.file?(exe)
+        raise ArgumentError, "'#{exe}' is a #{File.ftype(exe)}, not a file"
+      elsif !File.executable?(exe)
+        raise ArgumentError, "'#{exe}' is not executable"
       end
+      return
     end
 
-    raise ArgumentError, "Could not find command '#{exe}'" unless File.exists?(exe)
-    unless File.executable?(exe)
-      raise ArgumentError,
-      "'#{exe}' is not executable"
-    end
-  end
-
-  def extractexe(command)
-    # easy case: command was quoted
-    if command =~ /^"([^"]+)"/
-      $1
-    else
-      command.split(/ /)[0]
+    if resource[:path]
+      withenv :PATH => resource[:path].join(File::PATH_SEPARATOR) do
+        return if which(exe)
+      end
     end
-  end
 
-  def validatecmd(command)
-    exe = extractexe(command)
-    # if we're not fully qualified, require a path
-    self.fail "'#{command}' is not qualified and no path was specified. Please qualify the command or specify a path." if File.expand_path(exe) != exe and resource[:path].nil?
+    # 'which' will only return the command if it's executable, so we can't
+    # distinguish not found from not executable
+    raise ArgumentError, "Could not find command '#{exe}'"
   end
 end