xunch 0.0.6

data/lib/xunch/codec/codec.rb

@@ -0,0 +1,31 @@
+module Xunch
+  class Codec
+    DEFAULT_TYPE_MAP = {
+      "created_at" => :time,
+      "updated_at" => :time,
+      "approved_at" => :time
+    }
+
+    DEFAULT_DATE_FORMAT = "%Y-%m-%dT%H:%M:%S%:z"
+
+    def initialize(klass)
+      raise XunchCodecError.new("Codec class does not defined method '_accessible_attributes', maybe this klass is not a subclass of ActiveRecord::Base.") unless klass.method_defined?(:_accessible_attributes)
+      @klass = klass
+      @type_map = DEFAULT_TYPE_MAP
+      if @klass.const_defined? :TYPE_MAP
+        @type_map = @type_map.merge(@klass::TYPE_MAP)
+      end
+      @set_methods = {}
+      @get_methods = {}
+      @klass.attribute_names.each { |attribute|
+        if attribute.length == 0
+          next
+        end
+        field = Utils.format_field(attribute)
+        @get_methods[field] = attribute.to_sym
+        @set_methods[field] = (attribute + "=").to_sym
+      }
+    end
+
+  end
+end

data/lib/xunch/codec/hash_codec.rb

@@ -0,0 +1,98 @@
+module Xunch
+  class HashCodec < Codec
+
+    def initialize(klass,fields)
+      super(klass)
+      temp_set_methods = {}
+      temp_get_methods = {}
+      @fields = fields
+      @fields.each{ |field|
+        temp_get_method = @get_methods[field]
+        temp_set_method = @set_methods[field]
+        if temp_set_method == nil || temp_get_method == nil
+          raise XunchConfigError.new("field #{field} doesn't have set or get method")
+        end
+        temp_get_methods[field] = temp_get_method
+        temp_set_methods[field] = temp_set_method
+      }
+      @set_methods = temp_set_methods
+      @get_methods = temp_get_methods
+    end
+
+    def encode(value)
+      unless value.class.name == @klass.name
+        raise XunchCodecError.new("Codec error. Codec class is #{@klass}," << 
+          "object_id is #{@klass.object_id}, but value class is #{value.class}," << 
+          "object_id is #{value.class.object_id}.
+          value class = #{value.class.inspect} vs config class = #{@klass.inspect} ")
+      end
+      hash = Hash.new
+      @get_methods.each do | k , v |
+        var_value = value.send(v)
+        if var_value != nil
+          if var_value.class.name == Time.name or var_value.class.name == DateTime.name
+            hash[k] = var_value.strftime(DEFAULT_DATE_FORMAT)
+          else
+            hash[k] = var_value
+          end
+        end
+      end
+      return hash
+    end
+
+    def decode(hash)
+      value = @klass.new
+      count = 0
+      hash.each { |k, v|
+        if v == nil
+          count+=1
+        else
+          value.send(@set_methods[k],v)
+        end
+      }
+      if count == hash.length
+        return nil
+      else
+        return value
+      end
+    end
+
+    def encode_fields(value,fields)
+      hash = Hash.new
+      fields.each { |field|
+        get_method = @get_methods[field]
+        if get_method == nil
+          raise XunchCodecError.new("Undefined field #{field}")
+        end
+        var_value = value.send(get_method)
+        if var_value != nil
+          if var_value.class.name == Time.name or var_value.class.name == DateTime.name
+            hash[field] = var_value.strftime(DEFAULT_DATE_FORMAT)
+          else
+            hash[field] = var_value
+          end
+        end
+      }
+      return hash
+    end
+
+    def decode_fields(hash,fields)
+      value = @klass.new
+      count = 0
+      fields.each { |field|
+        v = hash[field]
+        if v == nil
+          count+=1
+        else
+          value.send(@set_methods[field],v)
+        end
+      }
+      if count == hash.length
+        return nil
+      else
+        return value
+      end
+    end
+  end
+end
+

data/lib/xunch/codec/json_codec.rb

@@ -0,0 +1,81 @@
+module Xunch
+  class JsonCodec < Codec
+
+    def initialize(klass)
+      super
+      @parser = Yajl::Parser
+      @encoder = Yajl::Encoder
+    end
+
+    def encode(value)
+      unless value.class.name == @klass.name
+        raise XunchCodecError.new("Codec error. Codec class is #{@klass}," << 
+          "object_id is #{@klass.object_id}, but value class is #{value.class}," << 
+          "object_id is #{value.class.object_id}.
+          value class = #{value.class.inspect} vs config class = #{@klass.inspect} ")
+      end
+      hash = Hash.new
+      @get_methods.each do | k , v |
+        var_value = value.send(v)
+        if var_value != nil
+          hash[k] = var_value
+        end
+      end
+      Yajl::Encoder.encode(hash)
+    end
+
+    def decode(json_string)
+      value = @klass.new
+      hash = Yajl::Parser.parse(json_string)
+      hash.each { |k, v|
+        if @type_map.include?(k)
+          case @type_map[k]
+          when :datetime
+            v = DateTime.strptime(v, DEFAULT_DATE_FORMAT)
+          when :time
+            v = DateTime.strptime(v, DEFAULT_DATE_FORMAT).to_time
+          when :bigdecimal
+            v = BigDecimal.new(v.to_s)
+          else
+            # do nothing
+          end
+        end
+        value.send(@set_methods[k],v)
+      }
+      value
+    end
+
+    def encode_fields(value,fields)
+      hash = Hash.new
+      @get_methods.each do | k , v |
+        var_value = value.send(v)
+        if var_value != nil
+          hash[k] = var_value
+        end
+      end
+      hash
+    end
+
+    def decode_fields(hash,fields)
+      value = @klass.new
+      hash = Yajl::Parser.parse(json_string)
+      hash.each { |k, v|
+        if @type_map.include?(k)
+          case @type_map[k]
+          when :datetime
+            v = DateTime.strptime(v, DEFAULT_DATE_FORMAT)
+          when :time
+            v = DateTime.strptime(v, DEFAULT_DATE_FORMAT).to_time
+          when :bigdecimal
+            v = BigDecimal.new(v.to_s)
+          else
+            # do nothing
+          end
+        end
+        value.send(@set_methods[k],v)
+      }
+      value
+    end
+  end
+end
+

data/lib/xunch/shard/redis.rb

@@ -0,0 +1,270 @@
+#
+# redis client support redis pool
+# 
+module Xunch
+  class RedisClient
+
+    DEFAULTS = {
+      :size => 1,
+      :timeout => nil,
+      :pool_timeout => 0,
+      :driver => :hiredis
+    }
+
+    def initialize(options = {})
+      @options = DEFAULTS.merge(options)
+      if RUBY_PLATFORM =~ /mingw/
+        @options[:driver] = nil
+      end
+      if(@options[:pool_timeout] > 0)
+        @pool_timeout = @options[:pool_timeout]
+      else
+        @pool_timeout = 1073741823
+      end
+      @pool = Array.new(@options[:size]) { redis = Redis.new(@options) }
+      @mutex = Mutex.new
+      @resource = ConditionVariable.new
+    end
+
+    def destroy
+      @pool.each {|redis| redis.quit if redis and redis.connected?}
+    end
+
+    def exists(key)
+      with do | redis |
+        redis.exists(key)
+      end
+    end
+
+    def del(*keys)
+      if keys.length > 5
+        with do | redis |
+          redis.pipelined do
+            redis.del(*keys)
+          end
+        end
+      else
+        with do | redis |
+          redis.del(*keys)
+        end
+      end
+    end
+
+    def expire(key, ttl)
+      with do | redis |
+        redis.expire(key,ttl)
+      end
+    end
+    
+    def ttl(key)
+      with do | redis |
+        redis.ttl(key)
+      end
+    end
+
+    # get value with key
+    #
+    # @param [String] key
+    # @return [String] value cache in redis
+    def get(key)
+      with do | redis |
+        redis.get(key)
+      end
+    end
+
+    def mget(keys)
+      with do | redis |
+        redis.mget(*keys)
+      end
+    end
+
+    # set key value with expire time in second
+    #
+    # @param [String] key
+    # @param [String] value
+    # @param [Fixnum] ttl time to live
+    # @return `"OK"`
+    def set(key, value, ttl)
+      with do | redis |
+        redis.setex(key,ttl,value)
+      end
+    end
+    
+    # multi set key value with expire time in second
+    # NOTE: use pipeline inner
+    #
+    # @param [Hash] hash key value pairs
+    # @param [Fixnum] ttl time to live
+    def mset(hash, ttl)
+      with do | redis |
+        if(ttl != 0)
+          redis.pipelined do
+            hash.each { |key,value|
+              redis.setex(key,ttl,value)
+            }
+          end
+        else
+          redis.mset(values)
+        end
+      end
+    end
+
+    def hset(key, hash, ttl)
+      with do | redis |
+        redis.pipelined do
+          redis.mapped_hmset(key, hash)
+          if(ttl > 0)
+            redis.expire(key,ttl)
+          end
+        end
+      end
+    end
+
+    def hget(key, *fields)
+      with do | redis |
+        redis.mapped_hmget(key, *fields)
+      end
+    end
+
+    def hgetall(key)
+      with do | redis |
+        redis.hgetall(key)
+      end
+    end
+
+    def hsetall(key,hash,ttl)
+      with do | redis |
+        redis.pipelined do
+          redis.mapped_hmset(key, hash)
+          if(ttl > 0)
+            redis.expire(key,ttl)
+          end
+        end
+      end
+    end
+    
+    # multi get hash type keys with fields
+    #
+    # @param keys [Array] redis hash key
+    # @param fields [Array] hash field names
+    def hmget(keys,*fields)
+      # block =  lambda { |args| p args }
+      with do | redis |
+        redis.pipelined do
+          keys.each { | key |
+            redis.mapped_hmget(key, *fields)
+          }
+        end
+      end
+    end
+
+    def hmset(hash, ttl)
+      with do | redis |
+        redis.pipelined do
+          hash.each { | key, value |
+            redis.mapped_hmset(key, value)
+            if(ttl > 0)
+              redis.expire(key, ttl)
+            end
+          }
+        end
+      end
+    end
+
+    def hmgetall(keys)
+      with do | redis |
+        redis.pipelined do
+          keys.each { | key |
+            redis.hgetall(key)
+          }
+        end
+      end
+    end
+
+    def llen(key)
+      with do | redis |
+        redis.llen(key)
+      end
+    end
+
+    def lrem(key,value)
+      with do | redis |
+        redis.lrem(key,1,value)
+      end
+    end
+
+    def lset(temp_key,new_key,values,ttl)
+      with do | redis |
+        redis.pipelined do
+          redis.del(temp_key)
+          values.each {
+            | value |
+            redis.rpush(temp_key,value)
+          }
+          result = redis.rename(temp_key,new_key)
+          if(ttl > 0)
+           redis.expire(new_key,ttl)
+          end
+        end
+      end
+    end
+
+    def lrange(key, start, stop)
+      with do | redis |
+        redis.lrange(key,start,stop)
+      end
+    end
+
+    # Rename a key. If the new key already exists it is overwritten.
+    #
+    # @param [String] old_name
+    # @param [String] new_name
+    # @return [String] `OK`
+    def rename(old_key, new_key)
+      with do | redis |
+        redis.rename(old_key,new_key)
+      end
+    end
+
+    def type(key)
+      with do | redis |
+        redis.type(key)
+      end
+    end
+
+    private
+    def with
+        redis = checkout_redis
+        begin
+         yield redis
+        ensure
+          checkin_redis(redis)
+        end
+      end
+
+    def checkout_redis
+      deadline = Time.now + @pool_timeout
+      @mutex.synchronize do
+        loop do
+          return @pool.pop unless @pool.empty?
+          to_wait = deadline - Time.now
+          raise Timeout::Error, "Waited #{@pool_timeout} seconds" if to_wait <= 0 and @pool_timeout > 0
+          @resource.wait(@mutex, to_wait)
+        end
+      end
+    end
+
+    def checkin_redis(redis)
+      redis = Redis.new(@options) unless redis and redis.connected?
+      @mutex.synchronize do
+        if @pool.length < @options[:size]
+          @pool.push redis
+          @resource.broadcast
+        else
+          redis.quit
+        end
+      end
+    end
+
+  end
+end