switch_board 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 91e063073337aaae7434db2dfac68242ede19862
+  data.tar.gz: 69c598242c91f8cae70bc15e1d36bd1bec949fc4
+SHA512:
+  metadata.gz: 710f0b21c6665cfaa75493c1fa3c02a464a45ed8589c5542868573558b180d9b3d6cc193132b230656139fbc972b033da111811ee72670696daf95e2db04d0a7
+  data.tar.gz: 50449a1bb33c60dec1cbc2e4673f5b71ce99d44428d2dcc2d5b8c1978526a8456a561111e1f9a5fe9a1f6a23e7deb6b8f96ced6fadfb78da1cb6cf12a02f104c

data/.document

@@ -0,0 +1,4 @@
+lib/**/*.rb
+README.rdoc
+ChangeLog.rdoc
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,3 @@
+html/
+pkg/
+*.gem

data/.rspec

@@ -0,0 +1 @@
+--colour --format documentation

data/.ruby-gemset

@@ -0,0 +1 @@
+switch_board

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.0.0-p247

data/ChangeLog.rdoc

@@ -0,0 +1,4 @@
+=== 0.1.0 / 2013-07-16
+
+* Initial release:
+

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rdoc'
+gem 'rubygems-tasks'
+
+#For the redis dataset
+gem 'redis'
+gem 'redis-objects'
+gem 'rsolr'
+
+group :test do
+  gem 'rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    switch_board (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    builder (3.2.2)
+    diff-lcs (1.2.4)
+    json (1.8.0)
+    rdoc (4.0.1)
+      json (~> 1.4)
+    redis (3.0.2)
+    redis-objects (0.6.1)
+      redis (>= 3.0.2)
+    rsolr (1.0.9)
+      builder (>= 2.1.2)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.3)
+    rspec-expectations (2.14.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.1)
+    rubygems-tasks (0.2.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rdoc
+  redis
+  redis-objects
+  rsolr
+  rspec
+  rubygems-tasks
+  switch_board!

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Avner Cohen
+
+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/README.md

@@ -0,0 +1,78 @@
+## switch_board
+
+![http://makemusicals.com/2011/11/communication-101-toeing-the-party-line/switchboard1/](http://makemusicals.com/wp-content/uploads/2011/11/switchboard1-300x236.jpg "Switchboard")
+
+### Description
+
+**SwitchBoard** is a utility gem designed to help in the coordination of locked objects by a set of "lockers".
+Think of a bank's cashiers, where customers are in line to be served.
+When a customer is served by a cashier, it is still in line to be served, but is now "locked".
+
+Locking expiration is allowed so that if during "serving" a cashier got some other business to do and runs home, it will go back to the queue when lock expires.
+
+The overall scope of the gem is:
+
+* Allow "lockers" to register themselves
+* Allow "lockers" to set a "lock" on object, with a predefined expiration period
+* Allow lockers with special "roles" to force locks
+* Allow external observes to see current state of locked object
+
+### Features
+
+The system is light weight and is designed to have low number of "lockers" with many object to be locked.
+It is pluggable and well tested so should allow extensions as needed.
+
+### Examples
+
+````ruby
+
+  require 'switch_board'
+
+
+  #create a new switch_board configuration
+  sb = SwitchBoard::Configuration.new #Redis backends
+  dataset = sb.dataset
+
+  #Register Lockers (unique identifier, Name/Alias)
+  dataset.register_locker(1, "Django")
+  dataset.register_locker(2, "Pier")
+  dataset.register_locker(3, "Mark")
+
+  #Print out the list of active users
+  p dataset.list_lockers
+
+  #Lock IDs for Pier - IDed as 2
+  dataset.lock_id(2, "qwerfggj", 5) # lock for 5 seconds
+  dataset.lock_id(2, "12345", 600) #Lock for 10 minutes
+
+  #Check to see if ID is locked
+  dataset.id_locked?("12345") #=> true
+  dataset.id_locked?("qwerfggj") #=> true
+  dataset.id_locked?("not_locked_id") #=> false
+  
+  #Show all locked objects
+  dataset.get_all_locked_ids #=> {"12345"=>"2", "qwerfggj"=>"2"}
+
+````
+### Other Gems
+
+Worth mentioning that there are other nice gems that takes care of Redis-backed Mutex implementaion:
+
+* https://github.com/dv/redis-semaphore
+* https://github.com/mlanett/redis-lock
+* https://github.com/kenn/redis-mutex
+
+However, this gem is not target a protection on specific a single resource during operation,
+instead it is targated to manage Distrbition of work between multiple clients/lockers that can take longer time to process the locked resources.
+It is also not targated for high scale systems, locking is done by humans so there is little to no risk in race conditions.
+And lastly, the gem provides an API to get all currently locked IDs which is important for the "switch_board" problem where some high level managment of the currently locked ID is needed.
+
+
+### Install
+
+````
+  $ gem install switch_board
+````
+### Copyright
+
+See LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'rake'
+
+begin
+  gem 'rubygems-tasks', '~> 0.2'
+  require 'rubygems/tasks'
+
+  Gem::Tasks.new
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install rubygems-tasks` to install Gem::Tasks."
+end
+
+begin
+  gem 'rdoc', '~> 3.0'
+  require 'rdoc/task'
+
+  RDoc::Task.new do |rdoc|
+    rdoc.title = "switch_board"
+  end
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install rdoc` to install 'rdoc/task'."
+end
+task :doc => :rdoc
+
+begin
+  gem 'rspec', '~> 2.4'
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new
+rescue LoadError => e
+  task :spec do
+    abort "Please run `gem install rspec` to install RSpec."
+  end
+end
+
+task :test    => :spec
+task :default => :spec

data/lib/switch_board/configuration.rb

@@ -0,0 +1,13 @@
+require 'switch_board/datasets/redis_dataset'
+
+module SwitchBoard
+
+  class Configuration
+    attr_accessor  :dataset
+
+    def initialize(dataset = SwitchBoard::RedisDataset.new)
+      @dataset = dataset
+    end
+
+  end
+end

data/lib/switch_board/datasets/abstract_dataset.rb

@@ -0,0 +1,62 @@
+#define API for the data set
+module SwitchBoard
+  class AbstractDataset
+
+    attr_accessor :persistance
+
+    def set_persistance(persistance)
+      @persistance = persistance
+    end
+
+    #Returns the next Model/ID that is available from the dataset
+    def get_next(limit = 1)
+      raise "#{__method__} not implemented in #{self.class.name}"
+    end
+
+    #get the IDs that are now locked by other lockers
+    def get_locked
+      raise "#{__method__} not implemented in #{self.class.name}"
+    end
+
+    #setup a new switchboard, a coordination persistence schema
+    def switchboard
+      raise "#{__method__} not implemented in #{self.class.name}"
+    end
+
+   #Add a new locker to the switchboard for future coordination
+    def register_locker(uid, name)
+      raise "#{__method__} not implemented in #{self.class.name}"
+    end
+
+    #list all the lockers registerd for this switchboard
+    def list_lockers
+      raise "#{__method__} not implemented in #{self.class.name}"
+    end 
+
+    #list retrive data of a specific locker
+    def locker(uid)
+      raise "#{__method__} not implemented in #{self.class.name}"
+    end 
+
+    #Set ID of an object as locked for a specific uid
+    def lock_id(locker_uid, id_to_lock, expire_in_sec = 60)
+      raise "#{__method__} not implemented in #{self.class.name}"
+    end
+
+    #Set ID of an object as locked for a specific uid
+    def unlock_id(locker_uid, id_to_unlock)
+      raise "#{__method__} not implemented in #{self.class.name}"
+    end
+
+    #Check to see if a certain ID is locked or not
+    def id_locked?(uid)
+      raise "#{__method__} not implemented in #{self.class.name}"
+    end
+
+    #Retrive all the locked ids in the switchboard
+    def get_all_locked_ids
+      raise "#{__method__} not implemented in #{self.class.name}"
+    end
+
+  end
+end

data/lib/switch_board/datasets/redis_dataset.rb

@@ -0,0 +1,102 @@
+require 'switch_board/datasets/abstract_dataset'
+require "redis"
+require 'json'
+
+module SwitchBoard
+
+  class RedisDataset < SwitchBoard::AbstractDataset
+
+     
+    LOCK_MAP_KEY = "switch_board::locked_ids"
+    attr_accessor  :con, :switchboard, :name
+
+    def initialize(host = "127.0.0.1", port = 6379, name = "redis_switchbord")
+      @con = Redis.new(:host => host, :port => port)
+      @name = name
+    end
+
+    def cleanup
+      ## clean up keys, used mainly for testing
+      @con.del @name
+      @con.del "#{LOCK_MAP_KEY}_z"
+      @con.del "#{LOCK_MAP_KEY}_h"
+    end
+
+    def get_locked
+      active_lockers = list_lockers.map { |item| JSON.parse(item)}
+      active_lockers
+    end
+
+    def switchboard
+      @switchboard ||= @con.smembers @name
+    end
+
+    def register_locker(uid, name)
+      @con.sadd @name, {uid: uid, name: name, created_at: redis_time}.to_json.to_s
+      list_lockers ## update lockers list
+      true
+    end
+
+    def list_lockers
+      list_lockers ||= (@con.smembers @name).map { |item| JSON.parse(item)}
+    end
+
+    def locker(uid)
+      (list_lockers.select {|locker| locker["uid"] == uid}).first
+    end
+
+    #Locking mechanisem is based on sorted set, sorted set is used to allow a simulation
+    # of expiration time on the keys in the map
+    def lock_id(locker_uid, id_to_lock, expire_in_sec = 5)
+      now = redis_time
+      @con.multi do
+        @con.zadd("#{LOCK_MAP_KEY}_z", (now + expire_in_sec), id_to_lock)
+        @con.hset("#{LOCK_MAP_KEY}_h", id_to_lock, locker_uid)
+      end
+    end
+
+    #Check if key exists to see if it is locked and it has not expired
+    #before getting keys, remove expired keys
+    def id_locked?(id_to_check)
+      @con.hexists("#{LOCK_MAP_KEY}_h", id_to_check)
+    end
+
+
+    def unlock_id(locker_uid, id_to_unlock)
+      @con.hset("#{LOCK_MAP_KEY}_h", id_to_lock, locker_uid)
+    end
+
+    def get_all_locked_ids
+      clean_old_keys
+      @con.hgetall "#{LOCK_MAP_KEY}_h"
+    end
+
+    def get_all_their_locked_ids(uid)
+      res = get_all_locked_ids
+      res.reject {|key, key_uid|  key_uid.to_s == uid.to_s }
+    end
+
+    def get_all_my_locked_ids(uid)
+      res = get_all_locked_ids
+      res.select {|key, key_uid|  key_uid.to_s == uid.to_s }
+    end
+    
+    ##################### Private Methods #################
+    private
+
+    def clean_old_keys
+      keys = @con.zrangebyscore("#{LOCK_MAP_KEY}_z", 0, redis_time)
+      if keys.size > 0
+        @con.zremrangebyscore("#{LOCK_MAP_KEY}_z", 0, redis_time)
+        keys.each {|key| @con.hdel("#{LOCK_MAP_KEY}_h", key)}
+      end
+    end
+
+    def redis_time
+      instant = @con.time
+      Time.at(instant[0], instant[1]).to_i
+    end    
+
+  end
+
+end

data/lib/switch_board/version.rb

@@ -0,0 +1,3 @@
+module SwitchBoard
+  VERSION = "0.1.0"
+end

data/lib/switch_board.rb

@@ -0,0 +1,26 @@
+require 'switch_board/version'
+require 'switch_board/configuration'
+
+module SwitchBoard
+
+ def self.logger
+    @logger ||= (rails_logger || default_logger)
+  end
+
+  def self.rails_logger
+    (defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger) ||
+    (defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:debug) && RAILS_DEFAULT_LOGGER)
+  end
+
+  def self.default_logger
+    require 'logger'
+    l = Logger.new(STDOUT)
+    l.level = Logger::INFO
+    l
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+end

data/run_test

@@ -0,0 +1 @@
+rspec ./spec/**.*

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rspec'
+
+Dir["#{File.dirname(__FILE__)}/../lib/**/*.rb"].each { |f| load(f)  }

data/spec/switch_board_spec.rb

@@ -0,0 +1,166 @@
+describe SwitchBoard do
+  it "should have a VERSION constant" do
+    subject.const_get('VERSION').should_not be_empty
+  end
+
+  it "should have a logger defined" do
+    subject.logger.should_not be_nil
+  end
+
+  it "should have good working logger" do
+    subject.logger.should respond_to(:info, :error, :debug)
+  end
+end
+
+describe :Configuration do
+  it "should have a dataset" do
+    conf = SwitchBoard::Configuration.new(SwitchBoard::RedisDataset.new("127.0.0.1", 6379, "testing_playground"))
+    conf.should respond_to(:dataset)
+  end
+end
+
+describe :ApplicationLifeCycle do
+    it "should not lose locks with multiple workers starting a new dataset" do
+      dataset1 = SwitchBoard::Configuration.new(SwitchBoard::RedisDataset.new("127.0.0.1", 6379, "testing_playground")).dataset
+      dataset1.cleanup
+      dataset1.register_locker(1, "Moshe")
+      dataset1.list_lockers.count.should eq 1
+      dataset2 = SwitchBoard::Configuration.new(SwitchBoard::RedisDataset.new("127.0.0.1", 6379, "testing_playground")).dataset
+      #dataset1 should still show single locker
+      dataset1.list_lockers.count.should eq 1
+  end
+
+  it "should be possible to name switchboard dataset" do
+    dataset = SwitchBoard::RedisDataset.new("127.0.0.1", 6379, "testing_playground")
+    dataset.name.should eq "testing_playground"
+  end
+end
+
+describe :RedisDataset do
+  let!(:dataset) {
+      dataset = SwitchBoard::Configuration.new(SwitchBoard::RedisDataset.new("127.0.0.1", 6379, "testing_playground")).dataset
+      dataset.cleanup
+      dataset
+    }
+
+  it "should implemenet get_locked" do
+    expect { dataset.get_locked }.not_to raise_error
+  end
+
+  describe :RedisDatasetSwitchBoard do
+    let!(:switchboard) {SwitchBoard::Configuration.new(SwitchBoard::RedisDataset.new("127.0.0.1", 6379, "testing_playground")).dataset.switchboard }
+
+    it "should be able to create a new locking set" do
+      switchboard.should match_array([])
+    end
+
+    it "should have clean locker board on startup" do
+      lockers = dataset.list_lockers
+      lockers.count.should eq 0
+    end
+
+    it "should allow registering lockers" do
+      dataset.register_locker(1, "Moshe")
+      dataset.register_locker(2, "Raz")
+      dataset.register_locker(3, "Pupik")
+      lockers = dataset.list_lockers
+      lockers.count.should eq 3
+    end
+
+    it "should allow registering with strings" do
+      dataset.register_locker("muke", "Moshe")
+      dataset.register_locker("uke", "Raz")
+      lockers = dataset.list_lockers
+      lockers.count.should eq 2
+    end
+
+    it "should allow getting a locker registerd with a non int UID" do
+      dataset.register_locker("muke", "Moshe")
+      dataset.locker("muke")["name"].should eq("Moshe")
+    end    
+
+    it "should allow getting name of a registered locker by uid" do
+      dataset.register_locker(1, "Pupik")
+      dataset.register_locker(2, "Raz")
+      dataset.register_locker(3, "Moshe")
+      dataset.locker(3)["name"].should eq "Moshe"
+    end
+
+    it "should return nil for non existing uid" do
+      dataset.register_locker(1, "Pupik")
+      dataset.register_locker(2, "Raz")
+      dataset.register_locker(3, "Moshe")
+      dataset.locker(4).should be_nil
+    end
+
+    it "should allow locking object id for specific locker" do
+      dataset.register_locker(1, "Pupik")
+      dataset.register_locker(2, "Raz")
+      expect { dataset.lock_id(1, "SOME_ID") }.not_to raise_error
+    end
+
+    it "should allow checking lock state for a given id " do
+      dataset.register_locker(1, "Pupik")
+      dataset.register_locker(2, "Raz")
+      expect { dataset.lock_id(1, "SOME_ID_E") }.not_to raise_error
+      is_locked = dataset.id_locked?("SOME_ID_E")
+      is_locked.should eq true
+    end
+
+
+    it "should allow should lock id only for as per expiration time" do
+      dataset.register_locker(1, "Pupik")
+      dataset.register_locker(2, "Raz")
+      expect { dataset.lock_id(1, "SOME_ID_2", 1) }.not_to raise_error
+      dataset.id_locked?("SOME_ID_2").should be_true
+      sleep(2)
+      dataset.id_locked?("SOME_ID_3").should be_false
+    end
+
+    it "should return unlocked of unlocked key" do
+      dataset.register_locker(1, "Pupik")
+      dataset.register_locker(2, "Raz")
+      dataset.id_locked?("SOME_ID_4").should be_false
+    end    
+
+    it "should allow getting all the locked IDs" do
+      dataset.register_locker(1, "Pupik")
+      dataset.register_locker(2, "Raz")
+      expect { dataset.lock_id(1, "SOME_ID_5") }.not_to raise_error
+      expect { dataset.lock_id(1, "SOME_OTHER_ID") }.not_to raise_error
+      expect { dataset.lock_id(2, "SOME_THIRD_ID") }.not_to raise_error      
+      expect { dataset.lock_id(2, "SOME_FOURTH_ID") }.not_to raise_error      
+      dataset.get_all_locked_ids.count.should eq 4
+    end
+
+    it "should get clean results when no IDs are locked" do
+      dataset.register_locker(1, "Pupik")
+      dataset.register_locker(2, "Raz")
+      dataset.get_all_locked_ids.count.should eq 0
+    end
+
+    it "should allow users to get all IDs not locked by itself" do
+      dataset.register_locker(1, "Pupik")
+      dataset.register_locker(2, "Raz")
+      dataset.lock_id(1, "SOME_ID_6")
+      dataset.lock_id(1, "SOME_ID_7")
+      dataset.lock_id(1, "SOME_ID_8")
+      dataset.lock_id(2, "SOME_ID_9")
+      dataset.get_all_their_locked_ids(2).count.should eq 3
+    end
+
+
+    it "should allow users to get all IDs locked by themselves" do
+      dataset.register_locker(1, "Pupik")
+      dataset.register_locker(2, "Raz")
+      dataset.lock_id(1, "SOME_ID_6")
+      dataset.lock_id(1, "SOME_ID_7")
+      dataset.lock_id(1, "SOME_ID_8")
+      dataset.lock_id(2, "SOME_ID_9")
+      dataset.get_all_my_locked_ids(2).count.should eq 1
+    end    
+
+
+  end
+
+end

data/switch_board.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/switch_board/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "switch_board"
+  gem.version       = SwitchBoard::VERSION
+  gem.summary       = %q{Coordinate a set of persisted data and distribute to an active set of registerd clients}
+  gem.description   = %q{Coordinate a set of persisted data models and distribute to an active set of registerd clients.  Allows locking and automatic expiration for locking on portions of the data}
+  gem.license       = "MIT"
+  gem.authors       = ["Avner Cohen"]
+  gem.email         = "israbirding@gmail.com"
+  gem.homepage      = "https://rubygems.org/gems/switch_board"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_development_dependency 'rdoc', '~> 3.0'
+  gem.add_development_dependency 'rspec', '~> 2.4'
+  gem.add_development_dependency 'rubygems-tasks', '~> 0.2'
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: switch_board
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Avner Cohen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: Coordinate a set of persisted data models and distribute to an active
+  set of registerd clients.  Allows locking and automatic expiration for locking on
+  portions of the data
+email: israbirding@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .document
+- .gitignore
+- .rspec
+- .ruby-gemset
+- .ruby-version
+- ChangeLog.rdoc
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/switch_board.rb
+- lib/switch_board/configuration.rb
+- lib/switch_board/datasets/abstract_dataset.rb
+- lib/switch_board/datasets/redis_dataset.rb
+- lib/switch_board/version.rb
+- run_test
+- spec/spec_helper.rb
+- spec/switch_board_spec.rb
+- switch_board.gemspec
+homepage: https://rubygems.org/gems/switch_board
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Coordinate a set of persisted data and distribute to an active set of registerd
+  clients
+test_files:
+- spec/spec_helper.rb
+- spec/switch_board_spec.rb