norton 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45ea8d2f8971be12351a0cd129ed8a851f2a7823
-  data.tar.gz: bd77674e841f9dd8c8e2603a46b75a4cf03ed281
+  metadata.gz: 9fe66b21646e48209504891cdab86b5ac24e1474
+  data.tar.gz: cc4d1eaed607c0f71510d38be5dbfeb641a39c0d
 SHA512:
-  metadata.gz: 1c4ca36139885b6ea121edc8c3b9ceb81ace3f9abe2c85e01f17c208f280748ef91cfc27b7f7d473e1fd4ca03cd79566193cf99e5e0b20de2273494212dce75f
-  data.tar.gz: 8e9c450ff7fc10a7d9c8007645ab60640f0be59549c2d952bd286e9babdfe023d3ad076fcf3ac46c27e9e993f6ab061b6cecdd02d693792dd0d9277aeb483fc0
+  metadata.gz: 459c0f017e79c424e3861f466667d16942bc980894a54877132a762084c51de66a1ea17a6256eb25e4b55645812454d8cd26ac52f3cda459f0204bbfe9298a95
+  data.tar.gz: aed208fccde64fc567af602d48faa093f4b782c280106c88b0ff5e5c5bd3068e209ab4ecce60788dd4d4ea6e8a23eb73162346764b4ac1e25ff4701568879e49

data/lib/norton.rb

@@ -6,7 +6,6 @@ require "norton/version"
 require "norton/helper"
 require "norton/timestamp"
 require "norton/counter"
-require "norton/timed_value"
 require "norton/objects/hash"
 require "norton/hash_map"
 
@@ -17,24 +16,42 @@ module Norton
   class InvalidType < StandardError; end
 
   class << self
+    attr_accessor :pools
     attr_accessor :redis
 
+    def pools
+      @pools ||= {}
+    end
+
     #
     # Setup your redis connection.
+    #
     # @param options={} [Hash] [Redis connection configuration]
     #   url - Redis connection url
     #   pool - Connection pool size
     #   timeout - Connection pool timeout
-    # @return [nil] [description]
-    def setup(options={})
-      pool_size = (options[:pool] || 1).to_i
-      timeout = (options[:timeout] || 2).to_i
+    #
+    # @example
+    #   {
+    #     "default" => { "url" => "redis://localhost:6379/0", "pool" => 4, "timeout" => 2 },
+    #     "norton2" => { "url" => "redis://localhost:6379/3", "pool" => 4, "timeout" => 2 }
+    #   }
+    #
+    # @return [Void]
+    #
+    def setup(options = {})
+      self.pools = {}
+      options.deep_symbolize_keys!
 
-      Norton.redis = ConnectionPool.new(:size => pool_size, :timeout => timeout) do
-        Redis.new(
-          options.slice(:url, :host, :port, :db, :path, :password, :namespace, :ssl_params, :driver)
-        )
+      options.each do |name, conn_params|
+        pool_size = (conn_params.delete(:pool) || 1).to_i
+        timeout   = (conn_params.delete(:timeout) || 2).to_i
+        Norton.pools[name] = ConnectionPool.new(size: pool_size, timeout: timeout) do
+          Redis.new(conn_params)
+        end
       end
+
+      Norton.redis = Norton.pools[:default]
     end
 
     # 批量获取多个对象的多个 Norton 字段, 仅仅支持 counter / timestamp
@@ -47,15 +64,22 @@ module Norton
     # @return [Array] 一组对象
     #
     def mget(objects, fields)
-      keys = objects.flat_map do |object|
-        fields.map { |f| object.norton_value_key(f) }
+      pools_with_name = fields.each_with_object({}) do |name, hash|
+        pool = objects[0].class.norton_value_redis_pool(name)
+        hash[pool] ||= []
+        hash[pool] << name
       end
-      nested_values = Norton.redis.with do |conn|
-        conn.mget(keys)
-      end.each_slice(fields.size)
 
-      objects.zip(nested_values).each do |object, values|
-        object.send(:assign_values, fields.zip(values).to_h)
+      pools_with_name.each do |pool, names|
+        keys = objects.flat_map do |object|
+          names.map { |name| object.norton_value_key(name) }
+        end
+        nested_values = pool.with do |conn|
+          conn.mget(keys)
+        end.each_slice(names.size)
+        objects.zip(nested_values).each do |object, values|
+          object.send(:assign_values, names.zip(values).to_h)
+        end
       end
 
       objects

data/lib/norton/counter.rb

@@ -16,11 +16,12 @@ module Norton
       # @return [type] [description]
       def counter(name, options={}, &blk)
         register_norton_value(name, :counter, options)
+        redis = norton_value_redis_pool(name)
 
         # Redis: GET
         define_method(name) do
           instance_variable_get("@#{name}") || begin
-            value = Norton.redis.with do |conn|
+            value = redis.with do |conn|
               conn.get(norton_value_key(name))
             end || send("#{name}_default_value")
             instance_variable_set("@#{name}", value.to_i)
@@ -29,7 +30,7 @@ module Norton
 
         # Redis: SET
         define_method("#{name}=") do |value|
-          if Norton.redis.with { |conn| conn.set(norton_value_key(name), value) }
+          if redis.with { |conn| conn.set(norton_value_key(name), value) }
             instance_variable_set("@#{name}", value.to_i)
           end
         end
@@ -40,7 +41,7 @@ module Norton
 
         # Redis: INCR
         define_method("incr_#{name}") do
-          value = Norton.redis.with do |conn|
+          value = redis.with do |conn|
             conn.incr(norton_value_key(name))
           end
           instance_variable_set("@#{name}", value.to_i)
@@ -48,7 +49,7 @@ module Norton
 
         # Redis: DECR
         define_method("decr_#{name}") do
-          value = Norton.redis.with do |conn|
+          value = redis.with do |conn|
             conn.decr(norton_value_key(name))
           end
           instance_variable_set("@#{name}", value.to_i)
@@ -56,7 +57,7 @@ module Norton
 
         # Redis: INCRBY
         define_method("incr_#{name}_by") do |increment|
-          value = Norton.redis.with do |conn|
+          value = redis.with do |conn|
             conn.incrby(norton_value_key(name), increment)
           end
           instance_variable_set("@#{name}", value.to_i)
@@ -64,7 +65,7 @@ module Norton
 
         # Redis: DECRBY
         define_method("decr_#{name}_by") do |decrement|
-          value = Norton.redis.with do |conn|
+          value = redis.with do |conn|
             conn.decrby(norton_value_key(name), decrement)
           end
           instance_variable_set("@#{name}", value.to_i)
@@ -74,7 +75,7 @@ module Norton
         define_method("reset_#{name}") do
           value = instance_eval(&blk)
 
-          Norton.redis.with do |conn|
+          redis.with do |conn|
             conn.set(norton_value_key(name), value)
           end
           instance_variable_set("@#{name}", value)
@@ -82,7 +83,7 @@ module Norton
 
         # Redis: DEL
         define_method("remove_#{name}") do
-          Norton.redis.with do |conn|
+          redis.with do |conn|
             conn.del(norton_value_key(name))
           end
           remove_instance_variable("@#{name}") if instance_variable_defined?("@#{name}")

data/lib/norton/hash_map.rb

@@ -7,13 +7,13 @@ module Norton
     end
 
     module ClassMethods
-      def hash_map(name)
-        self.register_norton_value(name, :hash_map)
+      def hash_map(name, options = {})
+        register_norton_value(name, :hash_map, options)
 
         define_method(name) do
           instance_variable_get("@#{name}") ||
             instance_variable_set("@#{name}",
-              Norton::Objects::Hash.new(self.norton_value_key(name))
+              Norton::Objects::Hash.new(norton_value_key(name), :pool_name => options[:redis])
             )
         end
 

data/lib/norton/helper.rb

@@ -44,6 +44,18 @@ module Norton
       def norton_value_type(name)
         norton_values.dig(name.to_sym, :type)
       end
+
+      #
+      # 返回当前类定义的某个 Norton Value 的 redis instance
+      #
+      # @param [String] name
+      #
+      # @return [ConnectionPool]
+      #
+      def norton_value_redis_pool(name)
+        pool_name = norton_values.dig(name.to_sym, :redis) || :default
+        Norton.pools[pool_name]
+      end
     end
 
     #
@@ -96,11 +108,19 @@ module Norton
     # @return [Model] 当前对象
     #
     def norton_mget(*names)
-      values = Norton.redis.with do |conn|
-        conn.mget(names.map { |name| norton_value_key(name) })
+      pools_with_name = names.each_with_object({}) do |name, hash|
+        pool = self.class.norton_value_redis_pool(name)
+        hash[pool] ||= []
+        hash[pool] << name
       end
 
-      assign_values(names.zip(values).to_h)
+      pools_with_name.each do |pool, fields|
+        values = pool.with do |conn|
+          conn.mget(fields.map { |field| norton_value_key(field) })
+        end
+
+        assign_values(fields.zip(values).to_h)
+      end
 
       self
     end
@@ -109,20 +129,23 @@ module Norton
     def assign_values(new_values)
       new_values.each do |field, val|
         type = self.class.norton_value_type(field)
+        ivar_name = :"@#{field}"
 
         case type
         when :counter
           value = cast_value(type, val || try("#{field}_default_value"))
-          instance_variable_set("@#{field}", value)
+          instance_variable_set(ivar_name, value)
         when :timestamp
           if !val.nil?
-            instance_variable_set("@#{field}", cast_value(type, val))
+            instance_variable_set(ivar_name, cast_value(type, val))
           elsif self.class.norton_values[field][:allow_nil]
-            instance_variable_set("@#{field}", nil)
+            instance_variable_set(ivar_name, nil)
           else
             value = cast_value(type, try("#{field}_default_value"))
-            instance_variable_set("@#{field}", value)
-            Norton.redis.with { |conn| conn.set(norton_value_key(field), value) }
+            instance_variable_set(ivar_name, value)
+            self.class.norton_value_redis_pool(field).with do |conn|
+              conn.set(norton_value_key(field), value)
+            end
           end
         end
       end

data/lib/norton/objects/hash.rb

@@ -1,40 +1,41 @@
 module Norton
   module Objects
     class Hash
-      attr_reader :key
+      attr_reader :key, :redis
 
-      def initialize(key)
-        @key = key
+      def initialize(key, options = {})
+        @key   = key
+        @redis = Norton.pools[options[:pool_name] || :default]
       end
 
       # Redis: HSET
       def hset(field, value)
-        Norton.redis.with { |conn| conn.hset(key, field, value) }
+        redis.with { |conn| conn.hset(key, field, value) }
       end
       alias_method :[]=, :hset
 
       # Redis: HGET
       def hget(field)
-        Norton.redis.with { |conn| conn.hget(key, field) }
+        redis.with { |conn| conn.hget(key, field) }
       end
       alias_method :get, :hget
       alias_method :[],  :hget
 
       # Redis: HMGET
       def hmget(*field)
-        Norton.redis.with { |conn| conn.hmget(key, field) }
+        redis.with { |conn| conn.hmget(key, field) }
       end
       alias_method :mget, :hmget
 
       # Redis: HDEL
       def hdel(*field)
-        Norton.redis.with { |conn| conn.hdel(key, field) }
+        redis.with { |conn| conn.hdel(key, field) }
       end
       alias_method :delete, :hdel
 
       # Redis: HINCRBY
       def hincrby(field, by = 1)
-        Norton.redis.with { |conn| conn.hincrby(key, field, by) }
+        redis.with { |conn| conn.hincrby(key, field, by) }
       end
       alias_method :incr, :hincrby
 
@@ -46,7 +47,7 @@ module Norton
 
       # Redis: HEXISTS
       def hexists(field)
-        Norton.redis.with { |conn| conn.hexists(key, field) }
+        redis.with { |conn| conn.hexists(key, field) }
       end
       alias_method :include?, :hexists
       alias_method :has_key?, :hexists
@@ -55,13 +56,13 @@ module Norton
 
       # Redis: HEXISTS
       def hkeys
-        Norton.redis.with { |conn| conn.hkeys(key) }
+        redis.with { |conn| conn.hkeys(key) }
       end
       alias_method :keys, :hkeys
 
       # Redis: DEL
       def clear
-        Norton.redis.with { |conn| conn.del(key) }
+        redis.with { |conn| conn.del(key) }
       end
     end
   end

data/lib/norton/timestamp.rb

@@ -15,12 +15,13 @@ module Norton
       # @return [type] [description]
       def timestamp(name, options={})
         register_norton_value(name, :timestamp, options)
+        redis = norton_value_redis_pool(name)
 
         # Redis: GET
         define_method(name) do
           return instance_variable_get("@#{name}") if instance_variable_defined?("@#{name}")
 
-          value = Norton.redis.with do |conn|
+          value = redis.with do |conn|
             raw_value = conn.get(norton_value_key(name))
             break raw_value if raw_value.present?
 
@@ -46,7 +47,7 @@ module Norton
         define_method("touch_#{name}") do
           value = options[:digits] == 13 ? (Time.current.to_f * 1000).to_i : Time.current.to_i
 
-          Norton.redis.with do |conn|
+          redis.with do |conn|
             conn.set(norton_value_key(name), value)
           end
           instance_variable_set("@#{name}", value)
@@ -54,7 +55,7 @@ module Norton
 
         # Redis: DEL
         define_method("remove_#{name}") do
-          Norton.redis.with do |conn|
+          redis.with do |conn|
             conn.del(norton_value_key(name))
           end
           remove_instance_variable("@#{name}") if instance_variable_defined?("@#{name}")

data/lib/norton/version.rb

@@ -1,3 +1,3 @@
 module Norton
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/norton.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = "~> 2.3.0"
+  spec.required_ruby_version = ">= 2.3.0"
 
   spec.add_dependency "redis", ">= 3.2.0"
   spec.add_dependency "connection_pool", "~> 2.2.0"

data/spec/norton/counter_spec.rb

@@ -7,6 +7,10 @@ class Dummy
     candies
   end
 
+  counter :views_count, :redis => :tmp do
+    14
+  end
+
   def id
     @id ||= Random.rand(10000)
   end
@@ -140,4 +144,19 @@ describe Norton::Counter do
       expect(dummy.instance_variable_defined?(:@candies_count)).to be(false)
     end
   end
+
+  describe "with another redis instance" do
+    it "saves the value in correct redis server" do
+      dummy.views_count = 10
+
+      value = Norton.pools[:tmp].with { |conn| conn.get(dummy.norton_value_key(:views_count)) }.to_i
+      expect(value).to eq(10)
+    end
+
+    it "gets the value correctly" do
+      Norton.pools[:tmp].with { |conn| conn.set(dummy.norton_value_key(:views_count), 10) }.to_i
+
+      expect(dummy.views_count).to eq(10)
+    end
+  end
 end

data/spec/norton/helper_spec.rb

@@ -6,6 +6,7 @@ class Dummy
   include Norton::HashMap
 
   counter   :counter1
+  counter   :custom_redis_counter, :redis => :tmp
   timestamp :time1
   timestamp :time2, :allow_nil => true
   hash_map  :map1
@@ -171,5 +172,20 @@ describe Norton::Helper do
         end
       end
     end
+
+    context "when the attributes in multiples redis servers" do
+      it "returns the value correctly" do
+        Dummy.norton_value_redis_pool(:counter1).with do |conn|
+          conn.set(dummy.norton_value_key(:counter1), 2)
+        end
+        Dummy.norton_value_redis_pool(:custom_redis_counter).with do |conn|
+          conn.set(dummy.norton_value_key(:custom_redis_counter), 99)
+        end
+
+        dummy.norton_mget(:counter1, :custom_redis_counter)
+        expect(dummy.instance_variable_get(:@counter1)).to eq(2)
+        expect(dummy.instance_variable_get(:@custom_redis_counter)).to eq(99)
+      end
+    end
   end
 end

data/spec/norton_spec.rb

@@ -2,9 +2,20 @@ require 'spec_helper'
 
 describe Norton do
   describe "#setup" do
-    it "should setup a redis connection pool" do
-      Norton.setup url: 'redis://localhost:6379/0'
-      expect(Norton.redis).not_to be_nil
+    xit "sets a redis connection pool" do
+      Norton.setup(
+        default: { url: "redis://localhost:6379/0" }
+      )
+      expect(Norton.pools[:default]).not_to be_nil
+    end
+
+    xit "sets multiple redis connection pools" do
+      Norton.setup(
+        default: { url: "redis://localhost:6379/0" },
+        norton2: { url: "redis://localhost:6379/3" }
+      )
+      expect(Norton.pools.keys).to match_array(%i[default norton2])
+      expect(Norton.pools[:norton2]).not_to be_nil
     end
   end
 
@@ -15,6 +26,7 @@ describe Norton do
       include Norton::HashMap
 
       counter   :counter1
+      counter   :custom_redis_counter, :redis => :tmp
       timestamp :time1
       timestamp :time2, :allow_nil => true
       hash_map  :map1
@@ -102,5 +114,20 @@ describe Norton do
         end
       end
     end
+
+    context "when the attributes in multiples redis servers" do
+      it "returns the value correctly" do
+        Dummy.norton_value_redis_pool(:counter1).with do |conn|
+          conn.set(dummy.norton_value_key(:counter1), 2)
+        end
+        Dummy.norton_value_redis_pool(:custom_redis_counter).with do |conn|
+          conn.set(dummy.norton_value_key(:custom_redis_counter), 99)
+        end
+
+        Norton.mget([dummy], %i[counter1 custom_redis_counter])
+        expect(dummy.instance_variable_get(:@counter1)).to eq(2)
+        expect(dummy.instance_variable_get(:@custom_redis_counter)).to eq(99)
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -21,10 +21,15 @@ RSpec.configure do |config|
 
   # Clean Up Redis
   config.before(:each) do
-    Norton.redis.with { |conn| conn.flushdb }
+    Norton.pools.each do |_name, conn|
+      conn.with { |conn| conn.flushdb }
+    end
   end
 end
 
-Norton.setup url: "redis://localhost:6379/0"
+Norton.setup(
+  default: { url: "redis://localhost:6379/0" },
+  tmp: { url: "redis://localhost:6379/2" }
+)
 
 ActiveRecord::Base.establish_connection :adapter => :nulldb

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: norton
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Larry Zhao
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-07 00:00:00.000000000 Z
+date: 2017-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -213,7 +213,6 @@ files:
 - lib/norton/hash_map.rb
 - lib/norton/helper.rb
 - lib/norton/objects/hash.rb
-- lib/norton/timed_value.rb
 - lib/norton/timestamp.rb
 - lib/norton/version.rb
 - norton.gemspec
@@ -234,7 +233,7 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
       version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
@@ -244,7 +243,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Provide simple helpers on persist values in redis for performance. Works

data/lib/norton/timed_value.rb

@@ -1,40 +0,0 @@
-module Norton
-  module TimedValue
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-
-      def timed_value(name, options={}, &blk)
-        if options[:ttl].nil?
-          raise 'Time to live not specified.'
-        end
-
-        if blk.nil?
-          raise 'Value generation not provided'
-        end
-
-        # Define getter
-        define_method(name) do
-          Norton.redis.with do |conn|
-            v = conn.get(self.norton_value_key(name))
-
-            if v.nil?
-              v = instance_eval(&blk)
-              conn.setex(self.norton_value_key(name), options[:ttl], v)
-            end
-
-            v
-          end
-        end
-
-        define_method("reset_#{name}") do
-          Norton.redis.with do |conn|
-            v = instance_eval(&blk)
-            conn.setex(self.norton_value_key(name), options[:ttl], v)
-            v
-          end
-        end
-      end
-    end
-  end
-end