puppet 0.9.2

data/lib/puppet/config.rb

@@ -0,0 +1,49 @@
+module Puppet # :nodoc:
+# The class for handling configuration files.
+class Config < Hash
+    # Slight override, since we can't seem to have a subclass where all instances
+    # have the same default block.
+    def [](section)
+        unless self.has_key?(section)
+            self[section] = {}
+        end
+        super
+    end
+
+    def initialize(file)
+        text = nil
+
+        begin
+            text = File.read(file)
+        rescue Errno::ENOENT
+            raise Puppet::Error, "No such file %s" % file
+        rescue Errno::EACCES
+            raise Puppet::Error, "Permission denied to file %s" % file
+        end
+
+        # Store it for later, in a way that we can test and such.
+        @file = Puppet::ParsedFile.new(file)
+
+        @values = Hash.new { |names, name|
+            names[name] = {}
+        }
+
+        section = "puppet"
+        text.split(/\n/).each { |line|
+            case line
+            when /^\[(\w+)\]$/: section = $1 # Section names
+            when /^\s*#/: next # Skip comments
+            when /^\s*$/: next # Skip blanks
+            when /^\s*(\w+)\s+(.+)$/: # settings
+                var = $1
+                value = $2
+                self[section][var] = value
+            else
+                raise Puppet::Error, "Could not match line %s" % line
+            end
+        }
+    end
+end
+end
+
+# $Id: config.rb 738 2005-10-31 22:50:09Z luke $

data/lib/puppet/daemon.rb

@@ -0,0 +1,208 @@
+# helper functions for daemons
+
+require 'puppet'
+
+module Puppet # :nodoc:
+    # A module that handles operations common to all daemons.
+    module Daemon
+        # Put the daemon into the background.
+        def daemonize
+            if pid = fork()
+                Process.detach(pid)
+                exit(0)
+            end
+
+            # Get rid of console logging
+            Puppet::Log.close(:console)
+
+            Process.setsid
+            Dir.chdir("/")
+            begin
+                $stdin.reopen "/dev/null"
+                $stdout.reopen "/dev/null", "a"
+                $stderr.reopen $stdout
+                Puppet::Log.reopen
+            rescue => detail
+                File.open("/tmp/daemonout", "w") { |f|
+                    f.puts "Could not start %s: %s" % [$0, detail]
+                }
+                Puppet.err "Could not start %s: %s" % [$0, detail]
+                exit(12)
+            end
+
+            name = $0.gsub(/.+#{File::SEPARATOR}/,'')
+            @pidfile = File.join(Puppet[:puppetvar], name + ".pid")
+            if FileTest.exists?(@pidfile)
+                Puppet.info "Deleting old pid file"
+                begin
+                    File.unlink(@pidfile)
+                rescue Errno::EACCES
+                    Puppet.err "Could not delete old PID file; cannot create new one"
+                    return
+                end
+            end
+
+            begin
+                File.open(@pidfile, "w") { |f| f.puts $$ }
+            rescue => detail
+                Puppet.err "Could not create PID file: %s" % detail
+            end
+            Puppet.info "pid file is %s" % @pidfile
+        end
+
+        def fqdn
+            unless defined? @fqdn and @fqdn
+                hostname = Facter["hostname"].value
+                domain = Facter["domain"].value
+                @fqdn = [hostname, domain].join(".")
+            end
+            return @fqdn
+        end
+
+        def httplog
+            args = []
+            # yuck; separate http logs
+            file = nil
+            if self.is_a?(Puppet::Server)
+                file = Puppet[:masterhttplog]
+            else
+                file = Puppet[:httplog]
+            end
+
+            unless FileTest.exists?(File.dirname(file))
+                Puppet.recmkdir(File.dirname(file))
+            end
+            args << file
+            if Puppet[:debug]
+                args << WEBrick::Log::DEBUG
+            end
+
+            log = WEBrick::Log.new(*args)
+
+            return log
+        end
+
+        def readcert
+            return unless @secureinit
+            # verify we've got all of the certs set up and such
+
+            if defined? @cert and defined? @key and @cert and @key
+                return true
+            end
+
+            # we are not going to encrypt our key, but we need at a minimum
+            # a keyfile and a certfile
+            @certfile = File.join(Puppet[:certdir], [@fqdn, "pem"].join("."))
+            @cacertfile = File.join(Puppet[:certdir], ["ca", "pem"].join("."))
+            @keyfile = File.join(Puppet[:privatekeydir], [@fqdn, "pem"].join("."))
+            @publickeyfile = File.join(Puppet[:publickeydir], [@fqdn, "pem"].join("."))
+
+            if File.exists?(@keyfile)
+                # load the key
+                @key = OpenSSL::PKey::RSA.new(File.read(@keyfile))
+            else
+                return false
+            end
+
+            if File.exists?(@certfile)
+                if File.exists?(@cacertfile)
+                    @cacert = OpenSSL::X509::Certificate.new(File.read(@cacertfile))
+                else
+                    raise Puppet::Error, "Found cert file with no ca cert file"
+                end
+                @cert = OpenSSL::X509::Certificate.new(File.read(@certfile))
+            else
+                return false
+            end
+            return true
+        end
+
+        def requestcert
+            retrieved = false
+            # create the directories involved
+            [Puppet[:certdir], Puppet[:privatekeydir], Puppet[:csrdir],
+                Puppet[:publickeydir]].each { |dir|
+                unless FileTest.exists?(dir)
+                    Puppet.recmkdir(dir, 0770)
+                end
+            }
+
+            if self.readcert
+                Puppet.info "Certificate already exists; not requesting"
+                return true
+            end
+
+            unless defined? @key and @key
+                # create a new one and store it
+                Puppet.info "Creating a new SSL key at %s" % @keyfile
+                @key = OpenSSL::PKey::RSA.new(Puppet[:keylength])
+                File.open(@keyfile, "w", 0660) { |f| f.print @key.to_pem }
+                File.open(@publickeyfile, "w", 0660) { |f|
+                    f.print @key.public_key.to_pem
+                }
+            end
+
+            unless defined? @driver
+                Puppet.err "Cannot request a certificate without a defined target"
+                return false
+            end
+
+            Puppet.info "Creating a new certificate request for %s" % @fqdn
+            name = OpenSSL::X509::Name.new([["CN", @fqdn]])
+
+            @csr = OpenSSL::X509::Request.new
+            @csr.version = 0
+            @csr.subject = name
+            @csr.public_key = @key.public_key
+            @csr.sign(@key, OpenSSL::Digest::MD5.new)
+
+            Puppet.info "Requesting certificate"
+
+            begin
+                cert, cacert = @driver.getcert(@csr.to_pem)
+            rescue => detail
+                raise Puppet::Error.new("Certificate retrieval failed: %s" %
+                    detail)
+            end
+
+            if cert.nil? or cert == ""
+                return nil
+            end
+            File.open(@certfile, "w", 0660) { |f| f.print cert }
+            File.open(@cacertfile, "w", 0660) { |f| f.print cacert }
+            begin
+                @cert = OpenSSL::X509::Certificate.new(cert)
+                @cacert = OpenSSL::X509::Certificate.new(cacert)
+                retrieved = true
+            rescue => detail
+                raise Puppet::Error.new(
+                    "Invalid certificate: %s" % detail
+                )
+            end
+
+            unless @cert.check_private_key(@key)
+                raise Puppet::DevError, "Received invalid certificate"
+            end
+            return retrieved
+        end
+
+        # Shut down our server
+        def shutdown
+            # Remove our pid file
+            if defined? @pidfile and @pidfile and FileTest.exists?(@pidfile)
+                begin
+                    File.unlink(@pidfile)
+                rescue => detail
+                    Puppet.err "Could not remove PID file %s: %s" % [@pidfile, detail]
+                end
+            end
+
+            # And close all logs
+            Puppet::Log.close
+
+            super
+        end
+    end
+end
+
+# $Id: daemon.rb 732 2005-10-28 05:39:59Z luke $

data/lib/puppet/element.rb

@@ -0,0 +1,71 @@
+# included so we can test object types
+require 'puppet'
+
+# the base class for both types and states
+# very little functionality; basically just defines the interface
+# and provides a few simple across-the-board functions like 'noop'
+class Puppet::Element
+    include Puppet
+    attr_writer :noop
+
+    class << self
+        attr_accessor :doc, :nodoc
+    end
+
+    # all of our subclasses must respond to each of these methods...
+    @@interface_methods = [
+        :retrieve, :insync?, :sync, :evaluate
+    ]
+
+    # so raise an error if a method that isn't overridden gets called
+    @@interface_methods.each { |method|
+        self.send(:define_method,method) {
+            raise Puppet::DevError, "%s has not overridden %s" %
+                [self.class,method]
+        }
+    }
+
+    Puppet::Util.logmethods(self, true)
+
+    # for testing whether we should actually do anything
+    def noop
+        unless defined? @noop
+            @noop = false
+        end
+        return @noop || Puppet[:noop] || false
+    end
+
+    # return the full path to us, for logging and rollback
+    # some classes (e.g., FileTypeRecords) will have to override this
+    def path
+        unless defined? @path
+            if defined? @parent and @parent
+                if self.is_a?(Puppet::Type::Component)
+                    @path = [@parent.path, self.name]
+                else
+                    @path = [@parent.path, self.class.name.to_s + "=" + self.name]
+                end
+            else
+                # The top-level name is always puppet[top], so we don't bother with
+                # that.  And we don't add the hostname here, it gets added
+                # in the log server thingy.
+                if self.name == "puppet[top]"
+                    @path = ["/"]
+                else
+                    # We assume that if we don't have a parent that we should not
+                    # cache the path
+                    if self.is_a?(Puppet::Type::Component)
+                        @path = [self.name]
+                    else
+                        @path = [self.class.name.to_s + "=" + self.name]
+                    end
+                end
+            end
+        end
+
+        return @path.join("/")
+    end
+
+end
+
+# $Id: element.rb 742 2005-11-16 17:12:11Z luke $

data/lib/puppet/event.rb

@@ -0,0 +1,259 @@
+require 'puppet'
+require 'puppet/type'
+
+module Puppet
+    # events are transient packets of information; they result in one or more (or none)
+    # subscriptions getting triggered, and then they get cleared
+    # eventually, these will be passed on to some central event system
+	class Event
+        include Puppet
+
+        # subscriptions are permanent associations determining how different
+        # objects react to an event
+        class Subscription
+            include Puppet
+            attr_accessor :event, :callback
+
+            # Remove the existing subscriptions and such
+            def self.clear
+                self.init
+            end
+
+            # Remove a subscription
+            def self.delete(sub)
+                type, name = sub.targetarray
+                if @dependencies[type][name].include?(sub)
+                    @dependencies[type][name].delete(sub)
+                end
+
+                type, name = sub.sourcearray
+                if @subscriptions[type][name].include?(sub)
+                    @subscriptions[type][name].delete(sub)
+                end
+            end
+
+            # Initialize our class variables.  This is in a method so it can
+            # be called to clear the variables, too.
+            def self.init
+                # A hash of subscriptions and another of dependencies, organized by
+                # type, then by name.  I'm storing them all here, so that I don't
+                # have to store the subscriptions with the individual objects,
+                # which makes creating and destroying objects as necessary much
+                # easier.
+                @subscriptions = Hash.new { |hash, key|
+                    hash[key] = Hash.new { |shash, skey|
+                        # Each object has an array of subscriptions
+                        shash[skey] = []
+                    }
+                }
+
+                @dependencies = Hash.new { |hash, key|
+                    hash[key] = Hash.new { |shash, skey|
+                        # Each object has an array of subscriptions
+                        shash[skey] = []
+                    }
+                }
+            end
+
+            self.init
+
+            # Store the new subscription in a central hash.
+            def self.newsub(sub)
+                # The dependencies map allows me to look up a subscription by
+                # target -- find out which objects a given object is subscribed
+                # to, and thus find out which objects that given object depends
+                # upon.
+                # DEPENDENCIES == TARGET
+                ttype, tname = sub.targetarray
+                @dependencies[ttype][tname] << sub
+
+                # Subscriptions are the list of subscriptions for a given object,
+                # i.e., the list of all objects that care about a given object's
+                # events.
+                # SUBSCRIPTION == SOURCE
+                stype, sname = sub.sourcearray
+                @subscriptions[stype][sname] << sub
+            end
+
+            # Trigger the subscriptions related to an event, and then pass it up
+            # as appropriate
+            def self.trigger(source, event, transaction)
+                type, name = self.split(source)
+
+                @subscriptions[type][name].each { |sub|
+                    if sub.match?(event)
+                        sub.trigger(transaction)
+                    end
+                }
+            end
+
+            # Look up an object by type and name.  This is used because we
+            # store symbolic links in our subscription hash rather than storing
+            # actual object references.
+            def self.retrieve(ary)
+                type, name = ary
+                typeobj = Puppet::Type.type(type)
+
+                unless typeobj
+                    return nil
+                end
+
+                obj = typeobj[name]
+                return obj
+            end
+
+            # Split an object into its type and name
+            def self.split(object)
+                return [object.class.name, object.name]
+            end
+
+            # Retrieve all of the subscriptions that result in a dependency.
+            # We return the whole dependency here, because it is being returned
+            # to the object that made the subscription.
+            def self.dependencies(target)
+                type, name = self.split(target)
+                return @dependencies[type][name]
+            end
+
+            # Return all objects that are subscribed to us.  We are only willing
+            # to return the object, not the subscription object, because the
+            # source shouldn't need to know things like the event or method that
+            # we're subscribed to.
+            def self.subscribers(source)
+                type, name = self.split(source)
+                return @subscriptions[type][name].collect { |sub|
+                    sub.target
+                }
+            end
+
+            # The hash here must include the target and source objects, the event,
+            # and the callback to call.
+            def initialize(hash)
+                hash.each { |param,value|
+                    # assign each value appropriately
+                    # this is probably wicked-slow
+                    self.send(param.to_s + "=",value)
+                }
+
+                self.class.newsub(self)
+                #Puppet.debug "New Subscription: '%s' => '%s'" %
+                #    [@source,@event]
+            end
+
+            # Determine whether the passed event matches our event
+            def match?(event)
+                if event == :NONE or @event == :NONE
+                    return false
+                elsif @event == :ALL_EVENTS or event == :ALL_EVENTS or event == @event
+                    return true
+                else
+                    return false
+                end
+            end
+
+            # The source is the event source.
+            def source=(object)
+                type, name = self.class.split(object)
+                @source = [type, name]
+            end
+
+            def source
+                self.class.retrieve(@source)
+            end
+
+            def sourcearray
+                @source
+            end
+
+            # The target is the object who will receive the callbacks, i.e.,
+            # a source generates an event, which results in a callback on the
+            # target.
+            def target=(object)
+                type, name = self.class.split(object)
+                @target = [type, name]
+            end
+
+            def target
+                self.class.retrieve(@target)
+            end
+
+            def targetarray
+                @target
+            end
+
+            # Trigger a subscription, which basically calls the associated method
+            # on the target object.
+            def trigger(transaction)
+                event = nil
+
+                if @event == :NONE
+                    # just ignore these subscriptions
+                    return
+                end
+
+                if transaction.triggered?(self.target, @callback) > 0
+                    Puppet.debug "%s has already run" % self
+                else
+                    # We need to call the method, so that it gets retrieved
+                    # as a real object.
+                    target = self.target
+                    #Puppet.debug "'%s' matched '%s'; triggering '%s' on '%s'" %
+                    #    [@source,@event,@method,target]
+                    begin
+                        if target.respond_to?(@callback)
+                            event = target.send(@callback)
+                        else
+                            Puppet.debug(   
+                                "'%s' of type '%s' does not respond to '%s'" %
+                                [target,target.class,@callback.inspect]
+                            )
+                        end
+                    rescue => detail
+                        # um, what the heck do i do when an object fails to
+                        # refresh?  shouldn't that result in the transaction
+                        # rolling back?  the 'onerror' metaparam will be used
+                        # to determine behaviour in that case
+                        Puppet.err "'%s' failed to %s: '%s'" %
+                            [target,@callback,detail]
+                        raise
+                        #raise "We need to roll '%s' transaction back" %
+                            #transaction
+                    end
+                    transaction.triggered(target, @callback)
+                end
+                return event
+            end
+        end
+
+		attr_accessor :event, :source, :transaction
+
+        @@events = []
+
+        @@subscriptions = []
+
+		def initialize(args)
+            unless args.include?(:event) and args.include?(:source)
+				raise Puppet::DevError, "Event.new called incorrectly"
+			end
+
+			@change = args[:change]
+			@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
+            self.event.to_s
+        end
+	end
+end
+
+# $Id: event.rb 710 2005-10-01 19:57:07Z luke $