puppet 0.18.4 → 0.22.4

data/lib/puppet/{server → network/handler}/logger.rb

@@ -1,7 +1,6 @@
 require 'yaml'
 
-module Puppet
-class Server
+class Puppet::Network::Handler
     class LoggerError < RuntimeError; end
 
     # Receive logs from remote hosts.
@@ -42,13 +41,12 @@ class Server
                 end
             end
 
-            Puppet::Log.newmessage(message)
+            Puppet::Util::Log.newmessage(message)
 
             # This is necessary or XMLRPC gets all pukey
             return ""
         end
     end
 end
-end
 
-# $Id: logger.rb 846 2006-01-20 20:38:01Z luke $
+# $Id: logger.rb 2259 2007-03-06 19:03:05Z luke $

data/lib/puppet/{server → network/handler}/master.rb

@@ -5,8 +5,7 @@ require 'puppet/sslcertificates'
 require 'xmlrpc/server'
 require 'yaml'
 
-module Puppet
-class Server
+class Puppet::Network::Handler
     class MasterError < Puppet::Error; end
     class Master < Handler
         include Puppet::Util
@@ -25,7 +24,7 @@ class Server
             facts["serverversion"] = Puppet.version.to_s
 
             # And then add the server name and IP
-            {"servername" => "hostname",
+            {"servername" => "fqdn",
                 "serverip" => "ipaddress"
             }.each do |var, fact|
                 if obj = Facter[fact]
@@ -34,10 +33,46 @@ class Server
                     Puppet.warning "Could not retrieve fact %s" % fact
                 end
             end
+
+            if facts["servername"].nil?
+                host = Facter.value(:hostname)
+                if domain = Facter.value(:domain)
+                    facts["servername"] = [host, domain].join(".")
+                else
+                    facts["servername"] = host
+                end
+            end
+        end
+
+        # Manipulate the client name as appropriate.
+        def clientname(name, ip, facts)
+            # Always use the hostname from Facter.
+            client = facts["hostname"]
+            clientip = facts["ipaddress"]
+            if Puppet[:node_name] == 'cert'
+                if name
+                    client = name
+                end
+                if ip
+                    clientip = ip
+                end
+            end
+
+            return client, clientip
         end
 
         # Tell a client whether there's a fresh config for it
         def freshness(client = nil, clientip = nil)
+            if Puppet.features.rails? and Puppet[:storeconfigs]
+                Puppet::Rails.connect
+
+                host = Puppet::Rails::Host.find_or_create_by_name(client)
+                host.last_freshcheck = Time.now
+                if clientip and (! host.ip or host.ip == "")
+                    host.ip = clientip
+                end
+                host.save
+            end
             if defined? @interpreter
                 return @interpreter.parsedate
             else
@@ -97,6 +132,7 @@ class Server
                 # XXX this should definitely be done in the protocol, somehow
                 case format
                 when "marshal":
+                    Puppet.warning "You should upgrade your client.  'Marshal' will not be supported much longer."
                     begin
                         facts = Marshal::load(CGI.unescape(facts))
                     rescue => detail
@@ -119,10 +155,7 @@ class Server
                 end
             end
 
-            unless client
-                client = facts["hostname"]
-                clientip = facts["ipaddress"]
-            end
+            client, clientip = clientname(client, clientip, facts)
 
             # Add any server-side facts to our server.
             addfacts(facts)
@@ -186,4 +219,5 @@ class Server
         end
     end
 end
-end
+
+# $Id: master.rb 2334 2007-03-19 23:04:32Z luke $

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

@@ -0,0 +1,158 @@
+# A simple server for triggering a new run on a Puppet client.
+class Puppet::Network::Handler
+    class Report < Handler
+        extend Puppet::Util::ClassGen
+
+        module ReportBase
+            include Puppet::Util::Docs
+            attr_writer :useyaml
+
+            def useyaml?
+                if defined? @useyaml
+                    @useyaml
+                else
+                    false
+                end
+            end
+        end
+
+        @interface = XMLRPC::Service::Interface.new("puppetreports") { |iface|
+            iface.add_method("string report(array)")
+        }
+
+        @reports = {}
+        @reportloader = Puppet::Util::Autoload.new(self, "puppet/reports")
+
+        class << self
+            attr_reader :hooks
+        end
+
+        # Add a new report type.
+        def self.newreport(name, options = {}, &block)
+            name = symbolize(name)
+
+            mod = genmodule(name, :extend => ReportBase, :hash => @reports, :block => block)
+
+            if options[:useyaml]
+                mod.useyaml = true
+            end
+
+            mod.send(:define_method, :report_name) do
+                name
+            end
+        end
+
+        # Load a report.
+        def self.report(name)
+            name = name.intern if name.is_a? String
+            unless @reports.include? name
+                if @reportloader.load(name)
+                    unless @reports.include? name
+                        Puppet.warning(
+                            "Loaded report file for %s but report was not defined" %
+                            name
+                        )
+                        return nil
+                    end
+                else
+                    return nil
+                end
+            end
+            @reports[symbolize(name)]
+        end
+
+        # Collect the docs for all of our reports.
+        def self.reportdocs
+            docs = ""
+
+            # Use this method so they all get loaded
+            reports.sort { |a,b| a.to_s <=> b.to_s }.each do |name|
+                mod = self.report(name)
+                docs += "%s\n%s\n" % [name, "-" * name.to_s.length]
+
+                docs += Puppet::Util::Docs.scrub(mod.doc) + "\n\n"
+            end
+
+            docs
+        end
+
+        # List each of the reports.
+        def self.reports
+            @reportloader.loadall
+            @reports.keys
+        end
+
+        def initialize(*args)
+            super
+            Puppet.config.use(:reporting)
+            Puppet.config.use(:metrics)
+        end
+
+        # Accept a report from a client.
+        def report(report, client = nil, clientip = nil)
+            # Unescape the report
+            unless @local
+                report = CGI.unescape(report)
+            end
+
+            Puppet.info "Processing reports %s for %s" % [reports().join(", "), client]
+            begin
+                process(report)
+            rescue => detail
+                Puppet.err "Could not process report for %s: %s" % [client, detail]
+                if Puppet[:trace]
+                    puts detail.backtrace
+                end
+            end
+        end
+
+        private
+
+        # Process the report using all of the existing hooks.
+        def process(yaml)
+            return if Puppet[:reports] == "none"
+
+            # First convert the report to real objects
+            begin
+                report = YAML.load(yaml)
+            rescue => detail
+                Puppet.warning "Could not load report: %s" % detail
+                return
+            end
+
+            # Used for those reports that accept yaml
+            client = report.host
+
+            reports().each do |name|
+                if mod = self.class.report(name)
+                    # We have to use a dup because we're including a module in the
+                    # report.
+                    newrep = report.dup
+                    begin
+                        newrep.extend(mod)
+                        if mod.useyaml?
+                            newrep.process(yaml)
+                        else
+                            newrep.process
+                        end
+                    rescue => detail
+                        if Puppet[:trace]
+                            puts detail.backtrace
+                        end
+                        Puppet.err "Report %s failed: %s" %
+                            [name, detail]
+                    end
+                else
+                    Puppet.warning "No report named '%s'" % name
+                end
+            end
+        end
+
+        # Handle the parsing of the reports attribute.
+        def reports
+            Puppet[:reports].gsub(/(^\s+)|(\s+$)/, '').split(/\s*,\s*/)
+        end
+    end
+end
+
+# $Id: report.rb 2406 2007-04-23 06:16:10Z luke $

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

@@ -0,0 +1,190 @@
+require 'puppet'
+require 'puppet/network/handler'
+
+# Serve Puppet elements.  Useful for querying, copying, and, um, other stuff.
+class Puppet::Network::Handler
+    class Resource < Handler
+        attr_accessor :local
+
+        @interface = XMLRPC::Service::Interface.new("resource") { |iface|
+            iface.add_method("string apply(string, string)")
+            iface.add_method("string describe(string, string, array, array)")
+            iface.add_method("string list(string, array, string)")
+        }
+
+        # Apply a TransBucket as a transaction.
+        def apply(bucket, format = "yaml", client = nil, clientip = nil)
+            unless @local
+                begin
+                    case format
+                    when "yaml":
+                        bucket = YAML::load(Base64.decode64(bucket))
+                    else
+                        raise Puppet::Error, "Unsupported format '%s'" % format
+                    end
+                rescue => detail
+                    raise Puppet::Error, "Could not load YAML TransBucket: %s" % detail
+                end
+            end
+
+            component = bucket.to_type
+
+            # Create a client, but specify the remote machine as the server
+            # because the class requires it, even though it's unused
+            client = Puppet::Network::Client.client(:Master).new(:Server => client||"localhost")
+
+            # Set the objects
+            client.objects = component
+
+            # And then apply the configuration.  This way we're reusing all
+            # the code in there.  It should probably just be separated out, though.
+            transaction = client.apply
+            
+            # And then clean up
+            component.remove
+
+            # It'd be nice to return some kind of report, but... at this point
+            # we have no such facility.
+            return "success"
+        end
+
+        # Describe a given object.  This returns the 'is' values for every property
+        # available on the object type.
+        def describe(type, name, retrieve = nil, ignore = [], format = "yaml", client = nil, clientip = nil)
+            Puppet.info "Describing %s[%s]" % [type.to_s.capitalize, name]
+            @local = true unless client
+            typeklass = nil
+            unless typeklass = Puppet.type(type)
+                raise Puppet::Error, "Puppet type %s is unsupported" % type
+            end
+
+            obj = nil
+
+            retrieve ||= :all
+            ignore ||= []
+
+            if obj = typeklass[name]
+                obj[:check] = retrieve
+            else
+                begin
+                    obj = typeklass.create(:name => name, :check => retrieve)
+                rescue Puppet::Error => detail
+                    raise Puppet::Error, "%s[%s] could not be created: %s" %
+                        [type, name, detail]
+                end
+            end
+
+            unless obj
+                raise XMLRPC::FaultException.new(
+                    1, "Could not create %s[%s]" % [type, name]
+                )
+            end
+
+            trans = obj.to_trans
+
+            # Now get rid of any attributes they specifically don't want
+            ignore.each do |st|
+                if trans.include? st
+                    trans.delete(st)
+                end
+            end
+
+            # And get rid of any attributes that are nil
+            trans.each do |attr, value|
+                if value.nil?
+                    trans.delete(attr)
+                end
+            end
+
+            unless @local
+                case format
+                when "yaml":
+                    trans = Base64.encode64(YAML::dump(trans))
+                else
+                    raise XMLRPC::FaultException.new(
+                        1, "Unavailable config format %s" % format
+                    )
+                end
+            end
+
+            return trans
+        end
+
+        # Create a new fileserving module.
+        def initialize(hash = {})
+            if hash[:Local]
+                @local = hash[:Local]
+            else
+                @local = false
+            end
+        end
+
+        # List all of the elements of a given type.
+        def list(type, ignore = [], base = nil, format = "yaml", client = nil, clientip = nil)
+            @local = true unless client
+            typeklass = nil
+            unless typeklass = Puppet.type(type)
+                raise Puppet::Error, "Puppet type %s is unsupported" % type
+            end
+
+            # They can pass in false
+            ignore ||= []
+            ignore = [ignore] unless ignore.is_a? Array
+            bucket = Puppet::TransBucket.new
+            bucket.type = typeklass.name
+
+            typeklass.list.each do |obj|
+                next if ignore.include? obj.name
+
+                #object = Puppet::TransObject.new(obj.name, typeklass.name)
+                bucket << obj.to_trans
+            end
+
+            unless @local
+                case format
+                when "yaml":
+                    begin
+                    bucket = Base64.encode64(YAML::dump(bucket))
+                    rescue => detail
+                        Puppet.err detail
+                        raise XMLRPC::FaultException.new(
+                            1, detail.to_s
+                        )
+                    end
+                else
+                    raise XMLRPC::FaultException.new(
+                        1, "Unavailable config format %s" % format
+                    )
+                end
+            end
+
+            return bucket
+        end
+
+        private
+
+        def authcheck(file, mount, client, clientip)
+            unless mount.allowed?(client, clientip)
+                mount.warning "%s cannot access %s" %
+                    [client, file]
+                raise Puppet::AuthorizationError, "Cannot access %s" % mount
+            end
+        end
+
+        # Deal with ignore parameters.
+        def handleignore(children, path, ignore)            
+            ignore.each { |ignore|                
+                Dir.glob(File.join(path,ignore), File::FNM_DOTMATCH) { |match|
+                    children.delete(File.basename(match))
+                }                
+            }
+            return children
+        end  
+
+        def to_s
+            "resource"
+        end
+    end
+end
+
+# $Id: resource.rb 2433 2007-04-30 15:43:50Z luke $