puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/util/log/destinations.rb

@@ -0,0 +1,268 @@
+Puppet::Util::Log.newdesttype :syslog do
+  def self.suitable?(obj)
+    Puppet.features.syslog?
+  end
+
+  def close
+    Syslog.close
+  end
+
+  def initialize
+    Syslog.close if Syslog.opened?
+    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 #{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
+end
+
+Puppet::Util::Log.newdesttype :file do
+  require 'fileutils'
+
+  def self.match?(obj)
+    Puppet::Util.absolute_path?(obj)
+  end
+
+  def close
+    if defined?(@file)
+      @file.close
+      @file = nil
+    end
+  end
+
+  def flush
+    @file.flush if defined?(@file)
+  end
+
+  attr_accessor :autoflush
+
+  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))
+      FileUtils.mkdir_p(File.dirname(path), :mode => 0755)
+      Puppet.info "Creating log directory #{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("#{msg.time} #{msg.source} (#{msg.level}): #{msg}")
+
+    @file.flush if @autoflush
+  end
+end
+
+Puppet::Util::Log.newdesttype :console do
+  require 'puppet/util/colors'
+  include Puppet::Util::Colors
+
+  def initialize
+    # Flush output immediately.
+    $stdout.sync = true
+  end
+
+  def handle(msg)
+    if msg.source == "Puppet"
+      puts colorize(msg.level, "#{msg.level}: #{msg}")
+    else
+      puts colorize(msg.level, "#{msg.level}: #{msg.source}: #{msg}")
+    end
+  end
+end
+
+Puppet::Util::Log.newdesttype :telly_prototype_console do
+  require 'puppet/util/colors'
+  include Puppet::Util::Colors
+
+  def initialize
+    # Flush output immediately.
+    $stderr.sync = true
+    $stdout.sync = true
+  end
+
+  def handle(msg)
+    error_levels = {
+      :warning => 'Warning',
+      :err     => 'Error',
+      :alert   => 'Alert',
+      :emerg   => 'Emergency',
+      :crit    => 'Critical'
+    }
+
+    str = msg.respond_to?(:multiline) ? msg.multiline : msg.to_s
+
+    case msg.level
+    when *error_levels.keys
+      $stderr.puts colorize(:hred, "#{error_levels[msg.level]}: #{str}")
+    when :info
+      $stdout.puts "#{colorize(:green, 'Info')}: #{str}"
+    when :debug
+      $stdout.puts "#{colorize(:cyan, 'Debug')}: #{str}"
+    else
+      $stdout.puts str
+    end
+  end
+end
+
+Puppet::Util::Log.newdesttype :host do
+  def initialize(host)
+    Puppet.info "Treating #{host} as a hostname"
+    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
+      @hostname ||= Facter["hostname"].value
+      unless defined?(@domain)
+        @domain = Facter["domain"].value
+        @hostname += ".#{@domain}" if @domain
+      end
+      if Puppet::Util.absolute_path?(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 #{msg}"
+        #puts "would have sent %s" %
+        #    CGI.escape(YAML.dump(msg))
+        begin
+          tmp = CGI.escape(YAML.dump(msg))
+        rescue => detail
+          puts "Could not dump: #{detail}"
+          return
+        end
+        # Add the hostname to the source
+        @driver.addlog(tmp)
+      rescue => detail
+        puts detail.backtrace if Puppet[:trace]
+        Puppet.err detail
+        Puppet::Util::Log.close(self)
+      end
+    end
+  end
+end
+
+# Log to a transaction report.
+Puppet::Util::Log.newdesttype :report do
+  attr_reader :report
+
+  match "Puppet::Transaction::Report"
+
+  def initialize(report)
+    @report = report
+  end
+
+  def handle(msg)
+    @report << msg
+  end
+end
+
+# Log to an array, just for testing.
+module Puppet::Test
+  class LogCollector
+    def initialize(logs)
+      @logs = logs
+    end
+
+    def <<(value)
+      @logs << value
+    end
+  end
+end
+
+Puppet::Util::Log.newdesttype :array do
+  match "Puppet::Test::LogCollector"
+
+  def initialize(messages)
+    @messages = messages
+  end
+
+  def handle(msg)
+    @messages << msg
+  end
+end
+
+Puppet::Util::Log.newdesttype :eventlog do
+  def self.suitable?(obj)
+    Puppet.features.eventlog?
+  end
+
+  def initialize
+    @eventlog = Win32::EventLog.open("Application")
+  end
+
+  def to_native(level)
+    case level
+    when :debug,:info,:notice
+      [Win32::EventLog::INFO, 0x01]
+    when :warning
+      [Win32::EventLog::WARN, 0x02]
+    when :err,:alert,:emerg,:crit
+      [Win32::EventLog::ERROR, 0x03]
+    end
+  end
+
+  def handle(msg)
+    native_type, native_id = to_native(msg.level)
+
+    @eventlog.report_event(
+      :source      => "Puppet",
+      :event_type  => native_type,
+      :event_id    => native_id,
+      :data        => (msg.source and msg.source != 'Puppet' ? "#{msg.source}: " : '') + msg.to_s
+    )
+  end
+
+  def close
+    if @eventlog
+      @eventlog.close
+      @eventlog = nil
+    end
+  end
+end

data/lib/vendor/puppet/util/log.rb

@@ -0,0 +1,275 @@
+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
+  extend Puppet::Util::ClassGen
+  include Puppet::Util::Tagging
+
+  @levels = [:debug,:info,:notice,:warning,:err,:alert,:emerg,:crit]
+  @loglevel = 2
+
+  @desttypes = {}
+
+  # Create a new destination type.
+  def self.newdesttype(name, options = {}, &block)
+
+    dest = genclass(
+      name,
+      :parent     => Puppet::Util::Log::Destination,
+      :prefix     => "Dest",
+      :block      => block,
+      :hash       => @desttypes,
+      :attributes => options
+    )
+    dest.match(dest.name)
+
+    dest
+  end
+
+  require 'puppet/util/log/destination'
+  require 'puppet/util/log/destinations'
+
+  @destinations = {}
+
+  @queued = []
+
+  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
+  end
+
+  def self.close_all
+    destinations.keys.each { |dest|
+      close(dest)
+    }
+    raise Puppet::DevError.new("Log.close_all failed to close #{@destinations.keys.inspect}") if !@destinations.empty?
+  end
+
+  # Flush any log destinations that support such operations.
+  def Log.flush
+    @destinations.each { |type, dest|
+      dest.flush if dest.respond_to?(:flush)
+    }
+  end
+
+  def Log.autoflush=(v)
+    @destinations.each do |type, dest|
+      dest.autoflush = v if dest.respond_to?(:autoflush=)
+    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)
+    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
+
+    name, type = @desttypes.find do |name, klass|
+      klass.match?(dest)
+    end
+
+    if type.respond_to?(:suitable?) and not type.suitable?(dest)
+      return
+    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
+
+  # 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
+
+    queuemessage(msg) if @destinations.length == 0
+
+    @destinations.each do |name, dest|
+      threadlock(dest) do
+        dest.handle(msg)
+      end
+    end
+  end
+
+  def Log.queuemessage(msg)
+    @queued.push(msg)
+  end
+
+  def Log.flushqueue
+    return unless @destinations.size >= 1
+    @queued.each do |msg|
+      Log.newmessage(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.setup_default
+        Puppet.err detail.to_s
+      end
+    end
+  end
+
+  def self.setup_default
+    Log.newdestination(
+      (Puppet.features.syslog?   ? :syslog   :
+      (Puppet.features.eventlog? ? :eventlog : Puppet[:puppetdlog])))
+  end
+
+  # Is the passed level a valid log level?
+  def self.validlevel?(level)
+    @levels.include?(level)
+  end
+
+  attr_accessor :time, :remote, :file, :line, :source
+  attr_reader :level, :message
+
+  def initialize(args)
+    self.level = args[:level]
+    self.message = args[:message]
+    self.source = args[:source] || "Puppet"
+
+    @time = Time.now
+
+    if tags = args[:tags]
+      tags.each { |t| self.tag(t) }
+    end
+
+    [:file, :line].each do |attr|
+      next unless value = args[attr]
+      send(attr.to_s + "=", value)
+    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].each do |param|
+        next unless descriptors[param]
+        send(param.to_s + "=", descriptors[param])
+      end
+    else
+      @source = source.to_s
+    end
+  end
+
+  def to_report
+    "#{time} #{source} (#{level}): #{to_s}"
+  end
+
+  def to_s
+    message
+  end
+end
+
+# This is for backward compatibility from when we changed the constant to Puppet::Util::Log
+# because the reports include the constant name.  Apparently the alias was created in
+# March 2007, should could probably be removed soon.
+Puppet::Log = Puppet::Util::Log

data/lib/vendor/puppet/util/log_paths.rb

@@ -0,0 +1,22 @@
+module Puppet::Util::LogPaths
+  # return the full path to us, for logging and rollback
+  # some classes (e.g., FileTypeRecords) will have to override this
+  def path
+    @path ||= '/' + pathbuilder.join('/')
+  end
+
+  def source_descriptors
+    descriptors = {}
+
+    descriptors[:tags] = tags
+
+    [:path, :file, :line].each do |param|
+      next unless value = send(param)
+      descriptors[param] = value
+    end
+
+    descriptors
+  end
+
+end
+

data/lib/vendor/puppet/util/logging.rb

@@ -0,0 +1,51 @@
+# A module to make logging a bit easier.
+require 'puppet/util/log'
+
+module Puppet::Util::Logging
+
+  def send_log(level, message)
+    Puppet::Util::Log.create({:level => level, :source => log_source, :message => message}.merge(log_metadata))
+  end
+
+  # Create a method for each log level.
+  Puppet::Util::Log.eachlevel do |level|
+    define_method(level) do |args|
+      args = args.join(" ") if args.is_a?(Array)
+      send_log(level, args)
+    end
+  end
+
+  def deprecation_warning(message)
+    $deprecation_warnings ||= Hash.new(0)
+    if $deprecation_warnings.length < 100 and ($deprecation_warnings[message] += 1) == 1
+      warning message
+    end
+  end
+
+  def clear_deprecation_warnings
+    $deprecation_warnings.clear if $deprecation_warnings
+  end
+
+  private
+
+  def is_resource?
+    defined?(Puppet::Type) && is_a?(Puppet::Type)
+  end
+
+  def is_resource_parameter?
+    defined?(Puppet::Parameter) && is_a?(Puppet::Parameter)
+  end
+
+  def log_metadata
+    [:file, :line, :tags].inject({}) do |result, attr|
+      result[attr] = send(attr) if respond_to?(attr)
+      result
+    end
+  end
+
+  def log_source
+    # We need to guard the existence of the constants, since this module is used by the base Puppet module.
+    (is_resource? or is_resource_parameter?) and respond_to?(:path) and return path.to_s
+    to_s
+  end
+end

data/lib/vendor/puppet/util/metaid.rb

@@ -0,0 +1,21 @@
+class Object
+  # The hidden singleton lurks behind everyone
+  def singleton_class; class << self; self; end; end
+  def meta_eval(&blk); singleton_class.instance_eval(&blk); end
+
+  # Adds methods to a singleton_class
+  def meta_def(name, &blk)
+    meta_eval { define_method name, &blk }
+  end
+
+  # Remove singleton_class methods.
+  def meta_undef(name, &blk)
+    meta_eval { remove_method name }
+  end
+
+  # Defines an instance method within a class
+  def class_def(name, &blk)
+    class_eval { define_method name, &blk }
+  end
+end
+

data/lib/vendor/puppet/util/methodhelper.rb

@@ -0,0 +1,32 @@
+# Where we store helper methods related to, um, methods.
+module Puppet::Util::MethodHelper
+  def requiredopts(*names)
+    names.each do |name|
+      devfail("#{name} is a required option for #{self.class}") if self.send(name).nil?
+    end
+  end
+
+  # Iterate over a hash, treating each member as an attribute.
+  def set_options(options)
+    options.each do |param,value|
+      method = param.to_s + "="
+      if respond_to? method
+        self.send(method, value)
+      else
+        raise ArgumentError, "Invalid parameter #{param} to object class #{self.class}"
+      end
+    end
+  end
+
+  # Take a hash and convert all of the keys to symbols if possible.
+  def symbolize_options(options)
+    options.inject({}) do |hash, opts|
+      if opts[0].respond_to? :intern
+        hash[opts[0].intern] = opts[1]
+      else
+        hash[opts[0]] = opts[1]
+      end
+      hash
+    end
+  end
+end