redis_ring 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in redis_ring.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    redis_ring (0.0.1)
+      json
+      sinatra
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    json (1.5.1)
+    mocha (0.9.12)
+    rack (1.2.1)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    sinatra (1.1.3)
+      rack (~> 1.1)
+      tilt (>= 1.2.2, < 2.0)
+    tilt (1.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mocha
+  redis_ring!
+  rspec

data/MIT-LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Adam Pohorecki, http://adam.pohorecki.pl/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "./spec/**/*_spec.rb"
+  t.rspec_opts = ["--profile --color"]
+end

data/bin/redis-ring

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$:.push File.expand_path("../../lib", __FILE__)
+
+require 'redis_ring'
+
+RedisRing::CLI.new(ARGV).run

data/config/redis-ring.sample.yml

@@ -0,0 +1,32 @@
+# By default RedisRing tries to guess the local IP address
+# setting host_name should be necessary only if that is not possible
+#host_name: localhost
+
+# This is the port on which RedisRing publishes it's HTTP interface
+# The Redis instances use ring_size next ports
+base_port: 6400
+
+# The number of Redis instances to start. Morte means more memory overhead (about 1MB per instance),
+# but more means also easier moving around parts of the database
+ring_size: 32
+
+# By default which redis-server is used. Overwrite this setting if redis-server is not in PATH
+#redis_path: /path/to/redis-server
+
+# By default config/redis.conf.erb from the gem is used, but you can also supply your own.
+# You can also change the redis server settings using the shared_config.conf file in base directory
+#redis_config_template_path: /path/to/redis.conf.erb
+
+# You can specify how much should Virtual Memory take in bytes (overall, not per Redis instance)
+total_vm_size: 8589934592 #8GB
+vm_page_size: 32
+
+# This is the root directory under which all files will be stored
+base_directory: /var/lib/redis
+
+# Like with Virtual Memory, you can also specify how much memory all the Redis instances should take together
+total_max_memory: 1073741824 # 1GB
+
+# This is the password that will be used by all Redis instances. Remember that a huge number of passwords can be
+# chacked in a second, so use a strong one. By default there is no password.
+#password: letmein

data/config/redis.conf.erb

@@ -0,0 +1,49 @@
+daemonize no
+
+port <%= port %>
+logfile <%= log_file %>
+dir <%= working_directory %>
+vm-swap-file <%= vm_swap_file %>
+vm-max-memory <%= vm_max_memory %>
+vm-pages <%= vm_pages %>
+vm-page-size <%= vm_page_size %>
+dbfilename <%= db_file_name %>
+appendfilename <%= aof_file_name %>
+# slaveof <masterip> <masterport>
+<% if password %>
+  requirepass <%= password %>
+<% end %>
+
+timeout 300
+
+loglevel notice
+
+databases 2048
+
+save 900 1
+save 300 10
+save 60 10000
+
+rdbcompression yes
+
+# maxclients 128
+# maxmemory <bytes>
+
+appendonly no
+
+# The name of the append only file (default: "appendonly.aof")
+
+# appendfsync always
+appendfsync everysec
+# appendfsync no
+
+vm-enabled yes
+vm-max-threads 4
+
+glueoutputbuf yes
+hash-max-zipmap-entries 64
+hash-max-zipmap-value 512
+
+activerehashing yes
+
+include <%= common_config_path %>

data/lib/redis_ring/application.rb

@@ -0,0 +1,47 @@
+module RedisRing
+
+  class Application
+
+    attr_reader :shards, :configuration
+
+    def initialize(configuration)
+      @configuration = configuration
+      @shards = {}
+    end
+
+    def start
+      self.stop
+
+      @configuration.ring_size.times do |shard_number|
+        shard_conf = ShardConfig.new(shard_number, configuration)
+        @shards[shard_number] = Shard.new(shard_conf)
+      end
+
+      @shards.each do |shard_no, shard|
+        shard.start
+      end
+    end
+
+    def stop
+      @shards.each do |shard_no, shard|
+        shard.stop
+      end
+      @shards = {}
+    end
+
+    def shards_hash
+      shards_hash = {}
+      shards.each do |shard_no, shard|
+        shards_hash[shard_no] = { :host => shard.host, :port => shard.port, :status => shard.status }
+      end
+
+      return { :count => configuration.ring_size, :shards => shards_hash }
+    end
+
+    class << self
+      attr_accessor :instance
+    end
+
+  end
+
+end

data/lib/redis_ring/cli.rb

@@ -0,0 +1,53 @@
+module RedisRing
+
+  class CLI
+
+    COMMANDS = [:help, :start]
+
+    attr_reader :argv
+
+    def initialize(argv)
+      @argv = argv
+    end
+
+    def run
+      command = argv[0]
+      if command.nil? || !COMMANDS.include?(command.to_sym)
+        usage
+        exit(1)
+      else
+        send(command, *argv[1..-1])
+        exit(0)
+      end
+    end
+
+    protected
+
+    def help
+      usage
+    end
+
+    def usage
+      puts <<USAGE
+Usage:
+  #{$0} command [arguments]
+
+Commands:
+  help - prints this message
+
+  start [config_file] - starts application
+USAGE
+    end
+
+    def start(config_file = nil)
+      config = config_file ? Configuration.from_yml_file(config_file) : Configuration.new
+
+      Application.instance = Application.new(config)
+      Application.instance.start
+
+      WebInterface.run!(:port => config.base_port)
+    end
+
+  end
+
+end

data/lib/redis_ring/configuration.rb

@@ -0,0 +1,79 @@
+module RedisRing
+
+  class ConfigurationError < StandardError; end
+  class RedisNotFound < ConfigurationError; end
+  class UnknownConfigurationParameter < ConfigurationError; end
+
+  class Configuration
+
+    PARAMETERS = [:host_name, :base_port, :ring_size, :redis_path, :redis_config_template_path,
+      :total_vm_size, :base_directory, :password, :total_max_memory, :vm_page_size]
+
+    attr_reader *PARAMETERS
+
+    def initialize(params = {})
+      set_params(params)
+      set_defaults
+      validate!
+    end
+
+    def self.from_yml_file(file_name)
+      return from_yml(File.read(file_name))
+    end
+
+    def self.from_yml(string)
+      args = YAML::load(string)
+      return new(args)
+    end
+
+    protected
+
+    attr_writer *PARAMETERS
+
+    def set_params(params)
+      params.each do |param, value|
+        if PARAMETERS.include?(param.to_sym)
+          self.send("#{param}=", value)
+        else
+          raise UnknownConfigurationParameter.new("Unknown configuration parameter: #{param.inspect}")
+        end
+      end
+    end
+
+    def set_defaults
+      self.host_name ||=  guess_host_name
+      self.base_port ||= 6400
+      self.ring_size ||= 32
+      self.redis_path ||= locate_redis
+      self.redis_config_template_path ||= default_redis_config_template_path
+      self.total_vm_size ||= 8 * 1024 * 1024 * 1024 # 8GB
+      self.base_directory ||= "/var/lib/redis"
+      self.total_max_memory ||= 1024 * 1024 * 1024 # 1GB
+      self.vm_page_size ||= 32
+    end
+
+    def validate!
+      raise RedisNotFound.new("redis_path is invalid (not found)") unless File.file?(redis_path)
+    end
+
+    def guess_host_name
+      orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true  # turn off reverse DNS resolution temporarily
+      UDPSocket.open do |s|
+        s.connect '64.233.187.99', 1
+        return s.addr.last
+      end
+    ensure
+      Socket.do_not_reverse_lookup = orig
+    end
+
+    def locate_redis
+      return %x[which redis-server].strip
+    end
+
+    def default_redis_config_template_path
+      File.expand_path('../../../config/redis.conf.erb', __FILE__)
+    end
+
+  end
+
+end

data/lib/redis_ring/shard.rb

@@ -0,0 +1,61 @@
+module RedisRing
+
+  class Shard
+
+    attr_reader :shard_config, :pid
+
+    def initialize(shard_config)
+      @shard_config = shard_config
+      @status = :stopped
+    end
+
+    def shard_number
+      shard_config.shard_number
+    end
+
+    def host
+      shard_config.host
+    end
+
+    def port
+      shard_config.port
+    end
+
+    def status
+      if @status == :stopped
+        return alive? ? :stopping : :stopped
+      elsif @status == :started
+        return alive? ? :running : :dead
+      else
+        raise RuntimeException.new("Unknown status: #{@status.inspect}")
+      end
+    end
+
+    def start
+      shard_config.save
+      @pid = fork_redis_server
+      @status = :started
+    end
+
+    def stop
+      send_kill_signal
+      @status = :stopped
+    end
+
+    protected
+
+    def alive?
+      @pid && File.exist?("/proc/#{@pid}")
+    end
+
+    def fork_redis_server
+      spawn(shard_config.redis_path, shard_config.config_file_name)
+    end
+
+    def send_kill_signal
+      system("kill -QUIT #{pid}")
+    end
+
+  end
+
+end

data/lib/redis_ring/shard_config.rb

@@ -0,0 +1,93 @@
+module RedisRing
+
+  class ShardConfig
+
+    attr_reader :shard_number, :configuration
+
+    def initialize(shard_number, configuration)
+      @shard_number = shard_number
+      @configuration = configuration
+    end
+
+    def render
+      template = ERB.new(File.read(configuration.redis_config_template_path))
+      return template.result(binding)
+    end
+
+    def save
+      FileUtils.mkdir_p(working_directory)
+
+      ['configs', 'logs', 'vm_files', 'db_files'].each do |dir_name|
+        FileUtils.mkdir_p(File.join(configuration.base_directory, dir_name))
+      end
+
+      FileUtils.touch(common_config_path) unless File.exist?(common_config_path)
+
+      File.open(config_file_name, 'w') { |f| f.write(render) }
+    end
+
+    def config_file_name
+      File.join(configuration.base_directory, 'configs', "shard-#{shard_number}.conf")
+    end
+
+    def host
+      configuration.host_name
+    end
+
+    def port
+      configuration.base_port + shard_number + 1
+    end
+
+    def redis_path
+      configuration.redis_path
+    end
+
+    def log_file
+      File.expand_path(file('logs', "shard-#{shard_number}.log"), working_directory)
+    end
+
+    def working_directory
+      "#{configuration.base_directory}/work/shard-#{shard_number}"
+    end
+
+    def vm_swap_file
+      file('vm_files', "shard-#{shard_number}.swap")
+    end
+
+    def vm_max_memory
+      configuration.total_max_memory / configuration.ring_size
+    end
+
+    def vm_pages
+      configuration.total_vm_size / configuration.vm_page_size / configuration.ring_size
+    end
+
+    def vm_page_size
+      configuration.vm_page_size
+    end
+
+    def db_file_name
+      file('db_files', "shard-#{shard_number}.rdb")
+    end
+
+    def aof_file_name
+      file('db_files', "shard-#{shard_number}.aof")
+    end
+
+    def password
+      configuration.password
+    end
+
+    def common_config_path
+      File.join(configuration.base_directory, "shared_config.conf")
+    end
+
+    protected
+
+    def file(*parts)
+      File.join('..', '..', *parts)
+    end
+
+  end
+
+end

data/lib/redis_ring/version.rb

@@ -0,0 +1,3 @@
+module RedisRing
+  VERSION = "0.0.1"
+end

data/lib/redis_ring/web_interface.rb

@@ -0,0 +1,16 @@
+module RedisRing
+
+  class WebInterface < Sinatra::Base
+
+    get "/" do
+      "RedisRing is running"
+    end
+
+    get "/shards" do
+      content_type :json
+      Application.instance.shards_hash.to_json
+    end
+
+  end
+
+end

data/lib/redis_ring.rb

@@ -0,0 +1,14 @@
+require 'socket'
+require 'yaml'
+require 'erb'
+require 'fileutils'
+
+require 'sinatra'
+require 'json'
+
+require 'redis_ring/configuration'
+require 'redis_ring/shard_config'
+require 'redis_ring/shard'
+require 'redis_ring/application'
+require 'redis_ring/web_interface'
+require 'redis_ring/cli'

data/redis_ring.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "redis_ring/version"
+
+Gem::Specification.new do |s|
+  s.name        = "redis_ring"
+  s.version     = RedisRing::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Adam Pohorecki"]
+  s.email       = ["adam@pohorecki.pl"]
+  s.homepage    = "http://github.com/psyho/redis_ring"
+  s.summary     = %q{A simplistic solution to redis sharding}
+  s.description = %q{RedisRing is a solution to run multiple small Redis instances intead of a single large one.}
+
+  s.rubyforge_project = "redis_ring"
+
+  s.add_dependency 'sinatra'
+  s.add_dependency 'json'
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'mocha'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/redis_ring/application_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe RedisRing::Application do
+
+  describe "#shards_hash" do
+    before(:each) do
+      RedisRing::Shard.any_instance.stubs(:fork_redis_server => 123)
+      RedisRing::ShardConfig.any_instance.stubs(:save)
+      RedisRing::ShardConfig.any_instance.stubs(:alive? => true)
+
+      @application = RedisRing::Application.new(RedisRing::Configuration.new)
+      @application.start
+    end
+
+    it "should return all shards" do
+      shard_hash = @application.shards_hash
+
+      shard_hash[:count].should == @application.configuration.ring_size
+      shard_hash[:shards].size.should == @application.configuration.ring_size
+    end
+  end
+
+end

data/spec/redis_ring/configuration_spec.rb

@@ -0,0 +1,82 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe RedisRing::Configuration do
+  describe "defaults" do
+    before(:each) do
+      @config = RedisRing::Configuration.new
+    end
+
+    it "should have default port" do
+      @config.base_port.should_not be_nil
+      @config.base_port.should be_an_instance_of(Fixnum)
+    end
+
+    it "should have default host" do
+      @config.host_name.should_not be_nil
+      @config.host_name.should =~ /\d+\.\d+\.\d+.\d+/
+    end
+
+    it "should have default ring_size" do
+      @config.ring_size.should_not be_nil
+      @config.base_port.should be_an_instance_of(Fixnum)
+      @config.base_port.should > 0
+    end
+
+    it "should have default redis_path" do
+      @config.redis_path.should_not be_nil
+      File.exist?(@config.redis_path).should be_true
+    end
+
+    it "should have default redis_config_template_path" do
+      @config.redis_config_template_path.should_not be_nil
+      File.exist?(@config.redis_config_template_path).should be_true
+    end
+
+    it "should have default total_vm_size" do
+      @config.total_vm_size.should_not be_nil
+      @config.total_vm_size.should > 0
+    end
+
+    it "should have default base_directory" do
+      @config.base_directory.should_not be_nil
+    end
+
+    it "should have no password by default" do
+      @config.password.should be_nil
+    end
+
+    it "should have default total_memory" do
+      @config.total_max_memory.should_not be_nil
+      @config.total_max_memory.should > 0
+    end
+
+    it "should have default vm_page_size" do
+      @config.vm_page_size.should_not be_nil
+      @config.vm_page_size.should > 0
+    end
+  end
+
+  it "should rise RedisNotFound exception if redis-server not found" do
+    lambda {
+      RedisRing::Configuration.new(:redis_path => '/this/does/not/exist')
+    }.should raise_exception(RedisRing::RedisNotFound)
+  end
+
+  it "should rise UnknownConfigurationParameter exception if an unknown configuration parameter is given" do
+    lambda {
+      RedisRing::Configuration.new(:unknown_parameter => 'some value')
+    }.should raise_exception(RedisRing::UnknownConfigurationParameter)
+  end
+
+  it "should load yml config" do
+    yml_string = <<-YML
+    base_port: 666
+    base_directory: /home/psyho/redis
+    YML
+
+    config = RedisRing::Configuration.from_yml(yml_string)
+
+    config.base_port.should == 666
+    config.base_directory.should == '/home/psyho/redis'
+  end
+end

data/spec/redis_ring/shard_config_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe RedisRing::ShardConfig do
+  it "should render redis config with default config variables" do
+    config = RedisRing::Configuration.new
+    shard_config = RedisRing::ShardConfig.new(0, config)
+
+    redis_conf = shard_config.render
+
+    redis_conf.should include((config.base_port + 1).to_s)
+    redis_conf.should include(config.base_directory)
+  end
+end

data/spec/redis_ring/shard_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe RedisRing::Shard do
+
+  describe "possible statuses" do
+    before(:each) do
+      @shard = RedisRing::Shard.new(RedisRing::ShardConfig.new(0, RedisRing::Configuration.new))
+      @pid = 123
+      @shard.shard_config.stubs(:save)
+      @shard.stubs(:fork_redis_server => @pid)
+      @shard.stubs(:send_kill_signal)
+    end
+
+    it "should be stopped initially" do
+      @shard.status.should == :stopped
+    end
+
+    it "should be running if started and alive" do
+      @shard.stubs(:alive? => true)
+      @shard.start
+
+      @shard.status.should == :running
+    end
+
+    it "should be stopping if started then stopped but still alive" do
+      @shard.stubs(:alive? => true)
+      @shard.start
+      @shard.stop
+
+      @shard.status.should == :stopping
+    end
+
+    it "should be stopped if started then stopped and not alive" do
+      @shard.stubs(:alive? => false)
+      @shard.start
+      @shard.stop
+
+      @shard.status.should == :stopped
+    end
+
+    it "should be dead if started but not alive" do
+      @shard.stubs(:alive? => false)
+      @shard.start
+
+      @shard.status.should == :dead
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'redis_ring'
+
+RSpec.configure do |c|
+  c.color_enabled = true
+  c.mock_with :mocha
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification 
+name: redis_ring
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Adam Pohorecki
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-08 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: RedisRing is a solution to run multiple small Redis instances intead of a single large one.
+email: 
+- adam@pohorecki.pl
+executables: 
+- redis-ring
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE.txt
+- Rakefile
+- bin/redis-ring
+- config/redis-ring.sample.yml
+- config/redis.conf.erb
+- lib/redis_ring.rb
+- lib/redis_ring/application.rb
+- lib/redis_ring/cli.rb
+- lib/redis_ring/configuration.rb
+- lib/redis_ring/shard.rb
+- lib/redis_ring/shard_config.rb
+- lib/redis_ring/version.rb
+- lib/redis_ring/web_interface.rb
+- redis_ring.gemspec
+- spec/redis_ring/application_spec.rb
+- spec/redis_ring/configuration_spec.rb
+- spec/redis_ring/shard_config_spec.rb
+- spec/redis_ring/shard_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/psyho/redis_ring
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: redis_ring
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A simplistic solution to redis sharding
+test_files: []
+