slashport 0.15.10

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'rake/rdoctask'
+
+require 'merb-core'
+require 'merb-core/tasks/merb'
+
+include FileUtils
+
+# Load the basic runtime dependencies; this will include 
+# any plugins and therefore plugin rake tasks.
+init_env = ENV['MERB_ENV'] || 'rake'
+Merb.load_dependencies(:environment => init_env)
+     
+# Get Merb plugins and dependencies
+Merb::Plugins.rakefiles.each { |r| require r } 
+
+# Load any app level custom rakefile extensions from lib/tasks
+tasks_path = File.join(File.dirname(__FILE__), "lib", "tasks")
+rake_files = Dir["#{tasks_path}/*.rake"]
+rake_files.each{|rake_file| load rake_file }
+
+desc "Start runner environment"
+task :merb_env do
+  Merb.start_environment(:environment => init_env, :adapter => 'runner')
+end
+
+require 'spec/rake/spectask'
+require 'merb-core/test/tasks/spectasks'
+desc 'Default: run spec examples'
+task :default => 'spec'
+
+##############################################################################
+# ADD YOUR CUSTOM TASKS IN /lib/tasks
+# NAME YOUR RAKE FILES file_name.rake
+##############################################################################

data/app/controllers/application.rb

@@ -0,0 +1,2 @@
+class Application < Merb::Controller
+end

data/app/controllers/cfg.rb

@@ -0,0 +1,8 @@
+class Cfg < Application
+
+  def index
+    self.content_type = :text
+    return SlashPort::Component.get_configs.to_yaml
+  end
+
+end

data/app/controllers/exceptions.rb

@@ -0,0 +1,13 @@
+class Exceptions < Merb::Controller
+  
+  # handle NotFound exceptions (404)
+  def not_found
+    render :format => :html
+  end
+
+  # handle NotAcceptable exceptions (406)
+  def not_acceptable
+    render :format => :html
+  end
+
+end

data/app/controllers/var.rb

@@ -0,0 +1,27 @@
+class Var < Application
+  def index
+    only_provides :json, :text, :pp
+
+    filter = Hash.new
+    params.each do |key, value|
+      # skip parameters from merb itself
+      next if ["action", "controller", "format", "id"].include?(key)
+      next if value == nil
+
+      # If it looks like a regex, treat it like one.
+      # That is, if the value is /something/ (begin and end with slash)
+      if value =~ /^\/.+\/$/
+        filter[key] = Regexp.new(value[1..-2]) rescue value
+      else
+        # otherwise, treat it like a literal string to full match.
+        filter[key] = Regexp.new("^#{Regexp.escape(value)}$")
+      end
+    end
+
+    # ensure filter isn't changed
+    filter.freeze
+
+    @attributes = SlashPort::Component.get_attributes(filter)
+    display @attributes
+  end
+end

data/app/controllers/vardoc.rb

@@ -0,0 +1,7 @@
+class Vardoc < Application
+
+  def index
+    render
+  end
+  
+end

data/app/helpers/cfg_helper.rb

@@ -0,0 +1,5 @@
+module Merb
+  module CfgHelper
+
+  end
+end # Merb

data/app/helpers/global_helpers.rb

@@ -0,0 +1,5 @@
+module Merb
+  module GlobalHelpers
+    # helpers defined here available to all views.  
+  end
+end

data/app/helpers/var_helper.rb

@@ -0,0 +1,5 @@
+module Merb
+  module VarHelper
+
+  end
+end # Merb

data/app/helpers/vardoc_helper.rb

@@ -0,0 +1,5 @@
+module Merb
+  module VardocHelper
+
+  end
+end # Merb

data/app/models/base/attribute.rb

@@ -0,0 +1,13 @@
+module SlashPort
+  class Attribute
+    attr_reader :handler
+    attr_reader :doc
+    attr_reader :sortkeys
+
+    def initialize(handler, doc, sortkeys=[])
+      @handler = handler
+      @doc = doc
+      @sortkeys = sortkeys
+    end
+  end # class Attribute
+end # module SlashPort

data/app/models/base/component.rb

@@ -0,0 +1,206 @@
+require "socket"
+
+module SlashPort
+  class Component
+    @@subclasses = Array.new
+    @@components = Array.new
+
+    def attributes
+      return self.class.attributes
+    end
+
+    def configs
+      return self.class.configs
+    end
+
+    def get_attributes(filter=nil)
+      get_things(attributes, filter)
+    end
+
+    def get_configs(filter=nil)
+      get_things(configs, filter)
+    end
+
+    def _want(pattern, *values)
+      if pattern == nil
+        return true
+      end
+
+      want = false
+      values.each do |value|
+        #puts "Checking #{pattern.class}/#{pattern} against #{value.class}/#{value.inspect}"
+        if (pattern.is_a?(Regexp) and !!(value.to_s =~ pattern))
+          #puts "Match! =~"
+          want = true
+          break
+        elsif value == pattern
+          #puts "Match! =="
+          want = true
+          break
+        end
+      end
+      return want
+    end
+
+    def get_things(thing, filter=nil)
+      return unless _want(filter["component"], self.class.label)
+
+      data = []
+
+      thing.each do |section, var|
+        next unless _want(filter["section"], section)
+        results = self.send(var.handler)
+        next if results == nil
+        results = [results] if !results.is_a?(Array)
+
+        results.each do |result|
+          result.labels["component"] = self.class.label
+          result.labels["section"] = section
+          result.labels["host"] = Socket.gethostname
+
+          keep = true
+          filter.each do |filterkey,filtervalue|
+            want = _want(filtervalue, result.labels[filterkey],
+                         result.data[filterkey])
+            #puts "Filter: #{want} => #{filterkey} #{filtervalue}"
+
+            if (!want)
+              keep = false
+              break
+            end
+          end
+
+          if keep
+            # if our filter includes a 'data' name, then we
+            # should strip all nonmatching data entries.
+            if (result.data.keys & filter.keys).length > 0
+              result.data.each_key do |key|
+                next if filter.has_key?(key)
+                #puts "Removing #{key} data"
+                result.data.delete(key)
+              end
+            end
+            data << result
+          end
+        end
+      end
+      return data
+    end
+
+    def path(*names)
+      return [self.class.label, *names].join("/")
+    end
+
+    # See Class#inherited for what this method 
+    def self.inherited(subclass)
+      puts "#{subclass.name} inherits #{self.name}"
+      @@subclasses << subclass
+
+      if subclass.respond_to?(:class_initialize)
+        subclass.class_initialize
+      end
+    end # def self.inherited
+
+    # class-level to easily map a attribute name to a method
+    # arguments:
+    #   :name => attribute name
+    #   :handler => method handler name
+    #   :doc => attribute documentation
+    #   :sort => [optional] array of keys for sort (used with var.text output)
+    def self.attribute(options = {})
+      if options[:doc] == nil
+        raise "Attribute #{self.name}/#{name} has no description"
+      end
+      name = options[:name]
+      puts "#{self.name}: new attribute #{name}"
+      options[:sort] ||= []
+
+      # remember: this is a class-level instance attribute
+      @attributes[options[:name]] = Attribute.new(options[:handler], options[:doc], options[:sort])
+    end # def self.attribute
+
+    # class-level to easily map a variable name to a handler
+    def self.config(name, handler, description=nil)
+      if description == nil
+        raise "Config #{self.name}/#{name} has no description"
+      end
+      #puts "#{self.name}: new config #{name}"
+
+      # remember: this is a class-level instance variable
+      @configs[name] = Variable.new(handler, description)
+    end # def self.config
+
+    def self.configs(filter=nil)
+      return @configs
+    end
+
+    def self.attributes(filter=nil)
+      return @attributes
+    end
+
+    # class-level initialization. This is called when ruby first
+    # creates this class object, a hack made possible by
+    # overriding Class#inherited (see 'def inherited' above).
+    def self.class_initialize
+      #puts "#{self}::class_initialize"
+      # remember, this is a class-level instance attribute
+      @attributes = Registry.new
+      @configs = Registry.new
+      @label = self.name.split("::")[-1].downcase
+
+      # disable this component by default
+      #puts "Disabling component '#{@label}' (default action, you must enable it if you want to use it)"
+      #disable
+      enable
+    end # def.class_initialize
+
+    # Show me all subclasses of SlashPort::Component
+    def self.components
+      if @@components.length == 0
+        @@subclasses.each do |klass|
+          component = klass.new
+          @@components << component
+        end
+      end
+
+      return @@components
+    end # def self.components
+
+    def self.get_things(thing, filter=nil)
+      data = []
+      self.components.each do |component|
+        next unless component.class.is_enabled?
+        result = component.send("get_#{thing}", filter)
+        if result
+          data += result
+        end
+      end
+      return data
+    end
+
+    def self.get_attributes(filter=nil)
+      return self.get_things("attributes", filter)
+    end
+
+    def self.get_configs(filter=nil)
+      return self.get_things("configs", filter)
+    end
+
+    def self.label
+      return @label
+    end
+
+    def self.disable
+      @active = false
+    end
+
+    def self.enable
+      @active = true
+    end
+
+    def self.is_enabled?
+      return @active
+    end
+
+  end # class Component
+end # module SlashPort

data/app/models/base/exec.rb

@@ -0,0 +1,40 @@
+class SlashPort::Exec
+  def initialize(cmd)
+    @cmd = cmd
+  end
+
+  def run
+    output = `#{@cmd}`
+    code = $?.exitstatus
+
+    return [output, code]
+  end
+
+  def to_tuple
+    data = []
+
+    output, code = run
+    lines = output.split(/\r?\n/)
+
+    if lines.length == 0
+      tuple = SlashPort::Tuple.new
+      tuple.data["output-lines"] = lines.length
+      tuple.data["exit-code"] = code
+      data << tuple
+    end
+
+    lines.each do |line|
+      tuple = SlashPort::Tuple.new
+      tuple.data["exit-code"] = code
+      begin
+        tuple.data["value"] = Float(line)
+      rescue ArgumentError => e
+        tuple.labels["string"] = 1
+        tuple.data["value"] = line
+      end
+
+      data << tuple
+    end
+    return data
+  end
+end

data/app/models/base/registry.rb

@@ -0,0 +1,4 @@
+module SlashPort
+  class Registry < Hash
+  end
+end

data/app/models/base/tuple.rb

@@ -0,0 +1,31 @@
+
+# A tuple is like a slashport row. 
+# Each tuple contains a set of labels and data.
+# Each label or data is a key:value pair, allowing you
+# to name each label and each data.
+#
+# For example, transmit packet counts for a network interface would have
+# a label of 'interface=eth0', for example, and a data of 'txpackets=12345'
+# Multiple labels are supported/encouraged, as are multiple data.
+# Following the interface example, you could hold all metrics for a single
+# network interface with a single Tuple: ie; 
+#   labels: { "interface" => "eth0" }
+#   data: { "txpackets" => 298374, "rxpackets" => 7577, "speed" => 1000 }
+#
+# Labels are intended to represent attributes that will not change.
+# Data are intended to represent attributes that can change.
+class SlashPort::Tuple
+  attr_accessor :labels
+  attr_accessor :data
+  def initialize
+    @labels = Hash.new
+    @data = Hash.new
+  end
+
+  def to_json
+    return {
+      "labels" => @labels,
+      "data" => @data,
+    }.to_json
+  end
+end

data/app/models/components/linuxhost.rb

@@ -0,0 +1,125 @@
+require 'rubygems'
+
+class SlashPort::Component
+  class LinuxHost < SlashPort::Component
+    attribute :name => "uptime",
+              :handler => :Uptime,
+              :doc => "Uptime in seconds"
+
+    attribute :name => "interfaces",
+              :handler => :IfStats,
+              :sort => ["interface", "field"],
+              :doc => "Interface Statistics"
+
+    attribute :name => "memory",
+              :handler => :MemStats,
+              :doc => "Memory stats from /proc/meminfo"
+
+    attribute :name => "disk",
+              :handler => :DiskStats,
+              :doc => "Disk stats from 'df'"
+
+    attribute :name => "load",
+              :handler => :LoadAverage,
+              :doc => "System load average reported by uptime(1)"
+
+    def _reapchild
+      begin
+        Process.wait(-1, Process::WNOHANG)
+      rescue Errno::ECHILD
+        # ignore
+      end
+    end
+
+    def Uptime
+      tuple = SlashPort::Tuple.new
+      tuple.data["uptime"] = File.open("/proc/uptime").read().split(" ")[0]
+      return tuple
+    end
+
+    def IfStats
+      data = Array.new
+      File.open("/proc/net/dev").readlines().each do |line|
+        line.chomp!
+        next if line =~ /^Inter-|^ face/
+
+        tuple = SlashPort::Tuple.new
+
+        fields = %w[rx_bytes rx_packets rx_errors rx_drop rx_fifo rx_frame
+                    rx_compressed rx_multicast tx_bytes tx_packets tx_errors
+                    tx_drop tx_fifo tx_colls tx_carrier tx_compressed]
+
+        interface, values = line.split(":")
+        interface.gsub!(/\s+/, "")
+        
+        tuple.labels["interface"] = interface
+        fields.zip(values.split).each do |field,value|
+          tuple.data[field] = value
+        end
+        data << tuple
+      end
+      return data
+    end
+
+    def MemStats
+      data = Array.new
+      tuple = SlashPort::Tuple.new
+      File.open("/proc/meminfo").readlines().each do |line|
+        line.chomp!
+        key, value, unit = line.split(/[: ]+/)
+        value = value.to_i
+        if unit == "kB"
+          value *= 1024
+        end
+
+        tuple.data[key.downcase] = value
+      end
+      data << tuple
+      return data
+    end # def MemStats
+
+    def DiskStats
+      data = Array.new
+      IO.popen("df -PlB 1").readlines().each do |line|
+        # skip header
+        next if line =~ /Filesystem\s/
+        # skip nonpath sources (tmpfs, udev, etc)
+        next unless line =~ /^\//
+
+        line.chomp!
+        tuple = SlashPort::Tuple.new
+        fields = %w[size used available percentused]
+        values = line.split
+        source = values.shift
+        mount = values.pop
+
+        tuple.labels["source"] = source
+        tuple.labels["mount"] = mount
+        fields.zip(values).each do |field,value|
+          if field == "percentused"
+            value = value.to_i / 100.0
+          end
+
+          tuple.data[field] = value
+        end
+        data << tuple
+      end
+      _reapchild
+      return data
+    end # def DiskStats
+
+    def LoadAverage
+      data = Array.new
+      tuple = SlashPort::Tuple.new
+      loads = %x{uptime}.chomp.delete(",").split(/ +/)[-3..-1].map { |x| x.to_f }
+      _reapchild
+      load1, load5, load15 = loads
+      tuple.data["load-1min"] = load1
+      tuple.data["load-5min"] = load5
+      tuple.data["load-15min"] = load15
+
+      data << tuple
+      return data
+    end # def LoadAverage
+  end # class LinuxHost
+end # class SlashPort::Component