puppet 0.9.2

data/lib/puppet.rb

@@ -0,0 +1,249 @@
+require 'singleton'
+require 'puppet/log'
+
+# see the bottom of the file for further inclusions
+
+#------------------------------------------------------------
+# the top-level module
+#
+# all this really does is dictate how the whole system behaves, through
+# preferences for things like debugging
+#
+# it's also a place to find top-level commands like 'debug'
+module Puppet
+    PUPPETVERSION="0.9.1"
+
+    def Puppet.version
+        return PUPPETVERSION
+    end
+
+    class Error < RuntimeError
+        attr_accessor :stack, :line, :file
+        def initialize(message)
+            @message = message
+
+            @stack = caller
+        end
+
+        def to_s
+            str = nil
+            if defined? @file and defined? @line and @file and @line
+                str = "%s in file %s at line %s" %
+                    [@message.to_s, @file, @line]
+            elsif defined? @line and @line
+                str = "%s at line %s" %
+                    [@message.to_s, @line]
+            else
+                str = @message.to_s
+            end
+
+            #if Puppet[:debug] and @stack
+            #    str += @stack.to_s
+            #end
+
+            return str
+        end
+    end
+
+    class DevError < Error; end
+
+    # the hash that determines how our system behaves
+    @@config = Hash.new(false)
+
+    # define helper messages for each of the message levels
+    Puppet::Log.eachlevel { |level|
+        define_method(level,proc { |args|
+            if args.is_a?(Array)
+                args = args.join(" ")
+            end
+            Puppet::Log.create(
+                :level => level,
+                :message => args
+            )
+        })
+        module_function level
+    }
+
+    # I keep wanting to use Puppet.error
+    # XXX this isn't actually working right now
+    alias :error :err
+
+    @defaults = {
+        :rrddir         => [:puppetvar,      "rrd"],
+        :logdir         => [:puppetvar,      "log"],
+        :bucketdir      => [:puppetvar,      "bucket"],
+        :statedir       => [:puppetvar,      "state"],
+
+        # then the files},
+        :manifestdir    => [:puppetconf,     "manifests"],
+        :manifest       => [:manifestdir,    "site.pp"],
+        :localconfig    => [:puppetconf,     "localconfig.ma"],
+        :logfile        => [:logdir,         "puppet.log"],
+        :httplogfile    => [:logdir,         "http.log"],
+        :masterlog      => [:logdir,         "puppetmaster.log"],
+        :masterhttplog  => [:logdir,         "masterhttp.log"],
+        :checksumfile   => [:statedir,       "checksums"],
+        :ssldir         => [:puppetconf,     "ssl"],
+
+        # and finally the simple answers,
+        :server         => "puppet",
+        :rrdgraph       => false,
+        :noop           => false,
+        :parseonly      => false,
+        :puppetport     => 8139,
+        :masterport     => 8140,
+    }
+    if Process.uid == 0
+        @defaults[:puppetconf] = "/etc/puppet"
+        @defaults[:puppetvar] = "/var/puppet"
+    else
+        @defaults[:puppetconf] = File.expand_path("~/.puppet")
+        @defaults[:puppetvar] = File.expand_path("~/.puppet/var")
+    end
+
+    def self.clear
+        @@config = Hash.new(false)
+    end
+
+	# configuration parameter access and stuff
+	def self.[](param)
+        if param.is_a?(String)
+            param = param.intern
+        elsif ! param.is_a?(Symbol)
+            raise ArgumentError, "Invalid parameter type %s" % param.class
+        end
+        case param
+        when :debug:
+            if Puppet::Log.level == :debug
+                return true
+            else
+                return false
+            end
+        when :loglevel:
+            return Puppet::Log.level
+        else
+            # allow manual override
+            if @@config.include?(param)
+                return @@config[param]
+            else
+                if @defaults.include?(param)
+                    default = @defaults[param]
+                    if default.is_a?(Proc)
+                        return default.call()
+                    elsif default.is_a?(Array)
+                        return File.join(self[default[0]], default[1])
+                    else
+                        return default
+                    end
+                else
+                    raise ArgumentError, "Invalid parameter %s" % param
+                end
+            end
+        end
+	end
+
+	# configuration parameter access and stuff
+	def self.[]=(param,value)
+        case param
+        when :debug:
+            if value
+                Puppet::Log.level=(:debug)
+            else
+                Puppet::Log.level=(:notice)
+            end
+        when :loglevel:
+            Puppet::Log.level=(value)
+        when :logdest:
+            Puppet::Log.newdestination(value)
+        else
+            @@config[param] = value
+        end
+	end
+
+    def self.asuser(user)
+        # FIXME this should use our user object, since it already knows how
+        # to find users and such
+        require 'etc'
+
+        begin
+            obj = Etc.getpwnam(user)
+        rescue ArgumentError
+            raise Puppet::Error, "User %s not found"
+        end
+
+        uid = obj.uid
+
+        olduid = nil
+        if Process.uid != uid
+            olduid = Process.uid
+            Process.euid = uid
+        end
+
+        retval = yield
+
+
+        if olduid
+            Process.euid = olduid
+        end
+
+        return retval
+    end
+
+    def self.setdefault(param,value)
+        if value.is_a?(Array) 
+            if value[0].is_a?(Symbol) 
+                unless @defaults.include?(value[0])
+                    raise ArgumentError, "Unknown basedir %s for param %s" %
+                        [value[0], param]
+                end
+            else
+                raise ArgumentError, "Invalid default %s for param %s" %
+                    [value.inspect, param]
+            end
+
+            unless value[1].is_a?(String)
+                raise ArgumentError, "Invalid default %s for param %s" %
+                    [value.inspect, param]
+            end
+
+            unless value.length == 2
+                raise ArgumentError, "Invalid default %s for param %s" %
+                    [value.inspect, param]
+            end
+
+            @defaults[param] = value
+        else
+            @defaults[param] = value
+        end
+    end
+
+    # XXX this should all be done using puppet objects, not using
+    # normal mkdir
+    def self.recmkdir(dir,mode = 0755)
+        if FileTest.exist?(dir)
+            return false
+        else
+            tmp = dir.sub(/^\//,'')
+            path = [File::SEPARATOR]
+            tmp.split(File::SEPARATOR).each { |dir|
+                path.push dir
+                if ! FileTest.exist?(File.join(path))
+                    Dir.mkdir(File.join(path), mode)
+                elsif FileTest.directory?(File.join(path))
+                    next
+                else FileTest.exist?(File.join(path))
+                    raise "Cannot create %s: basedir %s is a file" %
+                        [dir, File.join(path)]
+                end
+            }
+            return true
+        end
+    end
+end
+
+require 'puppet/util'
+require 'puppet/server'
+require 'puppet/type'
+require 'puppet/storage'
+
+# $Id$

data/lib/puppet/base64.rb

@@ -0,0 +1,19 @@
+# a stupid hack class to get rid of all of the warnings but
+# still make the encode/decode methods available
+
+# 1.8.2 has a Base64 class, but 1.8.1 just imports the methods directly
+# into Object
+
+require 'base64'
+
+unless defined? Base64
+    class Base64
+        def Base64.encode64(*args)
+            Object.method(:encode64).call(*args)
+        end
+
+        def Base64.decode64(*args)
+            Object.method(:decode64).call(*args)
+        end
+    end
+end

data/lib/puppet/client.rb

@@ -0,0 +1,519 @@
+# the available clients
+
+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'
+rescue LoadError => detail
+    $noclientnetworking = detail
+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]
+                Puppet.debug "Creating client for %s" % hash[:Server]
+
+                @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
+        end
+    end
+
+    # FIXME this still isn't a good design, because none of the handlers overlap
+    # so i could just as easily include them all in the main module
+    # but at least it's better organized for now
+    class Client
+        include Puppet
+
+        # FIXME the cert stuff should only come up with networking, so it
+        # should be in the network client, not the normal client
+        # but if i do that, it's hard to tell whether the certs have been initialized
+        include Puppet::Daemon
+        attr_reader :local, :secureinit
+
+        class << self
+            attr_reader :drivername
+        end
+
+        def initcerts
+            unless self.readcert
+                unless self.requestcert
+                    return nil
+                end
+            end
+
+            # unless we have a driver, we're a local client and we can't add
+            # certs anyway, so it doesn't matter
+            unless @driver
+                return true
+            end
+
+            self.setcerts
+        end
+
+        def initialize(hash)
+            # to whom do we connect?
+            @server = nil
+            @nil = nil
+            @secureinit = hash[:NoSecureInit] || true
+
+            if hash.include?(:FQDN)
+                @fqdn = hash[:FQDN]
+            else
+                self.fqdn
+            end
+
+            if hash.include?(:Cache)
+                @cache = hash[:Cache]
+            else
+                @cache = true
+            end
+
+            driverparam = self.class.drivername
+            if hash.include?(:Server)
+                if $noclientnetworking
+                    raise NetworkClientError.new("Networking not available: %s" %
+                        $nonetworking)
+                end
+
+                args = {:Server => hash[:Server]}
+                args[:Port] = hash[:Port] || Puppet[:masterport]
+
+                if self.readcert
+                    args[:Certificate] = @cert
+                    args[:Key] = @key
+                    args[:CAFile] = @cacertfile
+                end
+
+                @driver = Puppet::NetworkClient.new(args)
+                @local = false
+            elsif hash.include?(driverparam)
+                @driver = hash[driverparam]
+                @local = true
+            else
+                raise ClientError, "%s must be passed a Server or %s" %
+                    [self.class, driverparam]
+            end
+        end
+
+        def setcerts
+            @driver.cert = @cert
+            @driver.key = @key
+            @driver.ca_file = @cacertfile
+        end
+
+        class MasterClient < Puppet::Client
+            @drivername = :Master
+
+            def self.facts
+                facts = {}
+                Facter.each { |name,fact|
+                    facts[name] = fact.downcase
+                }
+
+                facts
+            end
+
+            # this method is how the client receives the tree of Transportable
+            # objects
+            # for now, just descend into the tree and perform and necessary
+            # manipulations
+            def apply
+                unless defined? @objects
+                    raise Puppet::Error, "Cannot apply; objects not defined"
+                end
+
+                begin
+                    Puppet::Storage.init
+                    Puppet::Storage.load
+                rescue => detail
+                    Puppet.err "Corrupt state file %s" % Puppet[:checksumfile]
+                    begin
+                        File.unlink(Puppet[:checksumfile])
+                        retry
+                    rescue => detail
+                        raise Puppet::Error.new("Cannot remove %s: %s" %
+                            [Puppet[statefile], detail])
+                    end
+                end
+
+                # FIXME this should be in getconfig, not apply
+                container = @objects.to_type
+                #if @local
+                #    container = @objects.to_type
+                #else
+                #    container = Marshal::load(@objects).to_type
+                #end
+
+                # this is a gross hack... but i don't see a good way around it
+                # set all of the variables to empty
+                Puppet::Transaction.init
+
+                # for now we just evaluate the top-level container, but eventually
+                # there will be schedules and such associated with each object,
+                # and probably with the container itself
+                transaction = container.evaluate
+                #transaction = Puppet::Transaction.new(objects)
+                transaction.toplevel = true
+                begin
+                    transaction.evaluate
+                rescue Puppet::Error => detail
+                    Puppet.err "Could not apply complete configuration: %s" %
+                        detail
+                rescue => detail
+                    Puppet.err "Found a bug: %s" % detail
+                end
+                Puppet::Metric.gather
+                Puppet::Metric.tally
+                if Puppet[:rrdgraph] == true
+                    Metric.store
+                    Metric.graph
+                end
+                Puppet::Storage.store
+
+                return transaction
+            end
+
+            def getconfig
+                #client.loadproperty('files/sslclient.properties')
+                Puppet.debug("getting config")
+
+                facts = self.class.facts
+
+                unless facts.length > 0
+                    raise Puppet::ClientError.new(
+                        "Could not retrieve any facts"
+                    )
+                end
+
+                objects = nil
+                if @local
+                    objects = @driver.getconfig(facts)
+
+                    if objects == ""
+                        raise Puppet::Error, "Could not retrieve configuration"
+                    end
+                else
+                    textfacts = CGI.escape(Marshal::dump(facts))
+
+                    # error handling for this is done in the network client
+                    textobjects = @driver.getconfig(textfacts)
+
+                    unless textobjects == ""
+                        begin
+                            textobjects = CGI.unescape(textobjects)
+                        rescue => detail
+                            raise Puppet::Error, "Could not CGI.unescape configuration"
+                        end
+                    end
+
+                    if @cache
+                        if textobjects == ""
+                            if FileTest.exists?(Puppet[:localconfig])
+                                textobjects = File.read(Puppet[:localconfig])
+                            else
+                                raise Puppet::Error.new(
+                                    "Cannot connect to server and there is no cached configuration"
+                                )
+                            end
+                        else
+                            # we store the config so that if we can't connect next time, we
+                            # can just run against the most recently acquired copy
+                            confdir = File.dirname(Puppet[:localconfig])
+                            unless FileTest.exists?(confdir)
+                                Puppet.recmkdir(confdir, 0770)
+                            end
+                            File.open(Puppet[:localconfig], "w", 0660) { |f|
+                                f.print textobjects
+                            }
+                        end
+                    elsif textobjects == ""
+                        raise Puppet::Error, "Could not retrieve configuration"
+                    end
+
+                    begin
+                        objects = Marshal::load(textobjects)
+                    rescue => detail
+                        raise Puppet::Error.new("Could not understand configuration")
+                    end
+                end
+                if objects.is_a?(Puppet::TransBucket)
+                    @objects = objects
+                else
+                    raise NetworkClientError,
+                        "Invalid returned objects of type %s" % objects.class
+                end
+            end
+        end
+
+        class Dipper < Puppet::Client
+            @drivername = :Bucket
+
+            def initialize(hash = {})
+                if hash.include?(:Path)
+                    bucket = Puppet::Server::FileBucket.new(
+                        :Bucket => hash[:Path]
+                    )
+                    hash.delete(:Path)
+                    hash[:Bucket] = bucket
+                end
+
+                super(hash)
+            end
+
+            def backup(file)
+                unless FileTest.exists?(file)
+                    raise(BucketError, "File %s does not exist" % file, caller)
+                end
+                contents = File.open(file) { |of| of.read }
+
+                string = Base64.encode64(contents)
+                #puts "string is created"
+
+                sum = @driver.addfile(string,file)
+                #puts "file %s is added" % file
+                return sum
+            end
+
+            def restore(file,sum)
+                restore = true
+                if FileTest.exists?(file)
+                    contents = File.open(file) { |of| of.read }
+
+                    cursum = Digest::MD5.hexdigest(contents)
+
+                    # if the checksum has changed...
+                    # this might be extra effort
+                    if cursum == sum
+                        restore = false
+                    end
+                end
+
+                if restore
+                    #puts "Restoring %s" % file
+                    if tmp = @driver.getfile(sum)
+                        newcontents = Base64.decode64(tmp)
+                        newsum = Digest::MD5.hexdigest(newcontents)
+                        File.open(file,File::WRONLY|File::TRUNC) { |of|
+                            of.print(newcontents)
+                        }
+                    else
+                        Puppet.err "Could not find file with checksum %s" % sum
+                        return nil
+                    end
+                    #puts "Done"
+                    return newsum
+                else
+                    return nil
+                end
+
+            end
+        end
+
+        # unlike the other client classes (again, this design sucks) this class
+        # is basically just a proxy class -- it calls its methods on the driver
+        # and that's about it
+        class ProxyClient < Puppet::Client
+            def self.mkmethods
+                interface = @handler.interface
+                namespace = interface.prefix
+
+                interface.methods.each { |ary|
+                    method = ary[0]
+                    Puppet.debug "%s: defining %s.%s" % [self, namespace, method]
+                    self.send(:define_method,method) { |*args|
+                        begin
+                            @driver.send(method, *args)
+                        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
+                        end
+                    }
+                }
+            end
+        end
+
+        class FileClient < Puppet::Client::ProxyClient
+            @drivername = :FileServer
+
+            # set up the appropriate interface methods
+            @handler = Puppet::Server::FileServer
+
+            self.mkmethods
+
+            def initialize(hash = {})
+                if hash.include?(:FileServer)
+                    unless hash[:FileServer].is_a?(Puppet::Server::FileServer)
+                        raise Puppet::DevError, "Must pass an actual FS object"
+                    end
+                end
+
+                super(hash)
+            end
+        end
+
+        class CAClient < Puppet::Client::ProxyClient
+            @drivername = :CA
+
+            # set up the appropriate interface methods
+            @handler = Puppet::Server::CA
+            self.mkmethods
+
+            def initialize(hash = {})
+                if hash.include?(:CA)
+                    hash[:CA] = Puppet::Server::CA.new()
+                end
+
+                super(hash)
+            end
+        end
+
+        class LogClient < Puppet::Client::ProxyClient
+            @drivername = :Logger
+
+            # set up the appropriate interface methods
+            @handler = Puppet::Server::Logger
+            self.mkmethods
+
+            def initialize(hash = {})
+                if hash.include?(:Logger)
+                    hash[:Logger] = Puppet::Server::Logger.new()
+                end
+
+                super(hash)
+            end
+        end
+
+        class StatusClient < Puppet::Client::ProxyClient
+            # set up the appropriate interface methods
+            @handler = Puppet::Server::ServerStatus
+            self.mkmethods
+        end
+
+    end
+#---------------------------------------------------------------
+end
+
+# $Id: client.rb 740 2005-11-01 20:22:19Z luke $