dcell 0.0.0 → 0.0.1

data/lib/dcell.rb

@@ -1,5 +1,95 @@
-require "dcell/version"
+require 'celluloid'
+require 'celluloid/zmq'
+require 'dcell/version'
 
+require 'dcell/actor_proxy'
+require 'dcell/directory'
+require 'dcell/mailbox_proxy'
+require 'dcell/messages'
+require 'dcell/node'
+require 'dcell/global'
+require 'dcell/responses'
+require 'dcell/router'
+require 'dcell/server'
+
+require 'dcell/registries/redis_adapter'
+require 'dcell/application'
+require 'dcell/celluloid_ext'
+
+# Distributed Celluloid
 module DCell
-  # Your code goes here...
+  DEFAULT_PORT  = 7777 # Default DCell port
+  ZMQ_POOL_SIZE = 1 # DCell uses a fixed-size 0MQ thread pool
+  @zmq_context  = ::ZMQ::Context.new(ZMQ_POOL_SIZE)
+  @config_lock  = Mutex.new
+
+  class << self
+    attr_reader :me, :registry, :zmq_context
+
+    # Configure DCell with the following options:
+    #
+    # * id: to identify the local node, defaults to hostname
+    # * addr: 0MQ address of the local node (e.g. tcp://4.3.2.1:7777)
+    # *
+    def setup(options = {})
+      # Stringify keys :/
+      options = options.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
+
+      @config_lock.synchronize do
+        @configuration = {
+          'id'   => generate_node_id,
+          'addr' => "tcp://127.0.0.1:#{DEFAULT_PORT}",
+          'registry' => {'adapter' => 'redis', 'server' => 'localhost'}
+        }.merge(options)
+
+        @me = Node.new @configuration['id'], @configuration['addr']
+
+        registry_adapter = @configuration['registry'][:adapter] || @configuration['registry']['adapter']
+        raise ArgumentError, "no registry adapter given in config" unless registry_adapter
+
+        registry_class_name = registry_adapter.split("_").map(&:capitalize).join << "Adapter"
+
+        begin
+          registry_class = DCell::Registry.const_get registry_class_name
+        rescue NameError
+          raise ArgumentError, "invalid registry adapter: #{@configuration['registry']['adapter']}"
+        end
+
+        @registry = registry_class.new(@configuration['registry'])
+
+        addr = @configuration['public'] || @configuration['addr']
+        DCell::Directory.set @configuration['id'], addr
+      end
+
+      me
+    end
+
+    # Obtain the local node ID
+    def id; @configuration['id']; end
+
+    # Obtain the 0MQ address to the local mailbox
+    def addr; @configuration['addr']; end
+    alias_method :address, :addr
+
+    # Attempt to generate a unique node ID for this machine
+    def generate_node_id
+      `hostname`.strip # Super creative I know
+    end
+
+    # Run the DCell application
+    def run
+      DCell::Application.run
+    end
+
+    # Run the DCell application in the background
+    def run!
+      DCell::Application.run!
+    end
+
+    # Start combines setup and run! into a single step
+    def start(options = {})
+      setup options
+      run!
+    end
+  end
 end

data/lib/dcell/actor_proxy.rb

@@ -0,0 +1,4 @@
+module DCell
+  # Proxy object for actors that live on remote nodes
+  class ActorProxy < Celluloid::ActorProxy; end
+end

data/lib/dcell/application.rb

@@ -0,0 +1,6 @@
+module DCell
+  # Actors which run when DCell is active
+  class Application < Celluloid::Application
+    supervise Server, :as => :dcell_server
+  end
+end

data/lib/dcell/celluloid_ext.rb

@@ -0,0 +1,57 @@
+# Celluloid mailboxes are the universal message exchange points. You won't
+# be able to marshal them though, unfortunately, because they contain
+# mutexes.
+#
+# DCell provides a message routing layer between nodes that can direct
+# messages back to local mailboxes. To accomplish this, DCell adds custom
+# marshalling to mailboxes so that if they're unserialized on a remote
+# node you instead get a proxy object that routes messages through the
+# DCell overlay network back to the node where the actor actually exists
+
+module Celluloid
+  class ActorProxy
+    # Marshal uses respond_to? to determine if this object supports _dump so
+    # unfortunately we have to monkeypatch in _dump support as the proxy
+    # itself normally jacks respond_to? and proxies to the actor
+    alias_method :__respond_to?, :respond_to?
+    def respond_to?(meth)
+      return false if meth == :marshal_dump
+      return true  if meth == :_dump
+      __respond_to? meth
+    end
+
+    # Dump an actor proxy via its mailbox
+    def _dump(level)
+      @mailbox._dump(level)
+    end
+
+    # Create an actor proxy object which routes messages over DCell's overlay
+    # network and back to the original mailbox
+    def self._load(string)
+      mailbox = Celluloid::Mailbox._load(string)
+
+      case mailbox
+      when DCell::MailboxProxy
+        DCell::ActorProxy.new mailbox
+      when Celluloid::Mailbox
+        Celluloid::ActorProxy.new(mailbox)
+      else raise "funny, I did not expect to see a #{mailbox.class} here"
+      end
+    end
+  end
+
+  class Mailbox
+    # This custom dumper registers actors with the DCell registry so they can
+    # be reached remotely.
+    def _dump(level)
+      mailbox_id = DCell::Router.register self
+      "#{mailbox_id}@#{DCell.id}"
+    end
+
+    # Create a mailbox proxy object which routes messages over DCell's overlay
+    # network and back to the original mailbox
+    def self._load(string)
+      DCell::MailboxProxy._load(string)
+    end
+  end
+end

data/lib/dcell/directory.rb

@@ -0,0 +1,23 @@
+module DCell
+  # Directory of nodes connected to the DCell cluster
+  module Directory
+    extend self
+
+    # Get the URL for a particular Node ID
+    def get(node_id)
+      DCell.registry.get_node node_id
+    end
+    alias_method :[], :get
+
+    # Set the address of a particular Node ID
+    def set(node_id, addr)
+      DCell.registry.set_node node_id, addr
+    end
+    alias_method :[]=, :set
+
+    # List all of the node IDs in the directory
+    def all
+      DCell.registry.nodes
+    end
+  end
+end

data/lib/dcell/global.rb

@@ -0,0 +1,23 @@
+module DCell
+  # Global object registry shared among all DCell nodes
+  module Global
+    extend self
+
+    # Get a global value
+    def get(key)
+      DCell.registry.get_global key.to_s
+    end
+    alias_method :[], :get
+
+    # Set a global value
+    def set(key, value)
+      DCell.registry.set_global key.to_s, value
+    end
+    alias_method :[]=, :set
+
+    # Get the keys for all the globals in the system
+    def keys
+      DCell.registry.global_keys.map(&:to_sym)
+    end
+  end
+end

data/lib/dcell/mailbox_proxy.rb

@@ -0,0 +1,61 @@
+module DCell
+  # A proxy object for a mailbox that delivers messages to the real mailbox on
+  # a remote node on a server far, far away...
+  class MailboxProxy
+    class InvalidNodeError < StandardError; end
+
+    def initialize(node_id, mailbox_id)
+      raise ArgumentError, "no mailbox_id given" unless mailbox_id
+
+      @node_id = node_id
+      @node = Node[node_id]
+      raise ArgumentError, "invalid node_id given" unless @node
+
+      @mailbox_id = mailbox_id
+    end
+
+    # name@host style address
+    def address
+      "#{@mailbox_id}@#{@node_id}"
+    end
+
+    def inspect
+      "#<DCell::MailboxProxy:0x#{object_id.to_s(16)} #{address}>"
+    end
+
+    # Send a message to the mailbox
+    def <<(message)
+      @node.send_message! Message::Relay.new(@mailbox_id, message)
+    end
+
+    # Send a system event
+    def system_event(event)
+      @node.send_message! Message::SystemEvent.new(@mailbox_id, event)
+    end
+
+    # Is the remote mailbox still alive?
+    def alive?
+      true # FIXME: hax!
+    end
+
+    # Custom marshaller for compatibility with Celluloid::Mailbox marshalling
+    def _dump(level)
+      "#{@mailbox_id}@#{@node_id}"
+    end
+
+    # Loader for custom marshal format
+    def self._load(string)
+      mailbox_id, node_id = string.split("@")
+
+      if DCell.id == node_id
+        # If we're on the local node, find the real mailbox
+        mailbox = DCell::Router.find mailbox_id
+        raise "tried to unmarshal dead Celluloid::Mailbox: #{mailbox_id}" unless mailbox
+        mailbox
+      else
+        # Create a proxy to the mailbox on the remote node
+        DCell::MailboxProxy.new(node_id, mailbox_id)
+      end
+    end
+  end
+end

data/lib/dcell/messages.rb

@@ -0,0 +1,67 @@
+module DCell
+  class Message
+    attr_reader :id
+
+    def initialize
+      # Memoize the original object ID so it will get marshalled
+      # Perhaps this should use a real UUID scheme
+      @id = object_id
+    end
+
+    # Query a node for the address of an actor
+    class Find < Message
+      attr_reader :caller, :name
+
+      def initialize(caller, name)
+        super()
+        @caller, @name = caller, name
+      end
+
+      def dispatch
+        @caller << SuccessResponse.new(@id, Celluloid::Actor[@name])
+      end
+    end
+
+    # List all registered actors
+    class List < Message
+      attr_reader :caller
+
+      def initialize(caller)
+        super()
+        @caller = caller
+      end
+
+      def dispatch
+        @caller << SuccessResponse.new(@id, Celluloid::Actor.registered)
+      end
+    end
+
+    # Relay a message to the given recipient
+    class Relay < Message
+      attr_reader :recipient, :message
+
+      def initialize(recipient, message)
+        super()
+        @recipient, @message = recipient, message
+      end
+
+      def dispatch
+        DCell::Router.route @recipient, @message
+      end
+    end
+
+    # Send a system event to the given recipient
+    class SystemEvent < Message
+      attr_reader :recipient, :event
+
+      def initialize(recipient, event)
+        super()
+        @recipient, @event = recipient, event
+      end
+
+      def dispatch
+        DCell::Router.route_system_event @recipient, @event
+      end
+    end
+  end
+end

data/lib/dcell/node.rb

@@ -0,0 +1,120 @@
+module DCell
+  # A node in a DCell cluster
+  class Node
+    include Celluloid
+    attr_reader :id, :addr
+
+    @nodes = {}
+    @lock  = Mutex.new
+
+    class << self
+      include Enumerable
+
+      # Return all available nodes in the cluster
+      def all
+        Directory.all.map do |node_id|
+          find node_id
+        end
+      end
+
+      # Iterate across all available nodes
+      def each
+        Directory.all.each do |node_id|
+          yield find node_id
+        end
+      end
+
+      # Find a node by its node ID
+      def find(id)
+        node = @lock.synchronize { @nodes[id] }
+        return node if node
+
+        addr = Directory[id]
+
+        if addr
+          if id == DCell.id
+            node = DCell.me
+          else
+            node = Node.new(id, addr)
+          end
+
+          @lock.synchronize do
+            @nodes[id] ||= node
+            @nodes[id]
+          end
+        end
+      end
+      alias_method :[], :find
+    end
+
+    def initialize(id, addr)
+      @id, @addr = id, addr
+      @socket = nil
+    end
+
+    def finalize
+      @socket.close if socket
+    end
+
+    # Obtain the node's 0MQ socket
+    def socket
+      return @socket if @socket
+
+      @socket = DCell.zmq_context.socket(::ZMQ::PUSH)
+      unless ::ZMQ::Util.resultcode_ok? @socket.connect @addr
+        @socket.close
+        @socket = nil
+        raise "error connecting to #{addr}: #{::ZMQ::Util.error_string}"
+      end
+
+      @socket
+    end
+
+    # Find an actor registered with a given name on this node
+    def find(name)
+      request = Message::Find.new(Thread.mailbox, name)
+      send_message request
+
+      response = receive do |msg|
+        msg.respond_to?(:request_id) && msg.request_id == request.id
+      end
+
+      abort response.value if response.is_a? ErrorResponse
+      response.value
+    end
+    alias_method :[], :find
+
+    # List all registered actors on this node
+    def actors
+      request = Message::List.new(Thread.mailbox)
+      send_message request
+
+      response = receive do |msg|
+        msg.respond_to?(:request_id) && msg.request_id == request.id
+      end
+
+      abort response.value if response.is_a? ErrorResponse
+      response.value
+    end
+    alias_method :all, :actors
+
+    # Send a message to another DCell node
+    def send_message(message)
+      begin
+        string = Marshal.dump(message)
+      rescue => ex
+        abort ex
+      end
+
+      unless ::ZMQ::Util.resultcode_ok? socket.send_string string
+        raise "error sending 0MQ message: #{::ZMQ::Util.error_string}"
+      end
+    end
+    alias_method :<<, :send_message
+
+    # Friendlier inspection
+    def inspect
+      "#<DCell::Node[#{@id}] @addr=#{@addr.inspect}>"
+    end
+  end
+end