gri 10.0.0

data/lib/gri/collector.rb

@@ -0,0 +1,284 @@
+#require 'gri/utils'
+require 'gri/msnmp'
+require 'gri/vendor'
+require 'gri/polling_unit'
+
+module GRI
+  class Collector
+    TYPES = {}
+
+    attr_reader :host, :options
+    attr_reader :loop, :attached_at
+    attr_accessor :interval, :timeout
+
+    def self.create col_type, host, options, fake_descr_hash={}, &cb
+      if (klass = TYPES[col_type])
+        klass.new host, options, fake_descr_hash, &cb
+      end
+    end
+
+    def initialize host, options, fake_descr_hash, &cb
+      @host = host
+      @options = options
+      @cname = @options['cname']
+      @hostname = @options['hostname'] || @options['alias']
+      @fake_descr_hash = fake_descr_hash || {}
+      @cb = cb
+      @buffers = []
+      @results = []
+      @on_error = nil
+      @on_retry = nil
+      on_init
+    end
+
+    def sync?; true; end
+
+    def on_init
+    end
+
+    def attach loop
+      @loop = loop
+      on_attach
+    end
+
+    def on_attach
+    end
+
+    def on_detach
+    end
+
+    def on_timeout
+    end
+
+    def on_error &block
+      @on_error = block
+    end
+
+    def on_retry &block
+      @on_retry = block
+    end
+  end
+
+  class SNMPCollector < Collector
+    TYPES['snmp'] = self
+    SYSOIDS = BER.enc_oid_list(['sysDescr', 'sysName', 'sysObjectID',
+                                 'sysUpTime', 'sysLocation'].map {|n|
+                                 oid = SNMP::OIDS[n] + '.0'
+                                 SNMP.add_oid n + '.0', oid
+                                 oid})
+
+    def sync?; false; end
+
+    def on_attach
+      now = Time.now
+      now_i = now.to_i
+      @attached_at = now
+      @results.clear
+      @tout = 5
+      @preq = nil
+      @snmp = SNMP.new(@cname || @host, options['port'])
+      @snmp.version = options['ver'] if options['ver']
+      @snmp.community = options['community'] if options['community']
+
+      varbind = SYSOIDS
+      get(varbind) {|results|
+        sysinfo = {'_host'=>(@hostname || host),
+          '_key'=>'SYS', '_time'=>now_i, '_mtime'=>now_i}
+        results.each {|enoid, tag, val|
+          (k = SNMP::ROIDS[enoid]) and sysinfo[k.sub(/\.0$/, '')] = val
+        }
+        sysinfo['sysDescr'] and sysinfo['sysDescr'].gsub!("\n", ' ')
+
+        vendor = Vendor.check sysinfo, options
+        puts "snmp: #{host} (#{vendor.name}): #{vendor.options.inspect}" if $debug
+        @snmp.version = vendor.options['ver'] if vendor.options['ver']
+        punits = vendor.get_punits
+        punits_d = punits.dup
+        @workhash = punits.inject({}) {|h, pu| h[pu.cat] = {}; h}
+        poll1(punits) {
+          if !options.has_key?('SYS') or options['SYS']
+            sysinfo.delete 'sysObjectID'
+            records = [sysinfo]
+          else
+            records = []
+          end
+          hfdh = @fake_descr_hash[host]
+
+          @workhash[:interfaces] = @workhash[''] #
+          for pu in punits_d
+            join_cat, join_key = pu.defs[:join]
+            if join_cat
+              for cat, wh in @workhash[pu.cat]
+                if wh and @workhash[join_cat]
+                  join_hash = @workhash[join_cat][wh[join_key]]
+                  wh.merge! join_hash if join_hash
+                end
+              end
+            end
+            pu.fix_workhash @workhash
+          end
+          @workhash.delete :interfaces #
+
+          for cat, wh in @workhash
+            (specs = DEFS.get_specs cat) and
+              (index_key = specs[:index_key] || specs[:named_index])
+            for ind, h in wh
+              h['_host'] = @hostname || host
+              h['_key'] = if index_key
+                            next if h[index_key].to_s.empty?
+                            "#{cat}_#{key_encode h[index_key]}"
+                          elsif ind.kind_of? Integer
+                            "#{cat}#{ind}"
+                          elsif ind.kind_of? Array
+                            "#{cat}_#{ind.join(',')}"
+                          else
+                            "#{cat}_#{ind}"
+                          end
+              h['_interval'] = @interval
+              h['_time'] = now_i
+              if hfdh and (f_descr = hfdh[h['_key']]) and
+                  (prop = specs[:prop]) and (descr_k = prop[:description])
+                h[descr_k] = f_descr
+              end
+              puts "  record #{h.inspect}" if h['_d']
+              records.push h
+            end
+          end
+          @cb.call records
+          @loop.detach self
+        }
+      }
+    end
+
+    def on_detach
+      @snmp.close rescue nil
+    end
+
+    def key_encode s
+      s.to_s.gsub(/[:\/]/, '-').gsub(/[ =]/, '_').gsub(/[^-a-zA-Z0-9_.]/) { #/
+        "%02X"%$&.unpack('C').first}
+    end
+
+    def poll1 punits, &cb
+      if punits.empty?
+        cb.call
+      else
+        pu = punits.shift
+        puts "  poll #{host} #{pu.name}" if $debug
+        @get_oid_buf = []
+        oids = pu.oids.dup
+        walk1(pu, oids) {poll1 punits, &cb}
+      end
+    end
+
+    def walk1 pu, oids, &cb
+      wh = @workhash[pu.cat]
+      if oids.empty?
+        if @get_oid_buf.empty?
+          cb.call
+        else
+          varbind = BER.cat_enoid @get_oid_buf
+          get(varbind) {|results|
+            results.each {|enoid, tag, val| pu.feed wh, enoid, tag, val}
+            cb.call
+          }
+        end
+      else
+        if (req_enoid = oids.shift) and req_enoid.getbyte(-1) == 0
+          @get_oid_buf.push req_enoid
+          walk1 pu, oids, &cb
+        else
+          walk(req_enoid) {|results|
+            results.each {|enoid, tag, val| pu.feed wh, enoid, tag, val}
+            walk1 pu, oids, &cb
+          }
+        end
+      end
+    end
+
+    def walk enoid, &cb
+      @results.clear
+      @retry_count = 0
+      @poll_cb = cb
+      @snmp.connect unless @snmp.sock
+      @snmp.walk_start(enoid) {|*res| @results.push res}
+      send_req enoid
+    rescue SocketError
+      @loop.detach self
+      @on_error.call if @on_error
+      Log.error "#{host}: error"
+    end
+
+    def get varbind, &cb
+      @results.clear
+      @retry_count = 0
+      @poll_cb = cb
+      @snmp.connect unless @snmp.sock
+      @snmp.get_start(varbind) {|*res| @results.push res}
+      send_req varbind
+    rescue SocketError
+      @loop.detach self
+      @on_error.call if @on_error
+      Log.error "#{host}: error"
+    end
+
+    def send_req arg
+      @preq = [@snmp.state, arg]
+      s = @snmp.make_req @snmp.state, arg
+      if @retry_count > 0
+        Log.debug "retry send_req, #{@buffers.size}"
+      end
+      @buffers.push s
+      loop.watch @snmp.sock, :w, @tout, self
+    end
+
+    def retry
+      if (@retry_count += 1) > 3
+        @loop.detach self
+        @on_error.call if @on_error
+        Log.error "#{host}: error"
+      elsif @preq
+        Log.warn "#{host}: retry #{@retry_count}"
+        @on_retry.call if @on_retry
+        @buffers.push @preq.last
+        loop.watch @snmp.sock, :w, @tout, self
+      else
+        @loop.detach self
+        @on_error.call if @on_error
+        Log.error "#{host}: cannot retry: #{@retry_count}"
+      end
+    end
+
+    def on_writable io=nil
+      unless @buffers.empty?
+        @snmp.sock.send @buffers.join(''), 0
+        @buffers.clear
+        loop.watch @snmp.sock, :r, @tout, self
+      end
+    end
+
+    def on_readable io=nil
+      msg = @snmp.sock.recv 2000, 0
+      arg = @snmp.recv_msg msg
+      if arg
+        @snmp.state = :SUCCESS if @snmp.state == :GET_REQ
+      end
+      if @snmp.state == :SUCCESS
+        @poll_cb.call @results
+        @preq = nil
+      elsif @snmp.state != :IDLE
+        send_req arg if arg
+      end
+    rescue SystemCallError
+      @snmp.state = :IDLE
+      Log.error "#{@host}: ERROR: #{$!}"
+      @loop.detach self
+      @on_error.call if @on_error
+    end
+
+    def on_timeout
+      Log.error "#{@host}: ERROR: timeout"
+      @on_error.call if @on_error
+    end
+  end
+end

data/lib/gri/config.rb

@@ -0,0 +1,134 @@
+module GRI
+  class Config
+    ROOT_PATH = '/usr/local/gri'
+    DEFAULT_PATH = ROOT_PATH + '/gri.conf'
+
+    def initialize
+      @h = {}
+    end
+
+    def setvar key, value
+      @h[key] = (Array === value) ? value : [value]
+    end
+
+    def getvar key
+      @h[key]
+    end
+
+    def []=(key, value)
+      (@h[key] ||= []).push value
+    end
+
+    def [](key)
+      (Array === (v = @h[key])) ? v.last : v
+    end
+
+    def keys
+      @h.keys
+    end
+
+    def has_key? key
+      @h.has_key? key
+    end
+
+    def to_h
+      @h.inject({}) {|h, item|
+        k, v = item
+        h[k] = (item.last.size > 1) ? v : v.first
+        h
+      }
+    end
+
+    def self.load_from_file path
+      conf = self.new
+      if File.exist? path
+        File.open(path) {|f|
+          while line = f.gets
+            line.chomp!
+            next if line =~ /^\s*(#|$)/
+            if line =~ /^\s*(\S+)\s+(.*)/
+              key, value = $1, $2
+              conf[key] = value
+            end
+          end
+        }
+      end
+      conf
+    end
+
+    def self.init path=nil
+      @config = path ? load_from_file(path) : new
+    end
+
+    def self.setvar key, value
+      @config.setvar key, value
+    end
+
+    def self.getvar key
+      @config.getvar key
+    end
+
+    def self.[]=(key, value)
+      @config[key] = value
+    end
+
+    def self.[](key)
+      @config[key]
+    end
+
+    def self.keys
+      @config.keys
+    end
+
+    def self.has_key? key
+      @config.has_key? key
+    end
+
+    def self.parse_options(*strs)
+      options = {}
+      for s in strs
+        next unless s
+        for var, value in s.scan(/([^=\s]+)(?:=((?:`[^`]+`)|(?:"[^"]+")|\S+))?/)
+          if value
+            if value =~ /^[`"]([^`"]+)[`"]/
+              value = $1
+            end
+            options[var] = value
+          else
+            if var =~ /^no-/
+              options[$~.post_match] = false
+            else
+              options[var] = var
+            end
+          end
+        end
+      end
+      options
+    end
+
+    def self.option_if_match matchstr, varname, config
+      h = {}
+      if (varlines = config.getvar varname)
+        for line in varlines
+          pat, *optstr = line.split
+          if matchstr =~ Regexp.new(pat)
+            h.merge!(parse_options(*optstr))
+          end
+        end
+      end
+      h
+    end
+
+    def self.get_targets_from_lines lines
+      targets = []
+      for line in lines
+        if line =~ /^\s*(\w\S*)(?:\s+(.*))?/
+          host, remain = $1, $2
+          options = parse_options remain
+          targets.push [host, options]
+        end
+      end
+      targets
+    end
+  end
+end

data/lib/gri/ds_list.rb

@@ -0,0 +1,166 @@
+require 'gri/utils'
+require 'gri/builtindefs'
+require 'gri/format_helper'
+
+module GRI
+  class DSList
+    include Utils
+    include FormatHelper
+    SORT_PROC = {
+      :by_name=>Proc.new {|a, b|
+        (cmp = a.first.to_s.gsub(/(\d+)/) {"%06d"%$1.to_i} <=>
+         b.first.to_s.gsub(/(\d+)/) {"%06d"%$1.to_i}).zero? ?
+        a.first <=> b.first : cmp
+      }
+    }
+
+    def initialize options={}
+      @options = options
+    end
+
+    def call env
+      req = Rack::Request.new env
+      dirs = @options[:dirs]
+
+      list_item = env['PATH_INFO'] || ''
+      host = File.basename list_item
+      gra_dir, records = search_records dirs, host
+      return [404, {}, ['Not Found']] unless gra_dir
+      dir = gra_dir + list_item
+      sysinfo = records['SYS'] || {}
+      data_hash = get_data_hash records
+      data_names = data_hash.keys.sort
+
+      @title = host
+      body = render(Grapher.layout) {render template, binding}
+      [200, {'Content-type' => 'text/html'}, [body]]
+    end
+
+    def get_data_hash records
+      h = {}
+      for key, record in records
+        next if !key or key == 'SYS'
+        data_name, index = parse_key key
+        next unless data_name
+        specs = DEFS.get_specs data_name
+        next unless specs and (specs[:list] or specs[:list_text])
+        next if specs[:hidden?] and specs[:hidden?].call(record)
+        record['_index'] = index; record[:key] = index
+        if specs[:prop]
+          specs[:prop].each {|k1, k2| record[k1] = record[k2] if record[k2]}
+          record[:name] ||= specs[:prop][:name]
+        end
+        h[data_name] ||= []
+        h[data_name] << [key, record, nil]
+      end
+      h
+    end
+
+    def format_data_list dir, data_name, items
+      host = File.basename dir
+      specs = DEFS.get_specs data_name
+      hdstr, pat = specs[:list] || specs[:list_text]
+      hds = (Array === hdstr) ? hdstr : hdstr.split(',')
+      formats = (pat || '%N').split(',')
+
+      p0 = ((hds.size == formats.size) ?
+            [hds.map {|hd| td(h(hd), :head=>true)}] :
+            [[td(h(hds.join('.')), :head=>true, :colspan=>formats.size)]])
+      ckeys = []
+      p1 = items.sort(&SORT_PROC[:by_name]).map {|key, prop|
+        host_key = "#{host}_#{key}"
+        href = File.exist?("#{dir}/#{host_key}.rrd") ?
+        (ckeys.push key; url_to("?r=#{host_key}")) : nil
+        format_tr formats, prop, :href=>href
+      }
+      if specs[:composite] and p1.size > 1
+        links = mk_comp_links specs[:composite], host, ckeys
+        p1.push [td(links.join(' | '), :colspan=>formats.size)]
+      end
+      p0 + p1
+    end
+
+    CMNAME = {'s'=>'stack', 'v'=>'overlay', ''=>'sum', 't'=>'tile'}
+    def mk_comp_links comps, host, ckeys
+      links = []
+      for cm in comps
+        href_fp = url_to "?p=#{cm}&"
+        href = href_fp + ckeys.map {|k| "r=#{host}_#{k}"}.join('&')
+        links.push mk_tag('a', {:href=>href}, CMNAME[cm])
+      end
+      links
+    end
+
+    def format_tr formats, prop, options={}
+      formats.map {|format|
+        format = format.gsub(/\\(\w)/) {
+          case $1
+          when 'r'; options[:class] = 'text-right'
+          end
+          ''
+        }
+        format_cell format, prop, options
+      }
+    end
+
+    def format_cell f, prop, options={}
+      str = f.gsub(/%([\.\/a-z\d][\.\/A-Za-z_\d]*)?([%A-Z])/) {
+        case $2
+        when 'D'
+          prop[:description]
+        when 'N'
+          name = prop[:name]
+          (href = options[:href]) ? "<a href=\"#{h href}\">#{h name}</a>" : name
+        when 'I'
+          addrs = (prop[:ipaddr] || '').split(',').map {|item|
+            if item =~ %r{^(\d+\.\d+\.\d+\.\d+)/(\d+\.\d+\.\d+\.\d+)}
+              ipaddr = $1
+              int, = $2.split('.').map {|s|s.to_i}.pack('C4').unpack('N')
+              mask = 32 - Integer(Math.log((int ^ 0xffffffff) + 1) / Math.log(2))
+              ipaddr + '/' + mask.to_s
+            else
+              item
+            end
+          }.join('</br>')
+        when 'L'
+          if $1
+            base, mag = $1.split('/')
+            base = base.to_i
+          end
+          #mag = (mag || 1).to_f
+          to_scalestr(prop[:lastvalue], base)
+        when 'S'
+          (prop[:astatus].to_i == 2) ? 'AdminDown' :
+            ((prop[:ostatus].to_i == 2) ? 'Down' : '')
+        when 'U'
+          to_scalestr(prop[:ub], $1.to_i)
+        else
+          ''
+        end
+      }
+      td str, :class=>options[:class]
+    end
+
+    def template
+      <<'EOS'
+<span class="large"><%=h host %></span>
+<small><%=h sysinfo['_sysdescr'] || '' %></small><br/>
+<hr/>
+
+<table>
+<% for data_name in data_names -%>
+<tr><td>
+<table class="table ds" width="100%">
+<% for row in format_data_list dir, data_name, data_hash[data_name] -%>
+  <tr>
+    <%= row.join('') %>
+  </tr>
+<% end -%>
+</table>
+</td></tr>
+<% end -%>
+</table>
+EOS
+    end
+  end
+end