puppet 0.18.4 → 0.22.4

data/lib/puppet/util/logging.rb

@@ -0,0 +1,20 @@
+# A module to make logging a bit easier.
+require 'puppet/util/log'
+
+module Puppet::Util::Logging
+    # Create a method for each log level.
+    Puppet::Util::Log.eachlevel do |level|
+        define_method(level) do |args|
+            if args.is_a?(Array)
+                args = args.join(" ")
+            end
+            Puppet::Util::Log.create(
+                :level => level,
+                :source => self,
+                :message => args
+            )
+        end
+    end
+end
+
+# $Id: logging.rb 2178 2007-02-07 23:56:59Z luke $

data/lib/puppet/util/metaid.rb

@@ -0,0 +1,22 @@
+class Object
+    # The hidden singleton lurks behind everyone
+    def metaclass; class << self; self; end; end
+    def meta_eval(&blk); metaclass.instance_eval(&blk); end
+
+    # Adds methods to a metaclass
+    def meta_def(name, &blk)
+        meta_eval { define_method name, &blk }
+    end
+
+    # Remove metaclass 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
+
+# $Id: metaid.rb 1504 2006-08-28 16:30:49Z luke $

data/lib/puppet/util/methodhelper.rb

@@ -0,0 +1,37 @@
+# Where we store helper methods related to, um, methods.
+module Puppet::Util::MethodHelper
+    def requiredopts(*names)
+        names.each do |name|
+            if self.send(name).nil?
+                devfail("%s is a required option for %s" % [name, self.class])
+            end
+        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 + "="
+            begin
+                self.send(method, value)
+            rescue NoMethodError
+                raise ArgumentError, "Invalid parameter %s to object class %s" %
+                        [param,self.class.to_s]
+            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
+
+# $Id: methodhelper.rb 2281 2007-03-14 17:49:19Z luke $

data/lib/puppet/util/metric.rb

@@ -0,0 +1,160 @@
+# included so we can test object types
+require 'puppet'
+
+# A class for handling metrics.  This is currently ridiculously hackish.
+class Puppet::Util::Metric
+    Puppet.config.setdefaults("metrics",
+        :rrddir => {:default => "$vardir/rrd",
+            :owner => "$user",
+            :group => "$group",
+            :desc => "The directory where RRD database files are stored.
+                Directories for each reporting host will be created under
+                this directory."
+        },
+        :rrdgraph => [false, "Whether RRD information should be graphed."],
+        :rrdinterval => ["$runinterval", "How often RRD should expect data.
+            This should match how often the hosts report back to the server."]
+    )
+    
+    # Load the library as a feature, so we can test its presence.
+    Puppet.features.add :rrd, :libs => 'RRD'
+
+    attr_accessor :type, :name, :value, :label
+
+    attr_writer :basedir
+
+    def basedir
+        if defined? @basedir
+            @basedir
+        else
+            Puppet[:rrddir]
+        end
+    end
+
+    def create(start = nil)
+        Puppet.config.use(:metrics)
+
+        start ||= Time.now.to_i - 5
+
+        path = self.path
+        args = [
+            path,
+            "--start", start,
+            "--step", Puppet[:rrdinterval]
+        ]
+
+        values.each { |value|
+            # the 7200 is the heartbeat -- this means that any data that isn't
+            # more frequently than every two hours gets thrown away
+            args.push "DS:%s:GAUGE:7200: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 dump
+        puts RRD.info(self.path)
+    end
+
+    def graph(range = nil)
+        unless Puppet.features.rrd?
+            Puppet.warning "RRD library is missing; cannot graph metrics"
+            return
+        end
+
+        unit = 60 * 60 * 24
+        colorstack = %w{#ff0000 #00ff00 #0000ff #099000 #000990 #f00990 #0f0f0f}
+
+        {:daily => unit, :weekly => unit * 7, :monthly => unit * 30, :yearly => unit * 365}.each do |name, time|
+            file = self.path.sub(/\.rrd$/, "-%s.png" % name)
+            args = [file]
+
+            args.push("--title",self.label)
+            args.push("--imgformat","PNG")
+            args.push("--interlace")
+            i = 0
+            defs = []
+            lines = []
+            #p @values.collect { |s,l| s }
+            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("LINE2:%s%s:%s" % [value[0],color,value[1]])
+            }
+            args << defs
+            args << lines
+            args.flatten!
+            if range 
+                args.push("--start",range[0],"--end",range[1])
+            else
+                args.push("--start", Time.now.to_i - time, "--end", Time.now.to_i)
+            end
+
+            begin
+                RRD.graph(*args)
+            rescue => detail
+                Puppet.err "Failed to graph %s: %s" % [self.name,detail]
+            end
+        end
+    end
+
+    def initialize(name,label = nil)
+        @name = name.to_s
+
+        if label
+            @label = label
+        else
+            @label = name.to_s.capitalize.gsub("_", " ")
+        end
+
+        @values = []
+    end
+
+    def path
+        return File.join(self.basedir, @name + ".rrd")
+    end
+
+    def newvalue(name,value,label = nil)
+        unless label
+            label = name.to_s.capitalize.gsub("_", " ")
+        end
+        @values.push [name,label,value]
+    end
+
+    def store(time)
+        unless Puppet.features.rrd?
+            Puppet.warning "RRD library is missing; cannot store metrics"
+            return
+        end
+        unless FileTest.exists?(self.path)
+            self.create(time - 5)
+        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,arg)
+            #system("rrdtool updatev %s '%s'" % [self.path, arg])
+        rescue => detail
+            raise Puppet::Error, "Failed to update %s: %s" % [self.name,detail]
+        end
+    end
+
+    def values
+        @values.sort { |a, b| a[1] <=> b[1] }
+    end
+end
+
+Puppet::Metric = Puppet::Util::Metric
+
+# $Id: metric.rb 2339 2007-03-21 18:32:09Z luke $

data/lib/puppet/util/package.rb

@@ -0,0 +1,31 @@
+require 'puppet'
+
+module Puppet::Util::Package
+    def versioncmp(version_a, version_b)
+        vre = /[-.]|\d+|[^-.\d]+/
+        ax = version_a.scan(vre)
+        bx = version_b.scan(vre)
+
+        while (ax.length>0 && bx.length>0) do
+            a = ax.shift
+            b = bx.shift
+
+            if( a == b )                 then next
+            elsif (a == '-' && b == '-') then next 
+            elsif (a == '-')             then return -1
+            elsif (b == '-')             then return 1
+            elsif (a == '.' && b == '.') then next 
+            elsif (a == '.' )            then return -1
+            elsif (b == '.' )            then return 1
+            elsif (a =~ /^\d+$/ && b =~ /^\d+$/) then
+                if( a =~ /^0/ or b =~ /^0/ ) then
+                    return a.to_s.upcase <=> b.to_s.upcase
+                end
+                return a.to_i <=> b.to_i
+            else 
+                return a.upcase <=> b.upcase
+            end
+        end
+        return version_a <=> version_b;
+    end
+end

data/lib/puppet/util/pidlock.rb

@@ -0,0 +1,68 @@
+require 'fileutils'
+
+class Puppet::Util::Pidlock
+	attr_reader :lockfile
+	
+	def initialize(lockfile)
+		@lockfile = lockfile
+	end
+	
+	def locked?
+		clear_if_stale
+		File.exists? @lockfile
+	end
+	
+	def mine?
+		Process.pid == lock_pid
+	end
+
+	def anonymous?
+		return false unless File.exists?(@lockfile)
+		File.read(@lockfile) == ""
+	end
+	
+	def lock(opts = {})
+		opts = {:anonymous => false}.merge(opts)
+
+		if locked?
+			mine?
+		else
+			if opts[:anonymous]
+				File.open(@lockfile, 'w') { |fd| true }
+			else
+				File.open(@lockfile, "w") { |fd| fd.write(Process.pid) }
+			end
+			true
+		end
+	end
+	
+	def unlock(opts = {})
+		opts = {:anonymous => false}.merge(opts)
+
+		if mine? or (opts[:anonymous] and anonymous?)
+			File.unlink(@lockfile)
+			true
+		else
+			false
+		end
+	end
+
+	private
+	def lock_pid
+		if File.exists? @lockfile
+			File.read(@lockfile).to_i
+		else
+			nil
+		end
+	end
+
+	def clear_if_stale
+		return if lock_pid.nil?
+		
+		begin
+			Process.kill(0, lock_pid)
+		rescue Errno::ESRCH
+			File.unlink(@lockfile)
+		end
+	end
+end

data/lib/puppet/util/plist.rb

@@ -0,0 +1,24 @@
+#--
+##############################################################
+# Copyright 2006, Ben Bleything <ben@bleything.net> and      #
+# Patrick May <patrick@hexane.org>                           #
+#                                                            #
+# Distributed under the MIT license.                         #
+##############################################################
+#++
+# = Plist
+#
+# This is the main file for plist.  Everything interesting happens in Plist and Plist::Emit.
+
+require 'base64'
+require 'cgi'
+require 'stringio'
+
+require 'puppet/util/plist/generator'
+require 'puppet/util/plist/parser'
+
+module Plist
+  VERSION = '3.0.0'
+end
+
+# $Id: plist.rb 1781 2006-10-16 01:01:35Z luke $

data/lib/puppet/util/plist/generator.rb

@@ -0,0 +1,226 @@
+#--###########################################################
+# Copyright 2006, Ben Bleything <ben@bleything.net> and      #
+# Patrick May <patrick@hexane.org>                           #
+#                                                            #
+# Distributed under the MIT license.                         #
+##############################################################
+#++
+# See Plist::Emit.
+module Plist
+  # === Create a plist
+  # You can dump an object to a plist in one of two ways:
+  #
+  # * <tt>Plist::Emit.dump(obj)</tt>
+  # * <tt>obj.to_plist</tt>
+  #   * This requires that you mixin the <tt>Plist::Emit</tt> module, which is already done for +Array+ and +Hash+.
+  #
+  # The following Ruby classes are converted into native plist types:
+  #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time, true, false
+  # * +Array+ and +Hash+ are both recursive; their elements will be converted into plist nodes inside the <array> and <dict> containers (respectively).
+  # * +IO+ (and its descendants) and +StringIO+ objects are read from and their contents placed in a <data> element.
+  # * User classes may implement +to_plist_node+ to dictate how they should be serialized; otherwise the object will be passed to <tt>Marshal.dump</tt> and the result placed in a <data> element.
+  #
+  # For detailed usage instructions, refer to USAGE[link:files/docs/USAGE.html] and the methods documented below.
+  module Emit
+    # Helper method for injecting into classes.  Calls <tt>Plist::Emit.dump</tt> with +self+.
+    def to_plist(envelope = true)
+      return Plist::Emit.dump(self, envelope)
+    end
+
+    # Helper method for injecting into classes.  Calls <tt>Plist::Emit.save_plist</tt> with +self+.
+    def save_plist(filename)
+      Plist::Emit.save_plist(self, filename)
+    end
+
+    # The following Ruby classes are converted into native plist types:
+    #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time
+    #
+    # Write us (via RubyForge) if you think another class can be coerced safely into one of the expected plist classes.
+    #
+    # +IO+ and +StringIO+ objects are encoded and placed in <data> elements; other objects are <tt>Marshal.dump</tt>'ed unless they implement +to_plist_node+.
+    #
+    # The +envelope+ parameters dictates whether or not the resultant plist fragment is wrapped in the normal XML/plist header and footer.  Set it to false if you only want the fragment.
+    def self.dump(obj, envelope = true)
+      output = plist_node(obj)
+
+      output = wrap(output) if envelope
+
+      return output
+    end
+
+    # Writes the serialized object's plist to the specified filename.
+    def self.save_plist(obj, filename)
+      File.open(filename, 'wb') do |f|
+        f.write(obj.to_plist)
+      end
+    end
+
+    private
+    def self.plist_node(element)
+      output = ''
+
+      if element.respond_to? :to_plist_node
+        output << element.to_plist_node
+      else
+        case element
+        when Array
+          if element.empty?
+            output << "<array/>\n"
+          else
+            output << tag('array') {
+              element.collect {|e| plist_node(e)}
+            }
+          end
+        when Hash
+          if element.empty?
+            output << "<dict/>\n"
+          else
+            inner_tags = []
+
+            element.keys.sort.each do |k|
+              v = element[k]
+              inner_tags << tag('key', CGI::escapeHTML(k.to_s))
+              inner_tags << plist_node(v)
+            end
+
+            output << tag('dict') {
+              inner_tags
+            }
+          end
+        when true, false
+          output << "<#{element}/>\n"
+        when Time
+          output << tag('date', element.utc.strftime('%Y-%m-%dT%H:%M:%SZ'))
+        when Date # also catches DateTime
+          output << tag('date', element.strftime('%Y-%m-%dT%H:%M:%SZ'))
+        when String, Symbol, Fixnum, Bignum, Integer, Float
+          output << tag(element_type(element), CGI::escapeHTML(element.to_s))
+        when IO, StringIO
+          element.rewind
+          contents = element.read
+          # note that apple plists are wrapped at a different length then
+          # what ruby's base64 wraps by default.
+          # I used #encode64 instead of #b64encode (which allows a length arg)
+          # because b64encode is b0rked and ignores the length arg.
+          data = "\n"
+          Base64::encode64(contents).gsub(/\s+/, '').scan(/.{1,68}/o) { data << $& << "\n" }
+          output << tag('data', data)
+        else
+          output << comment( 'The <data> element below contains a Ruby object which has been serialized with Marshal.dump.' )
+          data = "\n"
+          Base64::encode64(Marshal.dump(element)).gsub(/\s+/, '').scan(/.{1,68}/o) { data << $& << "\n" }
+          output << tag('data', data )
+        end
+      end
+
+      return output
+    end
+
+    def self.comment(content)
+      return "<!-- #{content} -->\n"
+    end
+
+    def self.tag(type, contents = '', &block)
+      out = nil
+
+      if block_given?
+        out = IndentedString.new
+        out << "<#{type}>"
+        out.raise_indent
+
+        out << block.call
+
+        out.lower_indent
+        out << "</#{type}>"
+      else
+        out = "<#{type}>#{contents.to_s}</#{type}>\n"
+      end
+
+      return out.to_s
+    end
+
+    def self.wrap(contents)
+      output = ''
+
+      output << '<?xml version="1.0" encoding="UTF-8"?>' + "\n"
+      output << '<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">' + "\n"
+      output << '<plist version="1.0">' + "\n"
+
+      output << contents
+
+      output << '</plist>' + "\n"
+
+      return output
+    end
+
+    def self.element_type(item)
+      return case item
+        when String, Symbol:          'string'
+        when Fixnum, Bignum, Integer: 'integer'
+        when Float:                   'real'
+        else
+          raise "Don't know about this data type... something must be wrong!"
+      end
+    end
+    private
+    class IndentedString #:nodoc:
+      attr_accessor :indent_string
+
+      @@indent_level = 0
+
+      def initialize(str = "\t")
+        @indent_string = str
+        @contents = ''
+      end
+
+      def to_s
+        return @contents
+      end
+
+      def raise_indent
+        @@indent_level += 1
+      end
+
+      def lower_indent
+        @@indent_level -= 1 if @@indent_level > 0
+      end
+
+      def <<(val)
+        if val.is_a? Array
+          val.each do |f|
+            self << f
+          end
+        else
+          # if it's already indented, don't bother indenting further
+          unless val =~ /\A#{@indent_string}/
+            indent = @indent_string * @@indent_level
+
+            @contents << val.gsub(/^/, indent)
+          else
+            @contents << val
+          end
+
+          # it already has a newline, don't add another
+          @contents << "\n" unless val =~ /\n$/
+        end
+      end
+    end
+  end
+end
+
+# we need to add this so sorting hash keys works properly
+class Symbol #:nodoc:
+  def <=> (other)
+    self.to_s <=> other.to_s
+  end
+end
+
+class Array #:nodoc:
+  include Plist::Emit
+end
+
+class Hash #:nodoc:
+  include Plist::Emit
+end
+
+# $Id: generator.rb 1781 2006-10-16 01:01:35Z luke $