hostmon 0.0.1

data/lib/hostmon/config.rb

@@ -0,0 +1,47 @@
+require "optparse"
+require "hostmon/models"
+
+module Hostmon
+  class Config
+    include Hostmon::Models
+    attr_reader :global_config, :report_dir, :conf_file, :amqp_config
+    attr_reader :bugzilla_config
+
+    def initialize
+      port = 9292
+      @conf_file = "./config.yml"
+
+      optparse = OptionParser.new do |o|
+        o.on("-f", "--config-file FILE",
+          "location of the config directory (default .)") do |arg|
+          @conf_file = arg
+        end
+        o.on("-p", "--port PORT", "port to bind to (default 9292)") do |arg|
+          port = arg.to_i
+        end
+      end
+
+      optparse.parse!
+      reload!
+      @global_config[:port] = port
+    end
+
+    def reload!
+      raw = File.read(@conf_file)
+      raise "failed to load #{@conf_file}" unless yaml = YAML.load(raw)
+
+      @global_config = yaml[:main]
+      @bugzilla_config = yaml[:bugzilla] || false
+      @amqp_config = yaml[:amqp] || {}
+      # do some sanity checking of other configuration parameters
+      [:report_dir].each do |c|
+        if not @global_config[c]
+          raise "Missing config name '#{c.to_s}'"
+        end
+      end
+
+      @global_config[:saved_reports] ||= 1
+      @report_dir = @global_config[:report_dir]
+    end
+  end # Hostmon::Config
+end # Hostmon

data/lib/hostmon/helpers.rb

@@ -0,0 +1,174 @@
+module Hostmon::Helpers
+  include Hostmon::Models
+
+  #fixme failing vs failed
+  def cluster_link(cluster)
+    "/cluster/#{cluster}"
+  end
+
+  def append_query_string(str)
+    v = str.dup
+    # CGI::escapeHTML()?
+    unless request.query_string.empty?
+      v << "?#{request.query_string.gsub("&", "&amp;")}"
+    end
+    return v
+  end
+
+  def color(status)
+    map = {:CHECK_OK => "green",
+      :CHECK_FAILED => "red"}
+    "[" + status.map do |s|
+      "<span style=\"color:#{map[s]||'orange'}\">#{s}</span>"
+    end.join(', ') + "]"
+  end
+
+  def rstatus(report)
+    j = report.ok? ? "ok" : "error"
+    "<#{j}>#{color(report.status)}</#{j}> #{bugzilla_link(report) if j=="error" } #{bugzilla_search_link(report) if j=="error" }"
+  end
+
+  def css_url
+    style = File.join(settings.root, "public/style.css")
+    mtime = File.mtime(style).to_i.to_s
+    return \
+    %Q[<link href="/style.css?#{mtime}" rel="stylesheet" type="text/css">]
+  end
+
+  def aggregate_bugzilla(check)
+    return "" unless settings.config.bugzilla_config
+    url = settings.config.bugzilla_config[:bugzilla_url]
+    h_url = settings.config.bugzilla_config[:hostlint_url]
+    failing = check.hosts_failing.map(&:first).size
+    failing += check.hosts_check_failing.map(&:first).size
+    succeeding = check.hosts_ok.map(&:first).size
+    fields = { :short_desc => "[hostlint] hosts failing #{check}",
+      :comment => "#{failing.size}/#{failing + succeeding} hosts failing at report time (#{Time.now}).
+    See #{h_url}/check/#{check}",
+      :keyword => ""
+    }
+    url_parts = []
+    fields.each do |k, v|
+      [v].flatten.each do |v2|
+        url_parts << "#{URI.escape(k.to_s)}=#{URI.escape(v2.to_s)}"
+      end
+    end
+    url += "&amp;" + url_parts.join("&amp;")
+    "<a href=\"#{url}\" target=\"_blank\" style=\"font-size:small;\">[file an aggregate bug]</a>"
+  end
+
+  def bugzilla_link(report)
+    return "" unless settings.config.bugzilla_config
+
+    # info should have host, cluster, report_time
+    url = settings.config.bugzilla_config[:bugzilla_url]
+    h_url = settings.config.bugzilla_config[:hostlint_url]
+    desc = "[hostlint ##{report.hostlint_id}] " +
+      "#{report.host}.#{report.cluster}: #{report.name}"
+    fields = { :short_desc => desc,
+      :comment => "hostlint link: #{h_url}/report/#{report.name}##{report.hostlint_id}
+#{report.body}",
+      :keyword => ""
+    }
+    url_parts = []
+    fields.each do |k, v|
+      [v].flatten.each do |v2|
+        url_parts << "#{URI.escape(k.to_s)}=#{URI.escape(v2.to_s)}"
+      end
+    end
+    url += "&amp;" + url_parts.join("&amp;")
+    "<a href=\"#{url}\" target=\"_blank\" style=\"font-size:small;\">file a bug</a>"
+  end
+
+  def bugzilla_search_link(check)
+    return "" unless settings.config.bugzilla_config
+
+    url = settings.config.bugzilla_config[:bugzilla_search_url]
+    desc = "[hostlint ##{check.hostlint_id}] " +
+      "#{check.host}.#{check.cluster}: #{check.name}"
+    fields = { :short_desc => desc }
+    url_parts = []
+    fields.each do |k, v|
+      [v].flatten.each do |v2|
+        url_parts << "#{URI.escape(k.to_s)}=#{URI.escape(v2.to_s)}"
+      end
+    end
+    url += "&amp;" + url_parts.join("&amp;")
+    "<a href=\"#{url}\" target=\"_blank\" style=\"font-size:small;\">search</a>"
+  end
+
+  # when single cluster view, don't display cluster in hostname
+  def hostlink(host, single=false)
+    str = "<a href=\"/host/#{host.cluster}/#{host}\">#{host}"
+    str << ".#{host.cluster}" unless single
+    str << "</a>"
+  end
+
+  def checklink(check)
+    "<a href=\"/check/#{check}\">#{check}</a>"
+  end
+
+  def hosts_selector(hosts)
+    @hosts = hosts
+    erb :'partials/hosts_selector', :layout => false
+  end
+
+  def status_selector()
+    erb :'partials/status_selector', :layout => false
+  end
+
+  def stats_helper(check)
+    total = ok = failed = check_failed = 0
+    Check.find(check).host_map.each do |h, r|
+      r = r.last
+      total += 1
+      if r.ok?
+        ok += 1
+      elsif r.failed?
+        failed += 1
+      else
+        check_failed += 1
+      end
+    end
+
+    ol = append_query_string("/check/#{check}/#{Host::OK}")
+    fl = append_query_string("/check/#{check}/#{Host::FAIL}")
+    cfl = append_query_string("/check/#{check}/#{Host::EXEC_FAIL}")
+
+    "<span><a style=\"color:green\" href=\"#{ol}\">#{ok}</a></span>" +
+      "/<span><a style=\"color:red\" href=\"#{fl}\">#{failed}</a></span>" +
+      "/<span><a style=\"color:orange\" href=\"#{cfl}\">#{check_failed}</a></span>" +
+      " <span>(#{total})</span>"
+  end
+
+  # fixme de-duplication
+  def host_helper(host)
+    ok = host.succeeding.size
+    failed = host.failing.size
+    check_failed = host.checks_failing.size
+    total = ok + failed + check_failed
+    if failed + check_failed != 0
+
+      ol = append_query_string("/host/#{host.cluster}/#{host}/#{Host::OK}")
+      fl = append_query_string("/host/#{host.cluster}/#{host}/#{Host::FAIL}")
+      cfl = append_query_string("/host/#{host.cluster}/#{host}/#{Host::EXEC_FAIL}")
+
+      "<span><a style=\"color:green\" href=\"#{ol}\">#{ok}</a></span>" +
+        "/<span><a style=\"color:red\" href=\"#{fl}\">#{failed}</a></span>" +
+        "/<span><a style=\"color:orange\" href=\"#{cfl}\">#{check_failed}</a></span>" +
+        " <span>(#{total})</span>"
+    end
+  end
+
+  def check_status_to_hosts_map
+    bucket = {}
+    @hosts.each do |h|
+      type = @status == Host::OK ? :checks_succeeding : :checks_failing
+      h.send(type).each do |c|
+        bucket[c.name] ||= []
+        bucket[c.name] << h
+      end
+    end
+    bucket
+  end
+end

data/lib/hostmon/models.rb

@@ -0,0 +1,4 @@
+require "hostmon/models/base"
+require "hostmon/models/host"
+require "hostmon/models/check"
+require "hostmon/models/report"

data/lib/hostmon/models/base.rb

@@ -0,0 +1,39 @@
+module Hostmon::Models
+  # fixme define [] for find
+  class Base
+    @@objects = Hash.new { |h, k| h[k] = Hash.new }
+    attr_reader :name
+
+    def initialize(name, params={})
+      @name = name
+      @params = params
+      @@objects[self.class.to_s][name] = self
+    end
+
+    def self.find(name)
+      return @@objects[self.name][name] rescue []
+    end
+
+    def self.each(&block)
+      h = @@objects[self.name] rescue {}
+      h.sort.each { |k, v| yield(k, v) }
+    end
+
+    def self.all
+      return @@objects[self.name].values.sort
+    end
+
+    def [](key)
+      return @params[key] rescue []
+    end
+
+    def to_s
+      return @name
+    end
+
+    def <=>(other)
+      return to_s <=> other.to_s
+    end
+
+  end # Hostmon::Models::Base
+end # Hostmon::Models

data/lib/hostmon/models/check.rb

@@ -0,0 +1,45 @@
+module Hostmon::Models
+  class Check < Base
+    attr_reader :name
+    attr_accessor :host_map
+
+    def self.absorb (name, host)
+      unless c = find(name)
+        c = new(name)
+      end
+      c.host_map[host] = host.check_reports(name)
+      c
+    end
+
+    def initialize(name)
+      super(name)
+      @host_map = {} #Host => reports
+    end
+
+    def host_status
+      ok = []
+      failed = []
+      check_failed = []
+      @host_map.each do |h, r|
+        if r.last.ok?
+          ok << [h, r.last]
+        elsif r.last.failed?
+          failed << [h, r.last]
+        else
+          check_failed << [h, r.last]
+        end
+      end
+      return ok, failed, check_failed
+    end
+
+    def hosts_ok
+      host_status[0] # .map(&:first)
+    end
+    def hosts_failing
+      host_status[1] # .map(&:first)
+    end
+    def hosts_check_failing
+      host_status[2] # .map(&:first)
+    end
+  end
+end

data/lib/hostmon/models/host.rb

@@ -0,0 +1,211 @@
+require "hostmon/models/base"
+
+module Hostmon::Models
+  class Host < Base
+    OK = "OK"
+    FAIL = "FAIL"
+    EXEC_FAIL = "EXEC_FAIL"
+    def self.statuses
+      [OK, FAIL, EXEC_FAIL]
+    end
+
+    @@clusters = Set.new
+
+    @@saved_reports = 1
+    def self.saved_reports
+      @@saved_reports
+    end
+    def self.saved_reports= (i)
+      @@saved_reports = i
+    end
+
+    @@checks = Set.new
+    @@check_map = {}
+
+    class << self
+      def clusters # attr_*
+        @@clusters
+      end
+      def hosts_failing(check)
+        @@check_map[check][FAIL]||Set.new
+      end
+
+      def hosts_succeeding(check)
+        @@check_map[check][OK]||Set.new
+      end
+
+      def check_map
+        @@check_map
+      end
+
+      def find_by_name_and_cluster(name, cluster)
+        Host.each do |host_name, host|
+          next unless host.name == name
+          return host if host.cluster == cluster
+        end
+        return nil
+      end
+
+      def find_by_cluster(cluster)
+        ret = []
+        Host.each do |name, host|
+          ret << host if host.cluster == cluster
+        end
+        return ret
+      end
+    end
+
+    attr_reader :hostname, :checks, :cluster, :status_map, :report
+    attr_accessor :reports, :report_time
+
+    def checks
+      @reports.map(&:first)
+    end
+
+
+    # return reports for checks that the host passes
+    def succeeding
+      ok_reports = Set.new
+      @reports.each do |n, r|
+        if r.last.ok?
+          ok_reports << r.last
+        end
+      end
+      ok_reports.sort
+    end
+
+    # return reports for checks that the host fails
+    def failing
+      failing_reports = Set.new
+      @reports.each do |n, r|
+        if r.last.failed?
+          failing_reports << r.last
+        end
+      end
+      failing_reports.sort
+    end
+
+    # return reports for checks that failed to execute properly
+    def checks_failing
+      failing = Set.new
+      @reports.each do |n, r|
+        if r.last.check_failed?
+          failing << r.last
+        end
+      end
+      failing.sort
+    end
+
+    # hacks
+    def to_s
+      @hostname
+    end
+
+    def name
+      @hostname
+    end
+
+    def initialize(h, c)
+      # needed to disambiguate
+      super(h+'.'+c)
+      @hostname = h
+      @cluster = c
+      @report_time = nil
+    end
+
+    def key
+      "#{@cluster}#{@name}"
+    end
+
+    def eql?(other)
+      key == other.key
+    end
+
+    def ==(other)
+      key == other.key
+    end
+
+    # fixme this is just silly
+    def sname
+      @hostname + "." + @cluster
+    end
+
+    # fixme @params is always empty right now
+    def <=>(other)
+      if @params[:host_sort] == "builtin"
+        return key <=> other.key
+      elsif @params[:host_sort] == "numeric"
+        regexp = /\d+/
+        match = @name.match(regexp)
+        match2 = other.name.match(regexp)
+        if match.pre_match != match2.pre_match
+          return match.pre_match <=> match2.pre_match
+        else
+          return match[0].to_i <=> match2[0].to_i
+        end
+      else
+        # http://www.bofh.org.uk/2007/12/16/comprehensible-sorting-in-ruby
+        sensible = lambda do |k|
+          k.sname.split(
+                 /((?:(?:^|\s)[-+])?(?:\.\d+|\d+(?:\.\d+?(?:[eE]\d+)?(?:$|(?![eE\.])))?))/ms
+                 ).map { |v| Float(v) rescue v.downcase }
+        end
+        return sensible.call(self) <=> sensible.call(other)
+      end
+    end
+
+    def hash
+      key.hash
+    end
+
+    # process and update (or create) a host and return it
+    # fixme saved_reports unbounded
+    # fixme special case for 0 (only store in memory)
+    def self.absorb(report)
+      h = report.host
+      c = report.cluster
+      unless host = find_by_name_and_cluster(h, c)
+        host = new(h, c)
+        puts "new host #{h}"
+      end
+      host.reports ||= Hash.new {|hsh,k| hsh[k] = Array.new}
+
+      # fixme slightly offensive
+      if host.reports[report.name].size < @@saved_reports
+        host.reports[report.name] << report
+        host.reports[report.name].sort! {|a,b| a.timestamp <=> b.timestamp }
+        report.write
+      elsif report.timestamp < host.reports[report.name].first.timestamp
+        return host
+      else
+        pp host.reports[report.name].size
+        pp @@saved_reports
+        host.reports[report.name] << report
+        host.reports[report.name].sort! {|a,b| a.timestamp <=> b.timestamp }
+        while host.reports[report.name].size > @@saved_reports
+          shift = host.reports[report.name].shift
+          shift.delete
+        end
+        report.write
+      end
+      ####################
+
+      time = report.timestamp
+      if (!host.report_time) || (host.report_time < time)
+        host.report_time = time
+      end
+      @@clusters << host.cluster
+      host
+    end
+
+    def check_reports(check_name)
+      reports[check_name]
+    end
+
+    # temporary
+    def inspect
+      @hostname
+    end
+
+  end # Hostmon::Models::Host
+end # Hostmon::Models