puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/reference/report.rb

@@ -0,0 +1,23 @@
+require 'puppet/reports'
+
+report = Puppet::Util::Reference.newreference :report, :doc => "All available transaction reports" do
+  Puppet::Reports.reportdocs
+end
+
+report.header = "
+Puppet clients can report back to the server after each transaction.  This
+transaction report is sent as a YAML dump of the
+`Puppet::Transaction::Report` class and includes every log message that was
+generated during the transaction along with as many metrics as Puppet knows how
+to collect.  See [Reports and Reporting](http://projects.puppetlabs.com/projects/puppet/wiki/Reports_And_Reporting) for more information on how to use reports.
+
+Currently, clients default to not sending in reports; you can enable reporting
+by setting the `report` parameter to true.
+
+To use a report, set the `reports` parameter on the server; multiple
+reports must be comma-separated.  You can also specify `none` to disable
+reports entirely.
+
+Puppet provides multiple report handlers that will process client reports:
+
+"

data/lib/vendor/puppet/reference/type.rb

@@ -0,0 +1,116 @@
+type = Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types and all their details" do
+  types = {}
+  Puppet::Type.loadall
+
+  Puppet::Type.eachtype { |type|
+    next if type.name == :puppet
+    next if type.name == :component
+    next if type.name == :whit
+    types[type.name] = type
+  }
+
+  str = %{
+
+## Resource Types
+
+- The *namevar* is the parameter used to uniquely identify a type instance.
+  This is the parameter that gets assigned when a string is provided before
+  the colon in a type declaration.  In general, only developers will need to
+  worry about which parameter is the `namevar`.
+
+  In the following code:
+
+      file { "/etc/passwd":
+        owner => root,
+        group => root,
+        mode  => 644
+      }
+
+  `/etc/passwd` is considered the title of the file object (used for things like
+  dependency handling), and because `path` is the namevar for `file`, that
+  string is assigned to the `path` parameter.
+
+- *Parameters* determine the specific configuration of the instance.  They either
+  directly modify the system (internally, these are called properties) or they affect
+  how the instance behaves (e.g., adding a search path for `exec` instances or determining recursion on `file` instances).
+
+- *Providers* provide low-level functionality for a given resource type.  This is
+  usually in the form of calling out to external commands.
+
+  When required binaries are specified for providers, fully qualifed paths
+  indicate that the binary must exist at that specific path and unqualified
+  binaries indicate that Puppet will search for the binary using the shell
+  path.
+
+- *Features* are abilities that some providers might not support.  You can use the list
+  of supported features to determine how a given provider can be used.
+
+  Resource types define features they can use, and providers can be tested to see
+  which features they provide.
+
+    }
+
+    types.sort { |a,b|
+      a.to_s <=> b.to_s
+    }.each { |name,type|
+
+      str << "
+
+----------------
+
+"
+
+  str << markdown_header(name, 3)
+  str << scrub(type.doc) + "\n\n"
+
+  # Handle the feature docs.
+  if featuredocs = type.featuredocs
+    str << markdown_header("Features", 4)
+    str << featuredocs
+    end
+
+    docs = {}
+    type.validproperties.sort { |a,b|
+      a.to_s <=> b.to_s
+    }.reject { |sname|
+      property = type.propertybyname(sname)
+      property.nodoc
+    }.each { |sname|
+      property = type.propertybyname(sname)
+
+      raise "Could not retrieve property #{sname} on type #{type.name}" unless property
+
+      doc = nil
+      unless doc = property.doc
+        $stderr.puts "No docs for #{type}[#{sname}]"
+        next
+      end
+      doc = doc.dup
+      tmp = doc
+      tmp = scrub(tmp)
+
+      docs[sname]  = tmp
+    }
+
+    str << markdown_header("Parameters", 4) + "\n"
+    type.parameters.sort { |a,b|
+      a.to_s <=> b.to_s
+    }.each { |name,param|
+      #docs[name] = indent(scrub(type.paramdoc(name)), $tab)
+      docs[name] = scrub(type.paramdoc(name))
+    }
+
+    additional_key_attributes = type.key_attributes - [:name]
+    docs.sort { |a, b|
+      a[0].to_s <=> b[0].to_s
+    }.each { |name, doc|
+      if additional_key_attributes.include?(name)
+        doc = "(**Namevar:** If omitted, this parameter's value defaults to the resource's title.)\n\n" + doc
+      end
+      str << markdown_definitionlist(name, doc)
+    }
+    str << "\n"
+  }
+
+  str
+end

data/lib/vendor/puppet/relationship.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+# subscriptions are permanent associations determining how different
+# objects react to an event
+
+require 'puppet/util/pson'
+
+# This is Puppet's class for modeling edges in its configuration graph.
+# It used to be a subclass of GRATR::Edge, but that class has weird hash
+# overrides that dramatically slow down the graphing.
+class Puppet::Relationship
+  extend Puppet::Util::Pson
+  attr_accessor :source, :target, :callback
+
+  attr_reader :event
+
+  def self.from_pson(pson)
+    source = pson["source"]
+    target = pson["target"]
+
+    args = {}
+    if event = pson["event"]
+      args[:event] = event
+    end
+    if callback = pson["callback"]
+      args[:callback] = callback
+    end
+
+    new(source, target, args)
+  end
+
+  def event=(event)
+    raise ArgumentError, "You must pass a callback for non-NONE events" if event != :NONE and ! callback
+    @event = event
+  end
+
+  def initialize(source, target, options = {})
+    @source, @target = source, target
+
+    options = (options || {}).inject({}) { |h,a| h[a[0].to_sym] = a[1]; h }
+    [:callback, :event].each do |option|
+      if value = options[option]
+        send(option.to_s + "=", value)
+      end
+    end
+  end
+
+  # Does the passed event match our event?  This is where the meaning
+  # of :NONE comes from.
+  def match?(event)
+    if self.event.nil? or event == :NONE or self.event == :NONE
+      return false
+    elsif self.event == :ALL_EVENTS or event == self.event
+      return true
+    else
+      return false
+    end
+  end
+
+  def label
+    result = {}
+    result[:callback] = callback if callback
+    result[:event] = event if event
+    result
+  end
+
+  def ref
+    "#{source} => #{target}"
+  end
+
+  def inspect
+    "{ #{source} => #{target} }"
+  end
+
+  def to_pson_data_hash
+    data = {
+      'source' => source.to_s,
+      'target' => target.to_s
+    }
+
+    ["event", "callback"].each do |attr|
+      next unless value = send(attr)
+      data[attr] = value
+    end
+    data
+  end
+
+  def to_pson(*args)
+    to_pson_data_hash.to_pson(*args)
+  end
+
+  def to_s
+    ref
+  end
+end

data/lib/vendor/puppet/reports/http.rb

@@ -0,0 +1,25 @@
+require 'puppet'
+require 'net/http'
+require 'uri'
+
+Puppet::Reports.register_report(:http) do
+
+  desc <<-DESC
+  Send report information via HTTP to the `reporturl`. Each host sends
+  its report as a YAML dump and this sends this YAML to a client via HTTP POST.
+  The YAML is the body of the request.
+  DESC
+
+  def process
+    url = URI.parse(Puppet[:reporturl])
+    req = Net::HTTP::Post.new(url.path)
+    req.body = self.to_yaml
+    req.content_type = "application/x-yaml"
+    Net::HTTP.new(url.host, url.port).start {|http|
+      response = http.request(req)
+      unless response.kind_of?(Net::HTTPSuccess)
+        Puppet.err "Unable to submit report to #{Puppet[:reporturl].to_s} [#{response.code}] #{response.msg}"
+      end
+    }
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'puppet/reports'
+
+Puppet::Reports.register_report(:log) do
+  desc "Send all received logs to the local log destinations.  Usually
+    the log destination is syslog."
+
+  def process
+    self.logs.each do |log|
+      log.source = "//#{self.host}/#{log.source}"
+      Puppet::Util::Log.newmessage(log)
+    end
+  end
+end
+

data/lib/vendor/puppet/reports/rrdgraph.rb

@@ -0,0 +1,128 @@
+Puppet::Reports.register_report(:rrdgraph) do
+  desc "Graph all available data about hosts using the RRD library.  You
+    must have the Ruby RRDtool library installed to use this report, which
+    you can get from 
+    [the RubyRRDTool RubyForge page](http://rubyforge.org/projects/rubyrrdtool/).  
+    This package may also be available as `ruby-rrd` or `rrdtool-ruby` in your 
+    distribution's package management system.  The library and/or package will both 
+    require the binary `rrdtool` package from your distribution to be installed.
+
+    This report will create, manage, and graph RRD database files for each
+    of the metrics generated during transactions, and it will create a
+    few simple html files to display the reporting host's graphs.  At this
+    point, it will not create a common index file to display links to
+    all hosts.
+
+    All RRD files and graphs get created in the `rrddir` directory.  If
+    you want to serve these publicly, you should be able to just alias that
+    directory in a web server.
+
+    If you really know what you're doing, you can tune the `rrdinterval`,
+    which defaults to the `runinterval`."
+
+  def hostdir
+    @hostdir ||= File.join(Puppet[:rrddir], self.host)
+  end
+
+  def htmlfile(type, graphs, field)
+    file = File.join(hostdir, "#{type}.html")
+    File.open(file, "w") do |of|
+      of.puts "<html><head><title>#{type.capitalize} graphs for #{host}</title></head><body>"
+
+      graphs.each do |graph|
+        if field == :first
+          name = graph.sub(/-\w+.png/, '').capitalize
+        else
+          name = graph.sub(/\w+-/, '').sub(".png", '').capitalize
+        end
+        of.puts "<img src=#{graph}><br>"
+      end
+      of.puts "</body></html>"
+    end
+
+    file
+  end
+
+  def mkhtml
+    images = Dir.entries(hostdir).find_all { |d| d =~ /\.png/ }
+
+    periodorder = %w{daily weekly monthly yearly}
+
+    periods = {}
+    types = {}
+    images.each do |n|
+      type, period = n.sub(".png", '').split("-")
+      periods[period] ||= []
+      types[type] ||= []
+      periods[period] << n
+      types[type] << n
+    end
+
+    files = []
+    # Make the period html files
+    periodorder.each do |period|
+      unless ary = periods[period]
+        raise Puppet::Error, "Could not find graphs for #{period}"
+      end
+      files << htmlfile(period, ary, :first)
+    end
+
+    # make the type html files
+    types.sort { |a,b| a[0] <=> b[0] }.each do |type, ary|
+      newary = []
+      periodorder.each do |period|
+        if graph = ary.find { |g| g.include?("-#{period}.png") }
+          newary << graph
+        else
+          raise "Could not find #{type}-#{period} graph"
+        end
+      end
+
+      files << htmlfile(type, newary, :second)
+    end
+
+    File.open(File.join(hostdir, "index.html"), "w") do |of|
+      of.puts "<html><head><title>Report graphs for #{host}</title></head><body>"
+      files.each do |file|
+        of.puts "<a href='#{File.basename(file)}'>#{File.basename(file).sub(".html",'').capitalize}</a><br/>"
+      end
+      of.puts "</body></html>"
+    end
+  end
+
+  def process(time = nil)
+    time ||= Time.now.to_i
+
+    unless File.directory?(hostdir) and FileTest.writable?(hostdir)
+      # Some hackishness to create the dir with all of the right modes and ownership
+      config = Puppet::Util::Settings.new
+      config.setdefaults(:reports, :hostdir => {:default => hostdir, :owner => 'service', :mode => 0755, :group => 'service', :desc => "eh"})
+
+      # This creates the dir.
+      config.use(:reports)
+    end
+
+    self.metrics.each do |name, metric|
+      metric.basedir = hostdir
+
+      if name == "time"
+        timeclean(metric)
+      end
+
+      metric.store(time)
+
+      metric.graph
+    end
+
+    mkhtml unless FileTest.exists?(File.join(hostdir, "index.html"))
+  end
+
+  # Unfortunately, RRD does not deal well with changing lists of values,
+  # so we have to pick a list of values and stick with it.  In this case,
+  # that means we record the total time, the config time, and that's about
+  # it.  We should probably send each type's time as a separate metric.
+  def timeclean(metric)
+    metric.values = metric.values.find_all { |name, label, value| ['total', 'config_retrieval'].include?(name.to_s) }
+  end
+end
+

data/lib/vendor/puppet/reports/store.rb

@@ -0,0 +1,74 @@
+require 'puppet'
+require 'fileutils'
+require 'tempfile'
+
+SEPARATOR = [Regexp.escape(File::SEPARATOR.to_s), Regexp.escape(File::ALT_SEPARATOR.to_s)].join
+
+Puppet::Reports.register_report(:store) do
+  desc "Store the yaml report on disk.  Each host sends its report as a YAML dump
+    and this just stores the file on disk, in the `reportdir` directory.
+
+    These files collect quickly -- one every half hour -- so it is a good idea
+    to perform some maintenance on them if you use this report (it's the only
+    default report)."
+
+  def process
+    validate_host(host)
+
+    dir = File.join(Puppet[:reportdir], host)
+
+    if ! FileTest.exists?(dir)
+      FileUtils.mkdir_p(dir)
+      FileUtils.chmod_R(0750, dir)
+    end
+
+    # Now store the report.
+    now = Time.now.gmtime
+    name = %w{year month day hour min}.collect do |method|
+      # Make sure we're at least two digits everywhere
+      "%02d" % now.send(method).to_s
+    end.join("") + ".yaml"
+
+    file = File.join(dir, name)
+
+    f = Tempfile.new(name, dir)
+    begin
+      begin
+        f.chmod(0640)
+        f.print to_yaml
+      ensure
+        f.close
+      end
+      FileUtils.mv(f.path, file)
+    rescue => detail
+      puts detail.backtrace if Puppet[:trace]
+      Puppet.warning "Could not write report for #{host} at #{file}: #{detail}"
+    end
+
+    # Only testing cares about the return value
+    file
+  end
+
+  # removes all reports for a given host?
+  def self.destroy(host)
+    validate_host(host)
+
+    dir = File.join(Puppet[:reportdir], host)
+
+    if File.exists?(dir)
+      Dir.entries(dir).each do |file|
+        next if ['.','..'].include?(file)
+        file = File.join(dir, file)
+        File.unlink(file) if File.file?(file)
+      end
+      Dir.rmdir(dir)
+    end
+  end
+
+  def validate_host(host)
+    if host =~ Regexp.union(/[#{SEPARATOR}]/, /\A\.\.?\Z/)
+      raise ArgumentError, "Invalid node name #{host.inspect}"
+    end
+  end
+  module_function :validate_host
+end

data/lib/vendor/puppet/reports/tagmail.rb

@@ -0,0 +1,179 @@
+require 'puppet'
+require 'pp'
+
+require 'net/smtp'
+require 'time'
+
+Puppet::Reports.register_report(:tagmail) do
+  desc "This report sends specific log messages to specific email addresses
+    based on the tags in the log messages.  
+
+    See the [documentation on tags](http://projects.puppetlabs.com/projects/puppet/wiki/Using_Tags) for more information.
+
+    To use this report, you must create a `tagmail.conf` file in the location
+    specified by the `tagmap` setting.  This is a simple file that maps tags to
+    email addresses:  Any log messages in the report that match the specified
+    tags will be sent to the specified email addresses.
+
+    Lines in the `tagmail.conf` file consist of a comma-separated list
+    of tags, a colon, and a comma-separated list of email addresses.
+    Tags can be !negated with a leading exclamation mark, which will
+    subtract any messages with that tag from the set of events handled
+    by that line.
+
+    Puppet's log levels (`debug`, `info`, `notice`, `warning`, `err`,
+    `alert`, `emerg`, `crit`, and `verbose`) can also be used as tags,
+    and there is an `all` tag that will always match all log messages.
+
+    An example `tagmail.conf`:
+
+        all: me@domain.com
+        webserver, !mailserver: httpadmins@domain.com
+
+    This will send all messages to `me@domain.com`, and all messages from
+    webservers that are not also from mailservers to `httpadmins@domain.com`.
+
+    If you are using anti-spam controls such as grey-listing on your mail
+    server, you should whitelist the sending email address (controlled by
+    `reportform` configuration option) to ensure your email is not discarded as spam.
+    "
+
+  # Find all matching messages.
+  def match(taglists)
+    matching_logs = []
+    taglists.each do |emails, pos, neg|
+      # First find all of the messages matched by our positive tags
+      messages = nil
+      if pos.include?("all")
+        messages = self.logs
+      else
+        # Find all of the messages that are tagged with any of our
+        # tags.
+        messages = self.logs.find_all do |log|
+          pos.detect { |tag| log.tagged?(tag) }
+        end
+      end
+
+      # Now go through and remove any messages that match our negative tags
+      messages = messages.reject do |log|
+        true if neg.detect do |tag| log.tagged?(tag) end
+      end
+
+      if messages.empty?
+        Puppet.info "No messages to report to #{emails.join(",")}"
+        next
+      else
+        matching_logs << [emails, messages.collect { |m| m.to_report }.join("\n")]
+      end
+    end
+
+    matching_logs
+  end
+
+  # Load the config file
+  def parse(text)
+    taglists = []
+    text.split("\n").each do |line|
+      taglist = emails = nil
+      case line.chomp
+      when /^\s*#/; next
+      when /^\s*$/; next
+      when /^\s*(.+)\s*:\s*(.+)\s*$/
+        taglist = $1
+        emails = $2.sub(/#.*$/,'')
+      else
+        raise ArgumentError, "Invalid tagmail config file"
+      end
+
+      pos = []
+      neg = []
+      taglist.sub(/\s+$/,'').split(/\s*,\s*/).each do |tag|
+        unless tag =~ /^!?[-\w\.]+$/
+          raise ArgumentError, "Invalid tag #{tag.inspect}"
+        end
+        case tag
+        when /^\w+/; pos << tag
+        when /^!\w+/; neg << tag.sub("!", '')
+        else
+          raise Puppet::Error, "Invalid tag '#{tag}'"
+        end
+      end
+
+      # Now split the emails
+      emails = emails.sub(/\s+$/,'').split(/\s*,\s*/)
+      taglists << [emails, pos, neg]
+    end
+    taglists
+  end
+
+  # Process the report.  This just calls the other associated messages.
+  def process
+    unless FileTest.exists?(Puppet[:tagmap])
+      Puppet.notice "Cannot send tagmail report; no tagmap file #{Puppet[:tagmap]}"
+      return
+    end
+
+    metrics = raw_summary['resources'] || {} rescue {}
+
+    if metrics['out_of_sync'] == 0 && metrics['changed'] == 0
+      Puppet.notice "Not sending tagmail report; no changes"
+      return
+    end
+
+    taglists = parse(File.read(Puppet[:tagmap]))
+
+    # Now find any appropriately tagged messages.
+    reports = match(taglists)
+
+    send(reports) unless reports.empty?
+  end
+
+  # Send the email reports.
+  def send(reports)
+    pid = Puppet::Util.safe_posix_fork do
+      if Puppet[:smtpserver] != "none"
+        begin
+          Net::SMTP.start(Puppet[:smtpserver]) do |smtp|
+            reports.each do |emails, messages|
+              smtp.open_message_stream(Puppet[:reportfrom], *emails) do |p|
+                p.puts "From: #{Puppet[:reportfrom]}"
+                p.puts "Subject: Puppet Report for #{self.host}"
+                p.puts "To: " + emails.join(", ")
+                p.puts "Date: #{Time.now.rfc2822}"
+                p.puts
+                p.puts messages
+              end
+            end
+          end
+        rescue => detail
+          puts detail.backtrace if Puppet[:debug]
+          raise Puppet::Error,
+            "Could not send report emails through smtp: #{detail}"
+        end
+      elsif Puppet[:sendmail] != ""
+        begin
+          reports.each do |emails, messages|
+            # We need to open a separate process for every set of email addresses
+            IO.popen(Puppet[:sendmail] + " " + emails.join(" "), "w") do |p|
+              p.puts "From: #{Puppet[:reportfrom]}"
+              p.puts "Subject: Puppet Report for #{self.host}"
+              p.puts "To: " + emails.join(", ")
+
+              p.puts messages
+            end
+          end
+        rescue => detail
+          puts detail.backtrace if Puppet[:debug]
+          raise Puppet::Error,
+            "Could not send report emails via sendmail: #{detail}"
+        end
+      else
+        raise Puppet::Error, "SMTP server is unset and could not find sendmail"
+      end
+    end
+
+    # Don't bother waiting for the pid to return.
+    Process.detach(pid)
+  end
+end
+