mitchellh-lightcloud 0.6 → 0.7

data/lib/lightcloud.rb

@@ -35,26 +35,30 @@ require File.join(File.dirname(__FILE__), 'tyrant_client')
 #  print LightCloud.get("hello") # => nil
 #
 class LightCloud
-  VERSION = '0.6'
+  VERSION = '0.7'
   DEFAULT_SYSTEM = 'default'
+  @@instance = nil
 
-  @@systems = {}
-
+  #--
+  # INSTANCE METHODS
+  #++
   # Initialize LightCloud as an instance instead of using the class
   # methods. Expects the same arguments as LightCloud.init, except
   # this will return a new instance of LightCloud.
   #
   # Any nodes initialized through here will not work one class methods.
-  def initialize(lookup_nodes, storage_nodes, system=DEFAULT_SYSTEM)
-    @systems = {}
-    self.class.init(lookup_nodes, storage_nodes, system, @systems)
+  def initialize(lookup_nodes=nil, storage_nodes=nil, system=DEFAULT_SYSTEM)
+    add_system(lookup_nodes, storage_nodes, system) if !lookup_nodes.nil? && !storage_nodes.nil?
   end
 
-  def self.init(lookup_nodes, storage_nodes, system=DEFAULT_SYSTEM, systems=@@systems)
+  #
+  # Create a new LightCloud system within a pre-existing instance.
+  def add_system(lookup_nodes, storage_nodes, system=DEFAULT_SYSTEM)
     lookup_ring, name_to_l_nodes = self.generate_ring(lookup_nodes)
     storage_ring, name_to_s_nodes = self.generate_ring(storage_nodes)
 
-    systems[system] = [lookup_ring, storage_ring, name_to_l_nodes, name_to_s_nodes]
+    @systems ||= {}
+    @systems[system] = [lookup_ring, storage_ring, name_to_l_nodes, name_to_s_nodes]    
   end
 
   #--
@@ -63,63 +67,40 @@ class LightCloud
   # Sets a value to a key on a LightCloud instance. See
   # LightCloud.set for more information
   def set(key, value, system=DEFAULT_SYSTEM)
-    self.class.set(key, value, system, @systems)
+    storage_node = locate_node_or_init(key, system)
+    return storage_node.set(key, value)
   end
 
   #
   # Gets a value to a key on a LightCloud instance. See
   # LightCloud.get for more information.
   def get(key, system=DEFAULT_SYSTEM)
-    self.class.get(key, system, @systems)
-  end
-
-  #
-  # Delete a value from a LightCloud instance. See
-  # LightCloud.delete for more information.
-  def delete(key, system=DEFAULT_SYSTEM)
-    self.class.delete(key, system, @systems)
-  end
-
-  #
-  # Sets a value to a key in the LightCloud system.
-  #
-  # Set first checks to see if the key is already stored. If it is
-  # it uses that same node to store the new value. Otherwise, it
-  # determines where to store the value based on the hash_ring
-  def self.set(key, value, system=DEFAULT_SYSTEM, systems=@@systems)
-    storage_node = self.locate_node_or_init(key, system, systems)
-    return storage_node.set(key, value)
-  end
-
-  #
-  # Gets a value based on a key. 
-  def self.get(key, system=DEFAULT_SYSTEM, systems=@@systems)
     result = nil
 
     # Try to lookup key directly
-    storage_node = self.get_storage_ring(system, systems).get_node(key)
+    storage_node = get_storage_ring(system).get_node(key)
     value = storage_node.get(key)
 
     result = value unless value.nil?
     
     # Else use the lookup ring
     if result.nil?
-      storage_node = self.locate_node(key, system, systems)
+      storage_node = locate_node(key, system)
       
       result = storage_node.get(key) unless storage_node.nil?
     end
 
-    result
+    result    
   end
 
   #
-  # Lookup the key and delete it from both the storage ring
-  # and lookup ring
-  def self.delete(key, system=DEFAULT_SYSTEM, systems=@@systems)
-    storage_node = self.locate_node(key, system, systems)
+  # Delete a value from a LightCloud instance. See
+  # LightCloud.delete for more information.
+  def delete(key, system=DEFAULT_SYSTEM)
+    storage_node = locate_node(key, system)
     
-    storage_node = get_storage_ring(system, systems).get_node(key) if storage_node.nil?
-    lookup_nodes = get_lookup_ring(system, systems).iterate_nodes(key)
+    storage_node = get_storage_ring(system).get_node(key) if storage_node.nil?
+    lookup_nodes = get_lookup_ring(system).iterate_nodes(key)
     lookup_nodes.each_index do |i|
       break if i > 1
       
@@ -133,13 +114,13 @@ class LightCloud
   #--
   # Lookup Cloud
   #++
-  def self.locate_node_or_init(key, system, systems=@@systems)
-    storage_node = self.locate_node(key, system, systems)
+  def locate_node_or_init(key, system)
+    storage_node = locate_node(key, system)
 
     if storage_node.nil?
-      storage_node = self.get_storage_ring(system, systems).get_node(key)
+      storage_node = get_storage_ring(system).get_node(key)
 
-      lookup_node = self.get_lookup_ring(system, systems).get_node(key)
+      lookup_node = get_lookup_ring(system).get_node(key)
       lookup_node.set(key, storage_node.to_s)
     end
 
@@ -149,8 +130,8 @@ class LightCloud
   #
   # Locates a node in the lookup ring, returning the node if it is found, or
   # nil otherwise.
-  def self.locate_node(key, system=DEFAULT_SYSTEM, systems=@@systems)
-    nodes = self.get_lookup_ring(system, systems).iterate_nodes(key)
+  def locate_node(key, system=DEFAULT_SYSTEM)
+    nodes = get_lookup_ring(system).iterate_nodes(key)
     
     lookups = 0
     value = nil
@@ -167,14 +148,14 @@ class LightCloud
     return nil if value.nil?
     
     if lookups == 0
-      return self.get_storage_node(value, system, systems)
+      return get_storage_node(value, system)
     else
-      return self._clean_up_ring(key, value, system, systems)
+      return _clean_up_ring(key, value, system)
     end
   end
 
-  def self._clean_up_ring(key, value, system, systems=@@systems)
-    nodes = self.get_lookup_ring(system, systems).iterate_nodes(key)
+  def _clean_up_ring(key, value, system)
+    nodes = get_lookup_ring(system).iterate_nodes(key)
 
     nodes.each_index do |i|
       break if i > 1
@@ -187,25 +168,84 @@ class LightCloud
       end
     end
 
-    return self.get_storage_node(value, system, systems)
+    return get_storage_node(value, system)
   end
 
   #--
   # Accessors for rings
   #++
-  def self.get_lookup_ring(system=DEFAULT_SYSTEM, systems=@@systems)
-    systems[system][0]
+  def get_lookup_ring(system=DEFAULT_SYSTEM)
+    @systems[system][0]
   end
 
-  def self.get_storage_ring(system=DEFAULT_SYSTEM, systems=@@systems)
-    systems[system][1]
+  def get_storage_ring(system=DEFAULT_SYSTEM)
+    @systems[system][1]
   end
 
   #--
   # Accessors for nodes
   #++
-  def self.get_storage_node(name, system=DEFAULT_SYSTEM, systems=@@systems)
-    systems[system][3][name]
+  def get_storage_node(name, system=DEFAULT_SYSTEM)
+    @systems[system][3][name]
+  end
+
+  #
+  # Given a set of nodes it creates the the nodes as Tokyo
+  # Tyrant objects and returns a hash ring with them
+  def generate_ring(nodes)
+    objects = []
+    name_to_obj = {}
+    
+    nodes.each do |name, nodelist|
+      obj = TyrantNode.new(name, nodelist)
+      name_to_obj[name] = obj
+
+      objects.push(obj)
+    end
+
+    return HashRing.new(objects), name_to_obj
+  end
+
+  #--
+  # CLASS METHODS
+  #++
+  #
+  # Initializes LightCloud library with lookup and storage nodes.
+  # This only needs to be called with servers with which you intend
+  # to use the class methods (set/get/delete)
+  def self.init(lookup_nodes, storage_nodes, system=DEFAULT_SYSTEM)
+    instance.add_system(lookup_nodes, storage_nodes, system)
+  end
+
+  #
+  # Sets a value to a key in the LightCloud system.
+  #
+  # Set first checks to see if the key is already stored. If it is
+  # it uses that same node to store the new value. Otherwise, it
+  # determines where to store the value based on the hash_ring
+  def self.set(key, value, system=DEFAULT_SYSTEM)
+    instance.set(key, value, system)
+  end
+
+  #
+  # Gets a value based on a key. 
+  def self.get(key, system=DEFAULT_SYSTEM)
+    instance.get(key, system)
+  end
+
+  #
+  # Lookup the key and delete it from both the storage ring
+  # and lookup ring
+  def self.delete(key, system=DEFAULT_SYSTEM)
+    instance.delete(key, system)
+  end
+
+  #--
+  # Instance accessor
+  #++
+  def self.instance
+    @@instance ||= self.new
+    @@instance
   end
 
   #--
@@ -225,21 +265,4 @@ class LightCloud
 
     return lookup_nodes, storage_nodes
   end
-  
-  #
-  # Given a set of nodes it creates the the nodes as Tokyo
-  # Tyrant objects and returns a hash ring with them
-  def self.generate_ring(nodes)
-    objects = []
-    name_to_obj = {}
-    
-    nodes.each do |name, nodelist|
-      obj = TyrantNode.new(name, nodelist)
-      name_to_obj[name] = obj
-
-      objects.push(obj)
-    end
-
-    return HashRing.new(objects), name_to_obj
-  end
 end

data/spec/lightcloud_spec.rb

@@ -33,9 +33,11 @@ describe LightCloud do
       
     @storage_ring = mock(HashRing)
     @storage_ring.stub!(:get_node).and_return(@storage_valid_node)
-      
-    LightCloud.stub!(:get_lookup_ring).and_return(@lookup_ring)
-    LightCloud.stub!(:get_storage_ring).and_return(@storage_ring)
+
+    @cloud = LightCloud.new
+    @cloud.stub!(:get_lookup_ring).and_return(@lookup_ring)
+    @cloud.stub!(:get_storage_ring).and_return(@storage_ring)
+    @cloud.stub!(:get_storage_node).and_return(@storage_valid_node)
   end
 
   describe "node generation" do
@@ -65,14 +67,14 @@ describe LightCloud do
     end
 
     it "should return the tyrant nodes as a name to node hash" do
-      unneeded, name_to_nodes = LightCloud.generate_ring(@valid_lookup_nodes)
+      unneeded, name_to_nodes = @cloud.generate_ring(@valid_lookup_nodes)
 
       name_to_nodes.should be_has_key('lookup1_A')
       name_to_nodes['lookup1_A'].should be_kind_of(TyrantNode)
     end
 
     it "should return a hash ring with the nodes" do
-      ring, unneeded = LightCloud.generate_ring(@valid_lookup_nodes)
+      ring, unneeded = @cloud.generate_ring(@valid_lookup_nodes)
 
       ring.should be_kind_of(HashRing)
     end
@@ -86,13 +88,13 @@ describe LightCloud do
 
     describe "locating or initting a storage node by key" do
       after do
-        LightCloud.should_receive(:locate_node).with(@key, anything, anything).once.and_return(@storage_node)
-        LightCloud.locate_node_or_init(@key, LightCloud::DEFAULT_SYSTEM, anything)
+        @cloud.should_receive(:locate_node).with(@key, anything).once.and_return(@storage_node)
+        @cloud.locate_node_or_init(@key, LightCloud::DEFAULT_SYSTEM)
       end
 
       it "should just return the storage node if it was found" do
-        LightCloud.should_not_receive(:get_storage_ring)
-        LightCloud.should_not_receive(:get_lookup_ring)
+        @cloud.should_not_receive(:get_storage_ring)
+        @cloud.should_not_receive(:get_lookup_ring)
       end
 
       it "should set the lookup ring to point to the new storage node if no previous storage node was found" do
@@ -106,27 +108,27 @@ describe LightCloud do
     describe "locating a storage node by key" do
       it "should return the storage node if the key is found in the lookup ring" do    
         @nodes[0].should_receive(:get).with(@key).and_return(@storage_node)
-        LightCloud.should_receive(:get_storage_node).with(@storage_node, anything, anything).once
+        @cloud.should_receive(:get_storage_node).with(@storage_node, anything).once
 
-        LightCloud.locate_node(@key)
+        @cloud.locate_node(@key)
       end
 
       it "should return nil if the key doesn't exist in the lookup ring" do
-        LightCloud.locate_node(@key).should be_nil
+        @cloud.locate_node(@key).should be_nil
       end
 
       it "should attempt to clean up the lookup ring if the value is NOT found in the first node" do
         @nodes[1].should_receive(:get).with(@key).and_return(@storage_node)
-        LightCloud.should_not_receive(:get_storage_node)
-        LightCloud.should_receive(:_clean_up_ring).with(@key, @storage_node, anything, anything).once
+        @cloud.should_not_receive(:get_storage_node)
+        @cloud.should_receive(:_clean_up_ring).with(@key, @storage_node, anything).once
 
-        LightCloud.locate_node(@key)
+        @cloud.locate_node(@key)
       end
     end
 
     describe "cleaning the lookup ring" do
       after do
-        LightCloud._clean_up_ring(@key, @storage_node, LightCloud::DEFAULT_SYSTEM)
+        @cloud._clean_up_ring(@key, @storage_node, LightCloud::DEFAULT_SYSTEM)
       end
 
       it "should set the key/value onto the first node (index 0)" do
@@ -144,7 +146,7 @@ describe LightCloud do
       end
       
       it "should return the storage node lookup" do
-        LightCloud.should_receive(:get_storage_node).with(@storage_node, anything, anything).once
+        @cloud.should_receive(:get_storage_node).with(@storage_node, anything).once
       end
     end
   end
@@ -154,15 +156,15 @@ describe LightCloud do
       @key = 'hello'
       @value = 'world!'
 
-      LightCloud.stub!(:locate_node_or_init).and_return(@generic_node)
+      @cloud.stub!(:locate_node_or_init).and_return(@generic_node)
     end
 
     after do
-      LightCloud.set(@key, @value)
+      @cloud.set(@key, @value)
     end
 
     it "should lookup the node or init for where to place key" do
-      LightCloud.should_receive(:locate_node_or_init).with(@key, anything, anything).once.and_return(@generic_node)
+      @cloud.should_receive(:locate_node_or_init).with(@key, anything).once.and_return(@generic_node)
     end
 
     it "should set the value on the node returned by locate node or init" do
@@ -178,19 +180,19 @@ describe LightCloud do
     end
 
     after do
-      LightCloud.get(@key).should eql(@value)
+      @cloud.get(@key).should eql(@value)
     end
 
     it "should not resort to the lookup table if it can find the key directly" do
       @generic_node.should_receive(:get).with(@key).and_return(@value)
 
-      LightCloud.should_not_receive(:locate_node)
+      @cloud.should_not_receive(:locate_node)
     end
 
     it "should get the storage node from the lookup table if it can't find the key directly" do
       @generic_node.should_receive(:get).once.and_return(nil)
 
-      LightCloud.should_receive(:locate_node).with(@key, anything, anything).and_return(@storage_valid_node)
+      @cloud.should_receive(:locate_node).with(@key, anything).and_return(@storage_valid_node)
       @storage_valid_node.should_receive(:get).with(@key).and_return(@value)
     end
   end
@@ -206,7 +208,7 @@ describe LightCloud do
       # spec in this context, which WOULD raise an error if
       # it failed
       lambda do
-        LightCloud.delete(@key)
+        @cloud.delete(@key)
       end.should_not raise_error
     end
 
@@ -217,54 +219,55 @@ describe LightCloud do
     end
 
     it "should first try to get the storage node from lookup ring" do
-      LightCloud.should_receive(:locate_node).with(@key, anything, anything).once.and_return(@generic_node)
-      LightCloud.should_not_receive(:get_storage_ring)
-
+      @cloud.should_receive(:locate_node).with(@key, anything).once.and_return(@generic_node)
+      @cloud.should_not_receive(:get_storage_ring)
     end
 
     it "should try to get storage node directly if lookup ring failed" do
-      LightCloud.should_receive(:locate_node).with(@key, anything, anything).once.and_return(nil)
-      LightCloud.should_receive(:get_storage_ring).once.and_return(@storage_ring)
+      @cloud.should_receive(:locate_node).with(@key, anything).once.and_return(nil)
+      @cloud.should_receive(:get_storage_ring).once.and_return(@storage_ring)
       @storage_ring.should_receive(:get_node).with(@key).once.and_return(@generic_node)
 
       @generic_node.should_receive(:delete).with(@key)
     end
 
     it "should only delete from a storage node if one was found" do
-      LightCloud.should_receive(:locate_node).with(@key, anything, anything).once.and_return(nil)
-      LightCloud.should_receive(:get_storage_ring).once.and_return(@storage_ring)
+      @cloud.should_receive(:locate_node).with(@key, anything).once.and_return(nil)
+      @cloud.should_receive(:get_storage_ring).once.and_return(@storage_ring)
       @storage_ring.should_receive(:get_node).with(@key).once.and_return(nil)
     end
   end
 
-  describe "lightcloud instances" do
+  describe "class methods" do
     before do
-      cloud_config = {
-        'lookup1_A' => ['127.0.0.1:1234', '127.0.0.2:1234'],
-        'storage1_A' => ['127.0.0.1:4567', '127.0.0.2:4567']
-      }
-
-      @cloud = LightCloud.new(*LightCloud.generate_nodes(cloud_config))
+      LightCloud.should_receive(:instance).and_return(@cloud)
+      
+      @key = 'foo'
+      @value = 'bar'
     end
 
-    it "should forward arguments to class method init on initialize" do
-      LightCloud.should_receive(:init).with('a', 'b', 'c', {}).once
-      LightCloud.new('a','b','c')
+    it "should call add_system on singleton when init is called" do
+      @cloud.should_receive(:add_system).with(@valid_lookup_nodes, @valid_storage_nodes, anything)
+
+      LightCloud.init(@valid_lookup_nodes, @valid_storage_nodes)
     end
 
-    it "should forward set arguments to class method" do
-      LightCloud.should_receive(:set).with('key', 'value', anything, anything).once
-      @cloud.set('key', 'value')
+    it "should call get on instance for get" do
+      @cloud.should_receive(:get).with(@key, anything).once
+      
+      LightCloud.get(@key)
     end
 
-    it "should forward get arguments to class method" do
-      LightCloud.should_receive(:get).with('key', anything, anything).once
-      @cloud.get('key')
+    it "should call set on instance for set" do
+      @cloud.should_receive(:set).with(@key, @value, anything).once
+
+      LightCloud.set(@key, @value)
     end
 
-    it "should forward delete arguments to class method" do
-      LightCloud.should_receive(:delete).with('key', anything, anything).once
-      @cloud.delete('key')
+    it "should call delete on instance for delete" do
+      @cloud.should_receive(:delete).with(@key, anything).once
+
+      LightCloud.delete(@key)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mitchellh-lightcloud
 version: !ruby/object:Gem::Version 
-  version: "0.6"
+  version: "0.7"
 platform: ruby
 authors: 
 - Mitchell Hashimoto
@@ -56,7 +56,7 @@ rdoc_options:
 - --line-numbers
 - --inline-source
 - --title
-- hash_ring
+- lightcloud
 - --main
 - README.rdoc
 require_paths: