mitchellh-lightcloud 0.5 → 0.6

data/README.rdoc

@@ -12,6 +12,8 @@ http://opensource.plurk.com/LightCloud/
 
 == Usage
 
+You can use it with class methods:
+
   require 'rubygems'
   require 'lightcloud'
 
@@ -29,6 +31,25 @@ http://opensource.plurk.com/LightCloud/
 
   print LightCloud.get("hello") # => nil
 
+Or you can also use it with instances:
+
+  require 'rubygems'
+  require 'lightcloud'
+
+  LIGHT_CLOUD = {
+    'lookup1_A' => ['127.0.0.1:41401', '127.0.0.1:41402'],
+    'storage1_A' => ['192.168.0.2:51401', '192.168.0.2:51402']
+  }
+
+  lookup_nodes, storage_nodes = LightCloud.generate_nodes(LIGHT_CLOUD)
+  cloud = LightCloud.new(lookup_nodes, storage_nodes)
+
+  cloud.set("hello", "world")
+  print cloud.get("hello") # => world
+  cloud.delete("hello")
+
+  print cloud.get("hello") # => nil
+
 == Installation
 
   sudo gem install mitchellh-lightcloud

data/lib/lightcloud.rb

@@ -35,46 +35,76 @@ require File.join(File.dirname(__FILE__), 'tyrant_client')
 #  print LightCloud.get("hello") # => nil
 #
 class LightCloud
-  VERSION = '0.5'
+  VERSION = '0.6'
   DEFAULT_SYSTEM = 'default'
 
   @@systems = {}
 
-  def self.init(lookup_nodes, storage_nodes, system=DEFAULT_SYSTEM)
+  # 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)
+  end
+
+  def self.init(lookup_nodes, storage_nodes, system=DEFAULT_SYSTEM, systems=@@systems)
     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[system] = [lookup_ring, storage_ring, name_to_l_nodes, name_to_s_nodes]
   end
 
   #--
   # Get/Set/Delete
   #++
+  # 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)
+  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)
-    storage_node = self.locate_node_or_init(key, system)
+  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)
+  def self.get(key, system=DEFAULT_SYSTEM, systems=@@systems)
     result = nil
 
     # Try to lookup key directly
-    storage_node = self.get_storage_ring(system).get_node(key)
+    storage_node = self.get_storage_ring(system, systems).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)
+      storage_node = self.locate_node(key, system, systems)
       
       result = storage_node.get(key) unless storage_node.nil?
     end
@@ -85,11 +115,11 @@ class LightCloud
   #
   # Lookup the key and delete it from both the storage ring
   # and lookup ring
-  def self.delete(key, system=DEFAULT_SYSTEM)
-    storage_node = self.locate_node(key, system)
+  def self.delete(key, system=DEFAULT_SYSTEM, systems=@@systems)
+    storage_node = self.locate_node(key, system, systems)
     
-    storage_node = get_storage_ring(system).get_node(key) if storage_node.nil?
-    lookup_nodes = get_lookup_ring(system).iterate_nodes(key)
+    storage_node = get_storage_ring(system, systems).get_node(key) if storage_node.nil?
+    lookup_nodes = get_lookup_ring(system, systems).iterate_nodes(key)
     lookup_nodes.each_index do |i|
       break if i > 1
       
@@ -103,13 +133,13 @@ class LightCloud
   #--
   # Lookup Cloud
   #++
-  def self.locate_node_or_init(key, system)
-    storage_node = self.locate_node(key, system)
+  def self.locate_node_or_init(key, system, systems=@@systems)
+    storage_node = self.locate_node(key, system, systems)
 
     if storage_node.nil?
-      storage_node = self.get_storage_ring(system).get_node(key)
+      storage_node = self.get_storage_ring(system, systems).get_node(key)
 
-      lookup_node = self.get_lookup_ring(system).get_node(key)
+      lookup_node = self.get_lookup_ring(system, systems).get_node(key)
       lookup_node.set(key, storage_node.to_s)
     end
 
@@ -119,8 +149,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)
-    nodes = self.get_lookup_ring(system).iterate_nodes(key)
+  def self.locate_node(key, system=DEFAULT_SYSTEM, systems=@@systems)
+    nodes = self.get_lookup_ring(system, systems).iterate_nodes(key)
     
     lookups = 0
     value = nil
@@ -137,14 +167,14 @@ class LightCloud
     return nil if value.nil?
     
     if lookups == 0
-      return self.get_storage_node(value, system)
+      return self.get_storage_node(value, system, systems)
     else
-      return self._clean_up_ring(key, value, system)
+      return self._clean_up_ring(key, value, system, systems)
     end
   end
 
-  def self._clean_up_ring(key, value, system)
-    nodes = self.get_lookup_ring(system).iterate_nodes(key)
+  def self._clean_up_ring(key, value, system, systems=@@systems)
+    nodes = self.get_lookup_ring(system, systems).iterate_nodes(key)
 
     nodes.each_index do |i|
       break if i > 1
@@ -157,25 +187,25 @@ class LightCloud
       end
     end
 
-    return self.get_storage_node(value, system)
+    return self.get_storage_node(value, system, systems)
   end
 
   #--
   # Accessors for rings
   #++
-  def self.get_lookup_ring(system=DEFAULT_SYSTEM)
-    @@systems[system][0]
+  def self.get_lookup_ring(system=DEFAULT_SYSTEM, systems=@@systems)
+    systems[system][0]
   end
 
-  def self.get_storage_ring(system=DEFAULT_SYSTEM)
-    @@systems[system][1]
+  def self.get_storage_ring(system=DEFAULT_SYSTEM, systems=@@systems)
+    systems[system][1]
   end
 
   #--
   # Accessors for nodes
   #++
-  def self.get_storage_node(name, system=DEFAULT_SYSTEM)
-    @@systems[system][3][name]
+  def self.get_storage_node(name, system=DEFAULT_SYSTEM, systems=@@systems)
+    systems[system][3][name]
   end
 
   #--

data/spec/lightcloud_spec.rb

@@ -86,8 +86,8 @@ describe LightCloud do
 
     describe "locating or initting a storage node by key" do
       after do
-        LightCloud.should_receive(:locate_node).with(@key, anything).once.and_return(@storage_node)
-        LightCloud.locate_node_or_init(@key, LightCloud::DEFAULT_SYSTEM)
+        LightCloud.should_receive(:locate_node).with(@key, anything, anything).once.and_return(@storage_node)
+        LightCloud.locate_node_or_init(@key, LightCloud::DEFAULT_SYSTEM, anything)
       end
 
       it "should just return the storage node if it was found" do
@@ -106,7 +106,7 @@ 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).once
+        LightCloud.should_receive(:get_storage_node).with(@storage_node, anything, anything).once
 
         LightCloud.locate_node(@key)
       end
@@ -118,7 +118,7 @@ describe LightCloud do
       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).once
+        LightCloud.should_receive(:_clean_up_ring).with(@key, @storage_node, anything, anything).once
 
         LightCloud.locate_node(@key)
       end
@@ -144,7 +144,7 @@ describe LightCloud do
       end
       
       it "should return the storage node lookup" do
-        LightCloud.should_receive(:get_storage_node).with(@storage_node, anything).once
+        LightCloud.should_receive(:get_storage_node).with(@storage_node, anything, anything).once
       end
     end
   end
@@ -162,7 +162,7 @@ describe LightCloud do
     end
 
     it "should lookup the node or init for where to place key" do
-      LightCloud.should_receive(:locate_node_or_init).with(@key, anything).once.and_return(@generic_node)
+      LightCloud.should_receive(:locate_node_or_init).with(@key, anything, anything).once.and_return(@generic_node)
     end
 
     it "should set the value on the node returned by locate node or init" do
@@ -190,7 +190,7 @@ describe LightCloud do
     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).and_return(@storage_valid_node)
+      LightCloud.should_receive(:locate_node).with(@key, anything, anything).and_return(@storage_valid_node)
       @storage_valid_node.should_receive(:get).with(@key).and_return(@value)
     end
   end
@@ -217,13 +217,13 @@ 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).once.and_return(@generic_node)
+      LightCloud.should_receive(:locate_node).with(@key, anything, anything).once.and_return(@generic_node)
       LightCloud.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).once.and_return(nil)
+      LightCloud.should_receive(:locate_node).with(@key, anything, anything).once.and_return(nil)
       LightCloud.should_receive(:get_storage_ring).once.and_return(@storage_ring)
       @storage_ring.should_receive(:get_node).with(@key).once.and_return(@generic_node)
 
@@ -231,9 +231,40 @@ describe LightCloud do
     end
 
     it "should only delete from a storage node if one was found" do
-      LightCloud.should_receive(:locate_node).with(@key, anything).once.and_return(nil)
+      LightCloud.should_receive(:locate_node).with(@key, anything, anything).once.and_return(nil)
       LightCloud.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
+    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))
+    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')
+    end
+
+    it "should forward set arguments to class method" do
+      LightCloud.should_receive(:set).with('key', 'value', anything, anything).once
+      @cloud.set('key', 'value')
+    end
+
+    it "should forward get arguments to class method" do
+      LightCloud.should_receive(:get).with('key', anything, anything).once
+      @cloud.get('key')
+    end
+
+    it "should forward delete arguments to class method" do
+      LightCloud.should_receive(:delete).with('key', anything, anything).once
+      @cloud.delete('key')
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mitchellh-lightcloud
 version: !ruby/object:Gem::Version 
-  version: "0.5"
+  version: "0.6"
 platform: ruby
 authors: 
 - Mitchell Hashimoto