puppet 0.25.5 → 2.6.0

data/lib/puppet/parser/files.rb

@@ -6,87 +6,83 @@ require 'puppet/parser/parser'
 # doesn't really belong in the Puppet::Module class,
 # but it doesn't really belong anywhere else, either.
 module Puppet::Parser::Files
-    module_function
+  module_function
 
-    # Return a list of manifests (as absolute filenames) that match +pat+
-    # with the current directory set to +cwd+. If the first component of
-    # +pat+ does not contain any wildcards and is an existing module, return
-    # a list of manifests in that module matching the rest of +pat+
-    # Otherwise, try to find manifests matching +pat+ relative to +cwd+
-    def find_manifests(start, options = {})
-        cwd = options[:cwd] || Dir.getwd
-        module_name, pattern = split_file_path(start)
-        begin
-            if mod = Puppet::Module.find(module_name, options[:environment])
-                return mod.match_manifests(pattern)
-            end
-        rescue Puppet::Module::InvalidName
-            # Than that would be a "no."
-        end
-        abspat = File::expand_path(start, cwd)
-        files = Dir.glob(abspat).reject { |f| FileTest.directory?(f) }
-        if files.size == 0
-            files = Dir.glob(abspat + ".pp").reject { |f| FileTest.directory?(f) }
-        end
-        return files
+  # Return a list of manifests (as absolute filenames) that match +pat+
+  # with the current directory set to +cwd+. If the first component of
+  # +pat+ does not contain any wildcards and is an existing module, return
+  # a list of manifests in that module matching the rest of +pat+
+  # Otherwise, try to find manifests matching +pat+ relative to +cwd+
+  def find_manifests(start, options = {})
+    cwd = options[:cwd] || Dir.getwd
+    module_name, pattern = split_file_path(start)
+    begin
+      if mod = Puppet::Module.find(module_name, options[:environment])
+        return [mod.name, mod.match_manifests(pattern)]
+      end
+    rescue Puppet::Module::InvalidName
+      # Than that would be a "no."
     end
+    abspat = File::expand_path(start, cwd)
+    [nil, Dir.glob(abspat + (File.extname(abspat).empty? ? '{,.pp,.rb}' : '' )).uniq.reject { |f| FileTest.directory?(f) }]
+  end
 
-    # Find the concrete file denoted by +file+. If +file+ is absolute,
-    # return it directly. Otherwise try to find it as a template in a
-    # module. If that fails, return it relative to the +templatedir+ config
-    # param.
-    # In all cases, an absolute path is returned, which does not
-    # necessarily refer to an existing file
-    def find_template(template, environment = nil)
-        if template =~ /^#{File::SEPARATOR}/
-            return template
-        end
-
-        if template_paths = templatepath(environment)
-            # If we can find the template in :templatedir, we return that.
-            template_paths.collect { |path|
-                File::join(path, template)
-            }.each do |f|
-                return f if FileTest.exist?(f)
-            end
-        end
+  # Find the concrete file denoted by +file+. If +file+ is absolute,
+  # return it directly. Otherwise try to find it as a template in a
+  # module. If that fails, return it relative to the +templatedir+ config
+  # param.
+  # In all cases, an absolute path is returned, which does not
+  # necessarily refer to an existing file
+  def find_template(template, environment = nil)
+    if template == File.expand_path(template)
+      return template
+    end
 
-        # check in the default template dir, if there is one
-        if td_file = find_template_in_module(template, environment)
-            return td_file
-        end
+    if template_paths = templatepath(environment)
+      # If we can find the template in :templatedir, we return that.
+      template_paths.collect { |path|
+        File::join(path, template)
+      }.each do |f|
+        return f if FileTest.exist?(f)
+      end
+    end
 
-        return nil
+    # check in the default template dir, if there is one
+    if td_file = find_template_in_module(template, environment)
+      return td_file
     end
 
-    def find_template_in_module(template, environment = nil)
-        path, file = split_file_path(template)
+    nil
+  end
 
-        # Because templates don't have an assumed template name, like manifests do,
-        # we treat templates with no name as being templates in the main template
-        # directory.
-        return nil unless file
+  def find_template_in_module(template, environment = nil)
+    path, file = split_file_path(template)
 
-        if mod = Puppet::Module.find(path, environment) and t = mod.template(file)
-            return t
-        end
-        nil
-    end
+    # Because templates don't have an assumed template name, like manifests do,
+    # we treat templates with no name as being templates in the main template
+    # directory.
+    return nil unless file
 
-    # Return an array of paths by splitting the +templatedir+ config
-    # parameter.
-    def templatepath(environment = nil)
-        dirs = Puppet.settings.value(:templatedir, environment).split(":")
-        dirs.select do |p|
-            File::directory?(p)
-        end
+    if mod = Puppet::Module.find(path, environment) and t = mod.template(file)
+      return t
     end
+    nil
+  end
 
-    # Split the path into the module and the rest of the path, or return
-    # nil if the path is empty or absolute (starts with a /).
-    # This method can return nil & anyone calling it needs to handle that.
-    def split_file_path(path)
-        path.split(File::SEPARATOR, 2) unless path =~ /^(#{File::SEPARATOR}|$)/
+  # Return an array of paths by splitting the +templatedir+ config
+  # parameter.
+  def templatepath(environment = nil)
+    dirs = Puppet.settings.value(:templatedir, environment).split(File::PATH_SEPARATOR)
+    dirs.select do |p|
+      File::directory?(p)
     end
+  end
+
+  # Split the path into the module and the rest of the path, or return
+  # nil if the path is empty or absolute (starts with a /).
+  # This method can return nil & anyone calling it needs to handle that.
+  def split_file_path(path)
+    path.split(File::SEPARATOR, 2) unless path == "" or path == File.expand_path(path)
+  end
 
 end

data/lib/puppet/parser/functions.rb

@@ -1,134 +1,122 @@
 require 'puppet/util/autoload'
 require 'puppet/parser/scope'
+require 'monitor'
 
-module Puppet::Parser
-module Functions
-    # A module for managing parser functions.  Each specified function
-    # becomes an instance method on the Scope class.
+# A module for managing parser functions.  Each specified function
+# is added to a central module that then gets included into the Scope
+# class.
+module Puppet::Parser::Functions
 
-    @functions = {}
+  (@functions = Hash.new { |h,k| h[k] = {} }).extend(MonitorMixin)
+  (@modules   = {}                          ).extend(MonitorMixin)
 
-    class << self
-        include Puppet::Util
-    end
+  class << self
+    include Puppet::Util
+  end
 
-    def self.autoloader
-        unless defined? @autoloader
-            @autoloader = Puppet::Util::Autoload.new(self,
-                "puppet/parser/functions",
-                :wrap => false
-            )
-        end
+  def self.autoloader
+    unless defined?(@autoloader)
 
-        @autoloader
+            @autoloader = Puppet::Util::Autoload.new(
+        self,
+        "puppet/parser/functions",
+        
+        :wrap => false
+      )
     end
 
-    # Create a new function type.
-    def self.newfunction(name, options = {}, &block)
-        name = symbolize(name)
+    @autoloader
+  end
 
-        if @functions.include? name
-            raise Puppet::DevError, "Function %s already defined" % name
-        end
+  Environment = Puppet::Node::Environment
 
-        # We want to use a separate, hidden module, because we don't want
-        # people to be able to call them directly.
-        unless defined? FCollection
-            eval("module FCollection; end")
-        end
+  def self.environment_module(env = nil)
+    @modules.synchronize {
+      @modules[ env || Environment.current || Environment.root ] ||= Module.new
+    }
+  end
 
-        ftype = options[:type] || :statement
+  # Create a new function type.
+  def self.newfunction(name, options = {}, &block)
+    name = symbolize(name)
 
-        unless ftype == :statement or ftype == :rvalue
-            raise Puppet::DevError, "Invalid statement type %s" % ftype.inspect
-        end
+    raise Puppet::DevError, "Function #{name} already defined" if functions.include?(name)
 
-        fname = "function_" + name.to_s
-        Puppet::Parser::Scope.send(:define_method, fname, &block)
+    ftype = options[:type] || :statement
 
-        # Someday we'll support specifying an arity, but for now, nope
-        #@functions[name] = {:arity => arity, :type => ftype}
-        @functions[name] = {:type => ftype, :name => fname}
-        if options[:doc]
-            @functions[name][:doc] = options[:doc]
-        end
+    unless ftype == :statement or ftype == :rvalue
+      raise Puppet::DevError, "Invalid statement type #{ftype.inspect}"
     end
 
-    # Remove a function added by newfunction
-    def self.rmfunction(name)
-        name = symbolize(name)
+    fname = "function_#{name}"
+    environment_module.send(:define_method, fname, &block)
 
-        unless @functions.include? name
-            raise Puppet::DevError, "Function %s is not defined" % name
-        end
+    # Someday we'll support specifying an arity, but for now, nope
+    #functions[name] = {:arity => arity, :type => ftype}
+    functions[name] = {:type => ftype, :name => fname}
+    functions[name][:doc] = options[:doc] if options[:doc]
+  end
 
-        @functions.delete(name)
+  # Remove a function added by newfunction
+  def self.rmfunction(name)
+    name = symbolize(name)
 
-        fname = "function_" + name.to_s
-        Puppet::Parser::Scope.send(:remove_method, fname)
-    end
+    raise Puppet::DevError, "Function #{name} is not defined" unless functions.include? name
 
-    # Determine if a given name is a function
-    def self.function(name)
-        name = symbolize(name)
+    functions.delete name
 
-        unless @functions.include? name
-            autoloader.load(name)
-        end
+    fname = "function_#{name}"
+    environment_module.send(:remove_method, fname)
+  end
 
-        if @functions.include? name
-            return @functions[name][:name]
-        else
-            return false
-        end
+  # Determine if a given name is a function
+  def self.function(name)
+    name = symbolize(name)
+
+    unless functions.include?(name) or functions(Puppet::Node::Environment.root).include?(name)
+      autoloader.load(name,Environment.current || Environment.root)
     end
 
-    def self.functiondocs
-        autoloader.loadall
+    ( functions(Environment.root)[name] || functions[name] || {:name => false} )[:name]
+  end
 
-        ret = ""
+  def self.functiondocs
+    autoloader.loadall
 
-        @functions.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, hash|
-            #ret += "%s\n%s\n" % [name, hash[:type]]
-            ret += "%s\n%s\n" % [name, "-" * name.to_s.length]
-            if hash[:doc]
-                ret += Puppet::Util::Docs.scrub(hash[:doc])
-            else
-                ret += "Undocumented.\n"
-            end
+    ret = ""
 
-            ret += "\n\n- **Type**: %s\n\n" % hash[:type]
-        end
+    functions.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, hash|
+      #ret += "#{name}\n#{hash[:type]}\n"
+      ret += "#{name}\n#{"-" * name.to_s.length}\n"
+      if hash[:doc]
+        ret += Puppet::Util::Docs.scrub(hash[:doc])
+      else
+        ret += "Undocumented.\n"
+      end
 
-        return ret
+      ret += "\n\n- **Type**: #{hash[:type]}\n\n"
     end
 
-    def self.functions
-        @functions.keys
-    end
+    ret
+  end
 
-    # Determine if a given function returns a value or not.
-    def self.rvalue?(name)
-        name = symbolize(name)
-
-        if @functions.include? name
-            case @functions[name][:type]
-            when :statement; return false
-            when :rvalue; return true
-            end
-        else
-            return false
-        end
-    end
+  def self.functions(env = nil)
+    @functions.synchronize {
+      @functions[ env || Environment.current || Environment.root ]
+    }
+  end
+
+  # Determine if a given function returns a value or not.
+  def self.rvalue?(name)
+    (functions[symbolize(name)] || {})[:type] == :rvalue
+  end
 
-    # Runs a newfunction to create a function for each of the log levels
+  # Runs a newfunction to create a function for each of the log levels
 
-    Puppet::Util::Log.levels.each do |level|
-        newfunction(level, :doc => "Log a message on the server at level
-        #{level.to_s}.") do |vals|
-            send(level, vals.join(" "))
-        end
+  Puppet::Util::Log.levels.each do |level|
+    newfunction(level, :doc => "Log a message on the server at level #{level.to_s}.") do |vals|
+      send(level, vals.join(" "))
     end
+  end
 
 end
-end

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

@@ -1,27 +1,27 @@
 # Test whether a given class or definition is defined
 Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :doc => "Determine whether a given
-    type is defined, either as a native type or a defined type, or whether a class is defined.
-    This is useful for checking whether a class is defined and only including it if it is.
-    This function can also test whether a resource has been defined, using resource references
-    (e.g., ``if defined(File['/tmp/myfile']) { ... }``).  This function is unfortunately
-    dependent on the parse order of the configuration when testing whether a resource is defined.") do |vals|
-        result = false
-        vals.each do |val|
-            case val
-            when String
-                # For some reason, it doesn't want me to return from here.
-                if Puppet::Type.type(val) or find_definition(val) or find_hostclass(val)
-                    result = true
-                    break
-                end
-            when Puppet::Parser::Resource::Reference
-                if findresource(val.to_s)
-                    result = true
-                    break
-                end
-            else
-                raise ArgumentError, "Invalid argument of type %s to 'defined'" % val.class
-            end
+  type is defined, either as a native type or a defined type, or whether a class is defined.
+  This is useful for checking whether a class is defined and only including it if it is.
+  This function can also test whether a resource has been defined, using resource references
+  (e.g., ``if defined(File['/tmp/myfile']) { ... }``).  This function is unfortunately
+  dependent on the parse order of the configuration when testing whether a resource is defined.") do |vals|
+    result = false
+    vals = [vals] unless vals.is_a?(Array)
+    vals.each do |val|
+      case val
+      when String
+        if Puppet::Type.type(val) or find_definition(val) or find_hostclass(val)
+          result = true
+          break
         end
-        result
+      when Puppet::Resource
+        if findresource(val.to_s)
+          result = true
+          break
+        end
+      else
+        raise ArgumentError, "Invalid argument of type '#{val.class}' to 'defined'"
+      end
+    end
+    result
 end

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

@@ -1,4 +1,4 @@
 Puppet::Parser::Functions::newfunction(:fail, :doc => "Fail with a parse error.") do |vals|
-        vals = vals.collect { |s| s.to_s }.join(" ") if vals.is_a? Array
-        raise Puppet::ParseError, vals.to_s
+    vals = vals.collect { |s| s.to_s }.join(" ") if vals.is_a? Array
+    raise Puppet::ParseError, vals.to_s
 end

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

@@ -1,21 +1,23 @@
 # Returns the contents of a file
-Puppet::Parser::Functions::newfunction(:file, :type => :rvalue,
-        :doc => "Return the contents of a file.  Multiple files
-        can be passed, and the first file that exists will be read in.") do |vals|
-            ret = nil
-            vals.each do |file|
-                unless file =~ /^#{File::SEPARATOR}/
-                    raise Puppet::ParseError, "Files must be fully qualified"
-                end
-                if FileTest.exists?(file)
-                    ret = File.read(file)
-                    break
-                end
-            end
-            if ret
-                ret
-            else
-                raise Puppet::ParseError, "Could not find any files from %s" %
-                    vals.join(", ")
-            end
+
+      Puppet::Parser::Functions::newfunction(
+        :file, :type => :rvalue,
+        
+    :doc => "Return the contents of a file.  Multiple files
+    can be passed, and the first file that exists will be read in.") do |vals|
+      ret = nil
+      vals.each do |file|
+        unless file =~ /^#{File::SEPARATOR}/
+          raise Puppet::ParseError, "Files must be fully qualified"
+        end
+        if FileTest.exists?(file)
+          ret = File.read(file)
+          break
+        end
+      end
+      if ret
+        ret
+      else
+        raise Puppet::ParseError, "Could not find any files from #{vals.join(", ")}"
+      end
 end