stn-dcell 0.16.0

data/lib/dcell/router.rb

@@ -0,0 +1,46 @@
+require 'weakref'
+
+module DCell
+  # Route incoming messages to their recipient actors
+  class Router
+    @mutex     = Mutex.new
+    @mailboxes = {}
+
+    class << self
+      # Enter a mailbox into the registry
+      def register(mailbox)
+        @mutex.synchronize do
+          address = mailbox.address
+          ref = @mailboxes[address]
+          @mailboxes[address] = WeakRef.new(mailbox) unless ref && ref.weakref_alive?
+
+          address
+        end
+      end
+
+      # Find a mailbox by its address
+      def find(mailbox_address)
+        @mutex.synchronize do
+          begin
+            ref = @mailboxes[mailbox_address]
+            return unless ref
+            ref.__getobj__
+          rescue WeakRef::RefError
+            # The referenced actor is dead, so prune the registry
+            @mailboxes.delete mailbox_address
+            nil
+          end
+        end
+      end
+
+      # Prune all entries that point to dead objects
+      def gc
+        @mutex.synchronize do
+          @mailboxes.each do |id, ref|
+            @mailboxes.delete id unless ref.weakref_alive?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcell/rpc.rb

@@ -0,0 +1,95 @@
+require 'weakref'
+
+module DCell
+  class RPB < Celluloid::BlockProxy
+    def initialize(id, mailbox, execution, arguments)
+      @id, @mailbox, @execution, @arguments = id, mailbox, execution, arguments
+    end
+
+    # Custom marshaller for compatibility with Celluloid::Mailbox marshalling
+    def _dump(level)
+      payload = Marshal.dump [@mailbox, @execution, @arguments]
+      "#{@id}:rpb:#{payload}"
+    end
+  end
+
+  class RPBC < Celluloid::BlockCall
+    def initialize(id, block_proxy, sender, arguments)
+      @id, @block_proxy, @sender, @arguments = id, block_proxy, sender, arguments
+    end
+
+    # Custom marshaller for compatibility with Celluloid::Mailbox marshalling
+    def _dump(level)
+      payload = Marshal.dump [@block_proxy, @sender, @arguments]
+      "#{@id}:rpbc:#{payload}"
+    end
+  end
+
+  class RPC < Celluloid::SyncCall
+    def initialize(id, sender, method, arguments, block)
+      @id, @sender, @method, @arguments, @block = id, sender, method, arguments, block
+    end
+
+    # Custom marshaller for compatibility with Celluloid::Mailbox marshalling
+    def _dump(level)
+      payload = Marshal.dump [@sender, @method, @arguments, @block]
+      "#{@id}:rpc:#{payload}"
+    end
+
+    # Loader for custom marshal format
+    def self._load(string)
+      id = string.slice!(0, string.index(":") + 1)
+      match = id.match(/^([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})@(.+?):$/)
+      raise ArgumentError, "couldn't parse call ID" unless match
+
+      uuid, node_id = match[1], match[2]
+
+      if DCell.id == node_id
+        Manager.claim uuid
+      else
+        type = string.slice!(0, string.index(":") + 1)
+        types = {
+          "rpc" => RPC,
+          "rpb" => RPB,
+          "rpbc" => RPBC,
+        }
+        types.fetch(type[0..-2]).new("#{uuid}@#{node_id}", *Marshal.load(string))
+      end
+    end
+
+    # Tracks calls-in-flight
+    class Manager
+      @mutex  = Mutex.new
+      @ids    = {}
+      @calls  = {}
+
+      def self.register(call)
+        @mutex.lock
+        begin
+          call_id = @ids[call.object_id]
+          unless call_id
+            call_id = Celluloid.uuid
+            @ids[call.object_id] = call_id
+          end
+
+          @calls[call_id] = WeakRef.new(call)
+          call_id
+        ensure
+          @mutex.unlock rescue nil
+        end
+      end
+
+      def self.claim(call_id)
+        @mutex.lock
+        begin
+          ref = @calls.delete(call_id)
+          ref.__getobj__ if ref
+        rescue WeakRef::RefError
+          # Nothing to see here, folks
+        ensure
+          @mutex.unlock rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/dcell/rspec.rb

@@ -0,0 +1 @@
+require File.expand_path('../../../spec/support/registry_examples', __FILE__)

data/lib/dcell/server.rb

@@ -0,0 +1,73 @@
+module DCell
+  # Servers handle incoming 0MQ traffic
+  class Server
+    include Celluloid::ZMQ
+
+    finalizer :close
+
+    # 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 Celluloid::Actor[:node_manager]
+
+      @socket = PullSocket.new
+
+      begin
+        @socket.bind(DCell.addr)
+        real_addr = @socket.get(::ZMQ::LAST_ENDPOINT).strip
+        DCell::Directory.set DCell.id, real_addr
+        DCell.addr = real_addr
+      rescue IOError
+        @socket.close
+        raise
+      end
+
+      async.run
+    end
+
+    # Wait for incoming 0MQ messages
+    def run
+      while true; async.handle_message @socket.read; end
+    end
+
+    def close
+      @socket.close if @socket
+    end
+
+    # Handle incoming messages
+    def handle_message(message)
+      begin
+        message = decode_message message
+      rescue InvalidMessageError => ex
+        Logger.crash("couldn't decode message", ex)
+        return
+      end
+
+      begin
+        message.dispatch
+      rescue => ex
+        Logger.crash("DCell::Server: message dispatch failed", ex)
+      end
+    end
+
+    class InvalidMessageError < StandardError; end # undecodable message
+
+    # Decode incoming messages
+    def decode_message(message)
+      if message[0..1].unpack("CC") == [Marshal::MAJOR_VERSION, Marshal::MINOR_VERSION]
+        begin
+          Marshal.load message
+        rescue => ex
+          raise InvalidMessageError, "invalid message: #{ex}"
+        end
+      else raise InvalidMessageError, "couldn't determine message format: #{message}"
+      end
+    end
+
+    # Terminate this server
+    def terminate
+      @socket.close
+      super
+    end
+  end
+end

data/lib/dcell/version.rb

@@ -0,0 +1,3 @@
+module DCell
+  VERSION = "0.16.0"
+end

data/spec/dcell/actor_proxy_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe DCell::CellProxy do
+  before :all do
+    @node = DCell::Node[TEST_NODE[:id]]
+    @node.id.should == TEST_NODE[:id]
+    @remote_actor = @node[:test_actor]
+
+    class LocalActor
+      include Celluloid
+
+      attr_reader :crash_reason
+      trap_exit   :exit_handler
+
+      def initialize
+        @crash_reason = nil
+      end
+
+      def exit_handler(actor, reason)
+        @crash_reason = reason
+      end
+    end
+  end
+
+  it "makes synchronous calls to remote actors" do
+    @remote_actor.value.should == 42
+  end
+
+  it "handles blocks" do
+    result = nil
+    @remote_actor.win do |value|
+      result = value
+    end
+    result.should == 10000
+  end
+
+  it "makes future calls to remote actors" do
+    @remote_actor.future(:value).value.should == 42
+  end
+
+  context :linking do
+    before :each do
+      @local_actor = LocalActor.new
+    end
+
+    it "links to remote actors" do
+      @local_actor.link @remote_actor
+      @local_actor.linked_to?(@remote_actor).should be_true
+      @remote_actor.linked_to?(@local_actor).should be_true
+    end
+
+    it "unlinks from remote actors" do
+      @local_actor.link @remote_actor
+      @local_actor.unlink @remote_actor
+
+      @local_actor.linked_to?(@remote_actor).should be_false
+      @remote_actor.linked_to?(@local_actor).should be_false
+    end
+
+    it "traps exit messages from other actors" do
+      @local_actor.link @remote_actor
+
+      expect do
+        @remote_actor.crash
+      end.to raise_exception(RuntimeError)
+
+      sleep 0.1 # hax to prevent a race between exit handling and the next call
+      @local_actor.crash_reason.should be_a(RuntimeError)
+      @local_actor.crash_reason.message.should == "the spec purposely crashed me :("
+    end
+  end
+end

data/spec/dcell/celluloid_ext_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Celluloid, "extensions" do
+  before do
+    class WillKane
+      include Celluloid
+
+      def speak
+        "Don't shove me Harv."
+      end
+    end
+    @marshal = WillKane.new
+  end
+
+  it "marshals Celluloid::CellProxy objects" do
+    string = Marshal.dump(@marshal)
+    Marshal.load(string).should be_alive
+  end
+
+  it "marshals Celluloid::Mailbox objects" do
+    @marshal.mailbox.should be_a(Celluloid::Mailbox)
+    string = Marshal.dump(@marshal.mailbox)
+    Marshal.load(string).should be_alive
+  end
+
+  it "marshals Celluloid::Future objects" do
+    future = @marshal.future(:speak)
+    future.should be_a(Celluloid::Future)
+    string = Marshal.dump(future)
+    Marshal.load(string).value.should == "Don't shove me Harv."
+  end
+end

data/spec/dcell/directory_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe DCell::Directory do
+  it "stores node addresses" do
+    DCell::Directory["foobar"] = "tcp://localhost:1870"
+    DCell::Directory["foobar"].should == "tcp://localhost:1870"
+  end
+  it "presents all stored addresses" do
+    DCell::Directory["foo"] = "tcp://fooaddress"
+    DCell::Directory["bar"] = "tcp://baraddress"
+    DCell::Directory.all.should include("foo")
+    DCell::Directory.all.should include("bar")
+  end
+  it "clears node addresses" do
+    DCell::Directory["foo"] = "tcp://fooaddress"
+    DCell::Directory["foobar"].should == "tcp://localhost:1870"
+    ["foo", "foobar"].each do |node|
+      DCell::Directory.remove node
+    end
+    DCell::Directory["foobar"].should_not == "tcp://localhost:1870"
+  end
+end

data/spec/dcell/explorer_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'dcell/explorer'
+
+describe DCell::Explorer do
+  EXPLORER_HOST = 'localhost'
+  EXPLORER_PORT = 7778
+  EXPLORER_BASE = "http://#{EXPLORER_HOST}:#{EXPLORER_PORT}"
+
+  before do
+    @explorer = DCell::Explorer.new(EXPLORER_HOST, EXPLORER_PORT)
+  end
+
+  it "reports the current node's status" do
+    response = Net::HTTP.get URI(EXPLORER_BASE)
+    response[%r{<a href="/nodes/(.*?)">}, 1].should == DCell.id
+  end
+end

data/spec/dcell/global_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe DCell::Global do
+  it "can handle unexisting keys" do
+    expect { DCell::Global[:unexisting] }.to_not raise_exception
+  end
+
+  it "stores values" do
+    DCell::Global[:the_answer] = 42
+    DCell::Global[:the_answer].should == 42
+
+    # Double check the global value is available on all nodes
+    node = DCell::Node[TEST_NODE[:id]]
+    node[:test_actor].the_answer.should == 42
+  end
+
+  it "stores the keys of all globals" do
+    DCell::Global[:foo] = 1
+    DCell::Global[:bar] = 2
+    DCell::Global[:baz] = 3
+
+    keys = DCell::Global.keys
+    [:foo, :bar, :baz].each { |key| keys.should include key }
+  end
+end

data/spec/dcell/node_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe DCell::Node do
+  before do
+    @node = DCell::Node[TEST_NODE[:id]]
+    @node.id.should == TEST_NODE[:id]
+  end
+
+  it "finds all available nodes" do
+    nodes = DCell::Node.all
+    nodes.should include(DCell.me)
+  end
+
+  it "finds remote actors" do
+    actor = @node[:test_actor]
+    actor.value.should == 42
+  end
+
+  it "lists remote actors" do
+    @node.actors.should include :test_actor
+    @node.all.should include :test_actor
+  end
+end

data/spec/dcell/registries/mongodb_adapter_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+require 'dcell/registries/mongodb_adapter'
+
+describe DCell::Registry::MongodbAdapter, :pending => TEST_ADEPTER != 'mongodb' && "no mongodb" do
+  subject { DCell::Registry::MongodbAdapter.new TEST_DB[:mongodb] }
+  it_behaves_like "a DCell registry"
+end

data/spec/dcell/registries/redis_adapter_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe DCell::Registry::RedisAdapter, :pending => TEST_ADEPTER != 'redis' && "no redis" do
+  subject { DCell::Registry::RedisAdapter.new TEST_DB[:redis] }
+  it_behaves_like "a DCell registry"
+end