puppet 0.24.5 → 0.24.6

data/lib/puppet/defaults.rb

@@ -122,16 +122,11 @@ module Puppet
             namespaces and methods.  This can be used as a coarse-grained
             authorization system for both ``puppetd`` and ``puppetmasterd``."
         ],
-        :environments => ["production,development", "The valid environments for Puppet clients.
-            This is more useful as a server-side setting than client, but any
-            environment chosen must be in this list.  Values should be
-            separated by a comma."],
         :environment => {:default => "production", :desc => "The environment Puppet is running in.  For clients
             (e.g., ``puppetd``) this determines the environment itself, which
             is used to find modules and much more.  For servers (i.e.,
             ``puppetmasterd``) this provides the default environment for nodes
-            we know nothing about.",
-            :hook => proc { |value| raise(ArgumentError, "Invalid environment %s" % value) unless Puppet::Node::Environment.valid?(value) }
+            we know nothing about."
         },
         :diff_args => ["", "Which arguments to pass to the diff command when printing differences between files."],
         :diff => ["diff", "Which diff command to use when printing differences between files."],
@@ -664,7 +659,8 @@ module Puppet
     setdefaults(:parser,
         :lexical => [false, "Whether to use lexical scoping (vs. dynamic)."],
         :templatedir => ["$vardir/templates",
-            "Where Puppet looks for template files."
+            "Where Puppet looks for template files.  Can be a list of colon-seperated
+             directories."
         ]
     )
 

data/lib/puppet/file_serving/fileset.rb

@@ -20,7 +20,7 @@ class Puppet::FileServing::Fileset
 
         # Now strip off the leading path, so each file becomes relative, and remove
         # any slashes that might end up at the beginning of the path.
-        result = files.collect { |file| file.sub(%r{^#{@path}/*}, '') }
+        result = files.collect { |file| file.sub(%r{^#{Regexp.escape(@path)}/*}, '') }
 
         # And add the path itself.
         result.unshift(".")
@@ -120,7 +120,7 @@ class Puppet::FileServing::Fileset
 
         return result
     end
-
+    public
     # Stat a given file, using the links-appropriate method.
     def stat(path)
         unless defined?(@stat_method)

data/lib/puppet/file_serving/metadata.rb

@@ -60,10 +60,10 @@ class Puppet::FileServing::Metadata < Puppet::FileServing::FileBase
 
         case stat.ftype
         when "file":
-            @checksum = ("{%s}" % @checksum_type) + send("%s_file" % @checksum_type, real_path)
+            @checksum = ("{%s}" % @checksum_type) + send("%s_file" % @checksum_type, real_path).to_s
         when "directory": # Always just timestamp the directory.
-            sumtype = @checksum_type.to_s =~ /time/ ? @checksum_type : "ctime"
-            @checksum = ("{%s}" % sumtype) + send("%s_file" % sumtype, path).to_s
+            @checksum_type = "ctime"
+            @checksum = ("{%s}" % @checksum_type) + send("%s_file" % @checksum_type, path).to_s
         when "link":
             @destination = File.readlink(real_path)
         else

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

@@ -12,12 +12,13 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
         Dir.entries(dir).find_all { |e| e =~ /\.rb$/ }.each do |file|
             fqfile = ::File.join(dir, file)
             begin
-                Puppet.info "Loading #{type} %s" % ::File.basename(file.sub(".rb",''))
+                Puppet.info "Loading %s %s" % 
+                    [type, ::File.basename(file.sub(".rb",''))]
                 Timeout::timeout(self.timeout) do
                     load fqfile
                 end
             rescue => detail
-                Puppet.warning "Could not load #{type} %s: %s" % [fqfile, detail]
+                Puppet.warning "Could not load %s %s: %s" % [type, fqfile, detail]
             end
         end
     end

data/lib/puppet/indirector/yaml.rb

@@ -34,11 +34,20 @@ class Puppet::Indirector::Yaml < Puppet::Indirector::Terminus
         end
     end
 
+    # Get the yaml directory
+    def base
+      (Puppet[:name] == "puppetmasterd") ? Puppet[:yamldir] : Puppet[:clientyamldir]
+    end
+
     # Return the path to a given node's file.
     def path(name)
-        base = (Puppet[:name] == "puppetmasterd") ? Puppet[:yamldir] : Puppet[:clientyamldir]
         File.join(base, self.class.indirection_name.to_s, name.to_s + ".yaml")
     end
+    
+    # Do a glob on the yaml directory, loading each file found
+    def search(request)
+      Dir.glob(File.join(base, self.class.indirection_name.to_s, request.key)).collect { |f| YAML.load_file(f) }
+    end
 
     private
 

data/lib/puppet/module.rb

@@ -19,6 +19,15 @@ class Puppet::Module
         end
     end
 
+    # Return an array of paths by splitting the +templatedir+ config
+    # parameter.
+    def self.templatepath(environment = nil)
+        dirs = Puppet.settings.value(:templatedir, environment).split(":")
+        dirs.select do |p|
+            p =~ /^#{File::SEPARATOR}/ && File::directory?(p)
+        end
+    end
+
     # Find and return the +module+ that +path+ belongs to. If +path+ is
     # absolute, or if there is no module whose name is the first component
     # of +path+, return +nil+
@@ -63,25 +72,39 @@ class Puppet::Module
             return template
         end
 
-        # If we can find the template in :templatedir, we return that.
-        td_file = File.join(Puppet.settings.value(:templatedir, environment), template)
-        return td_file if File.exists?(td_file)
-          
+        template_paths = templatepath(environment)
+        if template_paths
+            # If we can find the template in :templatedir, we return that.
+            td_file = template_paths.collect { |path|
+                File::join(path, template)
+            }.find { |f| File.exists?(f) }
+
+            return td_file unless td_file == nil
+        end
+
+        td_file = find_template_for_module(template, environment)
+
+        # check in the default template dir, if there is one
+        if td_file.nil?
+            raise Puppet::Error, "No valid template directory found, please check templatedir settings" if template_paths.nil?
+            td_file = File::join(template_paths.first, template)
+        end
+        td_file
+    end
+
+    def self.find_template_for_module(template, environment = nil)
         path, file = split_path(template)
 
         # 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.
-        if file.nil?
-            mod = nil
-        else
+        if not file.nil?
             mod = find(path, environment)
+            if mod
+                return mod.template(file)
+            end
         end
-        if mod
-            return mod.template(file)
-        else
-            return td_file # Return this anyway, since we're going to fail.
-        end
+        nil
     end
 
     # Return a list of manifests (as absolute filenames) that match +pat+
@@ -144,4 +167,5 @@ class Puppet::Module
     end
 
     private :initialize
+    private_class_method :find_template_for_module
 end

data/lib/puppet/network/client/master.rb

@@ -199,6 +199,7 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
 
         self.class.instance = self
         @running = false
+        @splayed = false
     end
 
     # Mark that we should restart.  The Puppet module checks whether we're running,
@@ -338,7 +339,7 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
             if Puppet[:debug]
                 puts detail.backtrace
             end
-            Puppet.err "Could not retrieve #{args[:name]}s: %s" % detail
+            Puppet.err "Could not retrieve %ss: %s" % [args[:name], detail]
         end
 
         # Now clean up after ourselves
@@ -389,12 +390,13 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
         Dir.entries(dir).find_all { |e| e =~ /\.rb$/ }.each do |file|
             fqfile = ::File.join(dir, file)
             begin
-                Puppet.info "Loading #{type} %s" % ::File.basename(file.sub(".rb",''))
+                Puppet.info "Loading %s %s" % 
+                    [type, ::File.basename(file.sub(".rb",''))]
                 Timeout::timeout(self.timeout) do
                     load fqfile
                 end
             rescue => detail
-                Puppet.warning "Could not load #{type} %s: %s" % [fqfile, detail]
+                Puppet.warning "Could not load %s %s: %s" % [type, fqfile, detail]
             end
         end
     end
@@ -477,20 +479,19 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
         @lockfile
     end
 
+    def splayed?
+        @splayed
+    end
+
     # Sleep when splay is enabled; else just return.
     def splay
         return unless Puppet[:splay]
+        return if splayed?
 
-        limit = Integer(Puppet[:splaylimit])
-
-        # Pick a splay time and then cache it.
-        unless time = Puppet::Util::Storage.cache(:configuration)[:splay_time]
-            time = rand(limit)
-            Puppet::Util::Storage.cache(:configuration)[:splay_time] = time
-        end
-
+        time = rand(Integer(Puppet[:splaylimit]))
         Puppet.info "Sleeping for %s seconds (splay is enabled)" % time
         sleep(time)
+        @splayed = true
     end
 
     private

data/lib/puppet/network/handler/fileserver.rb

@@ -70,7 +70,9 @@ class Puppet::Network::Handler
             mount.debug("Describing %s for %s" % [url, client]) if client
 
             # use the mount to resolve the path for us.
-            metadata = Puppet::FileServing::Metadata.new(url, :path => mount.file_path(path, client), :links => links)
+            return "" unless full_path = mount.file_path(path, client)
+
+            metadata = Puppet::FileServing::Metadata.new(url, :path => full_path, :links => links)
 
             return "" unless metadata.exist?
 
@@ -651,55 +653,38 @@ class Puppet::Network::Handler
             # and "bad batch".
             #
             def list(relpath, recurse, ignore, client = nil)
-                reclist(file_path(relpath, client), nil, recurse, ignore)
-            end
-
-            # Recursively list the files in this tree.
-            def reclist(basepath, abspath, recurse, ignore)
-                abspath = basepath if abspath.nil?
-                relpath = abspath.sub(%r{^#{basepath}}, '')
-                relpath = "/#{relpath}" if relpath[0] != ?/  #/
-                
-                return unless FileTest.exists?(abspath)
-                
-                desc = [relpath]
-                
-                ftype = File.stat(abspath).ftype
-
-                desc << ftype
-                if recurse.is_a?(Integer)
-                    recurse -= 1
+                abspath = file_path(relpath, client)
+                if FileTest.exists?(abspath)
+                    if FileTest.directory?(abspath) and recurse
+                        return reclist(abspath, recurse, ignore)
+                    else
+                        return [["/", File.stat(abspath).ftype]]
+                    end
                 end
+                return nil
+            end
 
-                ary = [desc]
-                if recurse == true or (recurse.is_a?(Integer) and recurse > -1)
-                    if ftype == "directory"
-                        children = Dir.entries(abspath)
-                        if ignore
-                            children = handleignore(children, abspath, ignore)
-                        end  
-                        children.each { |child|
-                            next if child =~ /^\.\.?$/
-                            reclist(basepath, File.join(abspath, child), recurse, ignore).each { |cobj|
-                                ary << cobj
-                            }
-                        }
+            def reclist(abspath, recurse, ignore)
+                require 'puppet/file_serving'
+                require 'puppet/file_serving/fileset'
+                args = { :recurse => recurse, :links => :follow }
+                args[:ignore] = ignore if ignore
+                fs = Puppet::FileServing::Fileset.new(abspath, args)
+                ary = fs.files.collect do |file|
+                    if file == "."
+                        file = "/"
+                    else
+                        file = File.join("/", file )
                     end
+                    stat = fs.stat(File.join(abspath, file))
+                    next if stat.nil?
+                    [ file, stat.ftype ]
                 end
 
                 return ary.compact
             end
 
-            # Deal with ignore parameters.
-            def handleignore(files, path, ignore_patterns)
-                ignore_patterns.each do |ignore|
-                    files.delete_if do |entry|
-                        File.fnmatch(ignore, entry, File::FNM_DOTMATCH)
-                    end
-                end
-                return files
-            end
-        end  
+        end
 
         # A special mount class specifically for the plugins mount -- just
         # has some magic to effectively do a union mount of the 'plugins'
@@ -727,7 +712,7 @@ class Puppet::Network::Handler
             end
             
             def file_path(relpath, client = nil)
-                mod = valid_modules.map { |m| mod_path_exists?(m, relpath, client) ? m : nil }.compact.first
+                return nil unless mod = valid_modules.map { |m| mod_path_exists?(m, relpath, client) ? m : nil }.compact.first
                 mod_file_path(mod, relpath, client)
             end
 
@@ -735,9 +720,16 @@ class Puppet::Network::Handler
             def list(relpath, recurse, ignore, client = nil)
                 result = []
                 valid_modules.each do |m|
-                    ary = reclist(mod_file_path(m, relpath, client), nil, recurse, ignore)
-                    ary = [] if ary.nil?
-                   result += ary
+                    modpath = mod_file_path(m, relpath, client)
+                    if FileTest.exists?(modpath)
+                        if FileTest.directory?(modpath) and recurse
+                            ary = reclist(modpath, recurse, ignore)
+                            ary = [] if ary.nil?
+                            result += ary
+                        else
+                            result += [["/", File.stat(modpath).ftype]]
+                        end
+                    end
                 end
                 result
             end

data/lib/puppet/network/handler/master.rb

@@ -24,7 +24,7 @@ class Puppet::Network::Handler
         # Tell a client whether there's a fresh config for it
         def freshness(client = nil, clientip = nil)
             # Always force a recompile.  Newer clients shouldn't do this (as of April 2008).
-            Time.now
+            return Time.now.to_i
         end
 
         def initialize(hash = {})

data/lib/puppet/network/http_server/rack.rb

@@ -0,0 +1,148 @@
+# Author: Christian Hofstaedtler <hofstaedtler@inqnet.at>
+# Copyright (c) 2006 Manuel Holtgrewe, 2007 Luke Kanies,
+#               2008 Christian Hofstaedtler
+#
+# This file is mostly based on the mongrel module, which is part of
+# the standard puppet distribution.
+#
+# puppet/network/http_server/mongrel.rb has the following license, 
+# and is based heavily on a file retrieved from:
+# http://ttt.ggnore.net/2006/11/15/xmlrpc-with-mongrel-and-ruby-off-rails/
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+
+require 'puppet'
+require 'puppet/network/handler'
+require 'puppet/sslcertificates'
+
+require 'xmlrpc/server'
+require 'puppet/network/xmlrpc/server'
+require 'puppet/network/http_server'
+require 'puppet/network/client_request'
+require 'puppet/network/handler'
+
+require 'resolv'
+require 'rack'
+
+# A handler for a Rack-style puppet(master)d. For the most part, it works 
+# exactly the same as HTTPServer::Mongrel:
+# After checking whether the request itself is sane, the handler forwards 
+# it to an internal instance of XMLRPC::BasicServer to process it.
+module Puppet::Network
+	class HTTPServer::Rack
+		attr_reader :xmlrpc_server
+
+		def initialize(handlers)
+			@debug = false
+			if Puppet[:debug]
+				@debug = true
+			end
+
+			Puppet.info "Starting Rack server for puppet version %s" % Puppet.version
+			if Puppet[:name] != "puppetmasterd" then
+				Puppet.warn 'Rack server is not named "puppetmasterd", this may be not what you want. ($0 = %s)' % $0
+			end
+
+			@xmlrpc_server = Puppet::Network::XMLRPCServer.new
+			handlers.each do |name, args|
+				unless handler = Puppet::Network::Handler.handler(name)
+					raise ArgumentError, "Invalid handler %s" % name
+				end
+				h = handler.new(args)
+				@xmlrpc_server.add_handler(handler.interface, h)
+			end
+			Puppet.info "Rack server is waiting to serve requests."
+		end
+
+		# Validate a rack-style request (in env), and run the requested XMLRPC
+		# call.
+		def process(env)
+			# time to serve a request
+			req = Rack::Request.new(env)
+
+			if @debug then
+				Puppet.info "Handling request, details:"
+				env.each do |name, val|
+					l = "  env: %s ->" % name
+					l = l + ' %s' % val
+					Puppet.info l
+				end
+			end
+
+			if not req.post? then
+				return [405, { "Content-Type" => "text/html" }, "Method Not Allowed"]
+			end
+			if req.media_type() != "text/xml" then
+				return [400, { "Content-Type" => "text/html" }, "Bad Request"]
+			end
+			if req.content_length().to_i <= 0 then
+				return [411, { "Content-Type" => "text/html" }, "Length Required"]
+			end
+
+			body = ''
+			req.body().each { |line| body = body + line }
+			if @debug then
+				Puppet.info "Request Body: %s" % body
+			end
+			if body.size != req.content_length().to_i then
+				if @debug then
+					Puppet.info "body length didnt match %d" % body.size
+					Puppet.info " vs. -> %d" % req.content_length().to_i
+				end
+				return [400, { "Content-Type" => "text/html" }, "Bad Request Length"]
+			end
+			info = client_info(env)
+			begin
+				data = @xmlrpc_server.process(body, info)
+				return [200, { "Content-Type" => "text/xml; charset=utf-8" }, data]
+			rescue => detail
+				Puppet.err "Rack: Internal Server Error: XMLRPC_Server.process problem. Details follow: "
+				detail.backtrace.each { |line| 	Puppet.err " --> %s" % line }
+				return [500, { "Content-Type" => "text/html" }, "Internal Server Error"]
+			end
+		end
+
+		private
+
+		def client_info(request)
+			ip = request["REMOTE_ADDR"]
+			# JJM #906 The following dn.match regular expression is forgiving
+			# enough to match the two Distinguished Name string contents
+			# coming from Apache, Pound or other reverse SSL proxies.
+			if dn = request[Puppet[:ssl_client_header]] and dn_matchdata = dn.match(/^.*?CN\s*=\s*(.*)/)
+				client = dn_matchdata[1].to_str
+				valid = (request[Puppet[:ssl_client_verify_header]] == 'SUCCESS')
+			else
+				begin
+					client = Resolv.getname(ip)
+				rescue => detail
+					Puppet.err "Could not resolve %s: %s" % [ip, detail]
+					client = "unknown"
+				end
+				valid = false
+			end
+			info = Puppet::Network::ClientRequest.new(client, ip, valid)
+			return info
+		end
+	end
+end
+