jah 0.0.3 → 0.0.5

data/lib/jah/agents/xmpp.rb

@@ -1,37 +1,50 @@
-require "eventmachine"#autoload :Client,
 require "blather/client/client"
 
 module Jah
  # include Blather::DSL
   class XmppAgent
     ROSTER = []
+    PUBSUB = {:pubs => [], :subs => []}
+    PEERS = []
+
     attr_reader :client
 
 
     def initialize #(jid, key, server, port=5222, debug=false, report=0)
-      Blather.logger.level = Logger::DEBUG if Jah.debug
-      @report = Jah.report
-      @client = Blather::Client.setup Jah.jid, Jah.key, Jah.server, Jah.port
+      Blather.logger.level = Logger::DEBUG if Opt.debug
+      @report = Opt.report
+      @client = Blather::Client.setup Opt.jid, Opt.key, Opt.host, Opt.port
       setup
       self
     end
 
     def process_message(to, msg, type = :chat)
+      args = msg.split(" ")
       if comm = Jah::Command.find(msg)
         puts "Commmand => #{comm} | #{msg}"
-        args = msg.split(" ")
         body = comm[2].send(comm[0], *args[1..-1])
+      elsif pub = PUBSUB[:pubs].find { |x| msg =~ /^#{x}:/ }
+        publish_pub(pub, *args[1..-1])
+        body = "Publishing...."
       else
         keywords = %w{ start stop restart monitor unmonitor }
-        kind = :god if msg =~ /#{keywords.join("|")}/
-        kind ||= msg =~ /^\!/ ? :ruby : :sh
+        kind = case msg
+               when /#{keywords.join("|")}/ then :god
+               when /^\!/ then :ruby
+               when /^pub\s/ then :pub
+               else :sh
+               end
         body = case kind
-          when :ruby
-          puts "Executing ruby command => #{msg}"
-          "=> #{execute_ruby(msg)}"
           when :sh
           puts "Executing *sh command => #{msg}"
           "$> #{execute_sh(msg)}"
+          when :pub
+          PEERS << to.stripped unless PEERS.find { |p| p == [to.stripped] }
+          puts "Executing pubsub command => #{msg}"
+          "P> #{execute_pub(msg)}"
+          when :ruby
+          puts "Executing ruby command => #{msg}"
+          "=> #{execute_ruby(msg)}"
           when :god
           puts "Executing god command => #{msg}"
           "G> #{execute_sh('god ' + msg)}"
@@ -71,6 +84,88 @@ module Jah
       res
     end
 
+    def execute_pub(code)
+      comm = code.split(" ")
+      case comm[1]
+      when "all" then all_pubs
+      when "mine" then my_pubs
+      when "list" then list_pub(comm[2])
+      when "fetch" then fetch_pubs || "Done."
+      when "create" then create_pub(comm[2])
+      when /^sub\w*/  then sub_pub(comm[2])
+      when /^unsub\w*/  then unsub_pub(comm[2])
+      when "destroy" then destroy_pub(comm[2])
+
+      end
+    end
+
+    def pub_node
+      @pub_node ||= "pubsub." + client.jid.domain
+    end
+
+    def create_pub(name)
+      client.write Blather::Stanza::PubSub::Create.new(:set,
+        pub_node, name) { |n| yield n if block_given? }
+      PUBSUB[:pubs] << name
+      "Done."
+    end
+
+    def publish_pub(name, *text)
+      client.write Blather::Stanza::PubSub::Publish.new(pub_node, name, :set, text.join)
+      text.join
+    end
+
+    def list_pub(name)
+      client.write Blather::Stanza::PubSub::Items.request(pub_node, name)
+    end
+
+    def destroy_pub(name)
+      client.write Blather::Stanza::PubSubOwner::Delete.new(:set, pub_node, '/' + name)
+      PUBSUB[:pubs] -= [name]
+      "Done."
+    end
+
+    def all_pubs
+      call = Blather::Stanza::DiscoItems.new
+      call.to = pub_node
+      client.write call
+    end
+
+    def my_pubs
+      out = "--- Pubsubs\n"
+      out << "Owner: #{PUBSUB[:pubs].join(', ')}\n" unless PUBSUB[:pubs].empty?
+      out << "Subscribed: #{PUBSUB[:subs].join(', ')}\n" unless PUBSUB[:subs].empty?
+      out == "" ? "No PubSubs." : out
+    end
+
+    def sub_pub(pub)
+      client.write Blather::Stanza::PubSub::Subscribe.new(:set, pub_node, '/' + pub, client.jid.stripped)
+      PUBSUB[:subs] << pub
+    end
+
+    def unsub_pub(pub)
+      client.write Blather::Stanza::PubSub::Unsubscribe.new(:set, pub_node, '/' + pub, client.jid.stripped)
+      PUBSUB[:subs] -= [pub]
+    end
+
+    def fetch_pubs
+      client.write Blather::Stanza::PubSub::Affiliations.new(:get, pub_node)
+      client.write Blather::Stanza::PubSub::Subscriptions.new(:get, pub_node)
+    end
+
+    def alert_peers(msg)
+      PEERS.each do |peer|
+        client.write Blather::Stanza::Message.new(peer, msg)
+      end
+    end
+
+    def process_items(items)
+      items.map do |item|
+        "\nItem: #{item.payload.strip}"
+      end
+    end
+
+
     #TODO: need to write raw....
     def beautify(txt)
       #txt.gsub!(/\*(.*)\*/, "<span style=\"font-weight: bold;\">\\1</span>")
@@ -94,13 +189,15 @@ module Jah
       #  return if client && client.setup?
       client.register_handler(:ready) do
         puts "Connected!"
-        ROSTER << [client.roster.items.keys, Jah.groups].flatten.uniq
+        ROSTER << [client.roster.items.keys, Opt.groups].flatten.uniq
         ROSTER.flatten!
         ROSTER.select { |j| j =~ /\@conference\./ }.each do |c|
           presence = Blather::Stanza::Presence.new
-          presence.to = "#{c}/#{Jah.hostname}"
+          presence.to = "#{c}/#{Opt.hostname}"
           client.write presence
         end
+
+        fetch_pubs
       end
 
       client.register_handler :subscription, :request? do |s|
@@ -121,16 +218,61 @@ module Jah
       #client.register_handler :message, :error?, :body do |m|
       #client.register_handler :message, :headline?, :body do |m|
       #client.register_handler :message, :normal?, :body do |m|
+      client.register_handler :pubsub_affiliations, :affiliations do |m|
+        puts "[PUB] =>  #{m.inspect}"
+        m.each do |af|
+          puts "[PUB ITEM] =>  #{af.inspect}"
+          PUBSUB[:pubs] = af[1].map { |p| p.gsub(/\//, '') }
+        end
+      end
+
+      client.register_handler :pubsub_subscriptions, :subscriptions do |m|
+        puts "[SUB] =>  #{m.inspect}"
+        m.each do |af|
+          puts "[SUB ITEM] =>  #{af.inspect}"
+          PUBSUB[:subs] = af[1].map { |p| p[:node].gsub(/\//, '') }
+        end
+      end
 
       client.register_handler :pubsub_event, :items do |m|
-        puts "[PUBSUB] => #{m.inspect}"
-        client.write m.body
+        puts "[PUBSUB EV] => #{m.inspect}"
+        alert_peers "PubSub: #{m.node} #{process_items(m.items)}"
+      end
+
+      client.register_handler :pubsub_items, :items do |m|
+        puts "[PUBSUB ITEMS] => #{m.inspect}"
+        alert_peers "PubSub: #{m.node} #{process_items(m.items)}"
+      end
+
+      client.register_handler :disco_items do |r|
+        puts "[ITEM] => #{r}"
+        # Pub.delete_all
+        # PubItem.delete_all
+        for item in r.items
+          puts "[IT] => #{item.name} on #{item.node.class}"
+          # next if item.name =~ /^home$/
+          if item.node =~ /\//
+            puts "[PUBSUB] => #{item.name} on #{item.node}"
+            alert_peers item.name
+          else
+            if item.jid.to_s =~ /conference\./
+              puts "[GROUP] => #{item.name} on #{item.node}"
+            else
+              puts "[USER] => #{item.jid} name #{item.name}"
+            end
+          end
+        end
       end
 
       client.register_handler :message, :groupchat? do |m|
-        if m.body =~ /^!|^>|^\\/ && m.to_s !~ /x.*:delay/ #delay.nil?
+        if m.body =~ Regexp.new(Opt.hostname)
+          body = m.body.split(":")[-1].strip
+        else
+          body = m.body
+        end
+        if m.body =~ /^!|^>|^\\|#{Opt.hostname}/ && m.to_s !~ /x.*:delay/ #delay.nil?
           puts "[GROUP] => #{m.inspect}"
-          for msg in process_message(m.from.stripped, m.body, :groupchat)
+          for msg in process_message(m.from.stripped, body, :groupchat)
             client.write msg
           end
         end
@@ -150,18 +292,17 @@ module Jah
 
     def run
       puts "Starting Jah Client...#{client.jid.stripped}"
-      trap(:INT) { EM.stop }
-      trap(:TERM) { EM.stop }
 
       EM.run do
         client.run
         if @report != 0
           puts "will report..."
-          EM.add_periodic_timer(@report) do
-            puts " I'm ok.. "
-            client.write Blather::Stanza::Message.new(
-                "nofxx@Jah.host.com", Jah::Collector.quick_results)
-          end
+          # TODO
+          # EM.add_periodic_timer(@report) do
+          #   puts " I'm ok.. "
+          #   client.write Blather::Stanza::Message.new(
+          #       "nofxx@Jah.host.com", Jah::Command.quick_results)
+          # end
         end
 
       end

data/lib/jah/cli.rb

@@ -3,33 +3,10 @@
 #
 
 #TODO: def init
-require 'logger'
+require "eventmachine"#autoload :Client,
 
 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)
@@ -39,14 +16,14 @@ module Jah
         opts.banner = <<BANNER
 Jah Gem Usage:
 
-jah [command] [opts] -c [config file]
+jah [command] [opts]
 
 Commands:
 
    start
    stop
    restart
-   install
+   config
 
 BANNER
         opts.separator "Config file:"
@@ -92,31 +69,23 @@ BANNER
     end
     private_class_method :parse_options
 
-    def self.dispatch(argv)
-      Jah::Opt.merge! autoload_config(parse_options(argv))
+    def self.work(argv)
+      trap(:INT) { stop! }
+      trap(:TERM) { stop! }
+
+      Opt.autoload_config(parse_options(argv))
+
       if comm = argv.shift
-        Jah::Agent.send(comm) rescue puts "Command not found: #{comm}"
+        Jah::Agent.send(comm) #rescue puts "Command not found: #{comm} #{@usage}"
       else
-        Jah.mode ? Jah::Agent.start : Install.new
+        Opt.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
+    def self.stop!
+      puts "Closing Jah..."
+      Opt.closing_time!
+      EM.stop
     end
 
   end

data/lib/jah/command.rb

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

data/lib/jah/commands/cpu.rb

@@ -0,0 +1,38 @@
+module Jah
+  class Cpu
+    include Command
+    register(:load, 'cpu\??$')
+
+    class << self
+
+      def load
+        read
+        "Med: #{@res[:med]}"
+      end
+
+      def read
+        @res = cpu_load
+        @res[:load] = @res.values.join(", ")
+        @res[:med]  = @res[:ten] / @res[:cores] = cores
+        @res
+      end
+
+      def cpu_load
+        if `uptime` =~ /load average(s*): ([\d.]+)(,*) ([\d.]+)(,*) ([\d.]+)\Z/
+          { :one  => $2.to_f,
+            :five => $4.to_f,
+            :ten  => $6.to_f }
+        end
+      end
+
+      def cores
+        @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
+end

data/lib/jah/commands/disk.rb

@@ -0,0 +1,35 @@
+module Jah
+
+  class Disk
+    include Command
+    attr_reader :path, :percent, :total, :free, :used, :mount
+    register(:disk, 'disk\??$')
+
+    def self.read
+      all.map do |d|
+        "\n*#{d[:path]}* => #{d[:percent]}"
+      end.join("\n")
+    end
+
+    def self.all
+      @disks = `df`.to_a.reject { |dl| dl =~ /Size|Use|none/ }.map do |l|
+        new l.split(" ")
+      end
+    end
+
+    def initialize(args)
+      @path, @total, @used, @free, @percent, @mount = args
+      @total, @used, @free = [@total, @used, @free].map(&:to_i)
+      @percent = @percent[0..-2].to_i
+    end
+
+    def self.mount
+    end
+
+    def self.umount
+    end
+
+
+  end
+
+end

data/lib/jah/commands/mem.rb

@@ -0,0 +1,49 @@
+module Jah
+
+  class Mem
+    include Command
+    register(:snap, 'mem\??$')
+
+    class << self
+
+      def snap
+        read
+        "Free: #{@res[:free]} Used: #{@res[:used]} #{@res[:percent]}%"
+      end
+
+      def read
+        mem_info = {}
+        `cat /proc/meminfo`.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?
+        @res = {}
+        @res[:total] = total = mem_info['MemTotal'] / 1024
+        @res[:free] = free = (mem_info['MemFree'] + mem_info['Buffers'] + mem_info['Cached']) / 1024
+        @res[:used] = total - free
+        @res[:percent] = (free / total.to_f * 100).to_i
+
+        @res[:swap_total] = stotal = mem_info['SwapTotal'] / 1024
+        @res[:swap_free] = sfree = mem_info['SwapFree'] / 1024
+        # @res[:swap_used] = stotal - sfree
+        # unless stotal == 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?)
+          @res[:used], @res[:free] = top[3,4]
+          @res[:total] = @res[:used] + @res[:free]
+          @res[:percent] = (@res[:free] / @res[:total].to_f * 100).to_i
+        else
+          raise e
+        end
+      end
+
+    end
+  end
+end

data/lib/jah/{collectors/net.rb → commands/netstat.rb}

@@ -1,9 +1,17 @@
 module Jah
-  class Net < Collector
-    #   :net  =>  "netstat -n | grep -i established | wc -l"
+  class Netstat
+    include Command
+    register(:net, 'net\??$')
+
     class << self
-    #  attr_reader :count, :ips
 
+      def net
+        out = ""
+        connections.each do |c|
+          out << "#{c[0]} => #{c[1]} connections\n"
+        end
+        out << "Total: #{Net.count}"
+      end
 
       def count
         `netstat -n | grep -i established | wc -l`.to_i
@@ -17,11 +25,5 @@ module Jah
       end
     end
 
-
-
-
-
-
-
   end
 end

data/lib/jah/commands/packages.rb

@@ -0,0 +1,25 @@
+module Jah
+
+  class Packages
+    include Command
+    register(:install, "install\s")
+    register(:pkg, "pkg\s")
+
+
+    class << self
+
+      def install(foo)
+        ActPkg.install(foo)
+      end
+
+      def pkg(*meths)
+        case res = ActPkg.send(*meths)
+        when Array
+          res.map { |i| ">#{i.name}  #{i.version}\n" }
+        when String then res
+        end
+      end
+    end
+
+  end
+end

data/lib/jah/commands/prok.rb

@@ -0,0 +1,97 @@
+module Jah
+
+  class Prok
+    include Command
+    attr_reader :user, :pid, :comm, :cpu, :mem, :rss, :vsz, :stat, :tty, :time
+    BANLIST = [/^ata/, /^init$/, /^scsi_/, /\/\d$/, /agetty/ ]
+    register(:read, 'proks?(\s|$)|top$')
+
+    def self.read(find = nil)
+      find ? Prok.find(find).to_s : Prok.all.map(&:to_s)
+
+    end
+
+    def self.all
+      `ps auxww`.to_a[1..-1].map do |l|
+        new(l.split)
+      end
+    end
+
+    def self.find(comm_or_pid)
+      all.select do |p|
+        unless comm_or_pid.to_i.zero?
+          p.pid == comm_or_pid.to_i
+        else
+          p.comm =~ /#{comm_or_pid}/
+        end
+      end
+    end
+
+    # USER  PID  %CPU  %MEM  VSZ  RSS  TTY  STAT  START  TIME  COMMAND
+    def initialize(args)
+      return unless args[0]
+      @user, @pid, @cpu, @mem, @vsz, @rss, @tty, @stat, @start, @time, *@comm = args
+
+      @pid, @vsz, @rss = [@pid, @vsz, @rss].map(&:to_i)
+      @cpu, @mem = [@cpu, @mem].map(&:to_f)
+      @comm = @comm.join(" ")
+    end
+
+    def hup!
+      exec "kill -1 #{pid}"
+    end
+
+    def kill!
+      exec "kill #{pid}"
+    end
+
+    def move_to_acre!
+      exec "kill -9 #{pid}"
+    end
+
+    def to_s
+      "#{pid} - #{user} - #{comm} (#{mem}, #{cpu})"
+    end
+
+    def self.genocide!(ary)
+      parsed = ary.gsub(/\W/, "").split(" ")
+      for prok in parsed
+        find(prok).each(&:kill!)
+      end
+    end
+
+    protected
+
+    def exec(comm)
+      puts "[PROK] exec => #{comm}"
+      `#{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/commands/services.rb

@@ -0,0 +1,14 @@
+module Jah
+  class Services
+    include Command
+
+
+
+
+
+  end
+
+
+
+
+end