mixed_gauge 0.2.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe193d3c4bbc6e42d5c285a7fc0db71b0d9fd63e
-  data.tar.gz: 135ac4476a0fb604f1c073853a1cef51fc8602d6
+  metadata.gz: b52a83a9e2dcfa88c05591683f5f3f8ca6cdc25e
+  data.tar.gz: 2ebdd85105cf34b3d4cf09485293953e85894be0
 SHA512:
-  metadata.gz: d3d30a1b8a4a637405393025144dfb8bfe450bb46bc01e37012c593d8ef5e97807bc2f18e7ebf690ea872ae5ad40eb74ea174bbea404e67a6b5e1eacc9db8c8f
-  data.tar.gz: 5b30aa9199b3d09a22e12c305c1b063a572843606422221c61efa62674df5d21f61d384d4b93be409eae3e9b8dd3310d7b4169658cf21902f1cd6aea75211f83
+  metadata.gz: 85c09e39e2a6963dda8afab08b8bad16e7ec4be4ac506f8b208295d84842f9d4b92344e099072cfdf3443af2ce7a7e51d7f629d0940aadeb42ff691541d43948
+  data.tar.gz: 8c014307fa8eae21d653ebed9264f01ba8408db1364a158fcec682fdab9a618f81a9aeff5dbc22e25404228992ed191485e96e26510a33ad9c35d5081a9cd9b9

data/.travis.yml

@@ -1,5 +1,6 @@
 language: ruby
 sudo: false
+script: "bundle exec rake && bundle exec ruby spec/performance_test.rb"
 branches:
   only:
     - master

data/CHANGELOG.md

@@ -1,4 +1,9 @@
 # CHANGELOG for mixed_gauge
+## 1.0.0
+- Change cluster slots definition interface: does not specify entire slots,
+    but specify only slots size.
+- Add config validation.
+- Change class name of generated model: SubModel -> Shard
 
 ## 0.2.1
 - Fix performance issue that `MixedGauge::Model.shard_for` is very slow.

data/README.md

@@ -2,19 +2,123 @@
 [![Build Status](https://travis-ci.org/taiki45/mixed_gauge.svg?branch=master)](https://travis-ci.org/taiki45/mixed_gauge) [![Coverage Status](https://coveralls.io/repos/taiki45/mixed_gauge/badge.svg?branch=master)](https://coveralls.io/r/taiki45/mixed_gauge?branch=master) [![Code Climate](https://codeclimate.com/github/taiki45/mixed_gauge/badges/gpa.svg)](https://codeclimate.com/github/taiki45/mixed_gauge) [![Gem Version](https://badge.fury.io/rb/mixed_gauge.svg)](http://badge.fury.io/rb/mixed_gauge)
 
 A simple and robust ActiveRecord extension for database sharding.
-mixed_gauge offers shards management with hash slots, re-sharding support,
-KVS actions, some ActiveRecord::Base actions.
+mixed_gauge offers shards management with hash slots and re-sharding support.
+It enable you to execute efficient queries to single node with KVS-like interface.
+And you can even execute limited RDB queries to all nodes with ActiveRecord interface,
+'course in-parallel.
 
-## Concept
-Shard management is based on hash slots mechanism.
+## Goal and concept
+- Simple
+- No downtime migrations
+- Rollback-able operations
 
-TODO: more doc.
+Database sharding tend to be over-complexed. There are cases which need these complex database sharding but in some cases database sharding can be more simple. The large data set which is enoght big to partition should be designed to be distributed, or should be re-design if it wasn't. Design to be distributed uses key based relation or reverse indexes to fits its limitation. In that case, the data set is almost design to be distributed, mixed_gauge strongly encourages your database sharding by its simplicity.
 
-## Why and When to use mixed_gauge
-TODO
+We, offer 24/7 services, must keep our services running. mixed_gauge supports online migrations: adding new nodes to cluster or removing some existing nodes from cluster. It comes with "key distibution model with hash slots" and  database replication and multi-master replication. In sharding we need re-sharding, move data from node to anoter node in cluster, when adding or removing new nodes from cluster. But by setting some rule to node management and using replication, we can finish moving data before adding or removing nodes. The detail operations are specified later chapter of this document.
 
-## Usage
+All operaions should be rollback-able in case of any failures. mixed_gauge's node management can rollback adding and removing nodes operation. The detail operations are specified later chapter of this document.
+
+
+## Main components of sharding teqnique
+### Distribution model
+mixed_gauge's database sharding is based on keys distribution model with hash slots. The key space is split into arbitrary size of slots. `hash(v) mod N` determines which slot is used where `N` is size of configured hash slots. Hash slot is a virtual node and it is assigned to real node.
+
+The default hash function is CRC32 which has better perfomance for this kind of cases. You can use other hash function.
+
+### Node management
+mixed_gauge's database sharding sets a rule to both adding nodes and removing nodes. The node size must be incresed by multiple of 2. At first, the node size is 1. Then the node size is incresed to 2, next is 4, and next of next is 8.
+
+By setting this rule, we can move (copy) data from node to node before adding or removing nodes by "database replication". For example, when we have `cluster(A)`, which has single node A and node A is assigned (0..1023) hash slots, and plan to migrate to `cluster(A, B)`, which has 2 nodes A and B and node A is assigned (0..511) slots and node B is assigned (512..1023) slots, we can copy and replicate from A to B before migration then just balance hash slots to node B.
+
+```
+(1)              (2)                               (3)
+   ┌───────┐           ┌───────┐       ┌───────┐         ┌───────┐       ┌───────┐
+   │       │           │       │       │       │         │       │       │       │
+   │   A   │           │   A   │──────▶│   B   │         │   A   │       │   B   │
+   │       │           │       │       │       │         │       │       │       │
+   └───────┘           └───────┘       └───────┘         └───────┘       └───────┘
+
+    0..1023             0..1023                           0..511         512..1023
+```
+
+### Migration operations
+```
+(1) From 1 node cluster
+
+     0..1023
+    ┌───────┐
+    │       │
+    │       │
+    │   A   │
+    │       │
+    │       │
+    └───────┘
+
+(2) Copy data and start replication
+
+     0..1023
+    ┌───────┐       ┌───────┐
+    │       │       │       │
+    │       │       │       │
+    │   A   │──────▶│   B   │
+    │       │       │       │
+    │       │       │       │
+    └───────┘       └───────┘
+
+(3) Change auto_increment config
+not to conflict id column
+
+     0..1023
+  1 ┌───────┐       ┌───────┐ 2
+  3 │       │       │       │ 4
+  5 │       │       │       │ 6
+  . │   A   │──────▶│   B   │ .
+  . │       │       │       │ .
+    │       │       │       │
+    └───────┘       └───────┘
+   increment=2    increment=2
+     offset=1       offset=2
+
+(4) Start Multi-master replication
+
+     0..1023
+    ┌───────┐       ┌───────┐
+    │       │──────▶│       │
+    │       │       │       │
+    │   A   │       │   B   │
+    │       │       │       │
+    │       │◀──────│       │
+    └───────┘       └───────┘
+
+(5) Deploy app and apply new cluster
+configuration
+
+    0..511         512..1023
+   ┌───────┐       ┌───────┐
+   │       │──────▶│       │
+   │       │       │       │
+   │   A   │       │   B   │
+   │       │       │       │
+   │       │◀──────│       │
+   └───────┘       └───────┘
+
+(6) Stop Multi-master replication
+
+    0..511         512..1023
+   ┌───────┐       ┌───────┐
+   │       │       │       │
+   │       │       │       │
+   │   A   │       │   B   │
+   │       │       │       │
+   │       │       │       │
+   └───────┘       └───────┘
+```
+
+In step 3, we set enough big offset not to conflict auto increment value
+on applying config.
 
+
+## Usage
 Add additional database connection config to `database.yml`.
 
 ```yaml
@@ -43,17 +147,17 @@ Configure slots (virtual node for cluster) then assign slots to real node.
 MixedGauge.configure do |config|
   config.define_cluster(:user) do |cluster|
     # When slots per node * max nodes per cluster = (2 ** 10) * (2 ** 10)
-    cluster.define_slots(1..1048576)
-    cluster.register(1..262144, :production_user_001)
-    cluster.register(262145..524288, :production_user_002)
-    cluster.register(524289..786432, :production_user_003)
-    cluster.register(786433..1048576, :production_user_004)
+    cluster.define_slot_size(1048576)
+    cluster.register(0..262143, :production_user_001)
+    cluster.register(262144..524287, :production_user_002)
+    cluster.register(524288..786431, :production_user_003)
+    cluster.register(786432..1048575, :production_user_004)
   end
 end
 ```
 
 Include `MixedGauge::Model` to your model class, specify cluster name for the
-model, specify distkey which determine nodes to store.
+model, specify distkey which determines node to store.
 
 ```ruby
 class User < ActiveRecord::Base
@@ -63,11 +167,11 @@ class User < ActiveRecord::Base
 end
 ```
 
-Use `.get` to retrive single model class which is connected to proper
+Use `.get` to retrive single record which is connected to proper
 database node. Use `.put!` to create new record to proper database node.
 
-`.all_shards` enables you to all model class which is connected to all
-database nodes in the cluster.
+`.all_shards` returns each model class which is connected to proper
+database node. You can query with these models and aggregate result.
 
 ```ruby
 User.put!(email: 'alice@example.com', name: 'alice')
@@ -79,7 +183,7 @@ alice.save!
 User.all_shards.flat_map {|m| m.find_by(name: 'alice') }.compact
 ```
 
-When you want to execute queries in parallel, use `.all_shards_in_parallel`.
+When you want to execute queries in all nodes in parallel, use `.all_shards_in_parallel`.
 It returns `Mixedgauge::AllShardsInParallel` and it offers some collection
 actions which runs in parallel. It is aliased to `.parallel`.
 
@@ -89,7 +193,7 @@ User.parallel.flat_map {|m| m.where(age: 1) }.size #=> 1
 ```
 
 When you want find by non-distkey, not recomended though, you can define finder
-methods to model class.
+methods to model class for convenience.
 
 ```ruby
 class User < ActiveRecord::Base
@@ -110,7 +214,7 @@ alice.save!
 ```
 
 Sometimes you want to generates distkey value before validation. Since mixed_gauge
-generates sub class of your models, AR's callback is not usesless for this usecase,
+generates sub class of your models, AR's callback is usesless for this usecase,
 so mixed_gauge offers its own callback method.
 
 ```ruby
@@ -136,6 +240,7 @@ access_token = AccessToken.put!
 access_token.token #=> a generated token
 ```
 
+
 ## Advanced configuration
 ### Hash fucntion
 Default hash fucntion is CRC32, which has better perfomance for this kind of
@@ -159,8 +264,8 @@ Suggested hash functions are:
 - FNV Hash
 - SuperFastHash
 
-## Installation
 
+## Installation
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -175,6 +280,6 @@ Or install it yourself as:
 
     $ gem install mixed_gauge
 
-## Contributing
 
+## Contributing
 Feel free to pull request and issue :)

data/lib/mixed_gauge.rb

@@ -6,7 +6,7 @@ require 'mixed_gauge/errors'
 require 'mixed_gauge/cluster_config'
 require 'mixed_gauge/config'
 require 'mixed_gauge/routing'
-require 'mixed_gauge/sub_model_repository'
+require 'mixed_gauge/shard_repository'
 require 'mixed_gauge/all_shards_in_parallel'
 require 'mixed_gauge/model'
 

data/lib/mixed_gauge/all_shards_in_parallel.rb

@@ -2,12 +2,12 @@ module MixedGauge
   # Support parallel execution with each shard and deal with AR connection
   # management in parallel execution.
   class AllShardsInParallel
-    # @param [Array<Class>] An array of sub model class
+    # @param [Array<Class>] An array of shard model class
     def initialize(shards)
       @shards = shards
     end
 
-    # @yield [Class] A sub model class
+    # @yield [Class] A shard model class
     # @return [Array] A result
     # @example
     #   User.all_shards_in_parallel.map(&:count).reduce(&:+)
@@ -19,7 +19,7 @@ module MixedGauge
       commands.map(&:get)
     end
 
-    # @yield [Class] A sub model class
+    # @yield [Class] A shard model class
     # @return [Array] A result
     # @example
     #   User.all_shards_in_parallel.flat_map {|m| m.where(age: 1) }
@@ -27,7 +27,7 @@ module MixedGauge
       map(&block).flatten
     end
 
-    # @yield [Class] A sub model class
+    # @yield [Class] A shard model class
     # @return [MixedGauge::AllShardsInParallel]
     # @example
     #   User.all_shards_in_parallel.each {|m| puts m.count }

data/lib/mixed_gauge/cluster_config.rb

@@ -9,25 +9,26 @@ module MixedGauge
       @connection_registry = {}
     end
 
-    # @param [Range] slots Range consisted with Fixnum.
-    def define_slots(slots)
-      @slots = slots
+    # @param [Integer] size The slot size of this cluster.
+    def define_slot_size(n)
+      @slots = 0..(n - 1)
     end
 
-    # @param [Range] slots
+    # @param [Range] assigned_slots The assigned range of slots of given
+    #   connection (shard).
     # @param [Symbol] connection connection name
-    def register(slots, connection)
-      @connection_registry[slots] = connection
+    def register(assigned_slots, connection)
+      @connection_registry[assigned_slots] = connection
     end
 
+    # @raise [RuntimeError]
     def validate_config!
-      # TODO
-      # validate non Fixnum slots.
+      Validator.new(slot_size, @connection_registry).validate!
     end
 
     # @return [Integer]
     def slot_size
-      @slots.size
+      defined?(@slot_size) ? @slot_size : @slot_size = @slots.size
     end
 
     # @param [Integer] slot
@@ -40,5 +41,78 @@ module MixedGauge
     def connections
       @connection_registry.values
     end
+
+    class Validator
+      # @param [Integer] slot_size
+      # @param [Hash{Range => Symbol}] connection_registry
+      def initialize(slot_size, connection_registry)
+        @slot_size = slot_size
+        @connection_registry = connection_registry
+      end
+
+      # @raise [RuntimeError]
+      def validate!
+        all_start_points = @connection_registry.keys.map(&:min).sort
+        all_end_points = @connection_registry.keys.map(&:max).sort
+
+        check_first_start_point(all_start_points.min)
+        check_coverage(all_start_points, all_end_points)
+        check_last_end_point(all_end_points.max)
+      end
+
+      private
+
+      # @param [Integer] first_start_point
+      def check_first_start_point(first_start_point)
+        unless first_start_point == 0
+          report_invalid_first_start_point(first_start_point)
+        end
+      end
+
+      # @param [Array<Integer>] all_start_points
+      # @param [Array<Integer>] all_end_points
+      def check_coverage(all_start_points, all_end_points)
+        all_end_points.each_with_index do |end_point, i|
+          break if all_end_points.size == i + 1
+
+          next_start_point = all_start_points[i + 1]
+          unless end_point.succ == next_start_point
+            report_invalid_coverage(end_point, all_start_points[i + 1])
+          end
+        end
+      end
+
+      # @param [Integer] last_end_point
+      def check_last_end_point(last_end_point)
+        unless last_end_point == @slot_size - 1
+          report_invalid_last_end_point(last_end_point)
+        end
+      end
+
+      # @param [Integer] point
+      def report_invalid_first_start_point(point)
+        r = @connection_registry.keys.find {|range| range.min == point }
+        connection = @connection_registry[r]
+        raise "First start point must be `0` but given `#{point}`: invalid slot configuration for #{connection}"
+      end
+
+      # @param [Integer] end_point
+      # @param [Integer] next_start_point
+      def report_invalid_coverage(end_point, next_start_point)
+        end_point_slot = @connection_registry.keys.find {|range| range.max == end_point }
+        end_point_connection = @connection_registry[end_point_slot]
+        start_point_slot = @connection_registry.keys.
+          find {|range| range.min == next_start_point && range.max != end_point }
+        start_point_connection = @connection_registry[start_point_slot]
+        raise %!End point `#{end_point}` of "#{end_point_connection}" or start point `#{next_start_point}` of "#{start_point_connection}" is invalid. Next start point must be "previous end point + 1".!
+      end
+
+      # @param [Integer] point
+      def report_invalid_last_end_point(point)
+        r = @connection_registry.keys.find {|range| range.max == point }
+        connection = @connection_registry[r]
+        raise "Last end point must be `#{@slot_size - 1}` but given `#{point}`: invalid slot configuration for #{connection}"
+      end
+    end
   end
 end

data/lib/mixed_gauge/config.rb

@@ -12,17 +12,14 @@ module MixedGauge
     end
 
     # Define config for specific cluster.
+    # See README.md for example.
     # @param [Symbol] cluster_name
     # @yield [MixedGauge::ClusterConfig]
-    # @example
-    #   config.define_cluster(:user) do |cluster|
-    #     cluster.define_slots(1..1048576)
-    #     cluster.register(1..524288, :production_user_001)
-    #     cluster.register(524289..1048576, :production_user_002)
-    #   end
+    # @raise [RuntimeError] When this cluster config is invalid.
     def define_cluster(cluster_name, &block)
       cluster_config = ClusterConfig.new(cluster_name)
       cluster_config.instance_eval(&block)
+      cluster_config.validate_config!
       @cluster_configs[cluster_name] = cluster_config
     end
 
@@ -34,14 +31,7 @@ module MixedGauge
 
     # Register arbitrary hash function. Hash function must be a proc and
     # must return integer.
-    # @example
-    #   # gem install fnv
-    #   require "fnv"
-    #   Mixedgauge.configure do |config|
-    #     config.register_hash_function do |key|
-    #       FNV.new.fnv1a_64(key)
-    #     end
-    #   end
+    # See README.md for example.
     def register_hash_function(&block)
       raise ArgumentError if block.arity != 1
       raise ArgumentError unless block.call('test value').is_a? Integer

data/lib/mixed_gauge/model.rb

@@ -20,7 +20,7 @@ module MixedGauge
 
     included do
       class_attribute :cluster_routing, instance_writer: false
-      class_attribute :sub_model_repository, instance_writer: false
+      class_attribute :shard_repository, instance_writer: false
       class_attribute :distkey, instance_writer: false
     end
 
@@ -30,7 +30,7 @@ module MixedGauge
       def use_cluster(name)
         config = MixedGauge.config.fetch_cluster_config(name)
         self.cluster_routing = MixedGauge::Routing.new(config)
-        self.sub_model_repository = MixedGauge::SubModelRepository.new(config, self)
+        self.shard_repository = MixedGauge::ShardRepository.new(config, self)
         self.abstract_class = true
       end
 
@@ -45,7 +45,7 @@ module MixedGauge
       # When distkey value is empty, raises MixedGauge::MissingDistkeyAttribute
       # error.
       # @param [Hash] attributes
-      # @return [ActiveRecord::Base] A sub class instance of included model
+      # @return [ActiveRecord::Base] A shard model instance
       # @raise [MixedGauge::MissingDistkeyAttribute]
       def put!(attributes)
         raise '`distkey` is not defined. Use `def_distkey`.' unless distkey
@@ -60,7 +60,7 @@ module MixedGauge
 
       # Returns nil when not found. Except that, is same as `.get!`.
       # @param [String] key
-      # @return [ActiveRecord::Base, nil] A sub model instance of included model
+      # @return [ActiveRecord::Base, nil] A shard model instance
       def get(key)
         raise 'key must be a String' unless key.is_a?(String)
         shard_for(key.to_s).find_by(distkey => key)
@@ -70,7 +70,7 @@ module MixedGauge
       # `ActiveRecord::RecordNotFound` so you can rescue that exception as same
       # as AR's RecordNotFound.
       # @param [String] key
-      # @return [ActiveRecord::Base] A sub model instance of included model
+      # @return [ActiveRecord::Base] A shard model instance
       # @raise [MixedGauge::RecordNotFound]
       def get!(key)
         get(key) or raise MixedGauge::RecordNotFound
@@ -93,22 +93,21 @@ module MixedGauge
         @before_put_callback = block
       end
 
-      # Returns a generated sub class of this model which is connected proper
-      # shard for given key.
+      # Returns a generated model class of included model class which has proper
+      # connection config for the shard for given key.
       # @param [String] key A value of distkey
-      # @return [Class] A sub model for this distkey value
+      # @return [Class] A generated model class for given distkey value
       def shard_for(key)
         connection_name = cluster_routing.route(key.to_s)
-        sub_model_repository.fetch(connection_name)
+        shard_repository.fetch(connection_name)
       end
 
-      # Returns all generated sub class of this model. Useful to query to
-      # all shards.
-      # @return [Array<Class>] An array of sub models
+      # Returns all generated shard model class. Useful to query to all shards.
+      # @return [Array<Class>] An array of shard models
       # @example
       #   User.all_shards.flat_map {|m| m.find_by(name: 'alice') }.compact
       def all_shards
-        sub_model_repository.all
+        shard_repository.all
       end
 
       # @return [Mixedgauge::AllShardsInParallel]

data/lib/mixed_gauge/routing.rb

@@ -7,6 +7,7 @@ module MixedGauge
       @cluster_config = cluster_config
     end
 
+    # slot can be one of (0..slot_size - 1)
     # @param [String] dist_key
     # @return [String] connection name
     def route(key)

data/lib/mixed_gauge/{sub_model_repository.rb → shard_repository.rb}

@@ -1,5 +1,5 @@
 module MixedGauge
-  class SubModelRepository
+  class ShardRepository
     attr_reader :base_class
 
     # @param [ClusterConfig] cluster_config
@@ -7,32 +7,33 @@ module MixedGauge
     def initialize(cluster_config, base_class)
       @base_class = base_class
 
-      sub_models = cluster_config.connections.map do |connection_name|
-        [connection_name, generate_sub_model(connection_name)]
+      shards = cluster_config.connections.map do |connection_name|
+        [connection_name, generate_model_for_shard(connection_name)]
       end
-      @sub_models = Hash[sub_models]
+      @shards = Hash[shards]
     end
 
     # @param [Symbol] connection_name
-    # @return [Class] A sub model of given base class
+    # @return [Class] A model class for this shard
     def fetch(connection_name)
-      @sub_models.fetch(connection_name)
+      @shards.fetch(connection_name)
     end
 
     # @return [Array<Class>]
     def all
-      @sub_models.values
+      @shards.values
     end
 
     private
 
     # @param [Symbol] connection_name
-    # @return [Class] A generated sub class of given AR model
-    def generate_sub_model(connection_name)
+    # @return [Class] A sub class of given AR model.
+    #   A sub class has connection setting for specific shard.
+    def generate_model_for_shard(connection_name)
       base_class_name = @base_class.name
       class_name = generate_class_name(connection_name)
 
-      sub_model = Class.new(base_class) do
+      model = Class.new(base_class) do
         self.table_name = base_class.table_name
         module_eval <<-RUBY, __FILE__, __LINE__ + 1
           def self.name
@@ -40,14 +41,14 @@ module MixedGauge
           end
         RUBY
       end
-      sub_model.class_eval { establish_connection(connection_name) }
-      sub_model
+      model.class_eval { establish_connection(connection_name) }
+      model
     end
 
-    # @param [Symbol] name
+    # @param [Symbol] connection_name
     # @return [String]
-    def generate_class_name(name)
-      "GeneratedModel#{name.to_s.gsub('-', '_').classify}"
+    def generate_class_name(connection_name)
+      "ShardFor#{connection_name.to_s.gsub('-', '_').classify}"
     end
   end
 end

data/lib/mixed_gauge/version.rb

@@ -1,3 +1,3 @@
 module MixedGauge
-  VERSION = '0.2.1'
+  VERSION = '1.0.0'
 end

data/mixed_gauge.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Taiki Ono']
   spec.email         = ['taiks.4559@gmail.com']
 
-  spec.summary       = %{An ActiveRecord extension for database sharding including re-sharding support.}
-  spec.description   = %{#{spec.summary} Offers shards management with hash slots, re-sharding support, key-value action, some ActiveRecord::Base actions.}
+  spec.summary       = %{A simple and robust ActiveRecord extension for database sharding.}
+  spec.description   = %{#{spec.summary} Supports shards management with hash slots, re-sharding support, efficient KVS queries, limited RDB queries.}
   spec.homepage      = 'https://github.com/taiki45/mixed_gauge'
   spec.license       = 'MIT'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mixed_gauge
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Taiki Ono
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-06-02 00:00:00.000000000 Z
+date: 2015-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -164,9 +164,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: An ActiveRecord extension for database sharding including re-sharding
-  support. Offers shards management with hash slots, re-sharding support, key-value
-  action, some ActiveRecord::Base actions.
+description: A simple and robust ActiveRecord extension for database sharding. Supports
+  shards management with hash slots, re-sharding support, efficient KVS queries, limited
+  RDB queries.
 email:
 - taiks.4559@gmail.com
 executables: []
@@ -199,7 +199,7 @@ files:
 - lib/mixed_gauge/model.rb
 - lib/mixed_gauge/railtie.rb
 - lib/mixed_gauge/routing.rb
-- lib/mixed_gauge/sub_model_repository.rb
+- lib/mixed_gauge/shard_repository.rb
 - lib/mixed_gauge/version.rb
 - lib/tasks/mixed_gauge.rake
 - mixed_gauge.gemspec
@@ -223,9 +223,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: An ActiveRecord extension for database sharding including re-sharding support.
+summary: A simple and robust ActiveRecord extension for database sharding.
 test_files: []
 has_rdoc: