dcell 0.10.0 → 0.12.0.pre

data/lib/dcell/node.rb

@@ -3,33 +3,39 @@ module DCell
   class Node
     include Celluloid
     include Celluloid::FSM
-    attr_reader :id, :addr, :timestamp
+    attr_reader :id, :addr
 
     # FSM
     default_state :disconnected
     state :shutdown
     state :disconnected, :to => [:connected, :shutdown]
     state :connected do
+      send_heartbeat
       Celluloid::Logger.info "Connected to #{id}"
     end
     state :partitioned do
       Celluloid::Logger.warn "Communication with #{id} interrupted"
     end
+    
+    @nodes = {}
+    @lock  = Mutex.new
+
+    @heartbeat_rate    = 5  # How often to send heartbeats in seconds
+    @heartbeat_timeout = 10 # How soon until a lost heartbeat triggers a node partition
 
     # Singleton methods
     class << self
       include Enumerable
       extend Forwardable
 
-      def_delegators "Celluloid::Actor[:node_manager]", :all, :each, :find, :[], :handle_gossip
-      def_delegators "Celluloid::Actor[:node_manager]", :gossip_rate, :heartbeat_timeout
+      def_delegators "Celluloid::Actor[:node_manager]", :all, :each, :find, :[]
+      def_delegators "Celluloid::Actor[:node_manager]", :heartbeat_rate, :heartbeat_timeout
     end
 
     def initialize(id, addr)
       @id, @addr = id, addr
-      @timestamp = 0
       @socket = nil
-      @fresh = true
+      @heartbeat = nil
 
       # Total hax to accommodate the new Celluloid::FSM API
       attach self
@@ -37,7 +43,6 @@ module DCell
 
     def finalize
       transition :shutdown
-      @gossip.cancel if @gossip
       @socket.close if @socket
     end
 
@@ -97,26 +102,17 @@ module DCell
       socket << message
     end
     alias_method :<<, :send_message
-
-    def tick
-      @timestamp += 1
-    end
-
-    def fresh?
-      @fresh
+    
+    # Send a heartbeat message after the given interval
+    def send_heartbeat
+      send_message DCell::Message::Heartbeat.new
+      @heartbeat = after(self.class.heartbeat_rate) { send_heartbeat }
     end
 
-    # Handle an incoming timestamp observation for this node
-    def handle_timestamp(t)
-      @fresh = false if t > 0
-      if @timestamp < t
-        @timestamp = t
-        transition :connected
-        transition :partitioned, :delay => self.class.heartbeat_timeout
-        unless state == :connected
-          Celluloid::Logger.info "Revived node #{id}"
-        end
-      end
+    # Handle an incoming heartbeat for this node
+    def handle_heartbeat
+      transition :connected
+      transition :partitioned, :delay => self.class.heartbeat_timeout
     end
 
     # Friendlier inspection

data/lib/dcell/node_manager.rb

@@ -4,15 +4,13 @@ module DCell
     include Celluloid::ZMQ
     include Enumerable
 
-    attr_reader :gossip_rate, :heartbeat_timeout
+    attr_reader :heartbeat_rate, :heartbeat_timeout
 
     def initialize
       @nodes = {}
 
-      @gossip_rate       = 5  # How often to send gossip in seconds
+      @heartbeat_rate    = 5  # How often to send heartbeats in seconds
       @heartbeat_timeout = 10 # How soon until a lost heartbeat triggers a node partition
-      each { |node| node.socket if node } # Connect all so we can gossip
-      @gossip = after(gossip_rate) { gossip_timeout }
     end
 
     # Return all available nodes in the cluster
@@ -47,35 +45,5 @@ module DCell
       @nodes[id]
     end
     alias_method :[], :find
-
-    # Send gossip to a random node (except ourself) after the given interval
-    def gossip_timeout
-      nodes = select { |node| node.state == :connected }
-      peer = nodes.select { |node| node.id != DCell.id }.sample(1)[0]
-      if peer
-        nodes = nodes.inject([]) { |a,n| a << [n.id, n.addr, n.timestamp]; a }
-        data = nil
-        if DCell.registry.is_a? Registry::GossipAdapter
-          data = peer.fresh? ? DCell.registry.values : DCell.registry.changed
-        end
-        DCell.me.tick
-        peer.send_message DCell::Message::Gossip.new nodes, data
-      end
-      @gossip = after(gossip_rate) { gossip_timeout }
-    end
-
-    def handle_gossip(peers, data)
-      peers.each do |id, addr, timestamp|
-        if (node = find(id))
-          node.handle_timestamp! timestamp
-        else
-          Directory[id] = addr
-          Celluloid::Logger.info "Found node #{id}"
-        end
-      end
-      if DCell.registry.is_a? Registry::GossipAdapter
-        data.map { |data| DCell.registry.observe data } if data
-      end
-    end
   end
 end

data/lib/dcell/registries/cassandra_adapter.rb

@@ -44,13 +44,45 @@ module DCell
 
         cass = Cassandra.new(keyspace, options[:servers])
 
+        @node_registry   = NodeRegistry.new(cass, columnfamily)
         @global_registry = GlobalRegistry.new(cass, columnfamily)
       end
 
+      def clear_nodes
+        @node_registry.clear
+      end
+
       def clear_globals
         @global_registry.clear
       end
 
+      class NodeRegistry
+        def initialize(cass, cf)
+          @cass = cass
+          @cf = cf
+        end
+
+        def get(node_id)
+          @cass.get @cf, "nodes", node_id
+        end
+
+        def set(node_id, addr)
+          @cass.insert @cf, "nodes", { node_id => addr }
+        end
+
+        def nodes
+          @cass.get(@cf, "nodes").keys
+        end
+
+        def clear
+          @cass.del @cf, "nodes"
+        end
+      end
+
+      def get_node(node_id);       @node_registry.get(node_id) end
+      def set_node(node_id, addr); @node_registry.set(node_id, addr) end
+      def nodes;                   @node_registry.nodes end
+
       class GlobalRegistry
         def initialize(cass, cf)
           @cass = cass

data/lib/dcell/registries/moneta_adapter.rb

@@ -16,6 +16,7 @@ module DCell
         # @moneta = Moneta::TieredCache.new options
         @moneta = Moneta::Memory.new options
 
+        @node_registry   = Registry.new(@moneta, :nodes)
         @global_registry = Registry.new(@moneta, :globals)
       end
 
@@ -38,6 +39,7 @@ module DCell
         end
 
         # DCell registry behaviors
+        alias_method :nodes, :all
         alias_method :global_keys, :all
 
         def clear
@@ -45,6 +47,11 @@ module DCell
         end
       end
 
+      def get_node(node_id);       @node_registry.get(node_id) end
+      def set_node(node_id, addr); @node_registry.set(node_id, addr) end
+      def nodes;                   @node_registry.nodes end
+      def clear_nodes;             @node_registry.clear end
+
       def get_global(key);        @global_registry.get(key) end
       def set_global(key, value); @global_registry.set(key, value) end
       def global_keys;            @global_registry.global_keys end

data/lib/dcell/registries/redis_adapter.rb

@@ -14,13 +14,44 @@ module DCell
         redis  = Redis.new options
         @redis = Redis::Namespace.new @namespace, :redis => redis
 
+        @node_registry   = NodeRegistry.new(@redis)
         @global_registry = GlobalRegistry.new(@redis)
       end
 
+      def clear_nodes
+        @node_registry.clear
+      end
+
       def clear_globals
         @global_registry.clear
       end
 
+      class NodeRegistry
+        def initialize(redis)
+          @redis = redis
+        end
+
+        def get(node_id)
+          @redis.hget 'nodes', node_id
+        end
+
+        def set(node_id, addr)
+          @redis.hset 'nodes', node_id, addr
+        end
+
+        def nodes
+          @redis.hkeys 'nodes'
+        end
+
+        def clear
+          @redis.del 'nodes'
+        end
+      end
+
+      def get_node(node_id);       @node_registry.get(node_id) end
+      def set_node(node_id, addr); @node_registry.set(node_id, addr) end
+      def nodes;                   @node_registry.nodes end
+
       class GlobalRegistry
         def initialize(redis)
           @redis = redis

data/lib/dcell/registries/zk_adapter.rb

@@ -36,13 +36,51 @@ module DCell
         end
 
         @zk = ZK.new(*servers)
+        @node_registry = NodeRegistry.new(@zk, @base_path)
         @global_registry = GlobalRegistry.new(@zk, @base_path)
       end
 
+      def clear_nodes
+        @node_registry.clear
+      end
+
       def clear_globals
         @global_registry.clear
       end
 
+      class NodeRegistry
+        def initialize(zk, base_path)
+          @zk, @base_path = zk, "#{base_path}/nodes"
+          @zk.mkdir_p @base_path
+        end
+
+        def get(node_id)
+          result, _ = @zk.get("#{@base_path}/#{node_id}")
+          result
+        rescue ZK::Exceptions::NoNode
+        end
+
+        def set(node_id, addr)
+          path = "#{@base_path}/#{node_id}"
+          @zk.set path, addr
+        rescue ZK::Exceptions::NoNode
+          @zk.create path, addr
+        end
+
+        def nodes
+          @zk.children @base_path
+        end
+
+        def clear
+          @zk.rm_rf @base_path
+          @zk.mkdir_p @base_path
+        end
+      end
+
+      def get_node(node_id);       @node_registry.get(node_id) end
+      def set_node(node_id, addr); @node_registry.set(node_id, addr) end
+      def nodes;                   @node_registry.nodes end
+
       class GlobalRegistry
         def initialize(zk, base_path)
           @zk, @base_path = zk, "#{base_path}/globals"
@@ -81,4 +119,4 @@ module DCell
       def global_keys;            @global_registry.global_keys end
     end
   end
-end
+end

data/lib/dcell/router.rb

@@ -43,28 +43,6 @@ module DCell
         end
       end
 
-      # Route a message to a given mailbox ID
-      def route(recipient, message)
-        recipient = find(recipient) if recipient.is_a? String
-
-        if recipient
-          recipient << message
-        else
-          Celluloid::Logger.debug("received message for invalid actor: #{mailbox_address.inspect}")
-        end
-      end
-
-      # Route a system event to a given mailbox ID
-      def route_system_event(mailbox_address, event)
-        recipient = find mailbox_address
-
-        if recipient
-          recipient.system_event event
-        else
-          Celluloid::Logger.debug("received message for invalid actor: #{mailbox_address.inspect}")
-        end
-      end
-
       # Prune all entries that point to dead objects
       def gc
         @mutex.synchronize do

data/lib/dcell/server.rb

@@ -6,7 +6,7 @@ module DCell
     # Bind to the given 0MQ address (in URL form ala tcp://host:port)
     def initialize
       # The gossip protocol is dependent on the node manager
-      link Actor[:node_manager]
+      link Celluloid::Actor[:node_manager]
 
       @addr   = DCell.addr
       @socket = PullSocket.new

data/lib/dcell/version.rb

@@ -1,3 +1,3 @@
 module DCell
-  VERSION = "0.10.0"
+  VERSION = "0.12.0.pre"
 end

data/spec/dcell/directory_spec.rb

@@ -5,4 +5,4 @@ describe DCell::Directory do
     DCell::Directory["foobar"] = "tcp://localhost:1870"
     DCell::Directory["foobar"].should == "tcp://localhost:1870"
   end
-end
+end

data/spec/dcell/global_spec.rb

@@ -11,10 +11,6 @@ describe DCell::Global do
 
     # Double check the global value is available on all nodes
     node = DCell::Node['test_node']
-    20.downto(0) do |i|
-      break if node[:test_actor].the_answer
-      sleep 1
-    end
     node[:test_actor].the_answer.should == 42
   end
 

data/spec/spec_helper.rb

@@ -7,8 +7,8 @@ Dir['./spec/support/*.rb'].map { |f| require f }
 
 RSpec.configure do |config|
   config.before(:suite) do
-    DCell.setup :directory => { :id => 'test_node', :addr => "tcp://127.0.0.1:#{TestNode::PORT}" }
-    @supervisor = DCell.run!
+    DCell.setup
+    DCell.run!
 
     TestNode.start
     TestNode.wait_until_ready
@@ -17,7 +17,4 @@ RSpec.configure do |config|
   config.after(:suite) do
     TestNode.stop
   end
-end
-
-# FIXME: this is hax to bypass the other at_exit handlers
-at_exit { exit! $!.status }
+end

data/spec/support/registry_examples.rb

@@ -1,4 +1,22 @@
 shared_context "a DCell registry" do
+  context "node registry" do
+    before :each do
+      subject.clear_nodes
+    end
+
+    it "stores node addresses" do
+      address = "tcp://localhost:7777"
+
+      subject.set_node("foobar", address)
+      subject.get_node("foobar").should == address
+    end
+
+    it "stores the IDs of all nodes" do
+      subject.set_node("foobar", "tcp://localhost:7777")
+      subject.nodes.should include "foobar"
+    end
+  end
+
   context "global registry" do
     before :each do
       subject.clear_globals

data/spec/test_node.rb

@@ -6,7 +6,7 @@ require 'bundler'
 Bundler.setup
 
 require 'dcell'
-DCell.setup :id => 'test_node', :addr => 'tcp://127.0.0.1:21264'
+DCell.start :id => 'test_node', :addr => 'tcp://127.0.0.1:21264'
 
 class TestActor
   include Celluloid
@@ -25,9 +25,5 @@ class TestActor
   end
 end
 
-class TestGroup < Celluloid::Group
-  supervise DCell::Group
-  supervise TestActor, :as => :test_actor
-end
-
-TestGroup.run
+TestActor.supervise_as :test_actor
+sleep