puppet 0.25.5 → 2.6.0

data/lib/puppet/util/loadedfile.rb

@@ -4,64 +4,62 @@
 require 'puppet'
 
 module Puppet
-    class NoSuchFile < Puppet::Error; end
-    class Util::LoadedFile
-        attr_reader :file, :statted
+  class NoSuchFile < Puppet::Error; end
+  class Util::LoadedFile
+    attr_reader :file, :statted
 
-        # Provide a hook for setting the timestamp during testing, so we don't
-        # have to depend on the granularity of the filesystem.
-        attr_writer :tstamp
+    # Provide a hook for setting the timestamp during testing, so we don't
+    # have to depend on the granularity of the filesystem.
+    attr_writer :tstamp
 
-        # Determine whether the file has changed and thus whether it should
-        # be reparsed.
-        def changed?
-            # Allow the timeout to be disabled entirely.
-            if Puppet[:filetimeout] < 0
-                return true
-            end
-            tmp = stamp()
+    # Determine whether the file has changed and thus whether it should
+    # be reparsed.
+    def changed?
+      # Allow the timeout to be disabled entirely.
+      return true if Puppet[:filetimeout] < 0
+      tmp = stamp
 
-            # We use a different internal variable than the stamp method
-            # because it doesn't keep historical state and we do -- that is,
-            # we will always be comparing two timestamps, whereas
-            # stamp() just always wants the latest one.
-            if tmp == @tstamp
-                return false
-            else
-                @tstamp = tmp
-                return @tstamp
-            end
-        end
+      # We use a different internal variable than the stamp method
+      # because it doesn't keep historical state and we do -- that is,
+      # we will always be comparing two timestamps, whereas
+      # stamp just always wants the latest one.
+      if tmp == @tstamp
+        return false
+      else
+        @tstamp = tmp
+        return @tstamp
+      end
+    end
 
-        # Create the file.  Must be passed the file path.
-        def initialize(file)
-            @file = file
-            unless FileTest.exists?(@file)
-                raise Puppet::NoSuchFile,
-                    "Can not use a non-existent file for parsing"
-            end
-            @statted = 0
-            @stamp = nil
-            @tstamp = stamp()
-        end
+    # Create the file.  Must be passed the file path.
+    def initialize(file)
+      @file = file
+      unless FileTest.exists?(@file)
+        raise Puppet::NoSuchFile,
+          "Can not use a non-existent file for parsing"
+      end
+      @statted = 0
+      @stamp = nil
+      @tstamp = stamp
+    end
 
-        # Retrieve the filestamp, but only refresh it if we're beyond our
-        # filetimeout
-        def stamp
-            if @stamp.nil? or (Time.now.to_i - @statted >= Puppet[:filetimeout])
-                @statted = Time.now.to_i
-                begin
-                    @stamp = File.stat(@file).ctime
-                rescue Errno::ENOENT
-                    @stamp = Time.now
-                end
-            end
-            return @stamp
+    # Retrieve the filestamp, but only refresh it if we're beyond our
+    # filetimeout
+    def stamp
+      if @stamp.nil? or (Time.now.to_i - @statted >= Puppet[:filetimeout])
+        @statted = Time.now.to_i
+        begin
+          @stamp = File.stat(@file).ctime
+        rescue Errno::ENOENT
+          @stamp = Time.now
         end
+      end
+      @stamp
+    end
 
-        def to_s
-            @file
-        end
+    def to_s
+      @file
     end
+  end
 end
 

data/lib/puppet/util/log.rb

@@ -1,538 +1,254 @@
-require 'syslog'
 require 'puppet/util/tagging'
+require 'puppet/util/classgen'
 
 # 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 Puppet::Util::Log
-    include Puppet::Util
-    include Puppet::Util::Tagging
-
-    @levels = [:debug,:info,:notice,:warning,:err,:alert,:emerg,:crit]
-    @loglevel = 2
-
-    @desttypes = {}
-
-    # A type of log destination.
-    class Destination
-        class << self
-            attr_accessor :name
-        end
-
-        def self.initvars
-            @matches = []
-        end
-
-        # Mark the things we're supposed to match.
-        def self.match(obj)
-            @matches ||= []
-            @matches << obj
-        end
-
-        # See whether we match a given thing.
-        def self.match?(obj)
-            # Convert single-word strings into symbols like :console and :syslog
-            if obj.is_a? String and obj =~ /^\w+$/
-                obj = obj.downcase.intern
-            end
-
-            @matches.each do |thing|
-                # Search for direct matches or class matches
-                return true if thing === obj or thing == obj.class.to_s
-            end
-            return false
-        end
-
-        def name
-            if defined? @name
-                return @name
-            else
-                return self.class.name
-            end
-        end
-
-        # Set how to handle a message.
-        def self.sethandler(&block)
-            define_method(:handle, &block)
-        end
-
-        # Mark how to initialize our object.
-        def self.setinit(&block)
-            define_method(:initialize, &block)
-        end
-    end
+  include Puppet::Util
+  extend Puppet::Util::ClassGen
+  include Puppet::Util::Tagging
 
-    # Create a new destination type.
-    def self.newdesttype(name, options = {}, &block)
-        dest = genclass(name, :parent => Destination, :prefix => "Dest",
-            :block => block,
-            :hash => @desttypes,
-            :attributes => options
-        )
-        dest.match(dest.name)
+  @levels = [:debug,:info,:notice,:warning,:err,:alert,:emerg,:crit]
+  @loglevel = 2
 
-        return dest
-    end
+  @desttypes = {}
 
-    @destinations = {}
+  # Create a new destination type.
+  def self.newdesttype(name, options = {}, &block)
 
-    class << self
-        include Puppet::Util
-        include Puppet::Util::ClassGen
-    end
+          dest = genclass(
+        name, :parent => Puppet::Util::Log::Destination, :prefix => "Dest",
+      :block => block,
+      :hash => @desttypes,
+        
+      :attributes => options
+    )
+    dest.match(dest.name)
 
-    # 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)
-                if @destinations.respond_to?(:close)
-                    @destinations[dest].close
-                end
-                @destinations.delete(dest)
-            end
-        else
-            @destinations.each { |name, dest|
-                if dest.respond_to?(:flush)
-                    dest.flush
-                end
-                if dest.respond_to?(:close)
-                    dest.close
-                end
-            }
-            @destinations = {}
-        end
-    end
-
-    def self.close_all
-        # And close all logs except the console.
-        destinations.each do |dest|
-            close(dest)
-        end
-    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
+    dest
+  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)
-        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::Util::Log.new(hash)
-        else
-            return nil
-        end
-    end
+  require 'puppet/util/log/destination'
+  require 'puppet/util/log/destinations'
 
-    def Log.destinations
-        return @destinations.keys
-    end
+  @destinations = {}
 
-    # Yield each valid level in turn
-    def Log.eachlevel
-        @levels.each { |level| yield level }
-    end
+  @queued = []
 
-    # Return the current log level.
-    def Log.level
-        return @levels[@loglevel]
+  class << self
+    include Puppet::Util
+    include Puppet::Util::ClassGen
+
+    attr_reader :desttypes
+  end
+
+  # Reset log to basics.  Basically just flushes and closes files and
+  # undefs other objects.
+  def Log.close(destination)
+    if @destinations.include?(destination)
+      @destinations[destination].flush if @destinations[destination].respond_to?(:flush)
+      @destinations[destination].close if @destinations[destination].respond_to?(:close)
+      @destinations.delete(destination)
     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
+
+  def self.close_all
+    destinations.keys.each { |dest|
+      close(dest)
+    }
+  end
+
+  # Flush any log destinations that support such operations.
+  def Log.flush
+    @destinations.each { |type, dest|
+      dest.flush if dest.respond_to?(:flush)
+    }
+  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)
+    raise Puppet::DevError, "Logs require a level" unless hash.include?(:level)
+    raise Puppet::DevError, "Invalid log level #{hash[:level]}" unless @levels.index(hash[:level])
+    @levels.index(hash[:level]) >= @loglevel ? Puppet::Util::Log.new(hash) : nil
+  end
+
+  def Log.destinations
+    @destinations
+  end
+
+  # Yield each valid level in turn
+  def Log.eachlevel
+    @levels.each { |level| yield level }
+  end
+
+  # Return the current log level.
+  def Log.level
+    @levels[@loglevel]
+  end
+
+  # Set the current log level.
+  def Log.level=(level)
+    level = level.intern unless level.is_a?(Symbol)
+
+    raise Puppet::DevError, "Invalid loglevel #{level}" unless @levels.include?(level)
+
+    @loglevel = @levels.index(level)
+  end
+
+  def Log.levels
+    @levels.dup
+  end
+
+  # Create a new log destination.
+  def Log.newdestination(dest)
+    # Each destination can only occur once.
+    if @destinations.find { |name, obj| obj.name == dest }
+      return
     end
 
-    def Log.levels
-        @levels.dup
+    name, type = @desttypes.find do |name, klass|
+      klass.match?(dest)
     end
 
-    newdesttype :syslog do
-        def close
-            Syslog.close
-        end
-
-        def initialize
-            if Syslog.opened?
-                Syslog.close
-            end
-            name = Puppet[:name]
-            name = "puppet-#{name}" unless name =~ /puppet/
-
-            options = Syslog::LOG_PID | Syslog::LOG_NDELAY
-
-            # XXX This should really be configurable.
-            str = Puppet[:syslogfacility]
-            begin
-                facility = Syslog.const_get("LOG_#{str.upcase}")
-            rescue NameError
-                raise Puppet::Error, "Invalid syslog facility %s" % str
-            end
-
-            @syslog = Syslog.open(name, options, facility)
-        end
-
-        def handle(msg)
-            # 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"
-                @syslog.send(msg.level, msg.to_s.gsub("%", '%%'))
-            else
-                @syslog.send(msg.level, "(%s) %s" %
-                    [msg.source.to_s.gsub("%", ""),
-                        msg.to_s.gsub("%", '%%')
-                    ]
-                )
-            end
-        end
+    raise Puppet::DevError, "Unknown destination type #{dest}" unless type
+
+    begin
+      if type.instance_method(:initialize).arity == 1
+        @destinations[dest] = type.new(dest)
+      else
+        @destinations[dest] = type.new
+      end
+      flushqueue
+      @destinations[dest]
+    rescue => detail
+      puts detail.backtrace if Puppet[:debug]
+
+      # If this was our only destination, then add the console back in.
+      newdestination(:console) if @destinations.empty? and (dest != :console and dest != "console")
     end
+  end
 
-    newdesttype :file do
-        match(/^\//)
-
-        def close
-            if defined? @file
-                @file.close
-                @file = nil
-            end
-        end
-
-        def flush
-            if defined? @file
-                @file.flush
-            end
-        end
-
-        def initialize(path)
-            @name = path
-            # first make sure the directory exists
-            # We can't just use 'Config.use' here, because they've
-            # specified a "special" destination.
-            unless FileTest.exist?(File.dirname(path))
-                Puppet.recmkdir(File.dirname(path))
-                Puppet.info "Creating log directory %s" % File.dirname(path)
-            end
-
-            # create the log file, if it doesn't already exist
-            file = File.open(path, File::WRONLY|File::CREAT|File::APPEND)
-
-            @file = file
-
-            @autoflush = Puppet[:autoflush]
-        end
-
-        def handle(msg)
-            @file.puts("%s %s (%s): %s" %
-                [msg.time, msg.source, msg.level, msg.to_s])
-
-            @file.flush if @autoflush
-        end
-    end
+  # Route the actual message. FIXME There are lots of things this method
+  # should do, like caching and 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)
+    return if @levels.index(msg.level) < @loglevel
 
-    newdesttype :console do
-
-
-        RED     = {:console => "", :html => "FFA0A0"}
-        GREEN   = {:console => "", :html => "00CD00"}
-        YELLOW  = {:console => "", :html => "FFFF60"}
-        BLUE    = {:console => "", :html => "80A0FF"}
-        PURPLE  = {:console => "", :html => "FFA500"}
-        CYAN    = {:console => "", :html => "40FFFF"}
-        WHITE   = {:console => "", :html => "FFFFFF"}
-        HRED    = {:console => "", :html => "FFA0A0"}
-        HGREEN  = {:console => "", :html => "00CD00"}
-        HYELLOW = {:console => "", :html => "FFFF60"}
-        HBLUE   = {:console => "", :html => "80A0FF"}
-        HPURPLE = {:console => "", :html => "FFA500"}
-        HCYAN   = {:console => "", :html => "40FFFF"}
-        HWHITE  = {:console => "", :html => "FFFFFF"}
-        RESET   = {:console => "",    :html => ""      }
-
-        @@colormap = {
-            :debug => WHITE,
-            :info => GREEN,
-            :notice => CYAN,
-            :warning => YELLOW,
-            :err => HPURPLE,
-            :alert => RED,
-            :emerg => HRED,
-            :crit => HRED
-        }
-
-        def colorize(level, str)
-            case Puppet[:color]
-            when true, :ansi, "ansi", :yes, "yes"; console_color(level, str)
-            when :html, "html"; html_color(level, str)
-            else str
-            end
-        end
-
-        def console_color(level, str)
-            @@colormap[level][:console] + str + RESET[:console]
-        end
-
-        def html_color(level, str)
-            %{<span style="color: %s">%s</span>} % [@@colormap[level][:html], str]
-        end
-
-        def initialize
-            # Flush output immediately.
-            $stdout.sync = true
-        end
-
-        def handle(msg)
-            if msg.source == "Puppet"
-                puts colorize(msg.level, "%s: %s" % [msg.level, msg.to_s])
-            else
-                puts colorize(msg.level, "%s: %s: %s" % [msg.level, msg.source, msg.to_s])
-            end
-        end
-    end
+    queuemessage(msg) if @destinations.length == 0
 
-    newdesttype :host do
-        def initialize(host)
-            Puppet.info "Treating %s as a hostname" % host
-            args = {}
-            if host =~ /:(\d+)/
-                args[:Port] = $1
-                args[:Server] = host.sub(/:\d+/, '')
-            else
-                args[:Server] = host
-            end
-
-            @name = host
-
-            @driver = Puppet::Network::Client::LogClient.new(args)
-        end
-
-        def handle(msg)
-            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(YAML.dump(msg))
-                    begin
-                        tmp = CGI.escape(YAML.dump(msg))
-                    rescue => detail
-                        puts "Could not dump: %s" % detail.to_s
-                        return
-                    end
-                    # Add the hostname to the source
-                    @driver.addlog(tmp)
-                rescue => detail
-                    if Puppet[:trace]
-                        puts detail.backtrace
-                    end
-                    Puppet.err detail
-                    Puppet::Util::Log.close(self)
-                end
-            end
-        end
+    @destinations.each do |name, dest|
+      threadlock(dest) do
+        dest.handle(msg)
+      end
     end
+  end
 
-    # Log to a transaction report.
-    newdesttype :report do
-        match "Puppet::Transaction::Report"
+  def Log.queuemessage(msg)
+    @queued.push(msg)
+  end
 
-        def initialize(report)
-            @report = report
-        end
-
-        def handle(msg)
-            @report.newlog(msg)
-        end
+  def Log.flushqueue
+    return unless @destinations.size >= 1
+    @queued.each do |msg|
+      Log.newmessage(msg)
     end
-
-    # Log to an array, just for testing.
-    newdesttype :array do
-        match "Array"
-
-        def initialize(array)
-            @array = array
-        end
-
-        def handle(msg)
-            @array << msg
-        end
+    @queued.clear
+  end
+
+  def Log.sendlevel?(level)
+    @levels.index(level) >= @loglevel
+  end
+
+  # Reopen all of our logs.
+  def Log.reopen
+    Puppet.notice "Reopening log files"
+    types = @destinations.keys
+    @destinations.each { |type, dest|
+      dest.close if dest.respond_to?(:close)
+    }
+    @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
 
-    # Create a new log destination.
-    def Log.newdestination(dest)
-        # Each destination can only occur once.
-        if @destinations.find { |name, obj| obj.name == dest }
-            return
-        end
-
-        name, type = @desttypes.find do |name, klass|
-            klass.match?(dest)
-        end
-
-        unless type
-            raise Puppet::DevError, "Unknown destination type %s" % dest
-        end
-
-        begin
-            if type.instance_method(:initialize).arity == 1
-                @destinations[dest] = type.new(dest)
-            else
-                @destinations[dest] = type.new()
-            end
-        rescue => detail
-            if Puppet[:debug]
-                puts detail.backtrace
-            end
-
-            # If this was our only destination, then add the console back in.
-            if @destinations.empty? and (dest != :console and dest != "console")
-                newdestination(:console)
-            end
-        end
-    end
+  # Is the passed level a valid log level?
+  def self.validlevel?(level)
+    @levels.include?(level)
+  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)
-        if @levels.index(msg.level) < @loglevel
-            return
-        end
-
-        @destinations.each do |name, dest|
-            threadlock(dest) do
-                dest.handle(msg)
-            end
-        end
-    end
+  attr_accessor :time, :remote, :file, :line, :version, :source
+  attr_reader :level, :message
 
-    def Log.sendlevel?(level)
-        @levels.index(level) >= @loglevel
-    end
+  def initialize(args)
+    self.level = args[:level]
+    self.message = args[:message]
+    self.source = args[:source] || "Puppet"
 
-    # Reopen all of our logs.
-    def Log.reopen
-        Puppet.notice "Reopening log files"
-        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
+    @time = Time.now
 
-    # Is the passed level a valid log level?
-    def self.validlevel?(level)
-        @levels.include?(level)
+    if tags = args[:tags]
+      tags.each { |t| self.tag(t) }
     end
 
-    attr_accessor :level, :message, :time, :remote, :file, :line, :version
-    attr_reader :source
-
-    def initialize(args)
-        unless args.include?(:level) && args.include?(:message)
-            raise ArgumentError, "Puppet::Util::Log called incorrectly"
-        end
-
-        if args[:level].class == String
-            @level = args[:level].intern
-        elsif args[:level].class == Symbol
-            @level = args[:level]
-        else
-            raise ArgumentError, "Level is not a string or symbol: #{args[:level].class}"
-        end
-
-        @message = args[:message].to_s
-        @time = Time.now
-
-        raise ArgumentError, "Invalid log level %s" % level unless self.class.validlevel?(level)
-
-        if tags = args[:tags]
-            tags.each { |t| self.tag(t) }
-        end
-
-        self.source = args[:source] || "Puppet"
-
-        # Tag myself with my log level
-        tag(level)
-
-        Log.newmessage(self)
+    [:file, :line, :version].each do |attr|
+      next unless value = args[attr]
+      send(attr.to_s + "=", value)
     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)
-        if source.respond_to?(:source_descriptors)
-            descriptors = source.source_descriptors
-            @source = descriptors[:path]
-
-            descriptors[:tags].each { |t| tag(t) }
-
-            [:file, :line, :version].each do |param|
-                next unless descriptors[param]
-                send(param.to_s + "=", descriptors[param])
-            end
-        else
-            @source = source.to_s
-        end
+    Log.newmessage(self)
+  end
+
+  def message=(msg)
+    raise ArgumentError, "Puppet::Util::Log requires a message" unless msg
+    @message = msg.to_s
+  end
+
+  def level=(level)
+    raise ArgumentError, "Puppet::Util::Log requires a log level" unless level
+    @level = level.to_sym
+    raise ArgumentError, "Invalid log level #{@level}" unless self.class.validlevel?(@level)
+
+    # Tag myself with my log level
+    tag(level)
+  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)
+    if source.respond_to?(:source_descriptors)
+      descriptors = source.source_descriptors
+      @source = descriptors[:path]
+
+      descriptors[:tags].each { |t| tag(t) }
+
+      [:file, :line, :version].each do |param|
+        next unless descriptors[param]
+        send(param.to_s + "=", descriptors[param])
+      end
+    else
+      @source = source.to_s
     end
+  end
 
-    def to_report
-        "%s %s (%s): %s" % [self.time, self.source, self.level, self.to_s]
-    end
+  def to_report
+    "#{time} #{source} (#{level}): #{to_s}"
+  end
 
-    def to_s
-        return @message
-    end
+  def to_s
+    message
+  end
 end
 
 # This is for backward compatibility from when we changed the constant to Puppet::Util::Log