puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,186 @@
+# included so we can test object types
+require 'puppet'
+
+# A class for handling metrics.  This is currently ridiculously hackish.
+class Puppet::Util::Metric
+
+  attr_accessor :type, :name, :value, :label
+  attr_writer :values
+
+  attr_writer :basedir
+
+  # Return a specific value
+  def [](name)
+    if value = @values.find { |v| v[0] == name }
+      return value[2]
+    else
+      return 0
+    end
+  end
+
+  def basedir
+    if defined?(@basedir)
+      @basedir
+    else
+      Puppet[:rrddir]
+    end
+  end
+
+  def create(start = nil)
+    Puppet.settings.use(:main, :metrics)
+
+    start ||= Time.now.to_i - 5
+
+    args = []
+
+    if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
+      @rrd = RRDtool.new(self.path)
+    end
+
+    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:#{value[0]}:GAUGE:7200:U:U"
+    }
+    args.push "RRA:AVERAGE:0.5:1:300"
+
+    begin
+      if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
+        @rrd.create( Puppet[:rrdinterval].to_i, start, args)
+      else
+        RRD.create( self.path, '-s', Puppet[:rrdinterval].to_i.to_s, '-b', start.to_i.to_s, *args)
+      end
+    rescue => detail
+      raise "Could not create RRD file #{path}: #{detail}"
+    end
+  end
+
+  def dump
+    if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
+      puts @rrd.info
+    else
+      puts RRD.info(self.path)
+    end
+  end
+
+  def graph(range = nil)
+    unless Puppet.features.rrd? || Puppet.features.rrd_legacy?
+      Puppet.warning "RRD library is missing; cannot graph metrics"
+      return
+    end
+
+    unit = 60 * 60 * 24
+    colorstack = %w{#00ff00 #ff0000 #0000ff #ffff00 #ff99ff #ff9966 #66ffff #990000 #099000 #000990 #f00990 #0f0f0f #555555 #333333 #ffffff}
+
+    {:daily => unit, :weekly => unit * 7, :monthly => unit * 30, :yearly => unit * 365}.each do |name, time|
+      file = self.path.sub(/\.rrd$/, "-#{name}.png")
+      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:#{value[0]}=#{self.path}:#{value[0]}:AVERAGE")
+        lines.push("LINE2:#{value[0]}#{color}:#{value[1]}")
+      }
+      args << defs
+      args << lines
+      args.flatten!
+      if range
+        if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
+          args.push("--start",range[0],"--end",range[1])
+        else
+          args.push("--start",range[0].to_i.to_s,"--end",range[1].to_i.to_s)
+        end
+      else
+        if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
+          args.push("--start", Time.now.to_i - time, "--end", Time.now.to_i)
+        else
+          args.push("--start", (Time.now.to_i - time).to_s, "--end", Time.now.to_i.to_s)
+        end
+      end
+
+      begin
+        #Puppet.warning "args = #{args}"
+        if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
+          RRDtool.graph( args )
+        else
+          RRD.graph( *args )
+        end
+      rescue => detail
+        Puppet.err "Failed to graph #{self.name}: #{detail}"
+      end
+    end
+  end
+
+  def initialize(name,label = nil)
+    @name = name.to_s
+
+    @label = label || self.class.labelize(name)
+
+    @values = []
+  end
+
+  def path
+    File.join(self.basedir, @name + ".rrd")
+  end
+
+  def newvalue(name,value,label = nil)
+    raise ArgumentError.new("metric name #{name.inspect} is not a string") unless name.is_a? String
+    label ||= self.class.labelize(name)
+    @values.push [name,label,value]
+  end
+
+  def store(time)
+    unless Puppet.features.rrd? || Puppet.features.rrd_legacy?
+      Puppet.warning "RRD library is missing; cannot store metrics"
+      return
+    end
+    self.create(time - 5) unless FileTest.exists?(self.path)
+
+    if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
+      @rrd ||= RRDtool.new(self.path)
+    end
+
+    # XXX this is not terribly error-resistant
+    args = [time]
+    temps = []
+    values.each { |value|
+      #Puppet.warning "value[0]: #{value[0]}; value[1]: #{value[1]}; value[2]: #{value[2]}; "
+      args.push value[2]
+      temps.push value[0]
+    }
+    arg = args.join(":")
+    template = temps.join(":")
+    begin
+      if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
+        @rrd.update( template, [ arg ] )
+      else
+        RRD.update( self.path, '-t', template, arg )
+      end
+      #system("rrdtool updatev #{self.path} '#{arg}'")
+    rescue => detail
+      raise Puppet::Error, "Failed to update #{self.name}: #{detail}"
+    end
+  end
+
+  def values
+    @values.sort { |a, b| a[1] <=> b[1] }
+  end
+
+  # Convert a name into a label.
+  def self.labelize(name)
+    name.to_s.capitalize.gsub("_", " ")
+  end
+end
+
+# This is necessary because we changed the class path in early 2007,
+# and reports directly yaml-dump these metrics, so both client and server
+# have to agree on the class name.
+Puppet::Metric = Puppet::Util::Metric

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

@@ -0,0 +1,243 @@
+
+unless defined? JRUBY_VERSION
+  Process.maxgroups = 1024
+end
+
+module RDoc
+  def self.caller(skip=nil)
+    in_gem_wrapper = false
+    Kernel.caller.reject { |call|
+      in_gem_wrapper ||= call =~ /#{Regexp.escape $0}:\d+:in `load'/
+    }
+  end
+end
+
+
+require "yaml"
+require "puppet/util/zaml.rb"
+
+class Symbol
+  def <=> (other)
+    self.to_s <=> other.to_s
+  end unless method_defined? '<=>'
+
+  def intern
+    self
+  end unless method_defined? 'intern'
+end
+
+[Object, Exception, Integer, Struct, Date, Time, Range, Regexp, Hash, Array, Float, String, FalseClass, TrueClass, Symbol, NilClass, Class].each { |cls|
+  cls.class_eval do
+    def to_yaml(ignored=nil)
+      ZAML.dump(self)
+    end
+  end
+}
+
+def YAML.dump(*args)
+  ZAML.dump(*args)
+end
+
+#
+# Workaround for bug in MRI 1.8.7, see
+#     http://redmine.ruby-lang.org/issues/show/2708
+# for details
+#
+if RUBY_VERSION == '1.8.7'
+  class NilClass
+    def closed?
+      true
+    end
+  end
+end
+
+class Object
+  # ActiveSupport 2.3.x mixes in a dangerous method
+  # that can cause rspec to fork bomb
+  # and other strange things like that.
+  def daemonize
+    raise NotImplementedError, "Kernel.daemonize is too dangerous, please don't try to use it."
+  end
+
+  # The following code allows callers to make assertions that are only
+  # checked when the environment variable PUPPET_ENABLE_ASSERTIONS is
+  # set to a non-empty string.  For example:
+  #
+  #   assert_that { condition }
+  #   assert_that(message) { condition }
+  if ENV["PUPPET_ENABLE_ASSERTIONS"].to_s != ''
+    def assert_that(message = nil)
+      unless yield
+        raise Exception.new("Assertion failure: #{message}")
+      end
+    end
+  else
+    def assert_that(message = nil)
+    end
+  end
+end
+
+# Workaround for yaml_initialize, which isn't supported before Ruby
+# 1.8.3.
+if RUBY_VERSION == '1.8.1' || RUBY_VERSION == '1.8.2'
+  YAML.add_ruby_type( /^object/ ) { |tag, val|
+    type, obj_class = YAML.read_type_class( tag, Object )
+    r = YAML.object_maker( obj_class, val )
+    if r.respond_to? :yaml_initialize
+      r.instance_eval { instance_variables.each { |name| remove_instance_variable name } }
+      r.yaml_initialize(tag, val)
+    end
+    r
+  }
+end
+
+class Fixnum
+  # Returns the int itself. This method is intended for compatibility to
+  # character constant in Ruby 1.9.  1.8.5 is missing it; add it.
+  def ord
+    self
+  end unless method_defined? 'ord'
+end
+
+class Array
+  # Ruby < 1.8.7 doesn't have this method but we use it in tests
+  def combination(num)
+    return [] if num < 0 || num > size
+    return [[]] if num == 0
+    return map{|e| [e] } if num == 1
+    tmp = self.dup
+    self[0, size - (num - 1)].inject([]) do |ret, e|
+      tmp.shift
+      ret += tmp.combination(num - 1).map{|a| a.unshift(e) }
+    end
+  end unless method_defined? :combination
+
+  alias :count :length unless method_defined? :count
+end
+
+
+class Symbol
+  # So, it turns out that one of the biggest memory allocation hot-spots in
+  # our code was using symbol-to-proc - because it allocated a new instance
+  # every time it was called, rather than caching.
+  #
+  # Changing this means we can see XX memory reduction...
+  if method_defined? :to_proc
+    alias __original_to_proc to_proc
+    def to_proc
+      @my_proc ||= __original_to_proc
+    end
+  else
+    def to_proc
+      @my_proc ||= Proc.new {|*args| args.shift.__send__(self, *args) }
+    end
+  end
+
+  # Defined in 1.9, absent in 1.8, and used for compatibility in various
+  # places, typically in third party gems.
+  def intern
+    return self
+  end unless method_defined? :intern
+end
+
+
+class String
+  def lines(separator = $/)
+    lines = split(separator)
+    block_given? and lines.each {|line| yield line }
+    lines
+  end
+end
+
+class IO
+  def lines(separator = $/)
+    lines = split(separator)
+    block_given? and lines.each {|line| yield line }
+    lines
+  end
+
+  def self.binread(name, length = nil, offset = 0)
+    File.open(name, 'rb') do |f|
+      f.seek(offset) if offset > 0
+      f.read(length)
+    end
+  end unless singleton_methods.include?(:binread)
+
+  def self.binwrite(name, string, offset = 0)
+    File.open(name, 'wb') do |f|
+      f.write(offset > 0 ? string[offset..-1] : string)
+    end
+  end unless singleton_methods.include?(:binwrite)
+
+end
+
+class Range
+  def intersection(other)
+    raise ArgumentError, 'value must be a Range' unless other.kind_of?(Range)
+    return unless other === self.first || self === other.first
+
+    start = [self.first, other.first].max
+    if self.exclude_end? && self.last <= other.last
+      start ... self.last
+    elsif other.exclude_end? && self.last >= other.last
+      start ... other.last
+    else
+      start .. [ self.last, other.last ].min
+    end
+  end unless method_defined? :intersection
+
+  alias_method :&, :intersection unless method_defined? :&
+end
+
+# Ruby 1.8.5 doesn't have tap
+module Kernel
+  def tap
+    yield(self)
+    self
+  end unless method_defined?(:tap)
+end
+
+# The mv method in Ruby 1.8.5 can't mv directories across devices
+# File.rename causes "Invalid cross-device link", which is rescued, but in Ruby
+# 1.8.5 it tries to recover with a copy and unlink, but the unlink causes the
+# error "Is a directory".  In newer Rubies remove_entry is used
+# The implementation below is what's used in Ruby 1.8.7 and Ruby 1.9
+if RUBY_VERSION == '1.8.5'
+  require 'fileutils'
+
+  module FileUtils
+    def mv(src, dest, options = {})
+      fu_check_options options, OPT_TABLE['mv']
+      fu_output_message "mv#{options[:force] ? ' -f' : ''} #{[src,dest].flatten.join ' '}" if options[:verbose]
+      return if options[:noop]
+      fu_each_src_dest(src, dest) do |s, d|
+        destent = Entry_.new(d, nil, true)
+        begin
+          if destent.exist?
+            if destent.directory?
+              raise Errno::EEXIST, dest
+            else
+              destent.remove_file if rename_cannot_overwrite_file?
+            end
+          end
+          begin
+            File.rename s, d
+          rescue Errno::EXDEV
+            copy_entry s, d, true
+            if options[:secure]
+              remove_entry_secure s, options[:force]
+            else
+              remove_entry s, options[:force]
+            end
+          end
+        rescue SystemCallError
+          raise unless options[:force]
+        end
+      end
+    end
+    module_function :mv
+
+    alias move mv
+    module_function :move
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'puppet/external/nagios'
+require 'puppet/external/nagios/base'
+require 'puppet/provider/naginator'
+
+module Puppet::Util::NagiosMaker
+  # Create a new nagios type, using all of the parameters
+  # from the parser.
+  def self.create_nagios_type(name)
+    name = name.to_sym
+    full_name = ("nagios_#{name}").to_sym
+
+    raise(Puppet::DevError, "No nagios type for #{name}") unless nagtype = Nagios::Base.type(name)
+
+    type = Puppet::Type.newtype(full_name) {}
+
+    type.ensurable
+
+    type.newparam(nagtype.namevar, :namevar => true) do
+      desc "The name of this nagios_#{nagtype.name} resource."
+    end
+
+    # We deduplicate the parameters because it makes sense to allow Naginator to have dupes.
+    nagtype.parameters.uniq.each do |param|
+      next if param == nagtype.namevar
+
+      # We can't turn these parameter names into constants, so at least for now they aren't
+      # supported.
+      next if param.to_s =~ /^[0-9]/
+
+      type.newproperty(param) do
+        desc "Nagios configuration file parameter."
+      end
+    end
+
+    type.newproperty(:target) do
+      desc 'The target.'
+
+      defaultto do
+        resource.class.defaultprovider.default_target
+      end
+    end
+
+    target = "/etc/nagios/#{full_name.to_s}.cfg"
+    provider = type.provide(:naginator, :parent => Puppet::Provider::Naginator, :default_target => target) {}
+    provider.nagios_type
+
+    type.desc "The Nagios type #{name.to_s}.  This resource type is autogenerated using the
+      model developed in Naginator, and all of the Nagios types are generated using the
+      same code and the same library.
+
+      This type generates Nagios configuration statements in Nagios-parseable configuration
+      files.  By default, the statements will be added to `#{target}`, but
+      you can send them to a different file by setting their `target` attribute.
+
+      You can purge Nagios resources using the `resources` type, but *only*
+      in the default file locations.  This is an architectural limitation.
+
+    "
+  end
+end

data/lib/vendor/puppet/util/network_device/base.rb

@@ -0,0 +1,27 @@
+require 'puppet/util/autoload'
+require 'uri'
+require 'puppet/util/network_device/transport'
+require 'puppet/util/network_device/transport/base'
+
+class Puppet::Util::NetworkDevice::Base
+
+  attr_accessor :url, :transport
+
+  def initialize(url)
+    @url = URI.parse(url)
+
+    @autoloader = Puppet::Util::Autoload.new(
+      self,
+      "puppet/util/network_device/transport",
+      :wrap => false
+    )
+
+    if @autoloader.load(@url.scheme)
+      @transport = Puppet::Util::NetworkDevice::Transport.const_get(@url.scheme.capitalize).new
+      @transport.host = @url.host
+      @transport.port = @url.port || case @url.scheme ; when "ssh" ; 22 ; when "telnet" ; 23 ; end
+      @transport.user = @url.user
+      @transport.password = @url.password
+    end
+  end
+end