super-test 1.0.9

data/data/user.house

@@ -0,0 +1,8 @@
+- name: hanyu
+  pasw: ll
+- name: lfsjlaf
+  type: his
+- name: ruguo
+  password: aaaa
+  spaceurl: ruguo32
+  tag : slfs

data/lib/action/module/check_action.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+$LOAD_PATH << File.join(File.dirname(__FILE__), '.')
+
+module CheckActionHelper
+	include MylogHelper
+	
+	# === 功能
+	# IOHEAD的正则匹配
+	# 
+	# === 参数
+	# - pattern  正则式
+	#
+	# Example
+	# assert_head "log_id:10"
+	def assert_head pattern
+		assert_match(pattern, Context.get("IOHEAD"), "IOHEAD mismatch")
+		puts "AssertOK IOHEAD #{pattern}"
+		$log.info "AssertOK IOHEAD #{pattern}"
+	end
+
+	# === 功能
+	# IOBODY的正则匹配
+	#
+	# === 参数
+	# - pattern  正则式
+	#
+	# Example
+	# assert_body "a.*b.*c"
+	def assert_body pattern
+		assert_match(pattern, Context.get("IOBODY"), "IOBODY mismatch")
+		puts "AssertOK IOBODY #{pattern}"
+		$log.info "AssertOK IOBODY #{pattern}"
+	end
+
+        # === 检查是否存在core文件
+        # 
+        # === 参数
+        # - host 机器
+        # 
+        # === Example:
+        # core_check
+        def core_check host=HOST, user=USERNAME, password=PASSWORD
+                if Util.is_localhost? (host) then
+                        ret = system "file ~/*.core"
+                else    
+                        ret = Util.exe_ssh_cmd! host, "file ~/*.core", user, password
+                end
+                Context.set("IOBODY", ret)
+		assert_body("cannot open")
+		$log.info "core_check"
+        end
+
+
+end
+
+
+

data/lib/action/module/cnnt_action.rb

@@ -0,0 +1,161 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+$LOAD_PATH << File.join(File.dirname(__FILE__), '.')
+
+require 'socket'
+
+
+module CNNTActionHelper
+	include Socket::Constants
+
+	# === 建立连接 用于长连接操作
+	# 
+	# === 参数
+	# - ip
+	# - port
+	#
+	# === 返回
+	# socekt 句柄
+	# 
+	# === Example:
+	# socket = cnnt_connect 127.0.0.1, 1900
+	def cnnt_connect ip, port
+		socket = Socket.new( AF_INET, SOCK_STREAM, 0 )
+		sockaddr = Socket.pack_sockaddr_in( port, ip )
+		socket.connect( sockaddr )
+		return socket
+	end
+	
+	# === 发送数据 用于长连接操作
+	# 
+	# === 参数
+	# socket 用于发送的socket句柄
+	# cont 发送的内容
+	#
+	# === 返回
+	# 发送的数据长度
+	#
+	# === Example
+	# cnnt_send socket, "dddd"
+	def cnnt_send socket, cont
+		socket.send cont, 0
+	end
+	
+	# === 关闭连接 用于长连接操作
+	#
+	# === 参数
+	# socket 用于操作的socket句柄
+	#
+	# === Example
+	# cnnt_close socket
+	def cnnt_close socket
+		socket.close
+	end
+
+	# === 发送一次数据 用于短连接操作
+	#
+	# === 参数
+	# ip	ip
+	# port	端口
+	# cont	要发送的内容
+	#
+	# === 返回
+	# 发送的数据长度
+	#
+	# === Example
+	# cnnt_short_send "127.0.0.1", 1900, "dddd"
+	def cnnt_direct_send ip, port, cont
+		socket = Socket.new( AF_INET, SOCK_STREAM, 0 )
+          	sockaddr = Socket.pack_sockaddr_in( port, ip )
+          	socket.connect( sockaddr )
+		ret = socket.send cont, 0
+          	socket.close
+		return ret
+	end
+
+	# === 创建一个server 处理部分需要用户自己完成
+	# 该server可以接收多线程的连接
+	#
+	# === 参数
+	# port 端口
+	# yield 处理函数
+	#
+	# === 返回
+	# 服务器线程句柄
+	#
+	# === Example
+	# a1 = cnnt_create_server(1999) {|client|
+        #       data = client.recvfrom(200)[0]
+	#	if data.length>0
+	# 		p data
+	#	end
+        #}
+	def cnnt_create_server port
+		svr_t = Thread.new {
+			socket = Socket.new( AF_INET, SOCK_STREAM, 0 )
+          		sockaddr = Socket.pack_sockaddr_in( port, 'localhost' )
+		  	socket.bind( sockaddr )
+	          	socket.listen( 5 )
+			loop do
+	          		client, client_sockaddr = socket.accept
+				Thread.new{
+					loop do
+						yield client
+					end
+				}
+			end
+        	  	socket.close
+		}
+		return svr_t
+	end
+	
+	# === 创建一个server 接收到的数据被放到cont数组中
+	# 该函数仅支持一个线程的连接请求
+	#
+	# === 参数
+	# port 端口
+	# cont 接收数据用的数组
+	#
+	# === 返回
+	# 服务器线程句柄
+	#
+	# === Example
+	# cont=[]
+	# cnnt_create_practical_server 1999, cont
+	# cnnt_direct_send "127.0.0.1", 1999, "dddd"
+	# p cont[0]
+	def cnnt_create_practical_server port, cont
+		svr_t = Thread.new {
+			socket = Socket.new( AF_INET, SOCK_STREAM, 0 )
+          		sockaddr = Socket.pack_sockaddr_in( port, 'localhost' )
+		  	socket.bind( sockaddr )
+	          	socket.listen( 5 )
+	          	client, client_sockaddr = socket.accept
+			loop do
+				cont << client.recvfrom(1024)[0]
+			end
+        	  	socket.close
+		}
+		return svr_t
+	end
+
+	# === 停止服务线程
+	#
+	# === 参数
+	# svr 服务器线程句柄
+	#
+	# === Example
+	# cnnt_stop_server svr
+	def cnnt_stop_server svr
+		svr.exit
+	end
+
+
+end
+
+
+
+if __FILE__ == $0
+end
+
+

data/lib/action/module/datacenter_action.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+$LOAD_PATH << File.join(File.dirname(__FILE__), '.')
+
+
+module DataCenterActionHelper
+
+	# 功能
+	# 对模块进行基线数据的恢复
+	#
+	# Example
+=begin
+mdl_friend = ModuleHouse.get_instance.get_by_name "friend"
+datacenter = DCHouse.get_instance.get_by_name "datacenter"
+new_conf = { 
+ "adr"=>datacenter["host"],
+ "username"=>datacenter["db01"]["dbuser"],
+ "port"=>datacenter["db01"]["dbport"],
+ "passwd"=>datacenter["db01"]["dbpass"],
+ "dbname"=>mdl_friend["dbname"],
+ "dbport"=>datacenter["db01"]["dbport"]
+}
+MoudleHouse.get_instance.set_new_conf(mdl_friend, new_conf)
+module_prepare datacenter, mdl_friend
+=end
+	def module_prepare datacenter, mdl	
+		if mdl["recoversql"] == 1
+			if mdl["dbversion"] == "5.1.30"
+				ssh_cmd datacenter["host"], datacenter["user"], datacenter["pass"], "#{datacenter["db01"]["dbpath"]}/bin/mysql -u#{datacenter["db01"]["dbuser"]} -p#{datacenter["db01"]["dbpass"]} #{mdl["dbname"]} < #{datacenter["datacenterpath"]}/#{mdl["basesql"]}"
+			end
+			if mdl["dbversion"] == "5.22"
+				ssh_cmd datacenter["host"], datacenter["user"], datacenter["pass"], "#{datacenter["db02"]["dbpath"]}/bin/mysql -u#{datacenter["db02"]["dbuser"]} -p#{datacenter["db02"]["dbpass"]} #{mdl["dbname"]} < #{datacenter["datacenterpath"]}/#{mdl["basesql"]}"
+			end
+		end
+		if mdl["recoverdata"] == 1
+			ssh_cmd datacenter["host"], datacenter["user"], datacenter["pass"], "H #{mdl["h_name"]} -pub #{datacenter["datacenterpath"]}/#{mdl["basedata"]} #{datacenter["datadownloadto"]}"
+		end
+	end
+
+
+end
+
+
+
+#if __FILE__ =
+#end
+
+

data/lib/action/module/http_pack_helper.rb

@@ -0,0 +1,163 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+#
+# Author:: wangkaihua.
+# Date:: 2009.12.18
+
+require 'webrick'
+
+class HttpRequest < WEBrick::HTTPRequest
+  attr_reader :io, :config
+  
+  def initialize(io)
+	@io=io
+	@config={
+		:RequestTimeout =>30,
+		:InputBufferSize =>65536,
+		:HTTPVersion =>WEBrick::HTTPVersion.new("1.1"),
+		:Logger =>WEBrick::Log.new,
+		:Escape8bitURI =>false,
+		:ServerSoftware =>"Ruby HttpServer 1.0"
+	}
+	super(@config)
+	parse(io)
+  end
+
+  def content
+  	query
+  end
+end
+
+class HttpResponse
+  attr_reader   :header
+  attr_accessor :body, :status, :status_message
+  
+  def initialize(status=200)
+    @status = status
+    @status_message = nil
+    @header = Table.new
+  end
+
+  def charset
+  	return nil if @header["Content-Type"]==nil
+	charset_array=@header["Content-Type"].scan(/charset=([^; ]*)/)[0]
+	return nil if charset_array==nil
+	return charset_array[0]
+  end
+
+  def to_http_pack(status_code=nil, status_message=nil, header=nil, body=nil)
+	_status_code_=(status_code==nil) ? @status : status_code
+	_status_message_=(status_message==nil) ? StatusCodeMapping[_status_code_] : status_message
+	_header_=(header==nil) ? @header : header
+	_body_=(body==nil) ? @body : body
+	
+#    _status_message_ ||= StatusCodeMapping[_status_code_]
+	
+	#encoding body.
+	unless _body_.nil?
+		if charset==nil
+			_body_=_body_.force_encoding("gbk")
+		else
+			encod=charset.downcase
+			if encod=="gbk" or encod=="gb2312"
+				_body_=_body_.force_encoding("gbk")
+			else
+				_body_=_body_.force_encoding("gbk").encode(encod)
+			end
+		end
+	end
+
+	#to pack.
+    http_pack = ""
+    http_pack << "#{HTTP_PROTO} #{_status_code_} #{_status_message_}" << CRLF
+    http_header(_header_, _body_).writeTo(http_pack)
+    http_pack << CRLF
+
+    http_pack << _body_ unless _body_.nil?
+    http_pack
+  end
+
+
+  private
+  # Helper Methods ------------------------------------------
+
+  def http_header(header=nil, body=nil)
+    new_header = Table.new(DEFAULT_HEADER)
+	
+	#auto modify content-length.
+	new_header["Content-Length"] = "0"	
+	new_header["Content-Length"] = body.bytesize unless body == nil
+    new_header["Connection"] = "close"
+    new_header["Date"]       = http_date(Time.now)
+
+    new_header.update(header) unless header.nil? 
+    new_header
+  end
+
+  def http_date( aTime )
+    aTime.gmtime.strftime( "%a, %d %b %Y %H:%M:%S GMT" )
+  end
+
+	
+end
+		
+# Constants -----------------------------------------------
+
+CRLF        = "\r\n"
+HTTP_PROTO  = "HTTP/1.0"
+SERVER_NAME = "HttpServer (Ruby #{RUBY_VERSION})"
+
+DEFAULT_HEADER = {
+  "Server" => SERVER_NAME
+}
+
+##
+# Mapping of status code and error message
+#
+StatusCodeMapping = {
+  200 => "OK",
+  400 => "Bad Request",
+  403 => "Forbidden",
+  405 => "Method Not Allowed",
+  411 => "Length Required",
+  500 => "Internal Server Error"
+}
+		
+##
+# a case-insensitive Hash class for HTTP header
+#
+class Table
+  include Enumerable
+
+  def initialize(hash={})
+    @hash = hash 
+    update(hash)
+  end
+
+  def [](key)
+  	# @hash[key.to_s.capitalize]
+  	@hash[key.to_s]
+  end
+
+  def []=(key, value)
+  	#@hash[key.to_s.capitalize] = value
+  	@hash[key.to_s] = value
+  end
+
+  def update(hash)
+    hash.each {|k,v| self[k] = v}
+    self
+  end
+
+  def each
+  	#@hash.each {|k,v| yield k.capitalize, v }
+  	@hash.each {|k,v| yield k, v }
+  end
+
+  def writeTo(port)
+    each { |k,v|
+		port << "#{k}: #{v}" << CRLF 
+	}
+  end
+end # class Table
+	

data/lib/action/module/httpserver_action.rb

@@ -0,0 +1,297 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+#
+# Author::  wangkaihua.  
+# Date::    Wed Dec 16 22:21:34 CST 2009
+
+##to-do-list:
+##
+##
+
+require "socket"
+require "thread"
+require "#{File.dirname(__FILE__)}/http_pack_helper"
+
+
+module HttpServerActionHelper
+
+	class GeneralServer
+	
+	  DEFAULT_HOST = "127.0.0.1"
+	
+	  def serve(io)
+		yield if block_given?
+	  end
+	
+	  @@services = {}   # Hash of opened ports, i.e. services
+	  @@servicesMutex = Mutex.new
+	
+	  def GeneralServer.stop(port, host = DEFAULT_HOST)
+	    @@servicesMutex.synchronize {
+	      @@services[host][port].stop
+	    }
+	  end
+	
+	  def GeneralServer.in_service?(port, host = DEFAULT_HOST)
+	    @@services.has_key?(host) and
+	      @@services[host].has_key?(port)
+	  end
+	
+	  def stop
+	    @connectionsMutex.synchronize  {
+	      if @tcpServerThread
+			@tcpServerThread.raise "stop"
+	      end
+	    }
+		@tcpServerThread.join
+	  end
+	
+	  def stopped?
+	    @tcpServerThread == nil
+	  end
+	
+	  def shutdown
+	    @shutdown = true
+	  end
+	
+	  def connections
+	    @connections.size
+	  end
+	
+	  def join
+	    @tcpServerThread.join if @tcpServerThread
+	  end
+	
+	  attr_reader :port, :host, :maxConnections
+	  attr_accessor :stdlog, :audit, :debug
+	
+	  def connecting(client)
+	    addr = client.peeraddr
+	    log("#{self.class.to_s} #{@host}:#{@port} client:#{addr[1]} " +
+	        "#{addr[2]}<#{addr[3]}> connect")
+	    true
+	  end
+	
+	  def disconnecting(clientPort)
+	    log("#{self.class.to_s} #{@host}:#{@port} " +
+	      "client:#{clientPort} disconnect")
+	  end
+	
+	  protected :connecting, :disconnecting
+	
+	  def starting()
+	    log("#{self.class.to_s} #{@host}:#{@port} start")
+	  end
+	
+	  def stopping()
+	    log("#{self.class.to_s} #{@host}:#{@port} stop")
+	  end
+	
+	  protected :starting, :stopping
+	
+	  def error(detail)
+	    log(detail.backtrace.join("\n"))
+	  end
+	
+	  def log(msg)
+	    if @stdlog
+	      @stdlog.puts("[#{Time.new.ctime}] %s" % msg)
+	      @stdlog.flush
+	    end
+	  end
+	
+	  protected :error, :log
+	
+	
+	  def initialize(port, host = DEFAULT_HOST, maxConnections = 4,
+	    stdlog = $stderr, audit = false, debug = false)
+	    @tcpServerThread = nil
+	    @port = port
+	    @host = host
+	    @maxConnections = maxConnections
+	    @connections = []
+	    @connectionsMutex = Mutex.new
+	    @connectionsCV = ConditionVariable.new
+	    @stdlog = stdlog
+	    @audit = audit
+	    @debug = debug
+	  end
+	
+	  def start(maxConnections = -1, &blk)
+	    raise "running" if !stopped?
+	    @shutdown = false
+	    @maxConnections = maxConnections if maxConnections > 0
+	    @@servicesMutex.synchronize  {
+	      if GeneralServer.in_service?(@port,@host)
+	        raise "Port already in use: #{host}:#{@port}!"
+	      end
+	      @tcpServer = TCPServer.new(@host,@port)
+	      @port = @tcpServer.addr[1]
+	      @@services[@host] = {} unless @@services.has_key?(@host)
+	      @@services[@host][@port] = self;
+	    }
+	    @tcpServerThread = Thread.new {
+	      begin
+	        starting if @audit
+	        while !@shutdown
+	          @connectionsMutex.synchronize  {
+	             while @connections.size >= @maxConnections
+	               @connectionsCV.wait(@connectionsMutex)
+	             end
+	          }
+	          client = @tcpServer.accept
+	          @connections << Thread.new(client)  { |myClient|
+	            begin
+	              myPort = myClient.peeraddr[1]
+	              serve(myClient, &blk) if !@audit or connecting(myClient)
+	            rescue => detail
+	              error(detail) if @debug
+	            ensure
+	              begin
+	                myClient.close
+	              rescue
+	              end
+	              @connectionsMutex.synchronize {
+	                @connections.delete(Thread.current)
+	                @connectionsCV.signal
+	              }
+	              disconnecting(myPort) if @audit
+	            end
+	          }
+	        end
+	       rescue => detail
+	        error(detail) if @debug
+	      ensure
+	        begin
+	          @tcpServer.close
+	        rescue
+	        end
+	        if @shutdown
+	          @connectionsMutex.synchronize  {
+	             while @connections.size > 0
+	               @connectionsCV.wait(@connectionsMutex)
+	             end
+	          }
+	        else
+	          @connections.each { |c| c.raise "stop" }
+	        end
+	        @tcpServerThread = nil
+	        @@servicesMutex.synchronize  {
+	          @@services[@host].delete(@port)
+	        }
+	        stopping if @audit
+	      end
+	    }
+	    self
+	  end
+	
+	end
+
+	class HttpServer < GeneralServer
+	  def initialize(port, host = DEFAULT_HOST, maxConnections = 4, 
+	                 stdlog = $stdout, audit = false, debug = false)
+	    super(port, host, maxConnections, stdlog, audit, debug)
+	  end
+	
+	private
+
+	  # Main Serve Loop -----------------------------------------
+	  
+	  def serve(io)  
+#	    # perform IP authentification
+#	    unless @handler.ip_auth_handler(io)
+#	      io << http_resp(403, "Forbidden")
+#	      return
+#	    end
+#	
+#	    # parse first line
+#	    if io.gets =~ /^(\S+)\s+(\S+)\s+(\S+)/
+#	      request = Request.new(io, $1, $2, $3)
+#	    else
+#	      io << http_resp(400, "Bad Request") 
+#	      return
+#	    end
+#	     
+#	    # parse HTTP headers
+#	    while (line=io.gets) !~ /^(\n|\r)/
+#	      if line =~ /^([\w-]+):\s*(.*)$/
+#	        request.header[$1] = $2.strip
+#	      end
+#	    end
+		request = HttpRequest.new(io)
+	    response = HttpResponse.new
+	
+	    # execute request handler
+		yield(request, response)
+	   
+	    # write response back to the client
+		io << response.to_http_pack
+	
+	  rescue Exception => e
+#	    io << http_resp(500, "Internal Server Error")
+	  	raise "[ERROR] Exception:#{e.to_s}"
+	  end
+	
+	end # class HttpServer
+
+end
+
+
+if __FILE__ == $0
+	require 'wise_test'
+	class MyTest <WiseTest
+		def test_httpserver_get
+			server=HttpServer.new(8787)
+			server.start do |request, response|
+				#process request
+				puts "[SERVER][get] request from client:"	
+				p request.header
+				p request.body
+
+				#customize your own response
+				puts "[SERVER][get] response to client:"
+				#response.status=403
+				response.header["Content-Type"]= "application/xhtml+xml;charset=gbk"
+				response.body="hello world!<-------path:/-------->哈喽我热烈的" if request.path=='/'
+				response.body="hello world!<-------path:/test/-------->哈喽我热烈的" if request.path.include? '/test/'
+				p response
+			end
+
+			get "http://127.0.0.1:8787/"
+			puts "[CLIENT] [1st] received from server:"
+			p @response.body
+			p @response.header.to_hash
+
+			get "http://127.0.0.1:8787/test/b/"
+			puts "[CLIENT] [2nd] received from server:"
+			p @response.body
+			p @response.header.to_hash
+
+			server.stop
+			#HttpServer.stop(8787)	
+		end
+		def test_httpserver_post
+			server=HttpServer.new(8787)
+			server.start do |request, response|
+				puts "[SERVER][post] request from client:"
+				p request.header
+				p request.content
+
+				puts "[SERVER][post] response to client:"
+				response.header["Content-Type"]= "application/xhtml+xml;charset=utf-8"
+				response.body="hello world!<-------path:/-------->哈喽我热烈的" if request.path=='/'
+				p response
+			end
+
+			`echo "this is a file" >/tmp/test`
+			post "http://127.0.0.1:8787/", {}, {}, {"testfile"=>"/tmp/test"}
+			puts "[CLIENT][post] received from server:"
+			p @response.body
+			p @response.header.to_hash
+
+			server.stop
+		end
+	end	
+end
+
+