woolen_common 0.0.1

data/lib/woolen_common/pcap/readme.md

@@ -0,0 +1,72 @@
+PCAP parser
+=========
+
+## 使用方法
+
+### 解析报文
+
+
+
+    ether = Mu::Pcap::Ethernet.from_bytes pkt_str
+    
+    puts ether.payload
+    
+  即: 一个报文( 必须是纯字符串 ), 被递归解析, 每个 `payload`  是它上一层的协议类( 比如 `Ethernet`, `IPv4`, `UDP` ), 下面是一些常用的方法:
+  
+* Ethernet
+
+    * `from_bytes(str)`
+    
+        解析报文, 并返回特定的类(公共)
+    
+    * `to_bytes`
+      
+        重新生成报文, 会重新计算checksum(公共)
+    
+    * `payload`
+    
+        负荷, 通俗叫报文内容, 如果还有被支持的上层协议, 则返回相对应的类. 则已经没有, 则返回真正的负荷.(公共)
+       
+    * `src(=)`, `dst(=)`, `type(=)`
+    
+        源物理地址, 目的物理地址, 以及上层负载类型( IP, IP6, ARP, PPPOE, 802_1Q )
+        
+
+* IPv4
+
+    * `:ip_id`, `:offset`, `:ttl`, `:proto`, `:src`, `:dst`, `:dscp`
+    
+        标志, 段偏移, 生存期, 上层协议(TCP,UDP, SCTP), 源IP, 目的IP, TOS标记
+
+    * v4?
+        
+        返回 true
+    
+    * fragment?
+    
+        检查是否分片
+
+* IPv6
+
+    * hop_limit
+    
+    * next_header
+    
+* TCP
+
+    * `src_port`, `dst_port`, `seq`, `ack`, `flags`, `window`, `urgent`, `mss`, `proto_family`
+    
+        不一一说明, `flags` 可以直接与 ( `TH_FIN`, `TH_SYN`, `TH_RST`, `TH_PUSH`, `TH_ACK`, `TH_URG`, `TH_ECE`, `TH_CWR`) 相与(&), 以判断标识.
+    
+* UDP
+   
+   * `dst_port`, `src_port`
+
+更详细的指导, 请查看 `rdoc`:
+
+在命令行输入 `gem server`, 打开浏览器, 输入 `http://localhost:8808`.
+    
+## Thanks to:
+Fork from : <https://github.com/mudynamics/pcapr-local/tree/master/lib/mu>
+
+Thanks to  mudynamics, github is <https://github.com/mudynamics>

data/lib/woolen_common/ruby_ext/blank.rb

@@ -0,0 +1,126 @@
+# -*- encoding : utf-8 -*-
+
+class Object
+    # An object is blank if it's false, empty, or a whitespace string.
+    # For example, "", "   ", +nil+, [], and {} are all blank.
+    #
+    # This simplifies:
+    #
+    #   if address.nil? || address.empty?
+    #
+    # ...to:
+    #
+    #   if address.blank?
+    def blank?
+        respond_to?(:empty?) ? empty? : !self
+    end
+
+    # An object is present if it's not <tt>blank?</tt>.
+    def present?
+        !blank?
+    end
+
+    # Returns object if it's <tt>present?</tt> otherwise returns +nil+.
+    # <tt>object.presence</tt> is equivalent to <tt>object.present? ? object : nil</tt>.
+    #
+    # This is handy for any representation of objects where blank is the same
+    # as not present at all. For example, this simplifies a common check for
+    # HTTP POST/query parameters:
+    #
+    #   state   = params[:state]   if params[:state].present?
+    #   country = params[:country] if params[:country].present?
+    #   region  = state || country || 'US'
+    #
+    # ...becomes:
+    #
+    #   region = params[:state].presence || params[:country].presence || 'US'
+    def presence
+        self if present?
+    end
+end
+
+class NilClass
+    # +nil+ is blank:
+    #
+    #   nil.blank? # => true
+    #
+    def blank?
+        true
+    end
+end
+
+class FalseClass
+    # +false+ is blank:
+    #
+    #   false.blank? # => true
+    #
+    def blank?
+        true
+    end
+end
+
+class TrueClass
+    # +true+ is not blank:
+    #
+    #   true.blank? # => false
+    #
+    def blank?
+        false
+    end
+end
+
+class Array
+    # An array is blank if it's empty:
+    #
+    #   [].blank?      # => true
+    #   [1,2,3].blank? # => false
+    #
+    alias_method :blank?, :empty?
+end
+
+class Hash
+    # A hash is blank if it's empty:
+    #
+    #   {}.blank?                # => true
+    #   {:key => 'value'}.blank? # => false
+    #
+    alias_method :blank?, :empty?
+end
+
+class String
+    # 0x3000: fullwidth whitespace
+    NON_WHITESPACE_REGEXP = %r![^\s#{[0x3000].pack("U")}]! unless defined? NON_WHITESPACE_REGEXP
+
+    # A string is blank if it's empty or contains whitespaces only:
+    #
+    #   "".blank?                 # => true
+    #   "   ".blank?              # => true
+    #   "　".blank?               # => true
+    #   " something here ".blank? # => false
+    #
+    def blank?
+        if self == '[BLANK]'
+            return true
+        end
+        # 1.8 does not takes [:space:] properly
+        if encoding_aware?
+            self !~ /[^[:space:]]/
+        else
+            self !~ NON_WHITESPACE_REGEXP
+        end
+    end
+    def is_na?
+        self.strip.upcase.include? 'NA'
+    end
+end
+
+class Numeric #:nodoc:
+    # No number is blank:
+    #
+    #   1.blank? # => false
+    #   0.blank? # => false
+    #
+    def blank?
+        false
+    end
+end

data/lib/woolen_common/ruby_ext/drb_ext.rb

@@ -0,0 +1,7 @@
+# -*- encoding : utf-8 -*-
+require 'drb'
+module DRb
+  class DRbObject
+    undef :type rescue nil
+  end
+end

data/lib/woolen_common/ruby_ext/string.rb

@@ -0,0 +1,116 @@
+# -*- encoding : utf-8 -*-
+require 'iconv' if RUBY_VERSION.to_f < 1.9
+class String # :nodoc: all
+
+    if defined?(Encoding) && ''.respond_to?(:encode)
+        def encoding_aware?
+            true
+        end
+    else
+        def encoding_aware?
+            false
+        end
+    end
+
+    #判断是否为utf8
+    def utf8?
+        if String.method_defined?(:encode)
+            return true if self.force_encoding("UTF-8").valid_encoding?
+            return false
+        else
+            unpack('U*') rescue return false
+            return true
+        end
+    end
+
+    #TODO：参数功能目前没有用
+    def to_utf8(enc='GBK')
+        if self.respond_to?(:encode)
+            return self if utf8?
+            self.encode('UTF-8', enc)
+        else
+            require 'iconv' if RUBY_VERSION.to_f < 1.9
+            return self if utf8?
+            begin
+                Iconv.iconv('UTF-8', enc, self).at(0).to_s
+            rescue
+                self
+            end
+        end
+    end
+
+    #TODO：参数功能目前没有用
+    def to_gbk(enc='UTF-8')
+        if self.respond_to?(:encode)
+            return self unless utf8?
+            self.encode('GBK', enc)
+        else
+            return self unless utf8?
+            require 'iconv' if RUBY_VERSION.to_f < 1.9
+            begin
+                Iconv.iconv('GBK', enc, self).at(0).to_s
+            rescue
+                self
+            end
+        end
+    end
+
+    def to_gb2312(enc = 'UTF-8')
+        # require 'iconv'
+        # Iconv.iconv('GB2312','UTF-8',self).at(0).to_s
+        if self.respond_to?(:encode)
+            self.encode('GB2312', enc)
+        else
+            begin
+                self.unpack("U*")
+                require 'iconv' if RUBY_VERSION.to_f < 1.9
+                Iconv.iconv('GB2312', enc, self).at(0).to_s
+            rescue ::ArgumentError
+                self
+            end
+        end
+    end
+
+    def to_arr()
+        self.split('&') #暂时未考虑&在\之后的问题,fix this bug
+    end
+
+    def __camelize(first_letter_in_uppercase=true)
+        if first_letter_in_uppercase
+            self.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+        else
+            self.to_s[0].chr.downcase + camelize(self)[1..-1]
+        end
+    end
+
+    alias camelize __camelize
+
+    def __underscore
+        word = self.to_s.dup
+        word.gsub!(/::/, '/')
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+    end
+
+    alias underscore __underscore
+
+end
+
+class << nil
+    def to_utf8
+        ''
+    end
+end
+
+
+if $0 == __FILE__
+    #  require 'string'
+    puts "中文123中文".to_gbk.dump
+    puts "中文123中文".to_gb2312.dump
+    puts File.join("中文abc/abc", "中文").to_gbk.dump
+    puts File.join("中文abc/abc", "中文").to_gb2312.dump
+    puts 'ab_c'.camelize
+end

data/lib/woolen_common/ruby_ext/win32_ole.rb

@@ -0,0 +1,4 @@
+require 'drb'
+class WIN32OLE
+    include DRb::DRbUndumped
+end

data/lib/woolen_common/ruby_proxy.rb

@@ -0,0 +1,5 @@
+# -*- encoding : utf-8 -*-
+require "#{File.join(File.dirname(__FILE__), 'ruby_proxy/exceptions')}"
+require "#{File.join(File.dirname(__FILE__), 'ruby_proxy/config')}"
+require "#{File.join(File.dirname(__FILE__), 'ruby_proxy/client')}"
+require "#{File.join(File.dirname(__FILE__), 'ruby_proxy/server')}"

data/lib/woolen_common/ruby_proxy/client.rb

@@ -0,0 +1,305 @@
+# -*- encoding : utf-8 -*-
+require 'drb'
+require "#{File.join(File.dirname(__FILE__), '..', 'ruby_ext/drb_ext')}"
+require "#{File.join(File.dirname(__FILE__), 'exceptions')}"
+require 'timeout'
+require 'socket'
+
+module ATU
+    class ATUConfig
+        class << self
+            attr_accessor :timeout
+        end
+    end
+    ATUConfig.timeout = 900
+    class ClientRet
+        include WoolenCommon::ToolLogger
+        class << self
+            attr_accessor :job_id
+            def check_job_done
+                # 60 * 10 / 0.5  10分钟内跑不完认为任务结束
+                start_time = Time.now.to_i
+                cnt = 0
+                loop do
+                    if RubyProxy::DRbClient.client.is_job_done?(self.job_id)
+                        debug "job[#{job_id}] done"
+                        return true
+                    else
+                        cnt += 1
+                        if cnt % 20 == 1
+                            debug "job[#{job_id}] is still running"
+                        end
+                        sleep 0.5
+                        if Time.now.to_i - start_time > ATUConfig.timeout
+                            warn "the time to check job done is over #{ATUConfig.timeout} sec"
+                            return false
+                        end
+                    end
+                end
+            end
+
+            def get_job_ret
+                if check_job_done
+                    return RubyProxy::DRbClient.client.get_the_job_ret(self.job_id)
+                end
+                nil
+            end
+        end
+    end
+
+    class << self
+        alias require_old require
+
+        def require(arg)
+            #TODO: path maybe confict
+            #~ path= File.expand_path File.join(Dir.pwd,arg)
+            #~ path += '.rb'
+            RubyProxy::DRbClient.proxy_load(arg)
+        end
+
+        def [](arg)
+            RubyProxy::DRbClient.proxy_global_get(arg)
+        end
+
+        def []=(arg, var)
+            RubyProxy::DRbClient.proxy_global_set(arg, var)
+        end
+
+        #load path
+        def <<(path)
+            RubyProxy::DRbClient.add_load_path(path)
+        end
+    end
+
+    #entry
+    def self.const_missing(name)
+        name = self.name.to_s + '::' + name.to_s
+        type = RubyProxy::DRbClient.client.proxy_type(name)
+        make_kclass(name, type)
+    end
+
+    def self.make_kclass(name, type)
+        #puts "make_kclass: #{name}, #{type}"
+        case type
+            when 'Class'
+                RubyProxy::KlassFactory.make_class(name) do |klass|
+                    klass.class_eval do
+                        def initialize(*arg)
+                            @proxy = RubyProxy::DRbClient.client.proxy(self.class.to_s, "new", *arg)
+                        end
+
+                        # I think all methods should be proxyed by remote
+                        undef :type rescue nil
+                        undef :to_s
+                        undef :to_a if respond_to?(:to_a)
+                        undef :methods
+
+                        def __proxy
+                            @proxy
+                        end
+
+                        def method_missing(name, *arg, &block)
+                            #return if @proxy.nil?
+                            #puts "#{@proxy.methods(false)}"
+                            #puts "proxy = #{@proxy} method=#{name} arg=#{arg.join(',')}"
+                            @proxy.__send__(name, *arg, &block)
+                        end
+
+                        def self.const_missing(name)
+                            name = self.name.to_s + "::" + name.to_s
+                            type = RubyProxy::DRbClient.client.proxy_type(name.to_s)
+                            ret = ATU::make_kclass(name, type)
+                            case type
+                                when 'Module', 'Class'
+                                    return ret
+                            end
+                            RubyProxy::DRbClient.client.proxy(name.to_s)
+                        end
+
+                        # TODO: block not support now
+                        def self.method_missing(name, *arg, &block)
+                            # puts "need to do method_missing :#{name}"
+                            RubyProxy::DRbClient.client.copy_env(ENV.to_hash)
+                            ClientRet.job_id = RubyProxy::DRbClient.client.proxy(self.name.to_s, name.to_s, *arg, &block)
+                            ClientRet.get_job_ret
+                        end
+
+                    end
+                end
+            when 'Module'
+                RubyProxy::KlassFactory.make_module(name) do |mod|
+                    mod.class_eval do
+                        def self.method_missing(name, *arg)
+                            RubyProxy::DRbClient.client.proxy(self.name.to_s, name.to_s, *arg)
+                        end
+
+                        def self.const_missing(name)
+                            name = self.name.to_s + "::" + name.to_s
+                            #puts "in module const_missing : #{name}"
+                            type = RubyProxy::DRbClient.client.proxy_type(name.to_s)
+                            ret = ATU::make_kclass(name, type)
+                            case type
+                                when 'Module', 'Class'
+                                    return ret
+                            end
+                            RubyProxy::DRbClient.client.proxy(name.to_s)
+                        end
+                    end
+                end
+            else
+
+        end
+
+    end
+
+end
+
+
+module RubyProxy
+
+    class KlassFactory
+        def self.make_klass(klass_name, type)
+            case type
+                when 'Class'
+                    make_class(klass_name)
+                when 'Module'
+                    make_module(klass_name)
+                else
+                    raise TypeError, "wrong make_klass type: #{type}"
+            end
+        end
+
+        # generate proxy class
+        def self.make_class(klass_name)
+            klass_name = klass_name.to_s
+            name_ok?(klass_name)
+            eval <<-EOF
+                class #{klass_name}
+                end
+            EOF
+            klass = eval(klass_name)
+            yield klass
+            klass
+        end
+
+        def self.make_module(klass_name)
+            klass_name = klass_name.to_s
+            name_ok?(klass_name)
+            eval <<-EOF
+                module #{klass_name}
+                end
+            EOF
+            klass = eval(klass_name)
+            yield klass
+            klass
+        end
+
+        def self.name_ok?(name)
+            raise TypeError, " name #{name} can't be class or module name." unless name =~ /^[A-Z][a-zA-Z_0-9]*/
+        end
+    end
+
+    # Get DRbClient
+    class DRbClient
+        @client = nil
+        include WoolenCommon::ToolLogger
+        class <<self
+            def client
+                begin
+                    stop_service if @client.nil? and Config.autostart
+                    start_service if @client.nil? and Config.autostart
+                    connect_addr = "druby://#{Config.ip}:#{Config.port}"
+                    @client ||= DRbObject.new(nil, connect_addr)
+                rescue DRb::DRbConnError
+                    raise RubyProxy::NotConnError, "can connect to druby server: #{connect_addr}"
+                end
+            end
+
+            def alive?
+                @client.respond_to?("any_thing")
+                true
+            rescue DRb::DRbConnError
+                false
+            end
+
+            attr_accessor :ip, :port
+
+            def proxy_load(file)
+                client.proxy_load(file)
+            end
+
+            def proxy_global_get(arg)
+                client.proxy_global_get(arg)
+            end
+
+            def proxy_global_set(arg, var)
+                client.proxy_global_set(arg, var)
+            end
+
+            def add_load_path(path)
+                #path = File.expand_path(path)
+                client.add_load_path(path)
+            end
+
+            # not use it later
+            def start_service(t=10)
+                message = nil
+                @service_log = nil
+                info 'start ruby proxy server...'
+                info start_command
+                #~ @server_thread =  Thread.new do |t|
+                #~ t.abort_on_exception = true
+                @service_log = IO.popen(start_command)
+                #~ end
+                #~ @server_thread.abort_on_exception = true
+                wait_until_server_start_time(t)
+                do_at_exit if Config.autostart
+            end
+
+            def start_command
+                #raise RubyProxy::CommandNotFoundError, "ruby command can not be found: #{Config.command}" unless File.file?(Config.command)
+                server_file = File.expand_path File.join(File.dirname(__FILE__), 'server.rb')
+                Config.command + " " + server_file
+            end
+
+            def stop_service(t=5)
+                #TCPSocket.new(Config.ip,Config.port)
+                @client ||= DRbObject.new(nil, "druby://#{Config.ip}:#{Config.port}")
+                @client.stop_proxy
+                sleep 1
+            rescue
+                debug "service not start,stop fail!"
+                debug "#{$!}"
+            ensure
+                @client = nil
+            end
+
+            def wait_until_server_start_time(t)
+                t.times do |tt|
+                    begin
+                        #~ raise CannotStartServer, "" unless @server_thread.alive?
+                        TCPSocket.new(Config.ip, Config.port)
+                        info 'server is starting'
+                        return true
+                    rescue Exception
+                        sleep 1
+                    end
+                end
+                raise RuntimeError, 'start drbserver fail'
+            end
+
+            def do_at_exit
+                at_exit do
+                    info 'try to stop service'
+                    stop_service
+                end
+            end
+
+        end
+    end
+end
+
+if $0 == __FILE__
+    a = ATU::Hello.new
+    puts a.return_1
+end