dcell 0.0.0 → 0.0.1

data/lib/dcell/registries/redis_adapter.rb

@@ -0,0 +1,86 @@
+require 'redis'
+require 'redis-namespace'
+
+module DCell
+  module Registry
+    class RedisAdapter
+      def initialize(options)
+        # Convert all options to symbols :/
+        options = options.inject({}) { |h,(k,v)| h[k.to_sym] = v; h }
+
+        @env = options[:env] || 'production'
+        @namespace = options[:namespace] || "dcell_#{@env}"
+
+        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
+        end
+
+        def get(key)
+          string = @redis.hget 'globals', key.to_s
+          Marshal.load string
+        end
+
+        # Set a global value
+        def set(key, value)
+          string = Marshal.dump value
+          @redis.hset 'globals', key.to_s, string
+        end
+
+        # The keys to all globals in the system
+        def global_keys
+          @redis.hkeys 'globals'
+        end
+
+        def clear
+          @redis.del 'globals'
+        end
+      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
+    end
+  end
+end

data/lib/dcell/registries/zk_adapter.rb

@@ -0,0 +1,122 @@
+require 'zk'
+
+module DCell
+  module Registry
+    class ZkAdapter
+      PREFIX  = "/dcell"
+      DEFAULT_PORT = 2181
+
+      # Create a new connection to Zookeeper
+      #
+      # servers: a list of Zookeeper servers to connect to. Each server in the
+      #          list has a host/port configuration
+      def initialize(options)
+        # Stringify keys :/
+        options = options.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
+
+        @env = options['env'] || 'production'
+        @base_path = "#{PREFIX}/#{@env}"
+
+        # Let them specify a single server instead of many
+        server = options['server']
+        if server
+          servers = [server]
+        else
+          servers = options['servers']
+          raise "no Zookeeper servers given" unless servers
+        end
+
+        # Add the default Zookeeper port unless specified
+        servers.map! do |server|
+          if server[/:\d+$/]
+            server
+          else
+            "#{server}:#{DEFAULT_PORT}"
+          end
+        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"
+          @zk.mkdir_p @base_path
+        end
+
+        def get(key)
+          value, _ = @zk.get "#{@base_path}/#{key}"
+          Marshal.load value
+        rescue ZK::Exceptions::NoNode
+        end
+
+        # Set a global value
+        def set(key, value)
+          path = "#{@base_path}/#{key}"
+          string = Marshal.dump value
+
+          @zk.set path, string
+        rescue ZK::Exceptions::NoNode
+          @zk.create path, string
+        end
+
+        # The keys to all globals in the system
+        def global_keys
+          @zk.children(@base_path)
+        end
+
+        def clear
+          @zk.rm_rf @base_path
+          @zk.mkdir_p @base_path
+        end
+      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
+    end
+  end
+end

data/lib/dcell/responses.rb

@@ -0,0 +1,16 @@
+module DCell
+  # Responses to calls
+  class Response
+    attr_reader :request_id, :value
+
+    def initialize(request_id, value)
+      @request_id, @value = request_id, value
+    end
+  end
+
+  # Request successful
+  class SuccessResponse < Response; end
+
+  # Request failed
+  class ErrorResponse < Response; end
+end

data/lib/dcell/router.rb

@@ -0,0 +1,71 @@
+require 'weakref'
+
+module DCell
+  # Route incoming messages to their recipient actors
+  class Router
+    @lock = Mutex.new
+    @table = {}
+
+    class << self
+      # Enter a mailbox into the registry
+      def register(mailbox)
+        id = mailbox.object_id.to_s(16)
+
+        @lock.synchronize do
+          ref = @table[id]
+          unless ref && ref.weakref_alive?
+            @table[id] = WeakRef.new(mailbox)
+          end
+        end
+
+        id
+      end
+
+      # Find a mailbox by its ID
+      def find(mailbox_id)
+        @lock.synchronize do
+          ref = @table[mailbox_id]
+          return unless ref
+          begin
+            ref.__getobj__
+          rescue WeakRef::RefError
+            # The referenced actor is dead, so prune the registry
+            @table.delete mailbox_id
+            nil
+          end
+        end
+      end
+
+      # Route a message to a given mailbox ID
+      def route(mailbox_id, message)
+        recipient = find mailbox_id
+
+        if recipient
+          recipient << message
+        else
+          Celluloid::Logger.debug("received message for invalid actor: #{mailbox_id.inspect}")
+        end
+      end
+
+      # Route a system event to a given mailbox ID
+      def route_system_event(mailbox_id, event)
+        recipient = find mailbox_id
+
+        if recipient
+          recipient.system_event event
+        else
+          Celluloid::Logger.debug("received message for invalid actor: #{mailbox_id.inspect}")
+        end
+      end
+
+      # Prune all entries that point to dead objects
+      def gc
+        @lock.synchronize do
+          @table.each do |id, ref|
+            @table.delete id unless ref.weakref_alive?
+          end
+        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,80 @@
+module DCell
+  # Servers handle incoming 0MQ traffic
+  class Server
+    include Celluloid::ZMQ
+
+    # Bind to the given 0MQ address (in URL form ala tcp://host:port)
+    def initialize
+      @addr   = DCell.addr
+      @socket = DCell.zmq_context.socket(::ZMQ::PULL)
+
+      unless ::ZMQ::Util.resultcode_ok? @socket.setsockopt(::ZMQ::LINGER, 0)
+        @socket.close
+        raise "couldn't set ZMQ::LINGER: #{::ZMQ::Util.error_string}"
+      end
+
+      unless ::ZMQ::Util.resultcode_ok? @socket.bind(@addr)
+        @socket.close
+        raise "couldn't bind to #{@addr}: #{::ZMQ::Util.error_string}"
+      end
+
+      run!
+    end
+
+    # Wait for incoming 0MQ messages
+    def run
+      while true
+        wait_readable @socket
+        message = ''
+
+        rc = @socket.recv_string message
+        if ::ZMQ::Util.resultcode_ok? rc
+          handle_message message
+        else
+          raise "error receiving ZMQ string: #{::ZMQ::Util.error_string}"
+        end
+      end
+    end
+
+    # Shut down the server
+    def finalize
+      @socket.close
+    end
+
+    # Handle incoming messages
+    def handle_message(message)
+      begin
+        message = decode_message message
+      rescue InvalidMessageError => ex
+        Celluloid::Logger.warn("couldn't decode message: #{ex.class}: #{ex}")
+        return
+      end
+
+      begin
+        message.dispatch
+      rescue Exception => ex
+        Celluloid::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

@@ -1,3 +1,3 @@
 module DCell
-  VERSION = "0.0.0"
+  VERSION = "0.0.1"
 end

data/spec/celluloid/zmq/mailbox_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'celluloid/rspec'
+
+describe Celluloid::ZMQ::Mailbox do
+  it_behaves_like "a Celluloid Mailbox"
+end

data/spec/dcell/actor_proxy_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe DCell::ActorProxy do
+  before :all do
+    @node = DCell::Node['test_node']
+    @node.id.should == 'test_node'
+    @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
+
+  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.to_s.should == "the spec purposely crashed me :("
+    end
+  end
+end