puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,203 @@
+# Module Puppet::IniConfig
+# A generic way to parse .ini style files and manipulate them in memory
+# One 'file' can be made up of several physical files. Changes to sections
+# on the file are tracked so that only the physical files in which
+# something has changed are written back to disk
+# Great care is taken to preserve comments and blank lines from the original
+# files
+#
+# The parsing tries to stay close to python's ConfigParser
+
+require 'puppet/util/filetype'
+
+module Puppet::Util::IniConfig
+  # A section in a .ini file
+  class Section
+    attr_reader :name, :file
+
+    def initialize(name, file)
+      @name = name
+      @file = file
+      @dirty = false
+      @entries = []
+    end
+
+    # Has this section been modified since it's been read in
+    # or written back to disk
+    def dirty?
+      @dirty
+    end
+
+    # Should only be used internally
+    def mark_clean
+      @dirty = false
+    end
+
+    # Add a line of text (e.g., a comment) Such lines
+    # will be written back out in exactly the same
+    # place they were read in
+    def add_line(line)
+      @entries << line
+    end
+
+    # Set the entry 'key=value'. If no entry with the
+    # given key exists, one is appended to teh end of the section
+    def []=(key, value)
+      entry = find_entry(key)
+      @dirty = true
+      if entry.nil?
+        @entries << [key, value]
+      else
+        entry[1] = value
+      end
+    end
+
+    # Return the value associated with KEY. If no such entry
+    # exists, return nil
+    def [](key)
+      entry = find_entry(key)
+      return(entry.nil? ? nil : entry[1])
+    end
+
+    # Format the section as text in the way it should be
+    # written to file
+    def format
+      text = "[#{name}]\n"
+      @entries.each do |entry|
+        if entry.is_a?(Array)
+          key, value = entry
+          text << "#{key}=#{value}\n" unless value.nil?
+        else
+          text << entry
+        end
+      end
+      text
+    end
+
+    private
+    def find_entry(key)
+      @entries.each do |entry|
+        return entry if entry.is_a?(Array) && entry[0] == key
+      end
+      nil
+    end
+
+  end
+
+  # A logical .ini-file that can be spread across several physical
+  # files. For each physical file, call #read with the filename
+  class File
+    def initialize
+      @files = {}
+    end
+
+    # Add the contents of the file with name FILE to the
+    # already existing sections
+    def read(file)
+      text = Puppet::Util::FileType.filetype(:flat).new(file).read
+      raise "Could not find #{file}" if text.nil?
+
+      section = nil   # The name of the current section
+      optname = nil   # The name of the last option in section
+      line = 0
+      @files[file] = []
+      text.each_line do |l|
+        line += 1
+        if l.strip.empty? || "#;".include?(l[0,1]) ||
+            (l.split(nil, 2)[0].downcase == "rem" && l[0,1].downcase == "r")
+          # Whitespace or comment
+          if section.nil?
+            @files[file] << l
+          else
+            section.add_line(l)
+          end
+        elsif " \t\r\n\f".include?(l[0,1]) && section && optname
+          # continuation line
+          section[optname] += "\n#{l.chomp}"
+        elsif l =~ /^\[([^\]]+)\]/
+          # section heading
+          section.mark_clean unless section.nil?
+          section = add_section($1, file)
+          optname = nil
+        elsif l =~ /^\s*([^\s=]+)\s*\=(.*)$/
+          # We allow space around the keys, but not the values
+          # For the values, we don't know if space is significant
+          if section.nil?
+            raise "#{file}:#{line}:Key/value pair outside of a section for key #{$1}"
+          else
+            section[$1] = $2
+            optname = $1
+          end
+        else
+          raise "#{file}:#{line}: Can't parse '#{l.chomp}'"
+        end
+      end
+      section.mark_clean unless section.nil?
+    end
+
+    # Store all modifications made to sections in this file back
+    # to the physical files. If no modifications were made to
+    # a physical file, nothing is written
+    def store
+      @files.each do |file, lines|
+        text = ""
+        dirty = false
+        lines.each do |l|
+          if l.is_a?(Section)
+            dirty ||= l.dirty?
+            text << l.format
+            l.mark_clean
+          else
+            text << l
+          end
+        end
+        if dirty
+          Puppet::Util::FileType.filetype(:flat).new(file).write(text)
+          return file
+        end
+      end
+    end
+
+    # Execute BLOCK, passing each section in this file
+    # as an argument
+    def each_section(&block)
+      @files.each do |file, list|
+        list.each do |entry|
+          yield(entry) if entry.is_a?(Section)
+        end
+      end
+    end
+
+    # Execute BLOCK, passing each file constituting this inifile
+    # as an argument
+    def each_file(&block)
+      @files.keys.each do |file|
+        yield(file)
+      end
+    end
+
+    # Return the Section with the given name or nil
+    def [](name)
+      name = name.to_s
+      each_section do |section|
+        return section if section.name == name
+      end
+      nil
+    end
+
+    # Return true if the file contains a section with name NAME
+    def include?(name)
+      ! self[name].nil?
+    end
+
+    # Add a section to be stored in FILE when store is called
+    def add_section(name, file)
+      raise "A section with name #{name} already exists" if include?(name)
+      result = Section.new(name, file)
+      @files[file] ||= []
+      @files[file] << result
+      result
+    end
+  end
+end
+

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

@@ -0,0 +1,26 @@
+module Puppet::Util::InlineDocs
+  def self.included(klass)
+    klass.send(:include, InstanceMethods)
+    klass.extend ClassMethods
+  end
+
+  module ClassMethods
+    attr_accessor :use_docs
+    def associates_doc
+      self.use_docs = true
+    end
+  end
+
+  module InstanceMethods
+    attr_writer :doc
+
+    def doc
+      @doc ||= ""
+    end
+
+    # don't fetch lexer comment by default
+    def use_docs
+      self.class.use_docs
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'puppet/util/autoload'
+require 'puppet/util'
+
+# A module that can easily autoload things for us.  Uses an instance
+# of Puppet::Util::Autoload
+module Puppet::Util::InstanceLoader
+  include Puppet::Util
+
+  # Are we instance-loading this type?
+  def instance_loading?(type)
+    defined?(@autoloaders) and @autoloaders.include?(type.intern)
+  end
+
+  # Define a new type of autoloading.
+  def instance_load(type, path, options = {})
+    @autoloaders ||= {}
+    @instances ||= {}
+    type = type.intern
+    @instances[type] = {}
+    @autoloaders[type] = Puppet::Util::Autoload.new(self, path, options)
+
+    # Now define our new simple methods
+    unless respond_to?(type)
+      meta_def(type) do |name|
+        loaded_instance(type, name)
+      end
+    end
+  end
+
+  # Return a list of the names of all instances
+  def loaded_instances(type)
+    @instances[type].keys
+  end
+
+  # Collect the docs for all of our instances.
+  def instance_docs(type)
+    docs = ""
+
+    # Load all instances.
+    instance_loader(type).loadall
+
+    # Use this method so they all get loaded
+    loaded_instances(type).sort { |a,b| a.to_s <=> b.to_s }.each do |name|
+      mod = self.loaded_instance(name)
+      docs += "#{name}\n#{"-" * name.to_s.length}\n"
+
+      docs += Puppet::Util::Docs.scrub(mod.doc) + "\n\n"
+    end
+
+    docs
+  end
+
+  # Return the instance hash for our type.
+  def instance_hash(type)
+    @instances[type.intern]
+  end
+
+  # Return the Autoload object for a given type.
+  def instance_loader(type)
+    @autoloaders[type.intern]
+  end
+
+  # Retrieve an alread-loaded instance, or attempt to load our instance.
+  def loaded_instance(type, name)
+    name = name.intern
+    return nil unless instances = instance_hash(type)
+    unless instances.include? name
+      if instance_loader(type).load(name)
+        unless instances.include? name
+          Puppet.warning(
+            "Loaded #{type} file for #{name} but #{type} was not defined"
+          )
+          return nil
+        end
+      else
+        return nil
+      end
+    end
+    instances[name]
+  end
+end

data/lib/vendor/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/vendor/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/vendor/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/vendor/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/vendor/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/vendor/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