gri 10.0.0

data/lib/gri/updater.rb

@@ -0,0 +1,201 @@
+require 'fileutils'
+
+require 'gri/builtindefs'
+require 'gri/rrd'
+require 'gri/utils'
+require 'gri/config'
+
+module GRI
+  class Updater
+    include Utils
+    attr_reader :options
+
+    def self.get_tag_ary description
+      unless @tag_pats
+        @tag_pats = (pats = GRI::Config.getvar 'tag-rule') ?
+        pats.map {|patline| pat, *remain =
+            patline.scan(/^\/([^\/]+)\/\s+(\S+)\s+(\S+)\s+(\S+)/)[0] #/
+          [Regexp.new(pat), *remain]} : []
+      end
+      @tag_pats.map {|re, group, subdir, descr_v|
+        if re === description
+          m = $~.to_a
+          if group =~ /^\$(\d+)(\.\w+)?/
+            group = m[$1.to_i].dup
+            group.downcase! if $2 == '.downcase'
+          end
+          if subdir =~ /^\$(\d+)(\.\w+)?/
+            subdir = m[$1.to_i].dup
+            subdir.downcase! if $2 == '.downcase'
+          end
+          if descr_v =~ /^\$(\d+)/
+            descr_v = m[$1.to_i]
+          end
+          [group, subdir, descr_v]
+        else
+          nil
+        end
+      }.compact
+    end
+
+    def initialize options={}
+      @options = options
+      @interval = options[:step] || options[:interval] || 300
+      @config = GRI::Config
+    end
+
+    def update time, record
+    end
+  end
+
+  class RRDUpdater < Updater
+    attr_reader :rrd, :key
+    attr_accessor :rrd_class
+
+    def initialize options={}
+      super
+      @tagrrds = {}
+    end
+
+    def create_rrd path, time, interval, ds_specs, rra_specs
+      ds_args, @record_keys = mk_ds_args ds_specs, interval
+      rra_args = rra_specs || mk_rra_args
+      @rrd_args = ds_args + rra_args
+      rrd = (@rrd_class || RRD).new @options[:rrdcached_address],
+        @options[:base_dir]
+      rrd.set_create_args path, (time - interval), interval, *@rrd_args
+      rrd
+    end
+
+    def mk_ds_args ds_specs, interval
+      ds_args = []
+      record_keys = []
+      n = 0
+      for spec_line in ds_specs
+        key, dsname, dst = spec_line.split /,/
+        heartbeat = interval * ((dst == 'DERIVE' or dst == 'COUNTER') ? 2.5 : 2)
+        key = key[1..-1].intern if key[0] == ?:
+        record_keys.push key
+        ds_args.push "DS:#{dsname}:#{dst}:#{heartbeat.to_i}:U:U"
+        n += 1
+      end
+      return ds_args, record_keys
+    end
+
+    def mk_rra_args
+      rra_args = []
+      for cf in ['average', 'max', 'min']
+        optrraname = "rra-#{@options[:data_name]}-#{cf}"
+        if (optrra = @config.getvar optrraname)
+          for line in optrra
+            steps, rows = line.split
+            rra_args.push "RRA:#{cf.upcase}:0.5:#{steps}:#{rows}"
+          end
+        else
+          optrraname = 'rra-' + cf
+          optrra = @config.getvar optrraname
+          if optrra
+            for line in optrra
+              steps, rows = line.split
+              rra_args.push "RRA:#{cf.upcase}:0.5:#{steps}:#{rows}"
+            end
+          end
+        end
+      end
+      rra_args.size.zero? ? default_rra_args : rra_args
+    end
+
+    def default_rra_args
+      ['RRA:AVERAGE:0.5:12:9000', 'RRA:MAX:0.5:1:20000',
+        'RRA:MAX:0.5:12:9000', 'RRA:MAX:0.5:144:2000']
+    end
+
+    def mk_key options
+      unless (key = options[:key])
+        data_name = options[:data_name]
+        key = (Numeric === (index = options[:index])) ?
+        "#{data_name}#{index}" : "#{data_name}_#{index}"
+      end
+      key
+    end
+
+    def mk_path options
+      host = options[:host]
+      dir = options[:dir] || options[:gra_dir] + '/' + host
+      dkey = mk_key options
+      "#{dir}/#{host}_#{dkey}.rrd"
+    end
+
+    def update time, record
+      unless @rrd
+        data_name = options[:data_name]
+        @specs = DEFS.get_specs data_name
+        return unless @specs # unknown data_name
+        return unless @specs[:ds]
+        #if (index_key = (@specs[:index_key] || @specs[:named_index]) and
+        #    index = record[index_key])
+        #  options[:index] = key_encode index
+        #  options.delete :key
+        #end
+        @key = mk_key options
+        return if (ex_proc = @specs[:exclude?]) and ex_proc.call(record)
+        path = mk_path options
+        ds_specs = @specs[:ds]
+        return if !ds_specs or ds_specs.empty?
+        @rrd = create_rrd path, time, (@interval || 300),
+          ds_specs, @specs[:rra]
+      end
+      data = @record_keys.map {|key| record[key]}
+      s = "#{time.to_i}:#{mk_update_str data}"
+      puts "  update #{@key} #{s}" if record['_d']
+      @rrd.buffered_update s
+
+      if (prop = @specs[:prop]) and (descr_k = prop[:description]) and
+          (description = record[descr_k]) and !description.empty?
+        for group, subdir, descr_v in Updater.get_tag_ary(description)
+          unless (tagrrd = @tagrrds[group + '/' + subdir])
+            tagrrd = create_tagrrd group, subdir, descr_v, record
+            @tagrrds[group + '/' + subdir] = tagrrd
+          end
+          tagrrd.buffered_update s
+        end
+      end
+    end
+
+    def mk_update_str data
+      data.map {|item|
+        if item =~ /\A0x[\da-f]+\z/i
+          Integer(item)
+        elsif item == '' or item == nil or
+            (item.kind_of?(Float) and not(item.finite?)) or
+            (item.kind_of?(String) and item !~ /\A[-+e\.\d]+$/i)
+          'U'
+        else
+          item
+        end
+      }.join(':')
+    end
+
+    def create_tagrrd group, subdir, descr_v, record
+      grp_dir = "#{options[:gra_dir]}/#{group}"
+      Dir.mkdir grp_dir unless File.exist? grp_dir
+      tag_dir = "#{grp_dir}/#{subdir}"
+      Dir.mkdir tag_dir unless File.exist? tag_dir
+      open(tag_dir + '/.description', 'w') {|f| f.puts descr_v}
+
+      time = record['_time']
+      path = "#{tag_dir}/#{@options[:host]}_#{@key}.rrd"
+      tagrrd = (@rrd_class ||RRD).new @options[:rrdcached_address],
+        @options[:base_dir]
+      tagrrd.set_create_args path, (time - @interval), @interval, *@rrd_args
+      tagrrd
+    end
+
+    def close
+      if @rrd
+        @rrd.flush_buffer
+      end
+      @tagrrds.each_value {|tagrrd| tagrrd.flush_buffer}
+    end
+  end
+end

data/lib/gri/util_daemon.rb

@@ -0,0 +1,19 @@
+module Process
+  class << self
+    unless method_defined?(:daemon)
+      def daemon(nochdir = nil, noclose = nil)
+        exit!(0) if Process.fork
+        Process.setsid
+        exit!(0) if Process.fork
+        Dir.chdir("/") unless nochdir
+        unless noclose
+          #File.umask(0)
+          STDIN.reopen("/dev/null", "r")
+          STDOUT.reopen("/dev/null", "w")
+          STDERR.reopen("/dev/null", "w")
+        end
+        0
+      end
+    end
+  end
+end

data/lib/gri/util_marshal.rb

@@ -0,0 +1,13 @@
+def Marshal.dump_to_file obj, path
+  tmppath = path + ".tmp#{$$}"
+  open(tmppath, 'w') {|f| Marshal.dump obj, f}
+  File.rename tmppath, path
+end
+
+def Marshal.load_from_file path
+  obj = nil
+  if File.size? path
+    open(path) {|f| obj = Marshal.load(f) rescue nil}
+  end
+  obj
+end

data/lib/gri/utils.rb

@@ -0,0 +1,63 @@
+require 'gri/ltsv'
+
+module GRI
+  module Utils
+    module_function
+
+    def load_records dir
+      values = LTSV.load_from_file dir + '/.records.txt'
+      values.inject({}) {|h, v| h[v['_key']] = v; h}
+    end
+
+    def search_records dirs, host
+      for dir in dirs
+        path = "#{dir}/#{host}/.records.txt"
+        if File.exist? path
+          values = LTSV.load_from_file path
+          rh = values.inject({}) {|h, v| (k = v['_key']) and h[k] = v; h}
+          return [dir, rh]
+        end
+      end
+      nil
+    end
+
+    def get_prop record
+      h = {}
+      data_name, index = parse_key record['_key']
+      record['_index'] = index
+      if data_name and (specs = DEFS.get_specs data_name) and specs[:prop]
+        specs[:prop].each {|k1, k2| h[k1] = record[k2] if record[k2]}
+        h[:name] ||= specs[:prop][:name]
+      end
+      h
+    end
+
+    def update_ltsv_file path, key, other
+      if File.exist? path
+        values = LTSV.load_from_file path
+        nvalues = values.inject({}) {|h, v| h[v[key]] = v; h}
+        nvalues.merge! other
+      else
+        nvalues = other
+      end
+      LTSV.dump_to_file nvalues, path
+    end
+
+    def parse_key s
+      s.to_s.scan(/\A([^_\d]*)(?:_?(.*))/).first
+    end
+
+    def parse_host_key s
+      s.to_s.scan(/\A([-\.A-Za-z0-9]+)_([^_\d]*)(?:_?(.*))/).first
+    end
+
+    def url_encode(s)
+      s.to_s.gsub(/[^a-zA-Z0-9_\-.]/n){ sprintf("%%%02X", $&.unpack("C")[0]) }
+    end
+
+    def key_encode s
+      s.to_s.tr(':/ =', '\-\-__').gsub(/[^-a-zA-Z0-9_.]/n) { #/
+        "%02X"%$&.unpack('C').first}
+    end
+  end
+end

data/lib/gri/vendor.rb

@@ -0,0 +1,76 @@
+module GRI
+  class Vendor
+    DEFS = {}
+    class <<DEFS
+      alias :update :merge!
+    end
+
+    attr_reader :name, :options
+
+    def self.check sysinfo, options={}
+      vdefs = nil
+      if !(sysobjectid = sysinfo['sysObjectID']) or sysobjectid.size < 5
+      else
+        sysoid = BER.dec_oid(sysobjectid[5..-1])
+        sysoid.size.downto(1) {|n|
+          sysoidkey = sysoid[0, n].map {|noid| noid.to_s}.join('.')
+          if (vdefs = self::DEFS[sysoidkey])
+            if Array === vdefs
+              vname, voptions, f_re, v_re = vdefs
+              vdefs = {:name=>vname, :options=>voptions,
+                :firm_re=>f_re, :version_re=>v_re}
+            end
+            break
+          end
+        }
+      end
+      vdefs ||= {:name=>'unknown'}
+      Vendor.new vdefs, sysinfo, options
+    end
+
+    def initialize vdefs, sysinfo, options
+      @name = vdefs[:name]
+      @sysinfo = sysinfo
+      @options = {'ver'=>'1', 'interfaces'=>true, 'ipaddr'=>true}
+      @options.merge! vdefs[:options] if vdefs[:options]
+      @options.merge! options if options
+      class <<@options
+        def set_unless_defined k, v=true
+          self[k] = v unless self.has_key? k
+        end
+      end
+      sysinfo['_firm'] = get_firm vdefs[:firm_re], sysinfo
+      sysinfo['_ver'] = get_ver vdefs[:version_re], sysinfo
+      sysinfo['_sysdescr'] = sysinfo['sysDescr']
+      if (cb = vdefs[:after_initialize])
+        cb.call @sysinfo, @options
+      end
+    end
+
+    def get_firm f_re, sysinfo
+      sysdescr = sysinfo['sysDescr'] || '?'
+      if f_re
+        match = f_re.match sysdescr
+        match ? match[1] : '?'
+      else
+        (f = sysdescr.scan(/\A([-\w]+)/).first) ? f[0] : '?'
+      end
+    end
+
+    def get_ver v_re, sysinfo
+      sysdescr = sysinfo['sysDescr'] || '?'
+      if v_re
+        match = v_re.match sysdescr
+        match ? match[1] : '?'
+      else
+        tmp, = sysdescr.scan(/(\d+\.[\.\d]+)/).first
+        tmp || '?'
+      end
+    end
+
+    def get_punits
+      units = PollingUnit.all_units
+      options.keys.map {|k| options[k] ? units[k] : nil}.compact
+    end
+  end
+end

data/lib/gri/version.rb

@@ -0,0 +1,3 @@
+module GRI
+  VERSION = "10.0.0"
+end

data/lib/gri/wmain.rb

@@ -0,0 +1,67 @@
+require 'optparse'
+
+require 'gri/msnmp'
+require 'gri/builtindefs'
+require 'gri/vendor'
+require 'gri/plugin'
+
+module GRI
+  class WMain
+    attr_writer :app
+
+    def initialize app=nil
+      @app = app
+      config_path = ENV['GRI_CONFIG_PATH'] || Config::DEFAULT_PATH
+      Config.init config_path
+    end
+
+    def run opts=nil
+      opts ||= {:server=>'webrick', :Port=>5125}
+      optparser = optparse opts
+      optparser.parse!
+      root_dir = Config['root-dir'] ||= Config::ROOT_PATH
+      plugin_dirs = Config.getvar('plugin-dir') || [root_dir + '/plugin']
+      Plugin.load_plugins plugin_dirs, Config
+
+      app = @app
+      builder = Rack::Builder.new {
+        use Rack::Static, :urls=>['/css', '/js'], :root=>app.public_dir
+        run app
+      }
+      if ENV['GATEWAY_INTERFACE']
+        Rack::Handler::CGI.run builder
+      else
+        if Rack.const_defined? :Server
+          opts[:app] = builder
+          Rack::Server.new(opts).start
+        else
+          Rack::Handler::WEBrick.run builder, opts
+        end
+      end
+    end
+
+    def optparse opts
+      op = OptionParser.new
+      op.on('--debug') {$debug = true; STDOUT.sync = true}
+      op.on('-d', '--daemonize') {opts[:daemonize] = true}
+      op.on('-h', '--host HOST') {|arg| opts[:Host] = arg}
+      op.on('-p', '--port PORT', Integer) {|arg| opts[:Port] = arg}
+      op.on('-s', '--server SERVER') {|arg| opts[:server] = arg}
+      class <<op
+        attr_accessor :options
+      end
+      op.options = opts
+      op
+    end
+  end
+end
+
+module Rack
+  class Static
+    alias :call0 :call
+    def call env
+      env['PATH_INFO'] ||= '/'
+      call0 env
+    end
+  end
+end