puppet 2.7.9 → 2.7.11

data/lib/puppet/util/instrumentation/data.rb

@@ -0,0 +1,34 @@
+require 'puppet/indirector'
+require 'puppet/util/instrumentation'
+
+# This is just a transport class to be used through the instrumentation_data
+# indirection. All the data resides in the real underlying listeners which this
+# class delegates to.
+class Puppet::Util::Instrumentation::Data
+  extend Puppet::Indirector
+
+  indirects :instrumentation_data, :terminus_class => :local
+
+  attr_reader :listener
+
+  def initialize(listener_name)
+    @listener = Puppet::Util::Instrumentation[listener_name]
+    raise "Listener #{listener_name} wasn't registered" unless @listener
+  end
+
+  def name
+    @listener.name
+  end
+
+  def to_pson(*args)
+    result = {
+      'document_type' => "Puppet::Util::Instrumentation::Data",
+      'data' => { :name => name }.merge(@listener.respond_to?(:data) ? @listener.data : {})
+    }
+    result.to_pson(*args)
+  end
+
+  def self.from_pson(data)
+    data
+  end
+end

data/lib/puppet/util/instrumentation/indirection_probe.rb

@@ -0,0 +1,29 @@
+require 'puppet/indirector'
+require 'puppet/util/instrumentation'
+
+# We need to use a class other than Probe for the indirector because
+# the Indirection class might declare some probes, and this would be a huge unbreakable
+# dependency cycle.
+class Puppet::Util::Instrumentation::IndirectionProbe
+  extend Puppet::Indirector
+
+  indirects :instrumentation_probe, :terminus_class => :local
+
+  attr_reader :probe_name
+
+  def initialize(probe_name)
+    @probe_name = probe_name
+  end
+
+  def to_pson(*args)
+    result = {
+      :document_type => "Puppet::Util::Instrumentation::IndirectionProbe",
+      :data => { :name => probe_name }
+    }
+    result.to_pson(*args)
+  end
+
+  def self.from_pson(data)
+    self.new(data["name"])
+  end
+end

data/lib/puppet/util/instrumentation/instrumentable.rb

@@ -0,0 +1,143 @@
+require 'monitor'
+require 'puppet/util/instrumentation'
+
+# This is the central point of all declared probes.
+# Every class needed to declare probes should include this module
+# and declare the methods that are subject to instrumentation:
+#
+#   class MyClass
+#     extend Puppet::Util::Instrumentation::Instrumentable
+#
+#     probe :mymethod
+#
+#     def mymethod
+#       ... this is code to be instrumented ...
+#     end
+#   end
+module Puppet::Util::Instrumentation::Instrumentable
+  INSTRUMENTED_CLASSES = {}.extend(MonitorMixin)
+
+  attr_reader :probes
+
+  class Probe
+    attr_reader :klass, :method, :label, :data
+
+    def initialize(method, klass, options = {})
+      @method = method
+      @klass = klass
+
+      @label = options[:label] || method
+      @data = options[:data] || {}
+    end
+
+    def enable
+      raise "Probe already enabled" if enabled?
+
+      # We're forced to perform this copy because in the class_eval'uated
+      # block below @method would be evaluated in the class context. It's better
+      # to close on locally-scoped variables than to resort to complex namespacing
+      # to get access to the probe instance variables.
+      method = @method; label = @label; data = @data
+      klass.class_eval {
+        alias_method("instrumented_#{method}", method)
+        define_method(method) do |*args|
+          id = nil
+          instrumentation_data = nil
+          begin
+            instrumentation_label = label.respond_to?(:call) ? label.call(self, args) : label
+            instrumentation_data = data.respond_to?(:call) ? data.call(self, args) : data
+            id = Puppet::Util::Instrumentation.start(instrumentation_label, instrumentation_data)
+            send("instrumented_#{method}".to_sym, *args)
+          ensure
+            Puppet::Util::Instrumentation.stop(instrumentation_label, id, instrumentation_data || {})
+          end
+        end
+      }
+      @enabled = true
+    end
+
+    def disable
+      raise "Probe is not enabled" unless enabled?
+
+      # For the same reason as in #enable, we're forced to do a local
+      # copy
+      method = @method
+      klass.class_eval do
+        alias_method(method, "instrumented_#{method}")
+        remove_method("instrumented_#{method}".to_sym)
+      end
+      @enabled = false
+    end
+
+    def enabled?
+      !!@enabled
+    end
+  end
+
+  # Declares a new probe
+  #
+  # It is possible to pass several options that will be later on evaluated
+  # and sent to the instrumentation layer.
+  #
+  # label::
+  #   this can either be a static symbol/string or a block. If it's a block
+  #   this one will be evaluated on every call of the instrumented method and
+  #   should return a string or a symbol
+  #   
+  # data::
+  #   this can be a hash or a block. If it's a block this one will be evaluated
+  #   on every call of the instrumented method and should return a hash.
+  # 
+  #Example:
+  #
+  #   class MyClass
+  #     extend Instrumentable
+  #
+  #     probe :mymethod, :data => Proc.new { |args|  { :data => args[1] } }, :label => Proc.new { |args| args[0] }
+  #
+  #     def mymethod(name, options)
+  #     end
+  #
+  #   end
+  #
+  def probe(method, options = {})
+    INSTRUMENTED_CLASSES.synchronize {
+      (@probes ||= []) << Probe.new(method, self, options)
+      INSTRUMENTED_CLASSES[self] = @probes
+    }
+  end
+
+  def self.probes
+    @probes
+  end
+
+  def self.probe_names
+    probe_names = []
+    each_probe { |probe| probe_names << "#{probe.klass}.#{probe.method}" }
+    probe_names
+  end
+
+  def self.enable_probes
+    each_probe { |probe| probe.enable }
+  end
+
+  def self.disable_probes
+    each_probe { |probe| probe.disable }
+  end
+
+  def self.clear_probes
+    INSTRUMENTED_CLASSES.synchronize {
+      INSTRUMENTED_CLASSES.clear
+    }
+    nil # do not leak our probes to the exterior world
+  end
+
+  def self.each_probe
+    INSTRUMENTED_CLASSES.synchronize {
+      INSTRUMENTED_CLASSES.each_key do |klass|
+        klass.probes.each { |probe| yield probe }
+      end
+    }
+    nil # do not leak our probes to the exterior world
+  end
+end

data/lib/puppet/util/instrumentation/listener.rb

@@ -0,0 +1,60 @@
+require 'puppet/indirector'
+require 'puppet/util/instrumentation'
+require 'puppet/util/instrumentation/data'
+
+class Puppet::Util::Instrumentation::Listener
+  include Puppet::Util
+  include Puppet::Util::Warnings
+  extend Puppet::Indirector
+
+  indirects :instrumentation_listener, :terminus_class => :local
+
+  attr_reader :pattern, :listener
+  attr_accessor :enabled
+
+  def initialize(listener, pattern = nil, enabled = false)
+    @pattern = pattern.is_a?(Symbol) ? pattern.to_s : pattern
+    raise "Listener isn't a correct listener (it doesn't provide the notify method)" unless listener.respond_to?(:notify)
+    @listener = listener
+    @enabled = enabled
+  end
+
+  def notify(label, event, data)
+    listener.notify(label, event, data)
+  rescue => e
+    warnonce("Error during instrumentation notification: #{e}")
+  end
+
+  def listen_to?(label)
+    enabled? and (!@pattern || @pattern === label.to_s)
+  end
+
+  def enabled?
+    !!@enabled
+  end
+
+  def name
+    @listener.name.to_s
+  end
+
+  def data
+    { :data => @listener.data }
+  end
+
+  def to_pson(*args)
+    result = {
+      :document_type => "Puppet::Util::Instrumentation::Listener",
+      :data => {
+        :name => name,
+        :pattern => pattern,
+        :enabled => enabled?
+      }
+    }
+    result.to_pson(*args)
+  end
+
+  def self.from_pson(data)
+    result = Puppet::Util::Instrumentation[data["name"]]
+    self.new(result.listener, result.pattern, data["enabled"])
+  end
+end

data/lib/puppet/util/instrumentation/listeners/log.rb

@@ -0,0 +1,29 @@
+require 'monitor'
+
+# This is an example instrumentation listener that stores the last
+# 20 instrumented probe run time.
+Puppet::Util::Instrumentation.new_listener(:log) do
+
+  SIZE = 20
+
+  attr_accessor :last_logs
+
+  def initialize
+    @last_logs = {}.extend(MonitorMixin)
+  end
+
+  def notify(label, event, data)
+    return if event == :start
+    log_line = "#{label} took #{data[:finished] - data[:started]}"
+    @last_logs.synchronize {
+      (@last_logs[label] ||= []) << log_line
+      @last_logs[label].shift if @last_logs[label].length > SIZE
+    }
+  end
+
+  def data
+    @last_logs.synchronize {
+      @last_logs.dup
+    }
+  end
+end

data/lib/puppet/util/instrumentation/listeners/performance.rb

@@ -0,0 +1,30 @@
+require 'monitor'
+
+Puppet::Util::Instrumentation.new_listener(:performance) do
+
+  attr_reader :samples
+
+  def initialize
+    @samples = {}.extend(MonitorMixin)
+  end
+
+  def notify(label, event, data)
+    return if event == :start
+
+    duration = data[:finished] - data[:started]
+    samples.synchronize do
+      @samples[label] ||= { :count => 0, :max => 0, :min => nil, :sum => 0, :average => 0 }
+      @samples[label][:count] += 1
+      @samples[label][:sum] += duration
+      @samples[label][:max] = [ @samples[label][:max], duration ].max
+      @samples[label][:min] = [ @samples[label][:min], duration ].reject { |val| val.nil? }.min
+      @samples[label][:average] = @samples[label][:sum] / @samples[label][:count]
+    end
+  end
+
+  def data
+    samples.synchronize do
+      @samples.dup
+    end
+  end
+end

data/lib/puppet/util/monkey_patches.rb

@@ -130,3 +130,11 @@ class IO
     lines
   end
 end
+
+# Ruby 1.8.5 doesn't have tap
+module Kernel
+  def tap
+    yield(self)
+    self
+  end unless method_defined?(:tap)
+end

data/lib/puppet/util/pidlock.rb

@@ -1,11 +1,7 @@
 require 'fileutils'
+require 'puppet/util/anonymous_filelock'
 
-class Puppet::Util::Pidlock
-  attr_reader :lockfile
-
-  def initialize(lockfile)
-    @lockfile = lockfile
-  end
+class Puppet::Util::Pidlock < Puppet::Util::AnonymousFilelock
 
   def locked?
     clear_if_stale
@@ -17,37 +13,36 @@ class Puppet::Util::Pidlock
   end
 
   def anonymous?
-    return false unless File.exists?(@lockfile)
-    File.read(@lockfile) == ""
+    false
   end
 
-  def lock(opts = {})
-    opts = {:anonymous => false}.merge(opts)
+  def lock
+    return mine? if locked?
 
-    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
+    File.open(@lockfile, "w") { |fd| fd.write(Process.pid) }
+    true
   end
 
   def unlock(opts = {})
-    opts = {:anonymous => false}.merge(opts)
-
-    if mine? or (opts[:anonymous] and anonymous?)
-      File.unlink(@lockfile)
+    if mine?
+      begin
+        File.unlink(@lockfile)
+      rescue Errno::ENOENT
+        # Someone deleted it for us ...and so we do nothing.  No point whining
+        # about a problem that the user can't actually do anything about.
+      rescue SystemCallError => e
+        # This one is a real failure though.  No idea what went wrong, but it
+        # is most likely "read only file(system)" or wrong permissions or
+        # something like that.
+        Puppet.err "Could not remove PID file #{@lockfile}: #{e}"
+        puts e.backtrace if Puppet[:trace]
+      end
       true
     else
       false
     end
   end
 
-  private
   def lock_pid
     if File.exists? @lockfile
       File.read(@lockfile).to_i
@@ -56,6 +51,7 @@ class Puppet::Util::Pidlock
     end
   end
 
+  private
   def clear_if_stale
     return if lock_pid.nil?
 

data/lib/puppet/util/rdoc/parser.rb

@@ -99,7 +99,7 @@ class Parser
       modpath = $1
       name = $2
       Puppet.debug "rdoc: module #{name} into #{modpath} ?"
-      Puppet::Module.modulepath.each do |mp|
+      Puppet::Node::Environment.new.modulepath.each do |mp|
         if File.identical?(modpath,mp)
           Puppet.debug "rdoc: found module #{name}"
           return name
@@ -110,7 +110,7 @@ class Parser
       # there can be paths we don't want to scan under modules
       # imagine a ruby or manifest that would be distributed as part as a module
       # but we don't want those to be hosted under <site>
-      Puppet::Module.modulepath.each do |mp|
+      Puppet::Node::Environment.new.modulepath.each do |mp|
         # check that fullpath is a descendant of mp
         dirname = fullpath
         previous = dirname

data/lib/puppet/util/reference.rb

@@ -36,14 +36,15 @@ class Puppet::Util::Reference
 
   def self.pdf(text)
     puts "creating pdf"
-    Puppet::Util.secure_open("/tmp/puppetdoc.txt", "w") do |f|
-      f.puts text
-    end
-    rst2latex = which('rst2latex') || which('rst2latex.py') || raise("Could not find rst2latex")
+    rst2latex = which('rst2latex') || which('rst2latex.py') ||
+      raise("Could not find rst2latex")
+
     cmd = %{#{rst2latex} /tmp/puppetdoc.txt > /tmp/puppetdoc.tex}
-    Puppet::Util.secure_open("/tmp/puppetdoc.tex","w") do |f|
-      # If we get here without an error, /tmp/puppetdoc.tex isn't a tricky cracker's symlink
-    end
+    Puppet::Util.replace_file("/tmp/puppetdoc.txt") {|f| f.puts text }
+    # There used to be an attempt to use secure_open / replace_file to secure
+    # the target, too, but that did nothing: the race was still here.  We can
+    # get exactly the same benefit from running this effort:
+    File.unlink('/tmp/puppetdoc.tex') rescue nil
     output = %x{#{cmd}}
     unless $CHILD_STATUS == 0
       $stderr.puts "rst2latex failed"
@@ -64,8 +65,6 @@ class Puppet::Util::Reference
     loaded_instances(:reference).sort { |a,b| a.to_s <=> b.to_s }
   end
 
-  HEADER_LEVELS = [nil, "#", "##", "###", "####", "#####"]
-
   attr_accessor :page, :depth, :header, :title, :dynamic
   attr_writer :doc
 
@@ -81,20 +80,6 @@ class Puppet::Util::Reference
     self.dynamic
   end
 
-  def markdown_header(name, level)
-    "#{HEADER_LEVELS[level]} #{name}\n\n"
-  end
-
-  def markdown_definitionlist(term, definition)
-    lines = definition.split("\n")
-    str = "#{term}\n: #{lines.shift}\n"
-    lines.each do |line|
-      str << "    " if line =~ /\S/
-      str << "#{line}\n"
-    end
-    str << "\n"
-  end
-
   def initialize(name, options = {}, &block)
     @name = name
     options.each do |option, value|