arbi 1.0.2

data/bin/arbi

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'arbi'
+
+client = Arbi::Client.new
+client.start
+client.close

data/bin/arbid

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require 'arbi'
+
+server = Arbi::Server.new
+
+["KILL", "ABRT", "INT", "QUIT"].each do |sig|
+    trap(sig){
+        server.close
+    }
+end
+
+server.start

data/lib/arbi.rb

@@ -0,0 +1,218 @@
+#!/usr/bin/ruby
+
+class Regexp
+    alias oldto_s to_s
+    def to_s
+        regex = oldto_s.gsub(/^\(\?|\)/, '')
+        "/#{regex.split(/:/, 2)[1]}/#{regex.split(':')[0].split('-')[0]}"
+    end
+end
+
+module Arbi
+
+    require 'getopt/long'
+    include Getopt
+
+    VERSION = "1.0.2"
+
+    @cmd = []
+
+    def self.add_plugin regex, instance
+        @cmd += [[regex, instance]]
+    end
+
+    def self.cmd
+        @cmd
+    end
+
+    def self.show_version
+        puts "Arbi (Client|Server) v#{VERSION}"
+        exit 0
+    end
+
+    class Server
+        require 'socket'
+
+        def initialize
+            @threads = Array.new
+            @sessions = Array.new
+            @address = 'localhost'
+            @port = 6969
+            parse_args
+            @server = TCPServer.new(@address, @port)
+        end
+
+        def show_help
+            puts "Arbi Server, USAGE:"
+            puts "\t#{$0} [switches]"
+            puts "\t\t--bind-address|-a\tAddress to bind, default to \"127.0.0.1\""
+            puts "\t\t        --port|-p\tPort to use for server, default to 40"
+            puts "\t\t     --version|-v\tPrint version and exit"
+            puts "\t\t        --help|-h\tPrint this help and exit"
+            exit 0
+        end
+
+        def start
+            @servert = Thread.new do
+                while(session = @server.accept)
+                    new_client session
+                end
+            end
+            @servert.join
+        end
+
+        def close
+            @sessions.each{ |session|
+                session.close
+            }
+
+            @threads.each{ |thread|
+                thread.kill
+            }
+            @server.close
+            @servert.kill
+        end
+
+    private
+
+        def parse_args
+            begin
+                opts = Arbi::Long.getopts(
+                    ["--bind-address", "-a", Arbi::REQUIRED],
+                    ["--port", "-p", Arbi::REQUIRED],
+                    ["--help", "-h", Arbi::BOOLEAN],
+                    ["--version", "-v", Arbi::BOOLEAN]
+                )
+            rescue Getopt::Long::Error => e
+                puts "Arguments error: #{e}"
+                exit 0
+            end
+
+            @address = opts['a']    if opts['a']
+            @port    = opts['p']    if opts['p']
+            show_help               if opts['h']
+            Arbi::show_version      if opts['v']
+        end
+
+        def new_client session
+            @threads.push Thread.start(session){ |session|
+                while message = session.gets
+                    toggle = true
+                    message = message.strip
+                    break if message =~ /^QUIT$/i
+
+                    if message =~ /^HELP$/i
+                        session.print "help:\r\n"
+                        Arbi::cmd.each { |pair|
+                            session.print "#{pair[0]}\r\n"
+                        }
+                        session.print "/^quit$/i\r\n"
+                        session.print "/^version$/i\r\n"
+                        session.print "/^help$/i\r\n"
+                        session.print "END\r\n"
+                        toggle = !toggle
+                    end
+
+                    if message =~ /^VERSION$/i
+                        session.print "version:\r\nArbi (Client|Server) v#{VERSION}\r\nEND\r\n"
+                        toggle = !toggle
+                    end
+
+                    Arbi::cmd.each { |pair|
+                        if message =~ pair[0]
+                            session.print (pair[1].class == Class ? pair[1].protocolize(pair[1].get_infos) : pair[1].class.protocolize(pair[1].get_infos))
+                            toggle = !toggle
+                        end
+                    }
+                    session.print "error:\r\nCommand doesn't exist\r\nEND\r\n" if toggle
+                end
+                @sessions -= [session]
+                session.close
+            }
+            @sessions.push session
+        end
+    end
+
+    class Client
+        def initialize
+            @address = 'localhost'
+            @port = 6969
+            @command = "help\r\nquit\r\n"
+            parse_args
+            @sock = TCPSocket.new(@address, @port)
+        end
+
+        def start
+            @sock.print @command
+            @command = @command.strip.split(/\r\n/).map(&:upcase)
+            @command.pop
+            toggle = false
+            while (line = @sock.gets)
+                puts (command = @command.shift) + ":"
+                buff = ""
+                while (l = @sock.gets).strip !~ /^END$/i do; buff << l; end
+                buff.gsub!(/END\s+$/m, '')
+                case line.strip
+                when /^error:$/i
+                    puts "ERROR: #{buff}"
+                    next
+                when /^help:$/i
+                    puts buff
+                when /^version$:/i
+                    puts buff
+                end
+                Arbi::cmd.each{|cmd|
+                    puts (cmd[1].class == Class ? cmd[1].friendlize(buff) : cmd[1].class.friendlize(buff)) if command =~ cmd[0]
+                }
+                puts if @command != []
+            end
+        end
+
+        def close
+            @sock.close
+        end
+
+        def show_help
+            puts "Arbi client:"
+            puts "\tUSAGE: #{$0} [switches]"
+            puts "\t\t   --help|-h\tshow this helps"
+            puts "\t\t--version|-v\tshow version of arbi"
+            puts "\t\t--address|-a\tset the address to connect, default to 'localhost'"
+            puts "\t\t   --port|-p\tset the port to connect, default to 40"
+            puts "\t\t--command|-c\tset commands to execute, defaults is 'help'"
+            exit 0
+        end
+
+    private
+
+        def parse_args
+            begin
+                opts = Arbi::Long.getopts(
+                    ["--help"],
+                    ["--version"],
+                    ["--address", "-a", Arbi::REQUIRED],
+                    ["--port", "-p", Arbi::REQUIRED],
+                    ["--commands", "-c", Arbi::REQUIRED]
+                )
+            rescue Arbi::Long::Error => e
+                p ARGV
+                $stderr.puts "Arguments error: #{e}"
+                exit 1
+            end
+
+            Arbi::show_version      if opts["v"]
+            show_help               if opts["h"]
+            @address    = opts["a"] if opts["a"]
+            @port       = opts["p"] if opts["p"]
+            @command    = "#{opts["c"]},quit".gsub(/,+/, ',').gsub(/\s+/, '').split(/,/).
+                delete_if{|x|x=~/^quit$/i}.uniq.push('quit', '').join("\r\n") if opts["c"]
+        end
+    end
+end
+
+require 'arbi/plugins/batteries'
+require 'arbi/plugins/cpu'
+require 'arbi/plugins/diskspace'
+require 'arbi/plugins/net'
+require 'arbi/plugins/ram'
+require 'arbi/plugins/thermal'

data/lib/arbi/common.rb

@@ -0,0 +1,3 @@
+def file_get_content file
+    File.readlines(file).join
+end

data/lib/arbi/plugins/batteries.rb

@@ -0,0 +1,85 @@
+class Batteries
+    require 'arbi/common'
+
+    def initialize
+        @AC = {'sanity' => false, 'state' => false, 'percent' => false}
+        @batteries = Dir.glob "/proc/acpi/battery/*"
+    end
+
+    def get_infos
+        batteries = Hash.new
+        @batteries.each { |battery|
+            batteries.merge!(get_battery_infos(battery))
+        }
+        batteries.merge average batteries
+    end
+
+    def self.protocolize batteries
+        str = "batteries:\r\n"
+        batteries.each { |key, value|
+            str << "#{key}|#{value["percent"] || '-'}"
+            if key != "AVERAGE"
+                str << "|#{value["state"] || '-'}|#{value["sanity"] || '-'}"
+            end
+            str << "\r\n"
+        }
+        str << "END\r\n"
+    end
+
+    def self.friendlize raw
+        raw.strip!
+        max = raw.lines.map{|x| x.split(/\|/)[0].length}.max + 4
+        str = "NAME".ljust(max) + "PERC    STATE       SANITY\r\n"
+        raw.split(/\r?\n/).each { |line|
+            datas = line.split /\|/
+            str << datas[0].ljust(max) + datas[1].ljust(8)
+            if datas[0] != "AVERAGE"
+                str << datas[2].ljust(12) + datas[3]
+            end
+            str << "\r\n"
+        }
+        str
+    end
+
+private
+
+    def average batteries
+        avg, n = 0, 0
+        batteries.each do |key, value|
+            if value["percent"]
+                avg += value["percent"].gsub(/%$/, '').to_i
+                n += 1
+            end
+        end
+        avg = (avg.to_f / n).to_s.gsub /\.0/, '' + '%'
+
+        ({'AVERAGE' => {
+            'sanity'    => '-',
+            'state'     => '-',
+            'percent'   => avg
+            }
+        })
+    end
+
+    def get_battery_infos dir
+        info = file_get_content dir + "/info"
+        state = file_get_content dir + "/state"
+        present = {'yes' => true, 'no' => false}[state.match(/^present:\s*?([^\s]+?)$/)[1]]
+        if !present then return {dir.gsub(/^\/proc\/acpi\/battery\//, '') => @AC} end
+        ({dir.gsub(/^\/proc\/acpi\/battery\//, '') => {
+            'sanity'    => sprintf('%.1f%%', 100.0 /
+                    (info.match(/^design capacity:\s*?([^\s]+?) mAh$/)[1].to_i) *
+                    (info.match(/^last full capacity:\s*?([^\s]+?) mAh$/)[1].to_i)).gsub(/\.0%$/, '%'),
+            'state'     => state.match(/^charging state:\s*?([^\s]+?)$/)[1],
+            'percent'   => sprintf('%.1f%%', 100.0 /
+                    (info.match(/^last full capacity:\s*?([^\s]+?) mAh$/)[1].to_i) *
+                    (state.match(/^remaining capacity:\s*?([^\s]+?) mAh$/)[1].to_i)).gsub(/\.0%$/, '%')
+        }})
+    end
+end
+
+if __FILE__ == $0
+    puts Batteries.friendlize Batteries.protocolize(Batteries.new.get_infos).gsub(/^batteries:\s+|^END\s+/m, '').strip
+else
+    Arbi.add_plugin /^batteries$/i, Batteries.new
+end

data/lib/arbi/plugins/cpu.rb

@@ -0,0 +1,89 @@
+class Cpu
+    require 'arbi/common'
+    require 'thread'
+
+    def initialize
+        @prev = {:idle => Hash.new, :total => Hash.new}
+        @percents = Hash.new
+        @mutex = Mutex.new
+        @serv = Thread.new do
+            while true
+                @mutex.lock
+                update
+                @mutex.unlock
+                sleep 2
+            end
+        end
+    end
+
+    def get_infos
+        @mutex.lock
+        perc = @percents
+        @mutex.unlock
+        perc
+    end
+
+    def self.protocolize percents
+        str = "cpu:\r\n"
+        percents.each { |key, value|
+            str += "#{key}|#{value}\r\n"
+        }
+        str + "END\r\n"
+    end
+
+    def self.friendlize raw
+        raw = raw.to_s.strip
+        max = raw.lines.map{|x|x.split(/\|/)[0].length}.max + 4
+        str = "NAME".ljust(max) + "PERC\r\n"
+        raw.split(/\r?\n/).each { |line|
+            datas = line.split /\|/
+            str << datas[0].ljust(max) + datas[1] + "\r\n"
+        }
+        str
+    end
+
+    def close
+        @serv.kill
+    end
+
+private
+
+    def update
+        file_get_content('/proc/stat').split("\n").each do |line|
+            if line =~ /^cpu/
+                datas = line.split /\s+/
+                name = datas.shift
+                name = (name == 'cpu' ? 'AVERAGE' : name)
+                total = eval datas.join('+')
+                idle = datas[3].to_i
+
+                if not @prev[:idle].include? name or not @prev[:total].include? name
+                    @prev[:idle][name] = @prev[:total][name] = 0
+                end
+
+                @percents[name] = (100 * ((total - @prev[:total][name]) - (idle - @prev[:idle][name])) / (total - @prev[:total][name])).to_s + "%"
+                @prev[:idle][name] = idle
+                @prev[:total][name] = total
+            end
+        end
+        
+        average = {"AVERAGE" => @percents["AVERAGE"]} and @percents.delete("AVERAGE") and @percents.merge!(average)
+    end
+end
+
+if __FILE__ == $0
+    x = Cpu.new
+    ["INT", "KILL", "ABRT", "ILL", "QUIT"].each do |sig|
+        trap(sig) do
+            x.close
+            exit 0
+        end
+    end
+    10.times {
+        sleep 2
+        puts Cpu.friendlize Cpu.protocolize(x.get_infos).gsub(/^cpu:\s+|END\s+/m, '')
+    }
+    x.close
+else
+    Arbi.add_plugin /^cpu$/i, Cpu.new
+end

data/lib/arbi/plugins/diskspace.rb

@@ -0,0 +1,68 @@
+class Diskspace
+    require 'arbi/common'
+    require 'sys/filesystem'
+    include Sys
+
+    def get_infos
+        devices = Array.new
+        get_devices.each do |device|
+            begin
+                diskstat = Filesystem.stat device['point']
+                device.merge!({'usage' => (100 - (100.0 / diskstat.blocks  * diskstat.blocks_available).round).to_s + "%",
+                    'space' => diskstat.blocks * diskstat.fragment_size})
+                devices += [device]
+            rescue
+            end
+        end
+        devices
+    end
+
+    def self.protocolize devices
+        str = "devices:\r\n"
+        devices.each do |device|
+            str += "#{device['device']}|#{device['point']}|#{device['usage']}|#{self.unitize device['space']}\r\n"
+        end
+        str + "END\r\n"
+    end
+
+    def self.friendlize raw
+        raw = raw.to_s.strip
+        dmax = [raw.lines.map{|line|line.split(/\|/)[0].length}.max + 4, 8].max
+        mmax = [raw.lines.map{|line|line.split(/\|/)[1].length}.max + 4, 7].max
+        str = "DEVICE".ljust(dmax) + "MOUNT".ljust(mmax) + "USE %  SPACE\r\n"
+        raw.split(/\r?\n/).each { |line|
+            datas = line.split /\|/
+            str << datas[0].ljust(dmax) + datas[1].ljust(mmax) + datas[2].ljust(7) + datas[3] + "\r\n"
+        }
+        str
+    end
+
+private
+
+    def get_devices
+        devices = Array.new
+        Filesystem.mounts do |fs|
+                devices += [{'device' => fs.name, 'point' => fs.mount_point}]
+        end
+        devices
+    end
+
+    def self.unitize misure
+        u = 'b'
+        %w(Kb Mb Gb Tb).each do |i|
+            if misure >= 1024
+                misure /= 1024.0
+                u = i
+            else
+                return misure.round.to_s + u
+            end
+        end
+        misure.round.to_s + u
+    end
+end
+
+if __FILE__ == $0
+    puts Diskspace.friendlize Diskspace.protocolize(Diskspace.new.get_infos).gsub(/^devices:\s+|END\s+$/m, '')
+else
+    Arbi::add_plugin /^diskstats$/i, Diskspace.new
+end

data/lib/arbi/plugins/net.rb

@@ -0,0 +1,120 @@
+class Net
+    require 'arbi/common'
+    require 'thread'
+
+    def initialize
+        @stats = Hash.new
+        @prev = {:up => Hash.new, :down => Hash.new}
+        @mutex = Mutex.new
+        @serv = Thread.new do
+            while true
+                @mutex.lock
+                update
+                @mutex.unlock
+                sleep 2
+            end
+        end
+    end
+
+    def get_infos
+        @mutex.lock
+        s = @stats
+        @mutex.unlock
+        s
+    end
+
+    def self.protocolize stats
+        str = "net:\r\n"
+        stats.each { |key, value|
+            str += "#{key}|#{value[:up]}|#{value[:down]}|#{value[:state] ? 'on' : 'off'}"
+            if value[:quality]
+                str += "|#{value[:essid]}|#{value[:quality]}"
+            end
+            str += "\r\n"
+        }
+        str + "END\r\n"
+    end
+
+    def self.friendlize raw
+        raw = raw.to_s.strip
+        nmax = raw.lines.map{|x|x.split(/\|/)[0].length}.max + 4
+        umax = raw.lines.map{|x|x.split(/\|/)[1].gsub(/^(\d+\.\d).*$/, '\1').length}.max + 2
+        dmax = raw.lines.map{|x|x.split(/\|/)[2].gsub(/^(\d+\.\d).*$/, '\1').length}.max + 2
+        emax = [[raw.lines.map{|x|x.split(/\|/)[4].to_s.length}.max + 4, 7].max, 34].min
+        str = "NAME".ljust(nmax) + "UP      DOWN    STATE  " + "ESSID".ljust(emax) + "QUALITY\r\n"
+        raw.split(/\r?\n/).each { |line|
+            datas = line.split(/\|/)
+            str << datas[0].ljust(nmax) + ('%.1f' % datas[1].to_f).ljust(8) + ('%.1f' % datas[2].to_f).ljust(8) + datas[3].ljust(7)
+            str << datas[4].ljust(emax) + datas[5] if datas[4]
+            str << "\r\n"
+        }
+        str
+    end
+
+private
+
+    def update
+        file_get_content('/proc/net/dev').gsub(/^.*\|.*?\n/m, '').split("\n").each do |line|
+            datas = line.gsub(/^\s+|\s+$/, '').split(/:\s+|\s+/)
+            name = datas.shift
+            down = datas[0].to_i
+            up = datas[8].to_i
+
+            if not @prev[:up].include? name or not @prev[:down].include? name
+                @prev[:up][name] = @prev[:down][name] = 0
+            end
+            
+            @stats[name] = {:up => (up - @prev[:up][name]) / 1024.0,
+                :down => (down - @prev[:down][name]) / 1024.0,
+                :state => get_state(name),
+                :quality => nil,
+                :essid => nil}
+            if @stats[name][:state]
+                @stats[name][:quality] = get_quality(name)
+                @stats[name][:essid] = get_essid(name) if @stats[name][:quality]
+            end
+            @prev[:up][name] = up
+            @prev[:down][name]  = down
+        end
+    end
+
+    def get_state interface
+        if file_get_content('/proc/net/route') =~ /#{interface}/
+            true
+        else
+            false
+        end
+    end
+
+    def get_quality interface
+        begin
+            file_get_content('/proc/net/wireless').match(/^\s*?#{interface}:.*$/)[0].strip.split(/:\s+|\s+/)[2].gsub('.', '') + "%"
+        rescue
+            nil
+        end
+    end
+
+    def get_essid interface
+        require "socket"
+
+        iwreq = [interface, " " * 32, 32, 0].pack("a16pII")
+        sock = Socket.new(Socket::AF_INET, Socket::SOCK_DGRAM, 0)
+        sock.ioctl(0x8B1B, iwreq)
+        return iwreq.unpack("a16pII")[1].strip
+    end
+
+    def close
+        @serv.kill
+    end
+end
+
+if __FILE__ == $0
+    x = Net.new
+    10.times {
+        sleep 2
+        puts Net.friendlize Net.protocolize(x.get_infos).gsub(/^net:\s+|END\s+$/m, '')
+    }
+    x.close
+else
+    Arbi::add_plugin /^net$/i, Net.new
+end

data/lib/arbi/plugins/ram.rb

@@ -0,0 +1,29 @@
+class Ram
+    require 'arbi/common'
+
+    def get_infos
+        mem = file_get_content('/proc/meminfo')
+        total = mem.match(/^MemTotal:\s*?([0-9]+) kB/)[1].to_i
+        free = mem.match(/^MemFree:\s*?([0-9]+) kB/)[1].to_i +
+            mem.match(/^Buffers:\s*?([0-9]+) kB/)[1].to_i +
+            mem.match(/^Cached:\s*?([0-9]+) kB/)[1].to_i
+        perc = 100.0 / total * free
+        {'used' => sprintf('%.1f%%', 100.0 - perc),
+            'free' => sprintf('%.1f%%', perc)}
+    end
+
+    def self.protocolize perc
+        "ram:\r\n#{perc['used']}|#{perc['free']}\r\nEND\r\n"
+    end
+
+    def self.friendlize raw
+        datas = raw.to_s.strip.split(/\r?\n/)[0].split(/\|/)
+        "USED    FREE\r\n#{datas[0].ljust(8)}#{datas[1]}"
+    end
+end
+
+if __FILE__ == $0
+    puts Ram.friendlize Ram.protocolize(Ram.new.get_infos).gsub(/^ram:\s+|END\s+$/m, '')
+else
+    Arbi::add_plugin /^ram$/i, Ram.new
+end

data/lib/arbi/plugins/thermal.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+class Thermal
+    require 'arbi/common'
+
+    def initialize
+        @temperatures = Hash.new
+        @tempdirs = Dir.glob "/proc/acpi/thermal_zone/*"
+        @tempdirs.each do |dir|
+            trip_points = file_get_content dir + "/trip_points"
+            name = dir.gsub(/^\/proc\/acpi\/thermal_zone\//, '')
+            @temperatures.merge!({name => {'temperature' => file_get_content(dir + '/temperature').match(
+                        /^temperature:\s*?([0-9]{1,3}) C$/)[1],
+                    'trip_critical' => trip_points.match(/^critical \(S5\):\s*?([0-9]{1,3}) C$/)[1],}})
+        end
+    end
+
+    def get_infos
+        @tempdirs.each do |dir|
+            @temperatures[dir.gsub(/^\/proc\/acpi\/thermal_zone\//, '')]["temperature"] =
+                file_get_content(dir + '/temperature').match(/^temperature:\s*?([0-9]{1,3}) C$/)[1]
+        end
+        @temperatures.merge average
+    end
+
+    def self.protocolize temperatures
+        str = "thermal:\r\n"
+        temperatures.each do |key, value|
+            str += "#{key}|#{value["temperature"]}#{key == "AVERAGE" ? '' : '|' + (value["trip_critical"] || '-')}\r\n"
+        end
+        str += "END\r\n"
+    end
+
+    def self.friendlize raw
+        raw = raw.to_s.strip
+        nmax = raw.lines.map{|x|x.split(/\|/)[0].length}.max + 4
+        tmax = [raw.lines.map{|x|x.split(/\|/)[1].length}.max + 4, 6].max
+        str = "NAME".ljust(nmax) + "TEMP".ljust(tmax) + "CRITICAL\r\n"
+        raw.split(/\r?\n/).each { |line|
+            datas = line.split /\|/
+            str << datas[0].ljust(nmax) + "#{datas[1]}°C".ljust(tmax)
+            str << "#{datas[2]}°C" if datas[2]
+            str << "\r\n"
+        }
+        str
+    end
+
+private
+
+    def average
+        avg, n = 0, 0
+        @temperatures.each do |value, key|
+            avg += key["temperature"].to_i
+            n += 1
+        end
+        avg = (sprintf '%.1f', (avg.to_f / n)).gsub /\.0$/, ''
+        return ({'AVERAGE' => {'temperature' => avg, 'trip_critical' => false}})
+    end
+end
+
+if __FILE__ == $0
+    puts Thermal.friendlize Thermal.protocolize(Thermal.new.get_infos).gsub(/^thermal:\s+|END\s+$/m, '')
+else
+    Arbi::add_plugin /^thermal$/i, Thermal.new
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: arbi
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 2
+  version: 1.0.2
+platform: ruby
+authors: 
+- shura
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-10 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: getopt
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sys-filesystem
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: ""
+email: shura1991@gmail.com
+executables: 
+- arbid
+- arbi
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/arbi.rb
+- lib/arbi/common.rb
+- lib/arbi/plugins/ram.rb
+- lib/arbi/plugins/diskspace.rb
+- lib/arbi/plugins/cpu.rb
+- lib/arbi/plugins/batteries.rb
+- lib/arbi/plugins/net.rb
+- lib/arbi/plugins/thermal.rb
+- bin/arbid
+- bin/arbi
+has_rdoc: true
+homepage: http://github.com/shurizzle/arbi
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: ""
+test_files: []
+