woolen_common 0.0.1

data/lib/woolen_common/ruby_proxy/config.rb

@@ -0,0 +1,44 @@
+# -*- encoding : utf-8 -*-
+module RubyProxy
+    class Config
+        @config = {
+            :ip => '127.0.0.1',
+            :port => 28889,
+            :command => 'ruby',
+            :autostart => false,
+        }
+        class <<self
+            def ip
+                @config[:ip]
+            end
+
+            def ip=(ip)
+                @config[:ip] = ip
+            end
+
+            def port=(port)
+                @config[:port] = port
+            end
+
+            def port
+                @config[:port]
+            end
+
+            def command
+                @config[:command]
+            end
+
+            def command=(command)
+                @config[:command] = command
+            end
+
+            def autostart
+                @config[:autostart]
+            end
+
+            def autostart=(bool)
+                @config[:autostart] = bool
+            end
+        end
+    end
+end

data/lib/woolen_common/ruby_proxy/exceptions.rb

@@ -0,0 +1,17 @@
+# -*- encoding : utf-8 -*-
+module RubyProxy
+    class Error < RuntimeError;
+    end
+    # can not connect to proxy server
+    class NotConError < Error;
+    end
+    #config command config error
+    class CommandNotFoundError < Error;
+    end
+    # start server fail error
+    class CannotStartServer < Error;
+    end
+    # format wrong with global variable
+    class GlobalVarFormatError < Error;
+    end
+end

data/lib/woolen_common/ruby_proxy/proxy.rb

@@ -0,0 +1,157 @@
+# -*- encoding : utf-8 -*-
+require 'drb'
+require "#{File.join(File.dirname(__FILE__), 'proxy_load')}"
+require "#{File.join(File.dirname(__FILE__), 'proxy_global_set')}"
+
+module RubyProxy
+    class Proxy
+        include WoolenCommon::ToolLogger
+        JOBS_QUEUE = Queue.new
+        JOBS_FINISH_ARRAY = []
+        JOBS_RETURN_ARRAY = []
+        MAX_HANDLE_THREAD = 1
+        $__proxy_job_id ||= 0
+        class << self
+            attr_accessor :worker_flag
+        end
+
+        def self.proxy(klass_name, method=nil, *arg)
+            job = {}
+            job[:klass_name] = Marshal.load(Marshal.dump(klass_name))
+            job[:method] = Marshal.load(Marshal.dump(method))
+            job[:arg] = Marshal.load(Marshal.dump(arg))
+            job[:id] = $__proxy_job_id + 1
+            $__proxy_job_id += 1
+            JOBS_QUEUE.push job
+            job[:id]
+        end
+
+        def self.set_work_flag(flag)
+            info "setting set_work_flag #{flag}"
+            self.worker_flag = flag
+        end
+
+        def self.worker_start
+            self.worker_flag = true
+            MAX_HANDLE_THREAD.times do |cnt|
+                debug "starting worker :#{cnt}"
+                Thread.new do
+                    loop do
+                        the_job = nil
+                        begin
+                            if self.worker_flag
+                                the_job = JOBS_QUEUE.pop
+                                if the_job
+                                    handle_job the_job
+                                end
+                            else
+                                sleep 0.5
+                            end
+                        rescue Exception => e
+                            error "handle job error :#{e}", e
+                        end
+                    end
+                end
+            end
+        end
+
+        def self.handle_job(job)
+            debug "doing job :#{job}"
+            klass_name = job[:klass_name]
+            method = job[:method]
+            arg = job[:arg]
+            begin
+                if method.nil?
+                    ret = proxy_module(klass_name)
+                else
+                    ret = proxy_module(klass_name).send(method, *arg)
+                end
+                debug "finish proxy action:#{method}"
+                JOBS_RETURN_ARRAY[job[:id]] = ret
+                    # return ret
+            rescue Exception => e
+                error "proxy invoke error:#{e.message}", e
+            ensure
+                JOBS_FINISH_ARRAY[job[:id]] = true
+            end
+        end
+
+        def self.is_job_done?(job_id)
+            if JOBS_FINISH_ARRAY[job_id]
+                true
+            else
+                false
+            end
+        end
+
+        def self.get_the_job_ret(job_id)
+            the_ret = JOBS_RETURN_ARRAY[job_id]
+            JOBS_RETURN_ARRAY[job_id] = nil
+            the_ret
+        end
+
+        def self.copy_env(env_hash)
+            env_hash.each do |key,value|
+                if key.blank? || value.blank?
+                    info 'try to copy empty_env'
+                    next
+                end
+                ENV["#{key}"] = "#{value}"
+            end
+            nil
+        end
+
+        def self.proxy_load(file_or_gem)
+            ProxyLoad.load_file(file_or_gem)
+        end
+
+        def self.proxy_global_set(arg, var)
+            ProxyGlobalSet.set(arg, var)
+        end
+
+        def self.proxy_global_get(arg)
+            ProxyGlobalSet.get(arg)
+        end
+
+        def self.add_load_path(path)
+            ProxyGlobalSet.add("$LOAD_PATH", path)
+        end
+
+        def self.proxy_type(klass_name)
+            return proxy_const_get(klass_name).class.to_s
+        end
+
+        def self.proxy_module(klass_name)
+            trace "need to proxy module: [#{klass_name}]"
+            m = proxy_const_get(klass_name)
+            trace "finish get const class:#{m}"
+            m.class_eval {
+                include DRb::DRbUndumped
+                extend DRb::DRbUndumped
+            } if (m.class.to_s == 'Class' or m.class.to_s == 'Module') and !m.include?(DRb::DRbUndumped)
+            return m
+        end
+
+        def self.proxy_const_get(klass_name)
+            atu = nil
+            klass_name_array = klass_name.split('::')
+            klass_name_array.shift if klass_name_array[0] == 'ATU'
+            trace "try to get class :#{klass_name},the class name array:#{klass_name_array}"
+            klass_name_array.each do |m|
+                if atu.nil?
+                    atu = Kernel.const_get(m)
+                    trace "get atu: [#{atu}]"
+                else
+                    trace "get const [#{m}] in atu: [#{atu}]"
+                    atu = atu.const_get(m)
+                end
+            end
+            atu
+        end
+
+        def self.stop_proxy
+            DRb.stop_service
+        end
+
+    end
+end

data/lib/woolen_common/ruby_proxy/proxy_global_set.rb

@@ -0,0 +1,44 @@
+# -*- encoding : utf-8 -*-
+require "#{File.join(File.dirname(__FILE__), 'exceptions')}"
+module RubyProxy
+    class ProxyGlobalSet
+        MAGIC_GLOBAL = ["$:", "$!", "$@", "$_", "$.", "$&", "$~", "$n", "$=", "$/", "$0", "$*", "$$", "$?"]
+        class <<self
+            def set(arg, value)
+                arg = convert_to_global(arg)
+                info "global set: #{arg} = #{value}"
+                eval("#{arg} = #{value}")
+            end
+
+            # add to $LOAD_PATH
+            def add(arg, value)
+                arg = convert_to_global(arg)
+                info "global add: #{arg} << #{value}"
+                eval("#{arg} << \"#{value}\"")
+            end
+
+            def get(arg)
+                arg = convert_to_global(arg)
+                info "global get: #{arg}"
+                eval(arg)
+            end
+
+            private
+            def convert_to_global(arg)
+                check_format(arg)
+                add_dollar_if_noexist(arg)
+            end
+
+            def check_format(arg)
+                if !MAGIC_GLOBAL.include?(arg) and !arg.match(/^\$?[a-zA-Z_]{1}[a-zA-Z_0-9]*$/)
+                    raise GlobalVarFormatError, "global variable format wrong: #{arg}"
+                end
+            end
+
+            def add_dollar_if_noexist(arg)
+                arg = "$" + arg unless arg.match(/^\$/)
+                arg
+            end
+        end
+    end
+end

data/lib/woolen_common/ruby_proxy/proxy_load.rb

@@ -0,0 +1,34 @@
+# -*- encoding : utf-8 -*-
+module RubyProxy
+    class ProxyLoad
+        include WoolenCommon::ToolLogger
+
+        @load_path = []
+        class <<self
+            attr_accessor :load_path
+
+            def load
+                load_path.uniq.each do |p|
+                    if File.directory?(p)
+                        Dir[p.chomp("/") + "/*.rb"].each do |file|
+                            load_file(file)
+                        end
+                    else
+                        load_file(p)
+                    end
+                end
+            end
+
+            def load_file(file)
+                begin
+                    trace "require file : #{file}"
+                    require file
+                    trace "finish require file : #{file}"
+                rescue Exception => e
+                    warn "require file : #{file} fail,exception:\n#{e}", e
+                    raise e
+                end
+            end
+        end
+    end
+end

data/lib/woolen_common/ruby_proxy/server.rb

@@ -0,0 +1,53 @@
+# -*- encoding : utf-8 -*-
+require 'rubygems'
+require 'drb'
+require "#{File.join(File.dirname(__FILE__), 'config')}"
+require "#{File.join(File.dirname(__FILE__), 'proxy')}"
+require 'drb/timeridconv'
+module RubyProxy
+    class DRbServer
+        include WoolenCommon::ToolLogger
+        @ip = Config.ip
+        @port = Config.port
+
+        class << self
+            attr_accessor :ip, :port
+        end
+
+        def self.start_service
+            DRb.install_id_conv(DRb::TimerIdConv.new)
+            DRb.start_service("druby://#{ip}:#{port}", Proxy)
+            #~ trap("INT") { DRb.stop_service }
+            # for ruby1.9
+            begin
+                Proxy.worker_start
+                DRb.thread.join
+            rescue Exception => e
+                error "服务线程异常:#{e.message}",e
+            ensure
+                DRb.stop_service
+            end
+        end
+
+        def self.stop_service
+            DRb.stop_service
+        end
+    end
+end
+
+if $0 == __FILE__
+    #~ ['INT'].each do |signal|
+    #~ trap(signal) {
+    #~ puts 'exit...'
+    #~ RubyProxy::DRbServer.stop_service
+    #~ }
+    #~ end
+    #~ puts "start server ip:#{ARGV[0] || "127.0.0.1"}"
+    #~ puts "start server port:#{ARGV[1] || 9000}"
+    RubyProxy::DRbServer.ip = ARGV[0] unless ARGV[0].nil?
+    RubyProxy::DRbServer.port = ARGV[1] unless ARGV[1].nil?
+    puts "start server ip: #{RubyProxy::DRbServer.ip}"
+    puts "start server port:#{RubyProxy::DRbServer.port}"
+    #~ Dir.chdir ARGV[2] unless ARGV[2].nil?
+    RubyProxy::DRbServer.start_service
+end

data/lib/woolen_common/splib.rb

@@ -0,0 +1,36 @@
+module Splib
+    LIBS = [:Array,
+            :CodeReloader,
+            :Constants,
+            :Conversions,
+            :Exec,
+            :Float,
+            :HumanIdealRandomIterator,
+            :Monitor,
+            :PriorityQueue,
+            :Sleep,
+            :UrlShorteners
+           ]
+    # args:: name of library to load
+    # Loads the given library. Currently available:
+    # :CodeReloader
+    # :Constants
+    # :Conversions
+    # :Exec
+    # :HumanIdealRandomIterator
+    # :PriorityQueue
+    # :UrlShorteners
+    # :all
+    def self.load(*args)
+        if args.include?(:all)
+            LIBS.each do |lib|
+                require File.join(File.dirname(__FILE__), 'splib', lib.to_s)
+            end
+        else
+            args.each do |lib|
+                raise NameError.new("Unknown library name: #{lib}") unless LIBS.include?(lib)
+                require File.join(File.dirname(__FILE__), 'splib', lib.to_s)
+            end
+        end
+    end
+end

data/lib/woolen_common/splib/Array.rb

@@ -0,0 +1,33 @@
+module Splib
+    # Only add this if we are in the 1.8 world and no one
+    # else has added it yet
+    if(Object::RUBY_VERSION < '1.9.0' && ![].respond_to?(:fixed_flatten))
+        class ::Array
+            # 1.9 compatible flatten method that allows
+            # a level parameter
+            def fixed_flatten(level = -1)
+                arr = self
+                case
+                when level < 0
+                    arr.flatten!
+                when level == 0
+                    self
+                when level > 0
+                    arr = []
+                    curr = self
+                    level.times do
+                        curr.each do |elm|
+                            if(elm.respond_to?(:to_ary))
+                                elm.each{|e| arr << e }
+                            else
+                                arr << elm
+                            end
+                        end
+                        curr = arr.dup
+                    end
+                end
+                arr
+            end
+        end
+    end
+end

data/lib/woolen_common/splib/CodeReloader.rb

@@ -0,0 +1,59 @@
+module Splib
+    # path:: path to file
+    # Read contents of file
+    def self.read_file(path)
+        file = File.open(path, 'rb')
+        cont = file.read
+        file.close
+        cont
+    end
+    # path:: path to ruby file
+    # type:: return constants only of given type
+    # Find all constants in a given ruby file. Array of 
+    # symbols is returned
+    def self.discover_constants(path, type=nil)
+        raise ArgumentError.new('Failed to locate plugin file') unless File.exists?(path)
+        consts = []
+        sandbox = Module.new
+        sandbox.module_eval(self.read_file(path))
+        sandbox.constants.each do |const|
+            klass = sandbox.const_get(const)
+            if(type.nil? || (type && klass < type))
+                sklass = klass.to_s.slice(klass.to_s.rindex(':')+1, klass.to_s.length)
+                consts << sklass.to_sym
+            end
+        end
+        return consts
+    end
+
+    # path:: path to ruby file
+    # holder:: module holding loaded ruby code
+    # Load code from a ruby file into a module
+    def self.load_code(path, holder=nil)
+        if(holder)
+            raise ArgumentError.new('Expecting a module containing loaded code') unless holder.respond_to?(:path)
+        else
+            holder = self.create_holder(path)
+        end
+        holder.module_eval(self.read_file(path))
+        holder
+    end
+
+    # holder:: module holding loaded ruby code
+    # Reload the code within the module
+    def self.reload_code(holder)
+        raise ArgumentError.new('Expecting a module containing loaded code') unless holder.respond_to?(:path)
+        self.load_code(holder.path)
+    end
+
+    # path:: path to ruby code
+    # Creates a module to hold loaded code
+    def self.create_holder(path)
+        return Module.new do
+            @path = path
+            def self.path
+                @path
+            end
+        end
+    end
+end