woolen_common 0.0.1

data/lib/woolen_common/splib/PriorityQueue.rb

@@ -0,0 +1,110 @@
+Splib.load :Monitor
+
+module Splib
+    # Exception raised when queue is empty
+    class EmptyQueue < RuntimeError
+    end
+    # This class provides some simple logic for item output. It is
+    # basically a priority based queue with some round robin thrown
+    # in to keep things interesting. This queue provides an easy way
+    # for many threads to populate it without drowning out each other.
+    # NOTE: Design help from the great Ryan "pizza_" Flynn
+    class PriorityQueue
+
+        # args:: config arguments
+        #   :raise_on_empty
+        # whocares:: lambda{|target| true||false}
+        # Create a priority queue
+        def initialize(*args, &whocares)
+            @raise = args.include?(:raise_on_empty)
+            @whocares = whocares
+            @target_queues = {}
+            @queues = {:PRIORITY => [], :NEW => [], :NORMAL => [], :WHOCARES => []}
+            @lock = Splib::Monitor.new
+        end
+        
+        # target:: target queue
+        # item:: item to queue
+        # This prioritizes output to help reduce lag when lots of output
+        # is being sent to another target. This will automatically decide
+        # how to queue the item based on the target
+        def prioritized_queue(target, item)
+            raise NameError.new('The target :internal_prio is a restricted target') if target == :internal_prio
+            @lock.synchronize do
+                @target_queues[target] = [] unless @target_queues[target]
+                if(@whocares && @whocares.call(target))
+                    @target_queues[target] << item
+                    add_queue(:WHOCARES, @target_queues[target])
+                else
+                    @target_queues[target] << item
+                    if(@target_queues[target].size < 2)
+                        add_queue(:NEW, @target_queues[target])
+                    else
+                        add_queue(:NORMAL, @target_queues[target])
+                    end
+                end
+                @lock.signal
+            end
+            item
+        end
+        
+        # item:: item to queue
+        # This will add item to the PRIORITY queue which gets
+        # sent before all other items.
+        def direct_queue(message)
+            @lock.synchronize do
+                @target_queues[:internal_prio] = [] unless @target_queues[:internal_prio]
+                @target_queues[:internal_prio] << message
+                add_queue(:PRIORITY, @target_queues[:internal_prio])
+                @lock.signal
+            end
+            message
+        end
+
+        # raise_e:: raise an exception on empty
+        # Returns the next message to send. This method decides what
+        # message to send based on the priority of the message. It
+        # will throw an Exceptions::EmptyQueue when there are no messages
+        # left.
+        def pop
+            m = nil
+            @lock.synchronize do
+                [:PRIORITY, :NEW, :NORMAL, :WHOCARES].each do |k|
+                    unless(@queues[k].empty?)
+                        q = @queues[k].shift
+                        unless(q.empty?)
+                            m = q.shift
+                            add_queue(k, q) unless(q.empty?)
+                            break
+                        end
+                    end
+                end
+            end
+            unless(m)
+                if(@raise)
+                    raise EmptyQueue.new('Queue is currently empty')
+                else
+                    @lock.wait_while{ empty? }
+                    m = pop
+                end
+            end
+            m
+        end
+
+        # Returns true if queue is empty
+        def empty?
+            @lock.synchronize{@target_queues.values.find{|n|!n.empty?}.nil?}
+        end
+
+        alias :push :prioritized_queue
+        alias :<< :direct_queue
+
+        private
+        
+        def add_queue(name, queue)
+            unless(@queues[name].include?(queue))
+                @queues[name] << queue
+            end
+        end
+    end
+end

data/lib/woolen_common/splib/Sleep.rb

@@ -0,0 +1,10 @@
+module Splib
+class << self
+    # secs:: Number of seconds to sleep (Use float to provide better actual sleep time)
+    def sleep(secs=nil)
+        start = Time.now.to_f
+        secs.nil? ? Kernel.sleep : Kernel.sleep(secs)
+        Time.now.to_f - start
+    end
+end
+end

data/lib/woolen_common/splib/UrlShorteners.rb

@@ -0,0 +1,48 @@
+require 'net/http'
+
+module Splib
+    # url:: URL to shorten
+    # Gets a tinyurl for given URL
+    def self.tiny_url(url)
+        connection = Net::HTTP.new('tinyurl.com', 80)
+        resp, data = connection.get("/api-create.php?url=#{url}")
+        if(resp.code !~ /^200$/)
+            raise "Failed to make the URL small."
+        end
+        return data.strip
+    end
+    # url:: URL to shorten
+    # Gets a tr.im for given URL
+    def self.trim_url(url)
+        connection = Net::HTTP.new('api.tr.im', 80)
+        resp, data = connection.get("/v1/trim_simple?url=#{url}")
+        if(resp.code !~ /^200$/)
+            raise "Failed to make the URL small."
+        end
+        return data.strip
+    end
+    # url:: URL to shorten
+    # Gets a is.gd for given URL
+    def self.isgd_url(url)
+        connection = Net::HTTP.new('is.gd', 80)
+        resp, data = connection.get("/api.php?longurl=#{url}")
+        if(resp.code !~ /^200$/)
+            raise "Failed to make the URL small."
+        end
+        return data.strip
+    end
+    # url:: URL to shorten
+    # Get shortest for given url
+    def self.shortest_url(url)
+        results = []
+        [:tiny_url, :isgd_url, :trim_url].each do |service|
+            begin
+                results << self.send(service, url)
+            rescue
+                #ignore#
+            end
+        end
+        raise 'Failed to make URL small' if results.empty?
+        results.sort{|a,b| a.length <=> b.length}[0]
+    end
+end

data/lib/woolen_common/ssh_proxy.rb

@@ -0,0 +1,146 @@
+# -*- encoding : utf-8 -*-
+require 'net/ssh'
+require "#{File.join(File.dirname(__FILE__), 'logger')}"
+module WoolenCommon
+    class SshProxy
+        include ToolLogger
+        class << self
+            attr_accessor :the_ssh_instances
+            def get_ssh_proxy(ip,port,user,passwd)
+                options = {:port => port,:password => passwd}
+                @the_ssh_instances ||= {}
+                @the_ssh_instances[ip] ||= {}
+                @the_ssh_instances[ip][port] ||= {}
+                @the_ssh_instances[ip][port][user] ||= {}
+                @the_ssh_instances[ip][port][user][passwd] ||= SshProxy.new(ip, user, options)
+                @the_ssh_instances[ip][port][user][passwd]
+            end
+        end
+
+        def initialize(host, user, options={})
+            @host = host
+            @user = user
+            @options = options
+            @conn_retry = options[:proxy_conn_retry] || 5
+            options.delete :proxy_conn_retry if options[:proxy_conn_retry]
+            # 超时时间设置30秒太长了，不是很合理，实际上5秒没有回复，那就是出问题了
+            @conn_timeout = options[:proxy_conn_timeout] || 5
+            options.delete :proxy_conn_timeout if options[:proxy_conn_timeout]
+            proxy_reset_conn
+        end
+
+        def proxy_reset_conn
+            @conn_retry.times do
+                begin
+                    Timeout.timeout(@conn_timeout) do
+                        @ssh_conn = Net::SSH.start(@host, @user, @options)
+                        if check_connector_close
+                            debug 'reconnect ssh ok'
+                            return
+                        end
+                    end
+                rescue Exception => e
+                    error "连接ssh服务器出错~!信息是:#{e.message},用户信息:@host:#{@host},@user:#{@user},@options:#{@options}"
+                end
+            end
+        end
+
+        def method_missing(name, *args, &block)
+            if check_connector_close
+                @ssh_conn.close rescue nil
+                proxy_reset_conn
+            end
+            #debug "SshProxy need to invoke methdo ::#{name} "
+            #debug "params::#{args}"
+            Timeout.timeout(@conn_timeout) do
+                return_result = ''
+                if @ssh_conn
+                    return_result = @ssh_conn.send(name, *args, &block)
+                    #debug "SshProxy invoke result ::#{return_result}"
+                else
+                    error 'ssh链接建立不起来！'
+                end
+                return return_result
+            end
+        end
+
+        def exec!(command, &block)
+            if check_connector_close
+                @ssh_conn.close rescue nil
+                proxy_reset_conn
+            end
+            Timeout.timeout(@conn_timeout) do
+                return @ssh_conn.exec!(command.unpack('C*').pack('C*'), &block)
+            end
+        end
+
+        def exec(command, &block)
+            if check_connector_close
+                @ssh_conn.close rescue nil
+                proxy_reset_conn
+            end
+            Timeout.timeout(@conn_timeout) do
+                return @ssh_conn.exec(command.unpack('C*').pack('C*'), &block)
+            end
+        end
+
+        def check_connector_close
+            begin
+                if @ssh_conn.nil? or @ssh_conn.closed?
+                    return true
+                end
+                Timeout.timeout(@conn_timeout) do
+                    if @ssh_conn.exec!('echo hello').include? 'hello'
+                        return false
+                    end
+                end
+            rescue Exception => e
+                error "检查连接出错，错误信息是：：#{e.message}"
+                return true
+            end
+            true
+        end
+
+        # 阻塞性下载
+        def sftp_download!(remote_path, local_path)
+            if check_connector_close
+                @ssh_conn.close rescue nil
+                proxy_reset_conn
+            end
+            @ssh_conn.sftp.connect! do |sftp_session|
+                return sftp_session.download!(remote_path, local_path)
+            end
+        end
+
+        # 非塞性下载
+        def sftp_download(remote_path, local_path)
+            if check_connector_close
+                @ssh_conn.close rescue nil
+                proxy_reset_conn
+            end
+            @ssh_conn.sftp.connect do |sftp_session|
+                return sftp_session.download!(remote_path, local_path)
+            end
+        end
+
+        def sftp_upload!(remote_path, local_path)
+            if check_connector_close
+                @ssh_conn.close rescue nil
+                proxy_reset_conn
+            end
+            @ssh_conn.sftp.connect! do |sftp_session|
+                return sftp_session.upload!(local_path,remote_path)
+            end
+        end
+
+        def sftp_upload(remote_path, local_path)
+            if check_connector_close
+                @ssh_conn.close rescue nil
+                proxy_reset_conn
+            end
+            @ssh_conn.sftp.connect do |sftp_session|
+                return sftp_session.upload(local_path,remote_path)
+            end
+        end
+    end
+end

data/lib/woolen_common/system_helper.rb

@@ -0,0 +1,123 @@
+# -*- encoding : utf-8 -*-
+module WoolenCommon
+    module SystemHelper
+        IPV4_REGEX = /^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$/
+
+        def ruby18?
+            RUBY_VERSION =~ /^1.8/ ? true : false
+        end
+
+        module_function :ruby18?
+
+        def ruby19?
+            RUBY_VERSION =~ /^1.9/ ? true : false
+        end
+
+        module_function :ruby19?
+
+        def platform
+            case RUBY_PLATFORM
+                when /w32/, /mswin32/
+                    "windows"
+                when /linux/
+                    "linux"
+                else
+                    "mac"
+            end
+        end
+
+        module_function :platform
+
+        def windows?
+            case RUBY_PLATFORM
+                when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+                    return true
+                when /java/
+                    begin
+                      require 'Win32API'
+                      return true
+                    rescue Exception
+                      return false
+                    end
+                else
+                    return false
+            end
+        end
+
+        module_function :windows?
+
+        def is_x64?
+            case RUBY_PLATFORM
+                when /x86_64/
+                    return true
+                else
+                    return false
+            end
+        end
+
+        module_function :is_x64?
+
+
+        def get_local_ip_addrs
+            result_array = []
+            if windows?
+                ip_addr_arrays = TCPSocket.gethostbyname(Socket.gethostname)
+                ip_addr_arrays.each do |one_addr|
+                    if one_addr.is_a? String
+                        if one_addr =~ IPV4_REGEX
+                            result_array << one_addr
+                        end
+                    end
+                end
+            else
+                output = %x{ip addr list}
+                output.split(/\n/).each { |str|
+                    if str =~ /inet ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/
+                        tmp = $1
+                        unless tmp =~ /127\./
+                            result_array << tmp
+                        end
+                    end
+                }
+            end
+            result_array
+        end
+
+        module_function :get_local_ip_addrs
+
+
+        def get_same_subnet_ip(check_ip)
+            same_count = 0
+            ip_size = 32
+            ctrl_ip_num = IPAddr.new(check_ip).to_i
+            result_ip = ''
+            get_local_ip_addrs.each do |one_ip|
+                cnt = 0
+                one_ip_num = IPAddr.new(one_ip).to_i
+                ip_size.times do |count|
+                    mask = 1 << (ip_size - count)
+                    if ctrl_ip_num & mask == one_ip_num & mask
+                        cnt += 1
+                        next if cnt < ip_size
+                    end
+                    if cnt > same_count
+                        result_ip = one_ip
+                        same_count = cnt
+                    end
+                    break
+                end
+            end
+            result_ip
+        end
+        module_function :get_same_subnet_ip
+
+        def get_platform_path(*args, &block)
+            real_path = CommonHelper.get_real_path(*args, &block)
+            if windows?
+                real_path.gsub!('/','\\')
+            end
+            real_path
+        end
+        module_function :get_platform_path
+    end
+end

data/lib/woolen_common/system_monitor.rb

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+require "#{File.join(File.dirname(__FILE__), 'logger')}"
+require "#{File.join(File.dirname(__FILE__), 'system_helper')}"
+module WoolenCommon
+    MONITOR_DEFAULT_CFG={
+        'net_if_ids' => [0]
+    }
+    class SystemMonitor
+        if SystemHelper.windows?
+            require "#{File.join(File.dirname(__FILE__), 'system_monitor', 'windows_monitor')}"
+            include WindowsMonitor
+        else
+            require "#{File.join(File.dirname(__FILE__), 'system_monitor', 'linux_monitor')}"
+            include LinuxMonitor
+        end
+
+        class << self
+            def run_monitor(monitor_cfg=MONITOR_DEFAULT_CFG)
+                get_common_performance monitor_cfg
+            end
+        end
+    end
+end