jah 0.0.3

data/lib/jah/cli.rb

@@ -0,0 +1,124 @@
+#
+# Jah Gem CLI
+#
+
+#TODO: def init
+require 'logger'
+
+module Jah
+
+  HOME = ENV['HOME'] + "/.jah/"
+  unless File.exists? HOME
+    FileUtils.mkdir_p HOME
+  end
+
+  Log = Logger.new(HOME + "jah.log")
+  def Log.write(d); self.warn(d); end
+  $stderr = Log
+
+  Opt = {}
+
+  def self.hostname
+    `hostname`.chomp.gsub(/\W/, "") rescue "jah#{rand(42000)}"
+  end
+
+  def self.locale
+    `locale | grep LANG`.scan(/LANG=(.*)\./)[0][0].downcase rescue "en_us"
+  end
+
+  def self.method_missing(w)
+    Opt[w.to_s.gsub("?", "").to_sym]
+  end
+
+  class Cli
+
+    def self.parse_options(argv)
+      options = {}
+
+      ARGV.options do |opts|
+        opts.banner = <<BANNER
+Jah Gem Usage:
+
+jah [command] [opts] -c [config file]
+
+Commands:
+
+   start
+   stop
+   restart
+   install
+
+BANNER
+        opts.separator "Config file:"
+        opts.on("-c", "--config CONFIG", String, "Jah Config file path" ) { |file|  options[:config] = file }
+        opts.separator ""
+        opts.separator "Operation mode:"
+        opts.on("-m", "--mode MODE", String, "Jah operation mode")   { |val| options[:mode] = val.to_sym }
+        opts.separator ""
+        opts.separator "   xmpp   -  Use xmpp client, requires JID and Password"
+        opts.separator "   post   -  Use post client, requires Jah Web Key"
+        opts.separator "   dump   -  Just dump to disk, Jah Web can login and read"
+        opts.separator ""
+        opts.separator "Server Options:"
+        opts.on("-j", "--jid JID", String, "Client JID (user@domain)")   { |val| options[:jid] = val }
+        opts.on("-k", "--key KEY", String, "Client XMPP Password or Jah Web Key")   { |val| options[:key] = val }
+        opts.on("-s", "--server SERVER", String, "Jah Server URL" ) { |url|  options[:server] = url }
+        opts.on("-p", "--port PORT", Integer, "Jah Server Port")  { |val| options[:port] = val.to_i }
+        opts.separator ""
+
+        opts.on("-t", "--talk TALK", String, "Which locale to use" ) { |i18n|  options[:i18n] = i18n }
+        opts.on("-f", "--file FILE", String, "Local temp file to track history" ) { |file|  options[:history] = file }
+        opts.on("-i", "--interval INTERVAL", Integer, "Poller interval")   { |val| options[:interval] = val.to_i }
+        opts.on("-l", "--level LEVEL", Logger::SEV_LABEL.map { |l| l.downcase }, "The level of logging to report" ) { |level| options[:level] = level }
+        opts.on("-g", "--[no-]god", "Don't use god")   { |val| options[:god] = false }
+        opts.on("-d", "--daemonize", "Run in background" ) { |d|  options[:daemon] = d }
+        opts.on("-r", "--report REPORT", "Report status to others on roster" ) { |r|  options[:report] = r }
+
+        opts.separator ""
+        opts.separator "Common Options:"
+        opts.on("-h", "--help", "Show this message" ) { puts opts; exit }
+        opts.on("-v", "--[no-]verbose", "Turn on logging to STDOUT" ) { |bool| options[:verbose] = bool }
+        opts.on("-V", "--version", "Show version") { |version|  puts Jah::VERSION;  exit }
+        opts.separator ""
+        begin
+          opts.parse!
+          @usage = opts.to_s
+        rescue
+          puts opts
+          exit
+        end
+      end
+      options
+    end
+    private_class_method :parse_options
+
+    def self.dispatch(argv)
+      Jah::Opt.merge! autoload_config(parse_options(argv))
+      if comm = argv.shift
+        Jah::Agent.send(comm) rescue puts "Command not found: #{comm}"
+      else
+        Jah.mode ? Jah::Agent.start : Install.new
+      end
+    end
+
+    # Load config [., ~/.jah, /etc]
+    def self.autoload_config(options)
+      conf = "jah.yaml"
+      file = options[:config] || [nil, HOME, "/etc/"].select { |c| File.exists? "#{c}#{conf}" }[0]
+      options = YAML.load(File.read(file + conf)).merge!(options) if file
+
+      # Map acl and group arrays
+      [:acl, :groups].each do |g|
+        options[g] = options[g].split(",").map(&:strip)
+      end
+      options[:groups].map! { |g| "#{g}@conference.#{options[:host]}" }
+
+      # find a better place for this
+      I18n.load_path += Dir[File.join(File.dirname(__FILE__), '..', 'locales', "*.{rb,yml}")]
+      I18n.default_locale = options[:i18n] || "en_us"
+      options
+    end
+
+  end
+
+end

data/lib/jah/collector.rb

@@ -0,0 +1,12 @@
+module Jah
+
+  class Collector
+
+
+    def self.quick_results
+      "CPU #{Cpu.get.load}, MEM #{Mem.get.percent}%"
+    end
+
+
+  end
+end

data/lib/jah/collectors/cpu.rb

@@ -0,0 +1,35 @@
+module Jah
+  class Cpu < Collector
+    attr_reader :load, :one, :five, :ten, :med
+    EXEC = "uptime"
+
+    def self.get
+      new
+    end
+
+    def initialize
+      l = cpu_load
+      @one = l[:one]
+      @five = l[:five]
+      @ten = l[:ten]
+      @load = l.values.join(", ")
+      @med = @ten / cores
+    end
+
+    def cpu_load
+      if `#{EXEC}` =~ /load average(s*): ([\d.]+)(,*) ([\d.]+)(,*) ([\d.]+)\Z/
+        { :one    => $2.to_f,
+          :five   => $4.to_f,
+          :ten    => $6.to_f }
+      end
+    end
+
+    def cores
+      case RUBY_PLATFORM
+      when /linux/  then `cat /proc/cpuinfo | grep 'model name' | wc -l`.to_i
+      when /darwin/ then `hwprefs cpu_count`.to_i
+      else 1
+      end
+    end
+  end
+end

data/lib/jah/collectors/disk.rb

@@ -0,0 +1,14 @@
+module Jah
+
+  class Disk < Collector
+    EXEC =  "df -h"
+
+    def self.all
+      @disks = `#{EXEC}`.to_a.reject { |dl| dl =~ /Size|none/ }.map do |l|
+        l = l.split(" ")
+        { :path => l[0], :total => l[1], :used => l[2], :avail => l[3], :percent => l[4]}
+      end
+    end
+
+  end
+end

data/lib/jah/collectors/mem.rb

@@ -0,0 +1,51 @@
+module Jah
+
+  class Mem < Collector
+    attr_reader :total, :free, :used, :percent, :cached, :buffered,
+    :swap_total, :swap_free, :swap_used, :swap_percent
+
+    EXEC = "cat /proc/meminfo"
+
+    def self.get
+      new
+    end
+
+    def initialize
+      do_something
+    end
+
+    def do_something
+      mem_info = {}
+      `#{EXEC}`.each do |line|
+        _, key, value = *line.match(/^(\w+):\s+(\d+)\s/)
+        mem_info[key] = value.to_i
+      end
+        
+      # memory info is empty - operating system may not support it (why doesn't an exception get raised earlier on mac osx?)
+      raise "No such file or directory" if mem_info.empty?
+
+      @total = mem_info['MemTotal'] / 1024
+      @free = (mem_info['MemFree'] + mem_info['Buffers'] + mem_info['Cached']) / 1024
+      @used = @total - @free
+      @percent = (@used / @total.to_f * 100).to_i
+
+      @swap_total = mem_info['SwapTotal'] / 1024
+      @swap_free = mem_info['SwapFree'] / 1024
+      @swap_used = swap_total - swap_free
+      unless @swap_total == 0
+        @swap_percent = (@swap_used / @swap_total.to_f * 100).to_i
+      end
+    rescue Exception => e
+      if e.message =~ /No such file or directory/
+        puts "/proc/meminfo not found.. trying top!"
+        top = `top -l 1`.to_a[5].split.map!{|m| m[0..-2].to_i}.reject(&:zero?)
+        @used, @free = top[3,4]
+        @total = @used + @free
+        @percent = (@used / @total.to_f * 100).to_i
+      else
+        raise e
+      end
+    end
+
+  end
+end

data/lib/jah/collectors/net.rb

@@ -0,0 +1,27 @@
+module Jah
+  class Net < Collector
+    #   :net  =>  "netstat -n | grep -i established | wc -l"
+    class << self
+    #  attr_reader :count, :ips
+
+
+      def count
+        `netstat -n | grep -i established | wc -l`.to_i
+      end
+
+      def connections
+        `netstat -ntu | grep ESTAB | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -nr`.to_a.map do |l|
+          count, ip = l.split
+          [ip, count]
+        end
+      end
+    end
+
+
+
+
+
+
+
+  end
+end

data/lib/jah/collectors/prok.rb

@@ -0,0 +1,88 @@
+module Jah
+
+  class Ps < Collector
+    COMM = "ps auxww"
+
+    def self.all
+      `#{COMM}`.to_a[1..-1].map do |l|
+          Prok.new(l.split)
+        end
+    end
+
+    def self.find(name)
+
+    end
+
+
+  end
+
+  class Prok
+    BANLIST = [/^ata/, /^init$/, /^scsi_/, /\/\d$/, /agetty/ ]
+    attr_reader :pid, :comm, :cpu, :mem, :rss, :vsz, :stat
+
+    def initialize(args) #      USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
+      return unless args[0]
+      @user  = args[0]
+      @pid   = args[1].chomp.to_i
+      @cpu   = args[2].chomp.to_f
+      @mem   = args[3].chomp.to_f
+      @vsz   = args[4].chomp.to_i
+      @rss   = args[5].chomp.to_i
+      @tty   = args[6]
+      @stat  = args[7]
+      @start = args[8]
+      @time  = args[9]
+      @comm  = args[10]
+      #@shr  = args[6]
+    end
+
+    def hup!
+      exec "kill -1 #{pid}"
+    end
+
+    def kill!
+      exec "kill #{pid}"
+    end
+
+    def move_to_acre!
+      exec "kill -9 #{pid}"
+    end
+
+    def self.genocide!(ary, f = nil)
+      for prok in ary
+        prok.kill
+      end
+    end
+
+    def exec(comm)
+      # SSHWorker.new(@host, @host.user, comm)
+    end
+
+    def force(f)
+      { :hup => "-1", :die => "-9"}[f]
+    end
+  end
+
+end
+
+    # COMM = {
+    #   :top => "top -n 1",
+    # }
+
+
+
+  #  def top
+  #   info, tasks, cpus, mem, swap, n, n, *rest = *@res[:top]
+  #   n, total, used, free, buffered = *mem.match(/(\d*)k\D*(\d*)k\D*(\d*)k\D*(\d*)k.*/)
+  #   cached = swap.match(/(\d*)k cached/)[0]
+  #   proks = rest.map do |r|
+  #     r.split(" ")
+  #   end
+
+  #   # fail... top don't show a good stat....
+    #   @proks = proks.reject do |p|
+    #     p[0] == nil || Prok::BANLIST.select{ |pl| pl =~ p[11] }[0]
+    #   end
+    #    rescue => e
+    #    nil
+    # end

data/lib/jah/collectors/services.rb

@@ -0,0 +1,13 @@
+module Jah
+  class Services < Collector
+
+
+
+
+
+  end
+
+
+
+
+end

data/lib/jah/collectors/who.rb

@@ -0,0 +1,20 @@
+module Jah
+
+  class Who < Collector
+    EXEC =  "who"
+
+    def self.all
+      @who = `#{EXEC}`.to_a.map do |l|
+        l = l.split(" ")
+
+        hash = {}
+
+        hash[:who] = l[0]
+        hash[:terminal] = l[1]
+        2.times{ l.delete(l[0]) }
+        hash[:date] = l.join(" ")
+        hash
+      end
+    end
+  end
+end

data/lib/jah/command.rb

@@ -0,0 +1,23 @@
+module Jah
+  REG = []
+
+  module Command
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def self.find(msg)
+      REG.select { |r| r[1] =~ msg.squeeze(" ").strip }.first
+    end
+
+    module ClassMethods
+
+    def register(handler, regex)
+      REG << [handler, /^#{regex}/, self]
+    end
+
+    end
+
+  end
+end

data/lib/jah/commands/admin.rb

@@ -0,0 +1,40 @@
+module Jah
+
+  class Admin
+    include Command
+
+    register(:get_roster, "roster$")
+    register(:drop_user, "drop\s")
+    #Jah::Command.register(:create_group, "")
+
+    class << self
+
+
+      def get_roster
+        out = ""
+        client.roster.grouped.each do |group, items|
+          out << "#{'*'*3} #{group || 'Ungrouped'} #{'*'*3}\n"
+          items.each { |item| out << "- #{item.name} (#{item.jid})\n" }
+          out << "\n"
+        end
+        out
+      end
+
+      def drop_user(user)
+        puts "DROP..."
+      end
+
+      def join_group()
+      end
+
+
+
+
+      def create_group(name)
+
+      end
+
+    end
+
+  end
+end

data/lib/jah/commands/extra.rb

@@ -0,0 +1,14 @@
+module Jah
+  class Extra
+    include Command
+    register :change_lang, 'change\slang.*\s(\w*)$'
+
+    # change\slang.*\s(\w*)$
+    def self.change_lang(_, new)
+      I18n.default_locale = new
+
+    end
+
+
+  end
+end

data/lib/jah/commands/pub.rb

@@ -0,0 +1,34 @@
+require "blather/client/dsl"
+
+module Jah
+
+  class Pub
+    include Command
+
+    register  :create, 'create\spubsub.*'
+
+
+    def self.create(_, node)
+    #  pubsub = Blather::DSL::PubSub.new()
+      request(Blather::Stanza::PubSub::Create.new(:set,
+        "Jah.host.com", node)) { |n| yield n if block_given? }
+
+
+    end
+
+    def self.all
+
+
+    end
+
+
+
+
+
+
+
+
+
+
+  end
+end

data/lib/jah/commands/status.rb

@@ -0,0 +1,61 @@
+module Jah
+
+  class Status
+    include Command
+    register(:ok, 'ok\??$')
+    register(:who, 'who\??$')
+    register(:mem, 'mem\??$')
+    register(:cpu, 'cpu\??$')
+    register(:net, 'net\??$')
+    register(:disk, 'disk\??$')
+    register(:proks, 'prok$|top$')
+
+
+    class << self
+
+      def ok
+        I18n.t("states." + case Jah::Cpu.get.med
+          when 0..0.5 then :green
+          when 0.51..0.7 then :yellow
+          else :red
+        end.to_s)
+      end
+
+      def mem
+        Mem.get.percent.to_s + "%"
+      end
+
+      def cpu
+        Cpu.get.load
+      end
+
+      def net
+        out = ""
+        Net.connections.each do |c|
+          out << "#{c[0]} => #{c[1]} connections\n"
+        end
+        out << "Total: #{Net.count}"
+      end
+
+      def disk
+        Disk.all.map do |d|
+          "\n*#{d[:path]}* => #{d[:percent]}"
+        end.join("\n")
+      end
+
+      def who
+        Who.all.map do |w|
+          "#{w[:who]} Logado via #{w[:terminal]} desde a data: #{w[:date]}"
+        end.join("\n")
+      end
+
+      def proks(find = nil)
+        Ps.all.map do |p|
+          next if find && p.comm !~ /#{find}/i
+          "#{p.comm} => #{p.mem}\n"
+        end
+      end
+
+    end
+  end
+end

data/lib/jah/god.rb

@@ -0,0 +1,24 @@
+  # def setup
+    #   DRb.start_service
+    #   @server = DRbObject.new(nil, God::Socket.socket(@config['god_port'])) || nil
+    # rescue => e
+    #   @config[:god] = false
+    # end
+
+    # # ping server to ensure that it is responsive
+    # def ping
+    #   if god?
+    #     tries = 3
+    #     begin
+    #       @server.ping
+    #     rescue Exception => e
+    #       retry if (tries -= 1) > 1
+    #       raise e, "The server is not available (or you do not have permissions to access it)"
+    #     end
+    #   end
+    # end
+
+
+    # def god?
+    #   @config[:god]
+    # end