puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/reports.rb

@@ -0,0 +1,89 @@
+require 'puppet/util/instance_loader'
+
+# This class is an implementation of a simple mechanism for loading and returning reports.
+# The intent is that a user registers a report by calling {register_report} and providing a code
+# block that performs setup, and defines a method called `process`. The setup, and the `process` method
+# are called in the context where `self` is an instance of {Puppet::Transaction::Report} which provides the actual
+# data for the report via its methods.
+#
+# @example Minimal scaffolding for a report...
+#   Puppet::Reports::.register_report(:myreport) do
+#     # do setup here
+#     def process
+#       if self.status == 'failed'
+#         msg = "failed puppet run for #{self.host} #{self.status}"
+#         . . .
+#       else
+#         . . .
+#       end
+#     end
+#   end
+#
+# Required configuration:
+# --
+# * A .rb file that defines a new report should be placed in the master's directory `lib/puppet/reports`
+# * The `puppet.conf` file must have `report = true` in the `[agent]` section
+#
+# @see Puppet::Transaction::Report
+# @api public
+#
+class Puppet::Reports
+  extend Puppet::Util::ClassGen
+  extend Puppet::Util::InstanceLoader
+
+  # Set up autoloading and retrieving of reports.
+  instance_load :report, 'puppet/reports'
+
+  class << self
+    # @api private
+    attr_reader :hooks
+  end
+
+  # Adds a new report type.
+  # The block should contain setup, and define a method with the name `process`. The `process` method is
+  # called when the report is executed; the `process` method has access to report data via methods available
+  # in its context where `self` is an instance of {Puppet::Transaction::Report}.
+  #
+  # For an example, see the overview of this class.
+  #
+  # @param name [Symbol] the name of the report (do not use whitespace in the name).
+  # @param options [Hash] a hash of options
+  # @option options [Boolean] :useyaml whether yaml should be used or not
+  # @todo Uncertain what the options :useyaml really does; "whether yaml should be used or not", used where/how?
+  #
+  def self.register_report(name, options = {}, &block)
+    name = name.intern
+
+    mod = genmodule(name, :extend => Puppet::Util::Docs, :hash => instance_hash(:report), :block => block)
+
+    mod.useyaml = true if options[:useyaml]
+
+    mod.send(:define_method, :report_name) do
+      name
+    end
+  end
+
+  # Collects the docs for all reports.
+  # @api private
+  def self.reportdocs
+    docs = ""
+
+    # Use this method so they all get loaded
+    instance_loader(:report).loadall
+    loaded_instances(:report).sort { |a,b| a.to_s <=> b.to_s }.each do |name|
+      mod = self.report(name)
+      docs << "#{name}\n#{"-" * name.to_s.length}\n"
+
+      docs << Puppet::Util::Docs.scrub(mod.doc) << "\n\n"
+    end
+
+    docs
+  end
+
+  # Lists each of the reports.
+  # @api private
+  def self.reports
+    instance_loader(:report).loadall
+    loaded_instances(:report)
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/reports/http.rb

@@ -0,0 +1,31 @@
+require 'puppet'
+require 'puppet/network/http_pool'
+require 'uri'
+
+Puppet::Reports.register_report(:http) do
+
+  desc <<-DESC
+    Send reports via HTTP or HTTPS. This report processor submits reports as
+    POST requests to the address in the `reporturl` setting. The body of each POST
+    request is the YAML dump of a Puppet::Transaction::Report object, and the
+    Content-Type is set as `application/x-yaml`.
+  DESC
+
+  def process
+    url = URI.parse(Puppet[:reporturl])
+    headers = { "Content-Type" => "application/x-yaml" }
+    options = {}
+    if url.user && url.password
+      options[:basic_auth] = {
+        :user => url.user,
+        :password => url.password
+      }
+    end
+    use_ssl = url.scheme == 'https'
+    conn = Puppet::Network::HttpPool.http_instance(url.host, url.port, use_ssl)
+    response = conn.post(url.path, self.to_yaml, headers, options)
+    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/vendor/gems/puppet-3.7.3/lib/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/vendor/gems/puppet-3.7.3/lib/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 `librrd-ruby`, `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::Settings.new
+      config.define_settings(:reports, :hostdir => {:type => :directory, :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 Puppet::FileSystem.exist?(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/vendor/gems/puppet-3.7.3/lib/puppet/reports/store.rb

@@ -0,0 +1,68 @@
+require 'puppet'
+require 'fileutils'
+require 'puppet/util'
+
+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 ! Puppet::FileSystem.exist?(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)
+
+    begin
+      Puppet::Util.replace_file(file, 0640) do |fh|
+        fh.print to_yaml
+      end
+    rescue => detail
+       Puppet.log_exception(detail, "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 Puppet::FileSystem.exist?(dir)
+      Dir.entries(dir).each do |file|
+        next if ['.','..'].include?(file)
+        file = File.join(dir, file)
+        Puppet::FileSystem.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/vendor/gems/puppet-3.7.3/lib/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://docs.puppetlabs.com/puppet/latest/reference/lang_tags.html) 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
+    `reportfrom` 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 Puppet::FileSystem.exist?(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], Puppet[:smtpport], Puppet[:smtphelo]) 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
+          message = "Could not send report emails through smtp: #{detail}"
+          Puppet.log_exception(detail, message)
+          raise Puppet::Error, message, detail.backtrace
+        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
+              p.puts messages
+            end
+          end
+        rescue => detail
+          message = "Could not send report emails via sendmail: #{detail}"
+          Puppet.log_exception(detail, message)
+          raise Puppet::Error, message, detail.backtrace
+        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
+