puppet 0.9.2 → 0.13.0

data/lib/puppet/event.rb

@@ -158,7 +158,12 @@ module Puppet
             end
 
             def source
-                self.class.retrieve(@source)
+                if source = self.class.retrieve(@source)
+                    return source
+                else
+                    raise Puppet::Error, "Could not retreive dependency %s[%s]" %
+                        @source
+                end
             end
 
             def sourcearray
@@ -192,7 +197,7 @@ module Puppet
                 end
 
                 if transaction.triggered?(self.target, @callback) > 0
-                    Puppet.debug "%s has already run" % self
+                    self.target.info "already applied %s" % [@callback]
                 else
                     # We need to call the method, so that it gets retrieved
                     # as a real object.
@@ -201,6 +206,7 @@ module Puppet
                     #    [@source,@event,@method,target]
                     begin
                         if target.respond_to?(@callback)
+                            target.log "triggering %s" % @callback
                             event = target.send(@callback)
                         else
                             Puppet.debug(   
@@ -240,14 +246,6 @@ module Puppet
 			@event = args[:event]
 			@source = args[:source]
 			@transaction = args[:transaction]
-
-            #Puppet.info "%s: %s(%s)" %
-            #Puppet.info "%s: %s changed from %s to %s" %
-            #    [@object,@state.name, @state.is,@state.should]
-
-            # initially, just stuff all instances into a central bucket
-            # to be handled as a batch
-            #@@events.push self
 		end
 
         def to_s
@@ -256,4 +254,4 @@ module Puppet
 	end
 end
 
-# $Id: event.rb 710 2005-10-01 19:57:07Z luke $
+# $Id: event.rb 841 2006-01-18 17:24:15Z luke $

data/lib/puppet/filetype.rb

@@ -0,0 +1,195 @@
+module Puppet
+    # Basic classes for reading, writing, and emptying files.  Not much
+    # to see here.
+    class FileType
+        attr_accessor :loaded, :path, :synced
+
+        class << self
+            attr_accessor :name
+        end
+
+        def self.inspect
+            "SvcType(#{self.name})"
+        end
+
+        def self.to_s
+            "SvcType(#{self.name})"
+        end
+
+        def svctype
+            self.class.name
+        end
+
+        def self.newfiletype(name, &block)
+            @filetypes ||= {}
+
+            klass = Class.new(self)
+
+            klass.name = name
+
+            klass.class_eval(&block)
+
+            const_set(name.to_s.capitalize, klass)
+
+            # Rename the read and write methods, so that we're sure they
+            # maintain the stats.
+            klass.class_eval do
+                # Rename the read method
+                define_method(:real_read, instance_method(:read))
+                define_method(:read) do
+                    begin
+                        val = real_read()
+                        @loaded = Time.now
+                        return val.gsub(/# HEADER.*\n/,'')
+                    rescue Puppet::Error => detail
+                        raise
+                    rescue => detail
+                        raise Puppet::Error, "%s could not read %s: %s" %
+                            [self.class, @path, detail]
+                    end
+                end
+
+                # And then the write method
+                define_method(:real_write, instance_method(:write))
+                define_method(:write) do |text|
+                    begin
+                        val = real_write(text)
+                        @synced = Time.now
+                        return val
+                    rescue Puppet::Error => detail
+                        raise
+                    rescue => detail
+                        if Puppet[:debug]
+                            puts detail.backtrace
+                        end
+                        raise Puppet::Error, "%s could not write %s: %s" %
+                            [self.class, @path, detail]
+                    end
+                end
+            end
+
+            @filetypes[name] = klass
+        end
+
+        def self.filetype(type)
+            @filetypes[type]
+        end
+
+        def initialize(path)
+            @path = path
+        end
+
+        # Operate on plain files.
+        newfiletype(:flat) do
+            # Read the file.
+            def read
+                if File.exists?(@path)
+                    File.read(@path)
+                else
+                    return nil
+                end
+            end
+
+            # Remove the file.
+            def remove
+                if File.exists?(@path)
+                    File.unlink(@path)
+                end
+            end
+
+            # Overwrite the file.
+            def write(text)
+                File.open(@path, "w") { |f| f.print text; f.flush }
+            end
+        end
+
+        # Operate on plain files.
+        newfiletype(:ram) do
+            def initialize(path)
+                super
+                @text = ""
+            end
+
+            # Read the file.
+            def read
+                Puppet.info "Reading %s" % @path
+                @text
+            end
+
+            # Remove the file.
+            def remove
+                Puppet.info "Removing %s" % @path
+                @text = ""
+            end
+
+            # Overwrite the file.
+            def write(text)
+                Puppet.info "Writing %s" % @path
+                @text = text
+            end
+        end
+
+        # Handle Linux-style cron tabs.
+        newfiletype(:crontab) do
+            # Only add the -u flag when the @path is different.  Fedora apparently
+            # does not think I should be allowed to set the @path to my
+            def cmdbase
+                uid = CronType.uid(@path)
+                cmd = nil
+                if uid == Process.uid
+                    return "crontab"
+                else
+                    return "crontab -u #{@path}"
+                end
+            end
+
+            # Read a specific @path's cron tab.
+            def read
+                %x{#{cmdbase(@path)} -l 2>/dev/null}
+            end
+
+            # Remove a specific @path's cron tab.
+            def remove
+                %x{#{cmdbase(@path)} -r 2>/dev/null}
+            end
+
+            # Overwrite a specific @path's cron tab; must be passed the @path name
+            # and the text with which to create the cron tab.
+            def write(text)
+                IO.popen("#{cmdbase(@path)} -", "w") { |p|
+                    p.print text
+                }
+            end
+        end
+
+        # SunOS has completely different cron commands; this class implements
+        # its versions.
+        newfiletype(:suntab) do
+            # Read a specific @path's cron tab.
+            def read
+                Puppet::Util.asuser(@path) {
+                    %x{crontab -l 2>/dev/null}
+                }
+            end
+
+            # Remove a specific @path's cron tab.
+            def remove
+                Puppet::Util.asuser(@path) {
+                    %x{crontab -r 2>/dev/null}
+                }
+            end
+
+            # Overwrite a specific @path's cron tab; must be passed the @path name
+            # and the text with which to create the cron tab.
+            def write(text)
+                Puppet::Util.asuser(@path) {
+                    IO.popen("crontab", "w") { |p|
+                        p.print text
+                    }
+                }
+            end
+        end
+    end
+end
+
+# $Id: filetype.rb 848 2006-01-24 06:01:58Z luke $

data/lib/puppet/log.rb

@@ -1,6 +1,6 @@
 require 'syslog'
 
-module Puppet # :nodoc:
+module Puppet
     # Pass feedback to the user.  Log levels are modeled after syslog's, and it is
     # expected that that will be the most common log destination.  Supports
     # multiple destinations, one of which is a remote server.
@@ -27,14 +27,14 @@ module Puppet # :nodoc:
             :crit => RESET
 		}
 
-        @destinations = {:syslog => Syslog.open("puppet")}
+        #@destinations = {:syslog => Syslog.open("puppet")}
+        @destinations = {:console => :console}
 
         # Reset all logs to basics.  Basically just closes all files and undefs
         # all of the other objects.
         def Log.close(dest = nil)
             if dest
                 if @destinations.include?(dest)
-                    Puppet.warning "Closing %s" % dest
                     if @destinations.respond_to?(:close)
                         @destinations[dest].close
                     end
@@ -67,6 +67,12 @@ module Puppet # :nodoc:
         # Create a new log message.  The primary role of this method is to
         # avoid creating log messages below the loglevel.
         def Log.create(hash)
+            unless hash.include?(:level)
+                raise Puppet::DevError, "Logs require a level"
+            end
+            unless @levels.index(hash[:level])
+                raise Puppet::DevError, "Invalid log level %s" % hash[:level]
+            end
             if @levels.index(hash[:level]) >= @loglevel 
                 return Puppet::Log.new(hash)
             else
@@ -74,6 +80,10 @@ module Puppet # :nodoc:
             end
         end
 
+        def Log.destinations
+            return @destinations.keys
+        end
+
         # Yield each valid level in turn
         def Log.eachlevel
             @levels.each { |level| yield level }
@@ -153,12 +163,15 @@ module Puppet # :nodoc:
             end
         end
 
-        # Route the actual message. FIXME There are lots of things this method should
-        # do, like caching, storing messages when there are not yet destinations,
-        # a bit more.
-        # It's worth noting that there's a potential for a loop here, if
-        # the machine somehow gets the destination set as itself.
+        # Route the actual message. FIXME There are lots of things this method
+        # should do, like caching, storing messages when there are not yet
+        # destinations, a bit more.  It's worth noting that there's a potential
+        # for a loop here, if the machine somehow gets the destination set as
+        # itself.
         def Log.newmessage(msg)
+            if @levels.index(msg.level) < @loglevel 
+                return
+            end
             @destinations.each { |type, dest|
                 case dest
                 when Module # This is the Syslog module
@@ -170,7 +183,9 @@ module Puppet # :nodoc:
                         dest.send(msg.level, msg.to_s.gsub("%", '%%'))
                     else
                         dest.send(msg.level, "(%s) %s" %
-                            [msg.source.to_s.gsub("%", ""), msg.to_s.gsub("%", '%%')]
+                            [msg.source.to_s.gsub("%", ""),
+                                msg.to_s.gsub("%", '%%')
+                            ]
                         )
                     end
                 when File:
@@ -207,9 +222,9 @@ module Puppet # :nodoc:
                         begin
                             #puts "would have sent %s" % msg
                             #puts "would have sent %s" %
-                            #    CGI.escape(Marshal::dump(msg))
+                            #    CGI.escape(YAML.dump(msg))
                             begin
-                                tmp = CGI.escape(Marshal::dump(msg))
+                                tmp = CGI.escape(YAML.dump(msg))
                             rescue => detail
                                 puts "Could not dump: %s" % detail.to_s
                                 return
@@ -230,6 +245,10 @@ module Puppet # :nodoc:
             }
         end
 
+        def Log.sendlevel?(level)
+            @levels.index(level) >= @loglevel 
+        end
+
         # Reopen all of our logs.
         def Log.reopen
             types = @destinations.keys
@@ -273,6 +292,10 @@ module Puppet # :nodoc:
 				raise Puppet::DevError,
                     "Level is not a string or symbol: #{args[:level].class}"
 			end
+
+            # Just return unless we're actually at a level we should send
+            #return unless self.class.sendlevel?(@level)
+
 			@message = args[:message].to_s
 			@time = Time.now
 			# this should include the host name, and probly lots of other
@@ -318,4 +341,4 @@ module Puppet # :nodoc:
 	end
 end
 
-# $Id: log.rb 742 2005-11-16 17:12:11Z luke $
+# $Id: log.rb 873 2006-02-07 23:12:33Z luke $

data/lib/puppet/metric.rb

@@ -1,7 +1,7 @@
 # included so we can test object types
 require 'puppet'
 
-module Puppet # :nodoc:
+module Puppet
     # A class for handling metrics.  This is currently ridiculously hackish.
 	class Metric
         def Metric.init
@@ -247,4 +247,4 @@ module Puppet # :nodoc:
     end
 end
 
-# $Id: metric.rb 732 2005-10-28 05:39:59Z luke $
+# $Id: metric.rb 846 2006-01-20 20:38:01Z luke $

data/lib/puppet/networkclient.rb

@@ -0,0 +1,145 @@
+require 'puppet'
+require 'puppet/sslcertificates'
+require 'puppet/type'
+require 'facter'
+require 'openssl'
+require 'puppet/transaction'
+require 'puppet/transportable'
+require 'puppet/metric'
+require 'puppet/daemon'
+require 'puppet/server'
+require 'puppet/base64'
+
+$noclientnetworking = false
+begin
+    require 'webrick'
+    require 'cgi'
+    require 'xmlrpc/client'
+    require 'xmlrpc/server'
+    require 'yaml'
+rescue LoadError => detail
+    $noclientnetworking = detail
+    raise Puppet::Error, "You must have the Ruby XMLRPC, CGI, and Webrick libraries installed"
+end
+
+module Puppet
+    class NetworkClientError < RuntimeError; end
+    class ClientError < RuntimeError; end
+    #---------------------------------------------------------------
+    if $noclientnetworking
+        Puppet.err "Could not load client network libs: %s" % $noclientnetworking
+    else
+        class NetworkClient < XMLRPC::Client
+            #include Puppet::Daemon
+
+            # add the methods associated with each namespace
+            Puppet::Server::Handler.each { |handler|
+                interface = handler.interface
+                namespace = interface.prefix
+
+                interface.methods.each { |ary|
+                    method = ary[0]
+                    Puppet.info "Defining %s.%s" % [namespace, method]
+                    self.send(:define_method,method) { |*args|
+                        #Puppet.info "Calling %s" % method
+                        #Puppet.info "peer cert is %s" % @http.peer_cert
+                        #Puppet.info "cert is %s" % @http.cert
+                        begin
+                            call("%s.%s" % [namespace, method.to_s],*args)
+                        rescue OpenSSL::SSL::SSLError => detail
+                            #Puppet.err "Could not call %s.%s: Untrusted certificates" %
+                            #    [namespace, method]
+                            raise NetworkClientError,
+                                "Certificates were not trusted"
+                        rescue XMLRPC::FaultException => detail
+                            #Puppet.err "Could not call %s.%s: %s" %
+                            #    [namespace, method, detail.faultString]
+                            #raise NetworkClientError,
+                            #    "XMLRPC Error: %s" % detail.faultString
+                            raise NetworkClientError, detail.faultString
+                        rescue Errno::ECONNREFUSED => detail
+                            msg = "Could not connect to %s on port %s" % [@host, @port]
+                            #Puppet.err msg
+                            raise NetworkClientError, msg
+                        rescue SocketError => detail
+                            Puppet.err "Could not find server %s" % @puppetserver
+                            exit(12)
+                        rescue => detail
+                            Puppet.err "Could not call %s.%s: %s" %
+                                [namespace, method, detail.inspect]
+                            #raise NetworkClientError.new(detail.to_s)
+                            raise
+                        end
+                    }
+                }
+            }
+
+            def ca_file=(cafile)
+                @http.ca_file = cafile
+                store = OpenSSL::X509::Store.new
+                cacert = OpenSSL::X509::Certificate.new(
+                    File.read(cafile)
+                )
+                store.add_cert(cacert) 
+                store.purpose = OpenSSL::X509::PURPOSE_SSL_CLIENT
+                @http.cert_store = store
+            end
+
+            def cert=(cert)
+                #Puppet.debug "Adding certificate"
+                @http.cert = cert
+                @http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+            end
+
+            def key=(key)
+                @http.key = key
+            end
+
+            def initialize(hash)
+                hash[:Path] ||= "/RPC2"
+                hash[:Server] ||= "localhost"
+                hash[:Port] ||= Puppet[:masterport]
+
+                @puppetserver = hash[:Server]
+
+                super(
+                    hash[:Server],
+                    hash[:Path],
+                    hash[:Port],
+                    nil, # proxy_host
+                    nil, # proxy_port
+                    nil, # user
+                    nil, # password
+                    true # use_ssl
+                )
+
+                if hash[:Certificate]
+                    self.cert = hash[:Certificate]
+                else
+                    Puppet.err "No certificate; running with reduced functionality."
+                end
+
+                if hash[:Key]
+                    self.key = hash[:Key]
+                end
+
+                if hash[:CAFile]
+                    self.ca_file = hash[:CAFile]
+                end
+
+                # from here, i need to add the key, cert, and ca cert
+                # and reorgize how i start the client
+            end
+
+            def local
+                false
+            end
+
+            def local?
+                false
+            end
+        end
+    end
+end
+
+# $Id: networkclient.rb 856 2006-01-30 16:18:24Z luke $