puppet 0.23.2 → 0.24.0

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

@@ -13,7 +13,7 @@ class Puppet::Network::Handler
 
         include Puppet::Util
 
-        attr_accessor :ast, :local
+        attr_accessor :ast
         attr_reader :ca
 
         @interface = XMLRPC::Service::Interface.new("puppetmaster") { |iface|
@@ -21,85 +21,22 @@ class Puppet::Network::Handler
                 iface.add_method("int freshness()")
         }
 
-        # FIXME At some point, this should be autodocumenting.
-        def addfacts(facts)
-            # Add our server version to the fact list
-            facts["serverversion"] = Puppet.version.to_s
-
-            # And then add the server name and IP
-            {"servername" => "fqdn",
-                "serverip" => "ipaddress"
-            }.each do |var, fact|
-                if obj = Facter[fact]
-                    facts[var] = obj.value
-                else
-                    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 == "" or host.ip == "NULL")
-                    host.ip = clientip
-                end
-                host.save
-            end
-            if defined? @interpreter
-                return @interpreter.parsedate
-            else
-                return 0
-            end
+            client ||= Facter.value("hostname")
+            config_handler.version(client, clientip)
         end
 
         def initialize(hash = {})
             args = {}
 
-            # Allow specification of a code snippet or of a file
-            if code = hash[:Code]
-                args[:Code] = code
-            else
-                args[:Manifest] = hash[:Manifest] || Puppet[:manifest]
-            end
-
             if hash[:Local]
                 @local = hash[:Local]
             else
                 @local = false
             end
 
-            args[:Local] = @local
+            args[:Local] = true
 
             if hash.include?(:CA) and hash[:CA]
                 @ca = Puppet::SSLCertificates::CA.new()
@@ -109,118 +46,86 @@ class Puppet::Network::Handler
 
             Puppet.debug("Creating interpreter")
 
-            if hash.include?(:UseNodes)
-                args[:UseNodes] = hash[:UseNodes]
-            elsif @local
-                args[:UseNodes] = false
-            end
-
             # This is only used by the cfengine module, or if --loadclasses was
             # specified in +puppet+.
             if hash.include?(:Classes)
                 args[:Classes] = hash[:Classes]
             end
 
-            @interpreter = Puppet::Parser::Interpreter.new(args)
+            @config_handler = Puppet::Network::Handler.handler(:configuration).new(args)
         end
 
+        # Call our various handlers; this handler is getting deprecated.
         def getconfig(facts, format = "marshal", client = nil, clientip = nil)
-            if @local
-                # we don't need to do anything, since we should already
-                # have raw objects
-                Puppet.debug "Our client is local"
-            else
-                Puppet.debug "Our client is remote"
+            facts = decode_facts(facts)
+            client, clientip = clientname(client, clientip, facts)
 
-                # 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
-                        raise XMLRPC::FaultException.new(
-                            1, "Could not rebuild facts"
-                        )
-                    end
-                when "yaml":
-                    begin
-                        facts = YAML.load(CGI.unescape(facts))
-                    rescue => detail
-                        raise XMLRPC::FaultException.new(
-                            1, "Could not rebuild facts"
-                        )
-                    end
-                else
-                    raise XMLRPC::FaultException.new(
-                        1, "Unavailable config format %s" % format
-                    )
-                end
-            end
+            # Pass the facts to the fact handler
+            Puppet::Node::Facts.new(client, facts).save unless local?
 
-            client, clientip = clientname(client, clientip, facts)
+            # And get the configuration from the config handler
+            config = nil
+            benchmark(:notice, "Compiled configuration for %s" % client) do
+                config = config_handler.configuration(client)
+            end
 
-            # Add any server-side facts to our server.
-            addfacts(facts)
+            return translate(config.extract)
+        end
 
-            retobjects = nil
+        private
 
-            # This is hackish, but there's no "silence" option for benchmarks
-            # right now
-            if @local
-                #begin
-                    retobjects = @interpreter.run(client, facts)
-                #rescue Puppet::Error => detail
-                #    Puppet.err detail
-                #    raise XMLRPC::FaultException.new(
-                #        1, detail.to_s
-                #    )
-                #rescue => detail
-                #    Puppet.err detail.to_s
-                #    return ""
-                #end
-            else
-                benchmark(:notice, "Compiled configuration for %s" % client) do
-                    begin
-                        retobjects = @interpreter.run(client, facts)
-                    rescue Puppet::Error => detail
-                        Puppet.err detail
-                        raise XMLRPC::FaultException.new(
-                            1, detail.to_s
-                        )
-                    rescue => detail
-                        Puppet.err detail.to_s
-                        return ""
-                    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
+
+        def config_handler
+            unless defined? @config_handler
+                @config_handler = Puppet::Network::Handler.handler(:config).new :local => local?
+            end
+            @config_handler
+        end
+
+        # 
+        def decode_facts(facts)
             if @local
-                return retobjects
+                # we don't need to do anything, since we should already
+                # have raw objects
+                Puppet.debug "Our client is local"
             else
-                str = nil
-                case format
-                when "marshal":
-                    str = Marshal::dump(retobjects)
-                when "yaml":
-                    str = retobjects.to_yaml(:UseBlock => true)
-                else
+                Puppet.debug "Our client is remote"
+
+                begin
+                    facts = YAML.load(CGI.unescape(facts))
+                rescue => detail
                     raise XMLRPC::FaultException.new(
-                        1, "Unavailable config format %s" % format
+                        1, "Could not rebuild facts"
                     )
                 end
-                return CGI.escape(str)
             end
+
+            return facts
         end
 
-        def local?
-            if defined? @local and @local
-                return true
+        # Translate our configuration appropriately for sending back to a client.
+        def translate(config)
+            if local?
+                config
             else
-                return false
+                CGI.escape(config.to_yaml(:UseBlock => true))
             end
         end
     end
 end
-
-# $Id: master.rb 2616 2007-06-18 21:03:18Z luke $

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

@@ -1,78 +1,24 @@
 require 'puppet/util/instance_loader'
+require 'puppet/reports'
 
 # A simple server for triggering a new run on a Puppet client.
 class Puppet::Network::Handler
     class Report < Handler
         desc "Accepts a Puppet transaction report and processes it."
 
-        extend Puppet::Util::ClassGen
-        extend Puppet::Util::InstanceLoader
-
-        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)")
         }
 
-        # Set up autoloading and retrieving of reports.
-        autoload :report, '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 => instance_hash(:report), :block => block)
-
-            if options[:useyaml]
-                mod.useyaml = true
-            end
-
-            mod.send(:define_method, :report_name) do
-                name
-            end
-        end
-
-        # Collect the docs for all of our reports.
-        def self.reportdocs
-            docs = ""
-
-            # Use this method so they all get loaded
-            instance_loader(:report).loadall
-            loaded_instances(:report).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
-            instance_loader(:report).loadall
-            loaded_instances(:report)
+            Puppet.warning "The interface for registering report types has changed; use Puppet::Reports.register_report for report type %s" % name
+            Puppet::Reports.register_report(name, options, &block)
         end
 
         def initialize(*args)
             super
-            Puppet.config.use(:reporting)
-            Puppet.config.use(:metrics)
+            Puppet.settings.use(:main, :reporting, :metrics)
         end
 
         # Accept a report from a client.
@@ -111,17 +57,13 @@ class Puppet::Network::Handler
             client = report.host
 
             reports().each do |name|
-                if mod = self.class.report(name)
+                if mod = Puppet::Reports.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
+                        newrep.process
                     rescue => detail
                         if Puppet[:trace]
                             puts detail.backtrace
@@ -142,4 +84,3 @@ class Puppet::Network::Handler
     end
 end
 
-# $Id: report.rb 2637 2007-06-20 00:16:41Z luke $

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

@@ -26,7 +26,7 @@ class Puppet::Network::Handler
 
         # Apply a TransBucket as a transaction.
         def apply(bucket, format = "yaml", client = nil, clientip = nil)
-            unless @local
+            unless local?
                 begin
                     case format
                     when "yaml":
@@ -39,21 +39,14 @@ class Puppet::Network::Handler
                 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
+            catalog = bucket.to_catalog
 
-            # And then apply the configuration.  This way we're reusing all
+            # And then apply the catalog.  This way we're reusing all
             # the code in there.  It should probably just be separated out, though.
-            transaction = client.apply
+            transaction = catalog.apply
             
             # And then clean up
-            component.remove
+            catalog.clear(true)
 
             # It'd be nice to return some kind of report, but... at this point
             # we have no such facility.
@@ -199,4 +192,3 @@ class Puppet::Network::Handler
     end
 end
 
-# $Id: resource.rb 2551 2007-06-04 20:37:14Z luke $

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

@@ -43,17 +43,17 @@ class Puppet::Network::Handler
             end
 
             if ignoreschedules
-                msg += " without schedules"
+                msg += " ignoring schedules"
             end
 
             Puppet.notice msg
 
             # And then we need to tell it to run, with this extra info.
             if fg
-                master.run(tags, ignoreschedules)
+                master.run(:tags => tags, :ignoreschedules => ignoreschedules)
             else
                 Puppet.newthread do
-                    master.run(tags, ignoreschedules)
+                    master.run(:tags => tags, :ignoreschedules => ignoreschedules)
                 end
             end
 
@@ -62,4 +62,3 @@ class Puppet::Network::Handler
     end
 end
 
-# $Id: runner.rb 2479 2007-05-07 22:29:44Z luke $

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

@@ -14,4 +14,3 @@ class Puppet::Network::Handler
     end
 end
 
-# $Id: status.rb 2479 2007-05-07 22:29:44Z luke $

data/lib/puppet/network/http.rb

@@ -0,0 +1,13 @@
+class Puppet::Network::HTTP
+    def self.server_class_by_type(kind)
+        return Puppet::Network::HTTP::WEBrick if kind.to_sym == :webrick
+        if kind.to_sym == :mongrel
+            raise ArgumentError, "Mongrel is not installed on this platform" unless Puppet.features.mongrel?
+            return Puppet::Network::HTTP::Mongrel 
+        end
+        raise ArgumentError, "Unknown HTTP server name [#{kind}]"
+    end
+end
+
+require 'puppet/network/http/webrick'
+require 'puppet/network/http/mongrel'