lpm 1.0.0

data/LICENSE

@@ -0,0 +1,3 @@
+== lpm
+
+Put appropriate LICENSE for your project here.

data/README

@@ -0,0 +1,3 @@
+== lpm
+
+You should document your project here.

data/Rakefile

@@ -0,0 +1,45 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'lpm'
+  s.version = '1.0.0'
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README', 'LICENSE']
+  s.summary = 'Linux Proc Monitor'
+  s.description = s.summary
+  s.author = 'Charles Cui'
+  s.email = 'zheng.cuizh@gmail.com'
+  s.executables = ['lpm']
+  s.files = %w(LICENSE README Rakefile) + Dir.glob("{bin,lib,spec,test}/**/*")
+  s.require_path = "lib"
+  s.bindir = "bin"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README', 'LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README" # page to start on
+  rdoc.title = "lpm Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end

data/bin/lpm

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+
+#--
+# Copyright (c) 2009, Charles Cui
+# All rights reserved. Licensed under the BSD license.  See LICENSE for details
+#++
+
+# $: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require 'rubygems'
+require 'socket'
+require 'optparse'
+require "logger"
+
+require File.join(File.dirname(__FILE__),"..","lib","utils.rb")
+require File.join(File.dirname(__FILE__),"..","lib","xiaoqian.rb")
+require File.join(File.dirname(__FILE__),"..","lib","server.rb")
+
+vars = {}
+ARGV.options do
+  |opts|
+  opts.banner = <<DOC
+  XiaoQian [also named => L(inux) P(roc) M(onitor)] :
+  Mail/Gtalk: zheng.cuizh@gmail.com
+  
+  Usage: #{File.basename($0)} [options] argv...
+  (sudo )lpm -t 15 --memcache=10.2.226.133:11011,10.2.226.133:11012 -P --pids=28261,28263 --log_level=1
+DOC
+
+  opts.on_head("LPM optins useage:")
+
+  vars[:port] = 9876
+  opts.on("-p", "--port=PORT", Integer,
+	  "lpm rest server requires a port number.","default port=#{vars[:port]}") {|vars[:port]|}
+	
+  # separater
+	opts.on()
+	
+  vars[:push] = false
+  opts.on("-P","--[no-]push",
+	  "if push is given, the --memcache must be set,", # multiline description
+	  "and a job will push server performance data to memcache server.",
+	  "default --push=#{vars[:push]}.") {|vars[:push]|}
+	  
+  vars[:timer] = 10
+  vars[:default_timer] = 10
+  opts.on("-t","--timer=Second", Integer,
+	  "periodic timer to push cache",
+	  "default --timer=#{vars[:default_timer]}(second).") {|vars[:timer]|}
+
+  # array
+  opts.on("-m", "--memcache=[LIST,LIST]", Array,
+    "memcache list,such as : --memcache=10.2.226.38:11211,10.2.226.37:11211","memcache server(s) must be alive.") {|vars[:memcache]|}
+  
+  vars[:log] = "/var/log/lpm.log"
+  opts.on("-l","--log=LogPath",
+    "default --log=#{vars[:log]}"){|vars[:log]|}
+    
+  vars[:default_log_level] = 3
+  opts.on("--log_level=LogLevel",Integer,"1 => DEBUG","2 => INFO","3 => WARN","4 => ERROR","5 => FATAL",
+    "default --log_level=#{vars[:default_log_level]}"){|vars[:log_level]|}  
+
+  opts.on("--pids=[PID,PID]", Array,
+    "pids list,such as : --pids=1234,2134,4321") {|vars[:pids]|}
+
+  # separater
+  opts.on_tail
+  opts.on_tail("common options:")
+
+  # no argument, shows at tail
+  opts.on_tail("--help", "show this message") {puts opts; exit}
+
+  # no argument
+  opts.on_tail("--version", "show version") do
+    puts "XiaoQian [L(inux) P(roc) M(onitor)] : 1.0.1"
+    exit
+  end
+  opts.parse!
+end
+
+$logger = nil
+
+begin
+  # $logger = Logger.new(vars[:log])
+  Logger::Formatter::Format = "%s, [%s#%d] %5s -- %s: %s#{$/}"
+  $logger = Logger.new(vars[:log],'daily',1048576)
+  if vars[:log_level] && (vars[:log_level] >= 1 || vars[:log_level] <= 5) then
+    $logger.level = vars[:log_level]
+  else
+    $logger.level = vars[:default_log_level]
+  end
+rescue Exception => e
+  $logger = nil
+  p "params error:#{e.to_s}"
+  p "can't access log file => #{vars[:log]}"
+end
+
+$logger.info "LPMServer is starting..."
+$logger.info "Server parameters are below : #{vars.inspect}"
+$logger.info "LPMServer will running @ 0.0.0.0:#{vars[:port]}"
+
+Daemon.start do
+  pid = []
+  pid << Process.fork do
+    $logger.info "LPMServer is starting..."
+    LPMServer.run('0.0.0.0',vars[:port])
+  end
+
+  if pid[0] then
+    pid << Process.fork do
+      $logger.info "Xiaoqian is starting..."
+      if vars[:push] then
+        vars[:timer] = vars[:default_timer] if (vars[:timer].to_i < 0)
+        Xiaoqian.run(vars[:timer].to_i,{:pids=>vars[:pids],:caches=>vars[:memcache],:log=>$logger}) if $logger
+      end
+    end
+  end
+  
+  $logger.info "LPMServer,Xiaoqian = #{pid.inspect}"
+  Process.waitall
+  $logger.info "LPM main process exit."
+end

data/lib/config/stipulation.rb

@@ -0,0 +1 @@
+# relations with LPMP(Caichen) in memcache

data/lib/lpm.rb

@@ -0,0 +1,8 @@
+require File.join(File.dirname(__FILE__),'lpm','proc.rb')
+require File.join(File.dirname(__FILE__),'lpm','process.rb')
+require File.join(File.dirname(__FILE__),'lpm','error.rb')
+require File.join(File.dirname(__FILE__),'lpm','utils.rb')
+require File.join(File.dirname(__FILE__),'utils.rb')
+require File.join(File.dirname(__FILE__),'xiaoqian.rb')
+
+raise PlatFormError,'The LPM works on Linux only.' unless RUBY_PLATFORM =~ /linux/

data/lib/lpm/error.rb

@@ -0,0 +1,3 @@
+class NoPidExist < RuntimeError; end
+class PlatFormError < RuntimeError; end
+class CpuLineSizeError < RuntimeError; end

data/lib/lpm/proc.rb

@@ -0,0 +1,67 @@
+module LPM
+  class Proc
+
+    class << self
+      def cpuinfo(*arguments)
+        begin
+          cpus_info = IO.read('/proc/cpuinfo').split("#{$/*2}")
+          return cpus_info.map do |cpu_info|
+            h = {}
+            cpu_info.split($/).each do |line|
+              kv = line.split(/\s*\:\s*/)
+              h[kv[0]] = kv[1]
+            end
+            h
+          end
+        rescue Exception => e
+          # => do nothing
+          return "{\"exception\":\"#{e.class}\",\"msg\":\"#{e}\"}"
+        ensure
+        end
+      end
+
+      def meminfo(*arguments)
+        begin
+          mem_info = IO.read('/proc/meminfo')
+          h = {}
+          mem_info.split($/).each do |line|
+            kv = line.split(/\s*\:\s*/)
+            h[kv[0].to_sym] = kv[1].chomp(' kB')
+          end
+          h
+        rescue Exception => e
+          # => do nothing
+          return "{\"exception\":\"#{e.class}\",\"msg\":\"#{e}\"}"
+        ensure
+        end
+      end
+
+      def loadavg(*arguments)
+        begin
+          load_avg = IO.read('/proc/loadavg').split(/\s+/)
+          h = {}
+          h[:last] = load_avg.pop
+          h[:running],h[:total] = load_avg.pop.split(/\//)
+          h[:load] = load_avg
+          h
+        rescue Exception => e
+          # => do nothing
+          return "{\"exception\":\"#{e.class}\",\"msg\":\"#{e}\"}"
+        ensure
+        end
+      end
+
+      def uptime(*arguments)
+        begin
+          total,idle = IO.read('/proc/uptime').split
+          {:total=>total,:idle=>idle}
+        rescue Exception => e
+          # => do nothing
+          return "{\"exception\":\"#{e.class}\",\"msg\":\"#{e}\"}"
+        ensure
+        end
+      end
+    end
+    
+  end
+end

data/lib/lpm/process.rb

@@ -0,0 +1,136 @@
+
+
+module LPM
+  class Process
+    attr :pid
+    def initialize pid
+      @pid = pid
+      @pwd = "/proc/#{@pid}"
+      raise NoPidExist,"The process which pid is #{@pid} does not exist." unless File.directory? @pwd
+    end
+
+    def attr(*arguments)
+      h = {}
+      begin
+        Dir.chdir("#{@pwd}/attr")
+        Dir.entries("#{@pwd}/attr").each do |d|
+          next if (d == '.') || (d == '..')
+          h[d.to_sym] = IO.read("#{@pwd}/attr/#{d}")
+        end
+      rescue Exception => e
+        # => do nothing
+        h = "{\"exception\":\"#{e.class}\",\"msg\":\"#{e}\"}"
+      end
+      h
+    end
+
+    def cwd(*arguments)
+      begin
+        File.readlink("#{@pwd}/cwd")
+      rescue Exception => e
+        # => do nothing
+        "{\"exception\":\"#{e.class}\",\"msg\":\"#{e}\"}"
+      end
+    end
+
+    def exe(*arguments)
+      begin
+        File.readlink("#{@pwd}/exe")
+      rescue Exception => e
+        # => do nothing
+        "{\"exception\":\"#{e.class}\",\"msg\":\"#{e}\"}"
+      end
+    end
+
+    def root(*arguments)
+      begin
+        File.readlink("#{@pwd}/root")
+      rescue Exception => e
+        # => do nothing
+        "{\"exception\":\"#{e.class}\",\"msg\":\"#{e}\"}"
+      end
+    end
+
+    def fd(*arguments)
+      r = []
+      begin
+        Dir.chdir("#{@pwd}/fd")
+        Dir.entries("#{@pwd}/fd").each do |d|
+          next if (d == '.') || (d == '..')
+          if FileTest.symlink?(d)
+            r << {d.to_sym => File.readlink(d)}
+          else
+            r << {d.to_sym => d}
+          end
+        end
+      rescue Exception => e
+        # => do nothing
+        r = "{\"exception\":\"#{e.class}\",\"msg\":\"#{e}\"}"
+      ensure
+        r
+      end
+    end
+
+    def smaps(*arguments)
+      r = []
+      begin
+        _fd = File.open("#{@pwd}/#{smaps}",'r')
+        _ls = _fd.readlines
+
+        while(_ls!=[])
+          h = {}
+          8.times do
+            k,v = _ls.shift.split(/\s*\:\s*/)
+            h[k.to_sym] = v
+          end
+          r << h
+        end
+
+      rescue Exception => e
+        # => do nothing
+        r = "{\"exception\":\"#{e.class}\",\"msg\":\"#{e}\"}"
+      ensure
+        _fd.close
+      end
+      r
+    end
+
+    def status(*arguments)
+      begin
+        _status = IO.read("#{@pwd}/status").split($/)
+        h = {}
+        _status.each do |line|
+          kv = line.split(/\s*\:\s*/)
+          h[kv[0].to_sym] = kv[1]
+        end
+        h
+      rescue Exception => e
+        # => do nothing
+        h = "{\"exception\":\"#{e.class}\",\"msg\":\"#{e}\"}"
+      ensure
+      end
+    end
+
+    def method_missing(method_name,*args)
+      begin
+        IO.read("#{@pwd}/#{method_name}")
+      rescue Exception => e
+        # => do nothing
+        "{\"exception\":\"#{e.class}\",\"msg\":\"#{e}\"}"
+      end
+    end
+  end
+
+	module ClassMethods
+
+	end
+
+	module InstanceMethods
+
+	end
+
+	def self.included(receiver)
+		receiver.extend         ClassMethods
+		receiver.send :include, InstanceMethods
+	end
+end

data/lib/lpm/utils.rb

@@ -0,0 +1,170 @@
+module LPM
+
+  # you could use utils like this:
+  # LPM::Utils.cpu(5)
+  # => {"cpu"=>100.0, "cpu0"=>100.0, "cpu1"=>100.0}
+
+  # also could use Utils as below:
+  # LPM::Proc.cpu(5)
+  # => {"cpu"=>100.0, "cpu0"=>100.0, "cpu1"=>100.0}
+  module Utils
+    module Proc
+      def pids(*arguments)
+        Dir.chdir '/proc'
+        Dir['[0-9]*'].inject([]) { |r, p|
+          r << {:pid => p, :cmdline => IO.read("#{p}/cmdline").gsub(/\000/,' ')}
+        }
+      end
+      
+      def date(*arguments)
+        `date +"%F %T"`.chomp
+      end
+
+      def df(*arguments)
+        size,use,avai = 0,0,0
+        str = `df`
+        arr = str.split($/)
+        arr.shift
+        arr.each { |l| x = l.split; size += x[1].to_i; use += x[2].to_i; avai += x[3].to_i  }
+        {:size => size,:use => use,:avai => avai}
+      end
+      
+      # ulimit -n is the most useful.
+      # it limitted the count of total available socket.
+      def ulimit(*arguments)
+        `ulimit -a`.split($/).map do |line|
+          a,b = line.split(/\s*\(.*?\)\s*/)
+          {a=>b}
+        end
+      end
+
+      # attention: sysctl seperator is ':' in macos.
+      def sysctl(*arguments)
+        `sysctl -a`.split($/).map do |line|
+          a,b = line.split(/\s*=\s*/)
+          {a=>b}
+        end
+      end
+
+      def locale(*arguments)
+        `locale`.split($/).map do |line|
+          a,b = line.split(/\s*=\s*/)
+          {a=>b}
+        end
+      end
+
+      # get cpu useage.
+      # total_0=USER[0]+NICE[0]+SYSTEM[0]+IDLE[0]+IOWAIT[0]+IRQ[0]+SOFTIRQ[0]
+      # sleep x
+      # total_1=USER[1]+NICE[1]+SYSTEM[1]+IDLE[1]+IOWAIT[1]+IRQ[1]+SOFTIRQ[1]
+      # cpu_usage=(IDLE[0]-IDLE[1]) / (total_0-total_1) * 100
+
+      # scale is 100
+      # cpu(5) => {"cpu3"=>99.3333333333333, "cpu"=>99.75, "cpu0"=>100.0, "cpu1"=>100.0, "cpu2"=>99.3355481727575}
+
+      def cpu(interv=3,debug=false,*arguments)
+        begin
+          interv = interv.to_i
+        rescue NoMethodError => e
+          interv = 3
+        end
+        
+        def getCpuStat(debug=false)
+          h = {}
+          IO.read('/proc/stat').split($/).map do|line|
+            a = line.split
+            # p "line => #{a.inspect}" if debug
+            #     user    nice system idle      iowait  irq  softirq
+            #cpu  1961269 660 285319 1290544224 1522385 2383 0
+            if(a[0]=~/cpu/)
+              # raise CpuLineSizeError,"The count of words each line is not equal 8." if a.size != 8
+              # p "cpu line => #{a.inspect}" if debug
+              h[a[0]] = {:total => a[1..-1].inject(0) do |sum,i|
+                                                        sum += i.to_f
+                                                      end,
+                          :idle => a[4].to_f}
+              # p "idle => #{h[a[0]][:idle]}" if debug
+            end
+          end
+          h
+        end
+
+        def getCpuUseage(h1,h2,debug=false)
+          # p h1.inspect if debug
+          # p h2.inspect if debug
+          # p "h2[:idle]-h1[:idle] = #{(h2[:idle]-h1[:idle]).to_f}" if debug
+          # p "h2[:total]-h1[:total] = #{(h2[:total]-h1[:total]).to_f}" if debug
+          100 - (h2[:idle]-h1[:idle]).to_f/(h2[:total]-h1[:total]).to_f * 100
+        end
+
+        cpu_old,cpu_new = {},{}
+        
+        th = Thread.fork do
+          cpu_old = getCpuStat(debug)
+          sleep interv
+          cpu_new = getCpuStat(debug)
+        end
+
+        th.join
+        
+        r = {}
+        cpu_old.each do |k,v|
+          r[k.to_sym] =getCpuUseage(cpu_old[k],cpu_new[k],debug)
+        end
+        r
+      end
+      
+      def hostname(*arguments)
+        `hostname`.chomp
+      end
+    end
+
+    # LPM::Process included the Process module,
+    # you can use as:
+    # => LPM::Process.new(pid).cpu
+    # then you will get that pid process's cpu total useage.
+    module Process
+
+      # rate = ((utime2+stime2) - (utime1+stime1)) / (total2 - total1)
+      # total = user + sys + idle + nice or get value from /proc/uptime
+      def cpu(interv=3,*arguments)
+        utime1,stime1,starttime1,total1,idle1 = nil
+        utime2,stime2,starttime2,total2,idle2 = nil
+
+        # t = Thread.fork do
+        utime1,stime1,starttime1 = IO.read("#{@pwd}/stat").split.values_at(15,16,23).map{|x|x.to_f}
+        # Attention : uptime file's end contain $/
+        # "3394903.84 3389669.77\n"
+        # if run in Thread,
+        # Process will hang on IO.read('/proc/uptime')
+        # like this => http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/125125
+        # i don't know why.
+        total1,idle1 = IO.read('/proc/uptime').chop.split.map{|x|x.to_f}
+        sleep interv
+        utime2,stime2,starttime2 = IO.read("#{@pwd}/stat").split.values_at(15,16,23).map{|x|x.to_f}
+        total2,idle2 = IO.read('/proc/uptime').chop.split.map{|x|x.to_f}
+        # end
+        
+        # t.join
+        ((utime2+stime2) - (utime1+stime1)).to_f / (total2 - total1).to_f
+      end
+      
+      def mem(*arguments)
+        (IO.read("#{@pwd}/statm").split.shift.to_f/1024).to_s
+      end
+    end
+    
+    class << self;include Proc;end
+  end
+
+  # insert into LPM::Proc's meta class.
+  begin
+    (class << LPM::Proc;include Utils::Proc;end) unless LPM::Proc.include? Utils::Proc
+    LPM::Process.send :include,Utils::Process
+  rescue NameError
+    require File.join(File.dirname(__FILE__),'proc.rb')
+    require File.join(File.dirname(__FILE__),'process.rb')
+    retry
+  end
+
+end

data/lib/server.rb

@@ -0,0 +1,70 @@
+require 'rubygems'
+require File.join(File.dirname(__FILE__),'lpm.rb')
+require File.join(File.dirname(__FILE__),'utils.rb')
+
+begin
+  gem 'sinatra'
+  require 'sinatra/base'
+  require 'activesupport' unless ({}.respond_to? :to_json)
+rescue LoadError => e
+  p <<DOC
+-----------------------------------------------------------------------
+LPM say:
+The LPM server require sinatra and activesupport.
+Please exec "gem install sinatra" or "gem install activesupport" first.
+-----------------------------------------------------------------------
+Ruby say:
+#{e}
+-----------------------------------------------------------------------
+DOC
+  exit(-1)
+end
+
+$LPMPool = {}
+
+class AppServer < Sinatra::Base
+    get '/' do
+      "{\"msg\":\"Welcome using LPM(Linux Proc Monitor)\"}"
+    end
+
+    get '/lpm/:verbose' do
+      r = ''
+      case params[:verbose]
+      when /ver/i
+        r = "0.1.2";break;
+      when /proc/i
+        redirect '/proc'
+      when /process/i
+        redirect '/process'
+      end
+      r
+    end
+
+    get '/proc/:method/*' do
+      if params[:method] == nil then
+        "Monitor target is needed,such as <a href='/proc/cpuinfo'>/proc/cpuinfo</a>"
+      else
+        (LPM::Proc.send params[:method],*(params[:splat].split('/'))).to_json
+      end
+    end
+
+    get '/process/:pid/:method/*' do
+      if params[:method] != nil and params[:pid].to_i >= 0 then
+        begin
+          a_lpm = $LPMPool[params[:pid]]||($LPMPool[params[:pid]] = LPM::Process.new(params[:pid]))
+          (a_lpm.send params[:method],*(params[:splat].split('/'))).to_json
+        rescue NoPidExist => e
+          %Q-{"success":false,"msg":#{e}}-
+        end
+      else
+        "Monitor target and pid is needed,such as <a href='/process/909/status'>/proc/cpuinfo</a>"
+      end
+    end
+end
+
+class LPMServer
+  def self.run(host='0.0.0.0',port=9876)
+    # Daemon.start{AppServer.run! :host => host, :port => port}
+    AppServer.run! :host => host, :port => port
+  end
+end

data/lib/utils.rb

@@ -0,0 +1,13 @@
+class Daemon
+  def Daemon.start
+    exit!(0) if fork
+    Process::setsid
+    exit!(0) if fork
+    Dir::chdir("/")
+    File::umask(0)
+    STDIN.reopen("/dev/null")
+    STDOUT.reopen("/dev/null", "w")
+    STDERR.reopen("/dev/null", "w")
+    yield if block_given?
+  end
+end

data/lib/xiaoqian.rb

@@ -0,0 +1,257 @@
+require "rubygems"
+require "eventmachine"
+require "memcache"
+require "logger"
+require 'activesupport' unless ({}.respond_to? :to_json)
+
+require File.join(File.dirname(__FILE__),'lpm.rb')
+
+class Xiaoqian
+  
+  # in memcache
+  # XQList:
+  # [
+  #   '10.2.226.37',
+  #   '10.2.226.38',
+  #   '10.2.226.39'->pids:
+  #                       [
+  #                         12345,
+  #                         23456
+  #                         34567
+  #                       ]
+  # ]
+  
+  # based on pids in memcache,XiaoQian server will periodic update processes array.
+  
+  # caches => ['10.2.226.38:11211','10.2.226.38:11212','10.2.226.39:11211']
+  # cacches => ['127.0.0.1:11011','127.0.0.1:11012']
+  # Xiaoqian.new(15,{:pids=>[28261,28263],:caches=>['10.2.226.133:11011','10.2.226.133:11012']})
+  def initialize(timer,opts = {:pids=>[],:caches=>[]})
+    @local_ip = get_local_ip
+    @timer = timer
+    @logger = opts[:log]
+    
+    # @XQcaches = get_cache_clients(caches)
+    @XQcaches = MemCache.new(opts[:caches],:namespace=>"XQ#{@local_ip}")
+    @QNYHcaches = MemCache.new(opts[:caches],:namespace=>"QNYH")
+    
+    @process = get_processes_instance(opts[:pids])
+    init_cache_config(opts[:pids],@local_ip)
+  end
+  
+  def init_cache_config(pids,local_ip)
+    # load File.join(File.dirname(__FILE__),'config','stipulation.rb')
+    @XQcaches.set :localhost,local_ip
+    @XQcaches.set :pids,pids
+    
+    
+    register_QNYH_XQList
+  end
+  
+  def register_QNYH_XQList
+    list = @QNYHcaches.get(:XQList) || []
+    unless list.include?(@local_ip) then
+      list << @local_ip
+        @QNYHcaches.set(:XQList,list)
+    end
+    list
+  end
+  
+  def get_local_ip
+    require 'socket'
+    IPSocket.getaddress(Socket.gethostname)
+  end
+  
+  # proIns =>
+  # {12345 => <LPM::Process>,67890 => <LPM::Process>}
+  def update_processes_instance(proIns={},pids=[])
+    keys = proIns.keys
+    pids.each do |pid|
+      begin
+        proIns[pid] = LPM::Process.new(pid) unless keys.include?(pid)
+      rescue Exception => e
+        @logger.error "update_processes_instance(#{proIns.inspect},#{pids.inspect})"
+        @logger.error e
+      end
+    end
+    keys = proIns.keys
+    (keys - pids).each{ |var| proIns.delete var }
+    proIns
+  end
+  
+  def get_processes_instance(pids=[])
+    h = {}
+    if pids then
+      pids.each{ |pid|
+        begin
+         h[pid] = LPM::Process.new(pid)
+        rescue Exception => e
+          @logger.error "get_processes_instance(#{pids.inspect})"
+          @logger.error e
+        end
+      }
+    end
+    h
+  end
+  
+  def get_cache_clients(caches=[])
+  
+    # EM::P::Memcache.connect =>
+    # # Connect to a memcached server (must support NOREPLY, memcached >= 1.2.4)
+    # def self.connect host = 'localhost', port = 11211
+    #   EM.connect host, port, self, host, port
+    # end
+    caches.inject([]){|arr,ca|
+      host,port = ca.split(':')
+      if port then
+        arr << EM::P::Memcache.connect(host,port.to_i)
+      else
+        arr << EM::P::Memcache.connect(host)
+      end
+    }
+  end
+  
+  def wrap_data(data)
+    {:ts => Time.now.to_i,:data => data}
+  end
+  
+  # Data from Job
+  # => {:ts=>123456789,:data=><Hash>}
+  
+  def process_job(timer)
+    @logger.error "[Pid => #{Process.pid}] -- Process Job start."
+    EM.run{
+      EM.add_periodic_timer(timer){
+        @logger.info "process_job is called."
+        @process = update_processes_instance(@process,@XQcaches.get(:pids))
+        @logger.info "@process => #{@process.inspect}."
+        r = []
+        t = []
+        
+        @process.each do |key,ins|
+          tmp = {}
+          t << Thread.fork{
+            tmp.update({:cpu => ins.cpu})
+          }
+          tmp.update({
+            :pid => ins.pid,
+            :cwd => ins.cwd,
+            :exe => ins.exe,
+            :root => ins.root,
+            :cmdline => ins.cmdline,
+            :memory => ins.mem
+          })
+          r << tmp
+        end
+        t.each{|x|x.join}
+        @logger.info "@process result => #{r.inspect}"
+        @XQcaches.set :host_process_grid,wrap_data({:root => r,:total => r.size}.to_json)
+      }
+    }
+  end
+  
+  # LPM::Proc or LPM::Process data will be wraped in json format.
+  # This format must be fit to the require of LPMP's javascript.
+  
+  def proc_job(timer)
+    @logger.error "[Pid => #{Process.pid}] -- Proc Job start."
+    EM.run{
+      # cpu
+      EM.add_periodic_timer(timer){
+        # cpu
+        @logger.debug "proc_job's cpu is called."
+        @XQcaches.set :host_proc_cpu,wrap_data({:value => LPM::Proc.cpu[:cpu].to_f,:time => Time.now.strftime("%m-%d %Hh:%Mm:%Ss")}.to_json)
+      }
+      # loadavg
+      EM.add_periodic_timer(timer){
+        # loadavg
+        @logger.debug "proc_job's loadavg is called."
+        @XQcaches.set :host_proc_loadavg,wrap_data({:value => LPM::Proc.loadavg[:load][0].to_f,:time => Time.now.strftime("%m-%d %Hh:%Mm:%Ss")}.to_json)
+      }
+      # meminfo
+      EM.add_periodic_timer(timer){
+        # meminfo
+        @logger.debug "proc_job's meminfo is called."
+        @XQcaches.set :host_proc_meminfo,wrap_data({:root => LPM::Proc.meminfo.inject([]){|a,e|
+          a << {:type => e[0],:count => e[1]}
+        },:time => Time.now.strftime("%m-%d %Hh:%Mm:%Ss")}.to_json)
+      }
+      # df
+      EM.add_periodic_timer(timer){
+        # df
+        @logger.debug "proc_job's df is called."
+        @XQcaches.set :host_proc_df,wrap_data({:root => LPM::Proc.df.inject([]){|a,e|
+          a << {:type => e[0],:count => e[1]}
+        },:time => Time.now.strftime("%m-%d %Hh:%Mm:%Ss")}.to_json)
+      }
+      # pids
+      EM.add_periodic_timer(timer){
+        # pids
+        @logger.debug "proc_job's pids is called."
+        @XQcaches.set :host_proc_pids,wrap_data(LPM::Proc.pids.map{ |e| {:text => e[:cmdline],:leaf => true,:cls => "file",:qtip => e[:pid]} }.to_json)
+      }
+      
+      # grid
+      EM.add_periodic_timer(timer){
+        @logger.info "proc_job's grid is called."
+        tmp = {}
+        t = Thread.fork{
+          tmp.update({:cpu => LPM::Proc.cpu["cpu"]})
+        }
+        tmp.update({
+          :ip => @local_ip,
+          :hostname => LPM::Proc.hostname,
+          :loadavg => LPM::Proc.loadavg[:load][0],
+          :mem_total => LPM::Proc.meminfo[:MemTotal],#.chomp(' kB'),
+          :mem_free => LPM::Proc.meminfo[:MemFree],#.chomp(' kB'),
+          :uptime_total => LPM::Proc.uptime[:total],
+          :uptime_idle => LPM::Proc.uptime[:idle],
+          :disk_size => LPM::Proc.df[:size],
+          :disk_use => LPM::Proc.df[:use],
+          :date => LPM::Proc.date
+        })
+        t.join
+        @logger.info "proc_grid => #{tmp.inspect}."
+        @XQcaches.set :host_proc_grid,wrap_data(tmp)
+      }
+    }
+  end
+  
+  def work_job
+    timer = @timer
+    @logger.error "work_job will run,and interval timer is #{timer}."
+    p = []
+    p << Process.fork{
+      begin
+        self.proc_job(timer)
+      rescue Exception => e
+        @logger.fatal "Proc Job fatal error!"
+        @logger.fatal e.to_s
+      end
+    }
+    if p[0] then
+      p << Process.fork{
+        begin
+          self.process_job(timer)
+        rescue Exception => e
+          @logger.fatal "Process Job fatal error!"
+          @logger.fatal e.to_s          
+        end
+      }
+    end
+    @logger.error "work_job is running."
+    @logger.error "process and proc job's pid => #{p.inspect}."
+    Process.waitall
+    @logger.error "work_job shutdown."
+  end
+  
+  def self.run(timer,opts = {:pids=>[],:caches=>[]})
+    begin
+      # Daemon.start{Xiaoqian.new(timer,{:pids=>opts[:pisd],:caches=>opts[:caches],:log=>opts[:log]}).work_job}
+      Xiaoqian.new(timer,{:pids=>opts[:pids],:caches=>opts[:caches],:log=>opts[:log]}).work_job
+    rescue Exception => e
+      opts[:log].error e
+      opts[:log].error "Xiaoqian.new(#{timer},#{{:pids=>opts[:pids],:caches=>opts[:caches],:log=>opts[:log]}}).work_job"
+    end
+  end
+end

data/test/self_test/em_periodic.rb

@@ -0,0 +1,38 @@
+require "rubygems"
+require "eventmachine"
+require "memcache"
+
+@cache = MemCache.new(['127.0.0.1:11011'],:namespace=>"XQ#{@local_ip}")
+
+EM.run{
+  p 'EM.run 1st block.'
+  EM.add_periodic_timer(5){
+    @cache.set :Timer1,"Time now => #{Time.now.to_s}"
+    p 'set Timer1'
+  }
+  
+  EM.add_periodic_timer(5){
+    puts @cache.get(:Timer1)
+  }
+  
+  EM.add_periodic_timer(7){
+    @cache.set :Timer2,"Hello dear All. I'm logger :)"
+    p 'set Timer2'
+  }
+  
+  EM.add_periodic_timer(7){
+    puts @cache.get(:Timer2)
+  }
+}
+
+EM.run{
+  p 'EM.run 2nd block.'
+  EM.add_periodic_timer(3){
+    @cache.set :Timer3,"Time now => #{Time.now.to_s}"
+    p 'set Timer1'
+  }
+  
+  EM.add_periodic_timer(3){
+    puts @cache.get(:Timer1)
+  }
+}

data/test/test_proc.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__),'..','lib','lpm.rb')
+
+require "Benchmark"
+require "pp"
+
+Benchmark.bm do |x|
+  x.report("CPU"){pp LPM::Proc.cpu}
+  x.report("CPU(5)"){pp LPM::Proc.cpu(5)}
+  x.report("CPU(10)"){pp LPM::Proc.cpu(10)}
+  x.report("CPU(15)"){pp LPM::Proc.cpu(15)}
+end
+
+# => below test is for LPM::Proc
+pp "LPM::Proc.loadavg => #{LPM::Proc.loadavg}"
+pp "LPM::Proc.uptime => #{LPM::Proc.uptime}"
+pp "LPM::Proc.meminfo => #{LPM::Proc.meminfo}"
+pp "LPM::Proc.cpuinfo => #{LPM::Proc.cpuinfo}"

data/test/test_process.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__),'..','lib','lpm.rb')
+
+require "Benchmark"
+require "pp"
+
+# if the pid equal 12345
+# then
+# p1 = LPM::Process.new(12345)
+# p1.cpu
+# p1.cwd
+# ...

data/test/test_utils.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__),'..','lib','lpm.rb')
+
+require "Benchmark"
+require "pp"
+
+# => below test is for LPM::Utils
+pp "LPM::Utils.ulimit => #{LPM::Utils.ulimit}"
+pp "LPM::Utils.locale => #{LPM::Utils.locale}"
+pp "LPM::Utils.sysctl => #{LPM::Utils.sysctl}"
+
+# => LPM::Utils can also be used as
+pp "LPM::Proc.ulimit => #{LPM::Proc.ulimit}"
+pp "LPM::Proc.locale => #{LPM::Proc.locale}"
+pp "LPM::Proc.sysctl => #{LPM::Proc.sysctl}"

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: lpm
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Charles Cui
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-29 00:00:00 +08:00
+default_executable: 
+dependencies: []
+
+description: Linux Proc Monitor
+email: zheng.cuizh@gmail.com
+executables: 
+- lpm
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- LICENSE
+- README
+- Rakefile
+- bin/lpm
+- lib/config/stipulation.rb
+- lib/lpm/error.rb
+- lib/lpm/proc.rb
+- lib/lpm/process.rb
+- lib/lpm/utils.rb
+- lib/lpm.rb
+- lib/server.rb
+- lib/utils.rb
+- lib/xiaoqian.rb
+- test/self_test/em_periodic.rb
+- test/test_proc.rb
+- test/test_process.rb
+- test/test_utils.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Linux Proc Monitor
+test_files: []
+