puppet 0.9.2

data/lib/puppet/log.rb

@@ -0,0 +1,321 @@
+require 'syslog'
+
+module Puppet # :nodoc:
+    # 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.
+	class Log
+        PINK=""
+        GREEN=""
+        YELLOW=""
+        SLATE=""
+        ORANGE=""
+        BLUE=""
+        RESET=""
+
+        @levels = [:debug,:info,:notice,:warning,:err,:alert,:emerg,:crit]
+        @loglevel = 2
+
+		@colors = {
+			:debug => SLATE,
+			:info => GREEN,
+			:notice => PINK,
+			:warning => ORANGE,
+			:err => YELLOW,
+            :alert => BLUE,
+            :emerg => RESET,
+            :crit => RESET
+		}
+
+        @destinations = {:syslog => Syslog.open("puppet")}
+
+        # 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
+                    @destinations.delete(dest)
+                end
+            else
+                @destinations.each { |type, dest|
+                    if dest.respond_to?(:flush)
+                        dest.flush
+                    end
+                    if dest.respond_to?(:close)
+                        dest.close
+                    end
+                }
+                @destinations = {}
+            end
+
+            Puppet.info "closed"
+        end
+
+        # Flush any log destinations that support such operations.
+        def Log.flush
+            @destinations.each { |type, dest|
+                if dest.respond_to?(:flush)
+                    dest.flush
+                end
+            }
+        end
+
+        # Create a new log message.  The primary role of this method is to
+        # avoid creating log messages below the loglevel.
+        def Log.create(hash)
+            if @levels.index(hash[:level]) >= @loglevel 
+                return Puppet::Log.new(hash)
+            else
+                return nil
+            end
+        end
+
+        # Yield each valid level in turn
+        def Log.eachlevel
+            @levels.each { |level| yield level }
+        end
+
+        # Return the current log level.
+        def Log.level
+            return @levels[@loglevel]
+        end
+
+        # Set the current log level.
+        def Log.level=(level)
+            unless level.is_a?(Symbol)
+                level = level.intern
+            end
+
+            unless @levels.include?(level)
+                raise Puppet::DevError, "Invalid loglevel %s" % level
+            end
+
+            @loglevel = @levels.index(level)
+        end
+
+        # Create a new log destination.
+        def Log.newdestination(dest)
+            # Each destination can only occur once.
+            if @destinations.include?(dest)
+                return
+            end
+
+            case dest
+            when "syslog", :syslog
+                if Syslog.opened?
+                    Syslog.close
+                end
+                @destinations[:syslog] = Syslog.open("puppet")
+            when /^\// # files
+                Puppet.info "opening %s as a log" % dest
+                # first make sure the directory exists
+                unless FileTest.exist?(File.dirname(dest))
+                    begin
+                        Puppet.recmkdir(File.dirname(dest))
+                        Puppet.info "Creating log directory %s" %
+                            File.dirname(dest)
+                    rescue => detail
+                        Log.destination = :console
+                        Puppet.err "Could not create log directory: %s" %
+                            detail
+                        return
+                    end
+                end
+
+                begin
+                    # create the log file, if it doesn't already exist
+                    file = File.open(dest,File::WRONLY|File::CREAT|File::APPEND)
+                rescue => detail
+                    Log.destination = :console
+                    Puppet.err "Could not create log file: %s" %
+                        detail
+                    return
+                end
+                @destinations[dest] = file
+            when "console", :console
+                @destinations[:console] = :console
+            when Puppet::Server::Logger
+                @destinations[dest] = dest
+            else
+                Puppet.info "Treating %s as a hostname" % dest
+                args = {}
+                if dest =~ /:(\d+)/
+                    args[:Port] = $1
+                    args[:Server] = dest.sub(/:\d+/, '')
+                else
+                    args[:Server] = dest
+                end
+                @destinations[dest] = Puppet::Client::LogClient.new(args)
+            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.
+        def Log.newmessage(msg)
+            @destinations.each { |type, dest|
+                case dest
+                when Module # This is the Syslog module
+                    next if msg.remote
+                    # XXX Syslog currently has a bug that makes it so you
+                    # cannot log a message with a '%' in it.  So, we get rid
+                    # of them.
+                    if msg.source == "Puppet"
+                        dest.send(msg.level, msg.to_s.gsub("%", '%%'))
+                    else
+                        dest.send(msg.level, "(%s) %s" %
+                            [msg.source.to_s.gsub("%", ""), msg.to_s.gsub("%", '%%')]
+                        )
+                    end
+                when File:
+                    dest.puts("%s %s (%s): %s" %
+                        [msg.time, msg.source, msg.level, msg.to_s])
+                when :console
+                    if msg.source == "Puppet"
+                        puts @colors[msg.level] + "%s: %s" % [
+                            msg.level, msg.to_s
+                        ] + RESET
+                    else
+                        puts @colors[msg.level] + "%s: %s: %s" % [
+                            msg.level, msg.source, msg.to_s
+                        ] + RESET
+                    end
+                when Puppet::Client::LogClient
+                    unless msg.is_a?(String) or msg.remote
+                        unless defined? @hostname
+                            @hostname = Facter["hostname"].value
+                        end
+                        unless defined? @domain
+                            @domain = Facter["domain"].value
+                            if @domain
+                                @hostname += "." + @domain
+                            end
+                        end
+                        if msg.source =~ /^\//
+                            msg.source = @hostname + ":" + msg.source
+                        elsif msg.source == "Puppet"
+                            msg.source = @hostname + " " + msg.source
+                        else
+                            msg.source = @hostname + " " + msg.source
+                        end
+                        begin
+                            #puts "would have sent %s" % msg
+                            #puts "would have sent %s" %
+                            #    CGI.escape(Marshal::dump(msg))
+                            begin
+                                tmp = CGI.escape(Marshal::dump(msg))
+                            rescue => detail
+                                puts "Could not dump: %s" % detail.to_s
+                                return
+                            end
+                            # Add the hostname to the source
+                            dest.addlog(tmp)
+                            #dest.addlog(msg.to_s)
+                            sleep(0.5)
+                        rescue => detail
+                            Puppet.err detail
+                            @destinations.delete(type)
+                        end
+                    end
+                else
+                    raise Puppet::Error, "Invalid log destination %s" % dest
+                    #puts "Invalid log destination %s" % dest.inspect
+                end
+            }
+        end
+
+        # Reopen all of our logs.
+        def Log.reopen
+            types = @destinations.keys
+            @destinations.each { |type, dest|
+                if dest.respond_to?(:close)
+                    dest.close
+                end
+            }
+            @destinations.clear
+            # We need to make sure we always end up with some kind of destination
+            begin
+                types.each { |type|
+                    Log.newdestination(type)
+                }
+            rescue => detail
+                if @destinations.empty?
+                    Log.newdestination(:syslog)
+                    Puppet.err detail.to_s
+                end
+            end
+        end
+
+        # Is the passed level a valid log level?
+        def self.validlevel?(level)
+            @levels.include?(level)
+        end
+
+		attr_accessor :level, :message, :time, :tags, :remote
+        attr_reader :source
+
+		def initialize(args)
+			unless args.include?(:level) && args.include?(:message)
+				raise Puppet::DevError, "Puppet::Log called incorrectly"
+			end
+
+			if args[:level].class == String
+				@level = args[:level].intern
+			elsif args[:level].class == Symbol
+				@level = args[:level]
+			else
+				raise Puppet::DevError,
+                    "Level is not a string or symbol: #{args[:level].class}"
+			end
+			@message = args[:message].to_s
+			@time = Time.now
+			# this should include the host name, and probly lots of other
+			# stuff, at some point
+			unless self.class.validlevel?(level)
+				raise Puppet::DevError, "Invalid message level #{level}"
+			end
+
+            if args.include?(:tags)
+                @tags = args[:tags]
+            end
+
+            if args.include?(:source)
+                self.source = args[:source]
+            else
+                @source = "Puppet"
+            end
+
+            Log.newmessage(self)
+		end
+
+        # If they pass a source in to us, we make sure it is a string, and
+        # we retrieve any tags we can.
+        def source=(source)
+            # We can't store the actual source, we just store the path.  This
+            # is a bit of a stupid hack, specifically testing for elements, but
+            # eh.
+            if source.is_a?(Puppet::Element) and source.respond_to?(:path)
+                @source = source.path
+            else
+                @source = source.to_s
+            end
+            unless defined? @tags and @tags
+                if source.respond_to?(:tags)
+                    @tags = source.tags
+                end
+            end
+        end
+
+		def to_s
+            return @message
+		end
+	end
+end
+
+# $Id: log.rb 742 2005-11-16 17:12:11Z luke $

data/lib/puppet/metric.rb

@@ -0,0 +1,250 @@
+# included so we can test object types
+require 'puppet'
+
+module Puppet # :nodoc:
+    # A class for handling metrics.  This is currently ridiculously hackish.
+	class Metric
+        def Metric.init
+            @@typemetrics = Hash.new { |typehash,typename|
+                typehash[typename] = Hash.new(0)
+            }
+
+            @@eventmetrics = Hash.new(0)
+
+            @@metrics = {}
+        end
+
+        def Metric.clear
+            Metric.init
+        end
+
+        def Metric.gather
+            Metric.init
+
+            # first gather stats about all of the types
+            Puppet::Type.eachtype { |type|
+                type.each { |instance|
+                    hash = @@typemetrics[type]
+                    hash[:total] += 1
+                    if instance.managed?
+                        hash[:managed] += 1
+                    end
+                }
+            }
+
+            # the rest of the metrics are injected directly by type.rb
+        end
+
+        def Metric.add(type,instance,metric,count)
+            return unless defined? @@typemetrics
+            case metric
+            when :outofsync:
+                @@typemetrics[type][metric] += count
+            when :changes:
+                @@typemetrics[type][:changed] += 1
+                @@typemetrics[type][:totalchanges] += count
+            else
+                raise Puppet::DevError, "Unknown metric %s" % metric
+            end
+        end
+
+        # we're currently throwing away the type and instance information
+        def Metric.addevents(type,instance,events)
+            return unless defined? @@eventmetrics
+            events.each { |event|
+                @@eventmetrics[event] += 1
+            }
+        end
+
+        # Iterate across all of the metrics
+        def Metric.each
+            @@metrics.each { |name,metric|
+                yield metric
+            }
+        end
+
+        # I'm nearly positive this method is used only for testing
+        def Metric.load(ary)
+            @@typemetrics = ary[0]
+            @@eventmetrics = ary[1]
+        end
+
+        def Metric.graph(range = nil)
+            @@metrics.each { |name,metric|
+                metric.graph(range)
+            }
+        end
+
+        def Metric.store(time = nil)
+            require 'RRD'
+            unless time
+                time = Time.now.to_i
+            end
+            @@metrics.each { |name,metric|
+                metric.store(time)
+            }
+        end
+
+        def Metric.tally
+            type = Metric.new("typecount","Types")
+            type.newvalue("Number",@@typemetrics.length)
+
+            metrics = {
+                :total => "Instances",
+                :managed => "Managed Instances",
+                :outofsync => "Out of Sync Instances",
+                :changed => "Changed Instances",
+                :totalchanges => "Total Number of Changes",
+            }
+            total = Hash.new(0)
+            @@typemetrics.each { |type,instancehash|
+                name = type.name.to_s
+                instmet = Metric.new("type-" + name,name.capitalize)
+                metrics.each { |symbol,label|
+                    instmet.newvalue(symbol.to_s,instancehash[symbol],label)
+                    total[symbol] += instancehash[symbol]
+                }
+            }
+
+            totalmet = Metric.new("typetotals","Type Totals")
+            metrics.each { |symbol,label|
+                totalmet.newvalue(symbol.to_s,total[symbol],label)
+            }
+
+            eventmet = Metric.new("events")
+            total = 0
+            @@eventmetrics.each { |event,count|
+                event = event.to_s
+                # add the specific event as a value, with the label being a
+                # capitalized version with s/_/ /g
+                eventmet.newvalue(
+                    event,
+                    count,
+                    event.capitalize.gsub(/_/,' ')
+                )
+
+                total += count
+            }
+            eventmet.newvalue("total",total,"Event Total")
+        end
+
+        attr_accessor :type, :name, :value, :label
+
+
+        def create
+            dir = Puppet[:rrddir]
+            unless dir
+                raise "Cannot store metrics unless RRDDir is set"
+            end
+
+            unless FileTest.exist?(dir)
+                tmp = dir.sub(/^\//,'')
+                path = [File::SEPARATOR]
+                tmp.split(File::SEPARATOR).each { |d|
+                    path.push d
+                    unless FileTest.exist?(File.join(path))
+                        Dir.mkdir(File.join(path))
+                    end
+                }
+            end
+
+            unless FileTest.directory?(dir)
+                raise Puppet::Error.new("%s must be a directory" % dir)
+            end
+
+            path = self.path
+            args = [
+                path,
+                "--start", Time.now.to_i - 5,
+                "--step", "300", # XXX Defaulting to every five minutes, but prob bad
+            ]
+
+            @values.each { |value|
+                args.push "DS:%s:GAUGE:600:U:U" % value[0]
+            }
+            args.push "RRA:AVERAGE:0.5:1:300"
+
+            begin
+                RRD.create(*args)
+            rescue => detail
+                raise "Could not create RRD file %s: %s" % [path,detail]
+            end
+        end
+
+        def initialize(name,label = nil)
+            @name = name
+            if label
+                @label = label
+            else
+                @label = name.capitalize
+            end
+
+            @values = []
+            if @@metrics.include?(self.name)
+                raise "Somehow created two metrics with name %s" % self.name
+            else
+                @@metrics[self.name] = self
+            end
+        end
+
+        def newvalue(name,value,label = nil)
+            unless label
+                label = name.capitalize
+            end
+            @values.push [name,label,value]
+        end
+
+        def path
+            return File.join(Puppet[:rrddir],@name + ".rrd")
+        end
+
+        def graph(range = nil)
+            args = [self.path.sub(/rrd$/,"png")]
+            args.push("--title",self.label)
+            args.push("--imgformat","PNG")
+            args.push("--interlace")
+            colorstack = %w{#ff0000 #00ff00 #0000ff #099000 #000990 #f00990}
+            i = 0
+            defs = []
+            lines = []
+            @values.zip(colorstack).each { |value,color|
+                next if value.nil?
+                # this actually uses the data label
+                defs.push("DEF:%s=%s:%s:AVERAGE" % [value[0],self.path,value[0]])
+                lines.push("LINE3:%s%s:%s" % [value[0],color,value[1]])
+            }
+            args << defs
+            args << lines
+            args.flatten!
+            if range 
+                args.push("--start",range[0],"--end",range[1])
+            end
+
+            begin
+                RRD.graph(*args)
+            rescue => detail
+                Puppet.err "Failed to graph %s: %s" % [self.name,detail]
+            end
+        end
+
+        def store(time)
+            unless FileTest.exists?(File.join(Puppet[:rrddir],@name + ".rrd"))
+                self.create
+            end
+
+            # XXX this is not terribly error-resistant
+            args = [time]
+            @values.each { |value|
+                args.push value[2]
+            }
+            arg = args.join(":")
+            begin
+                RRD.update(self.path,args.join(":"))
+            rescue => detail
+                raise Puppet::Error, "Failed to update %s: %s" % [self.name,detail]
+            end
+        end
+    end
+end
+
+# $Id: metric.rb 732 2005-10-28 05:39:59Z luke $