stn-dcell 0.16.0

data/lib/dcell/info_service.rb

@@ -0,0 +1,122 @@
+require 'rbconfig'
+
+module DCell
+  class InfoService
+    include Celluloid
+    attr_reader :os, :os_version, :hostname, :platform, :distribution
+    attr_reader :cpu_arch, :cpu_type, :cpu_vendor, :cpu_speed, :cpu_count
+    attr_reader :ruby_version, :ruby_engine, :ruby_platform
+
+    UPTIME_REGEX = /up ((\d+ days?,)?\s*(\d+:\d+|\d+ \w+)),.*(( \d.\d{2},?){3})/
+
+    def initialize
+      @cpu_arch = RbConfig::CONFIG['host_cpu']
+      @os       = RbConfig::CONFIG['host_os'][/^[A-Za-z]+/]
+
+      uname = `uname -a`.match(/\w+ (\w[\w+\.\-]*) ([\w+\.\-]+)/)
+      @hostname, @os_version = uname[1], uname[2]
+
+      @platform     = RUBY_PLATFORM
+      @ruby_version = RUBY_VERSION
+      @ruby_engine  = RUBY_ENGINE
+
+      case os
+      when 'darwin'
+        cpu_info = `sysctl -n machdep.cpu.brand_string`.match(/^((\w+).*) @ (\d+.\d+)GHz/)
+        if cpu_info
+          @cpu_type   = cpu_info[1]
+          @cpu_vendor = cpu_info[2].downcase.to_sym
+          @cpu_speed  = Float(cpu_info[3])
+        end
+
+        @cpu_count = Integer(`sysctl hw.ncpu`[/\d+/])
+        os, release, build = `sw_vers`.scan(/:\t(.*)$/).flatten
+        @distribution = "#{os} #{release} (#{build})"
+      when 'linux'
+        cpu_info = File.read("/proc/cpuinfo")
+
+        @cpu_vendor = cpu_info[/vendor_id:\s+\s+(Genuine)?(\w+)/, 2]
+        model_name  = cpu_info.match(/model name\s+:\s+((\w+).*) @ (\d+.\d+)GHz/)
+        if model_name
+          @cpu_type   = model_name[1].gsub(/\s+/, ' ')
+          @cpu_vendor = model_name[2].downcase.to_sym
+          @cpu_speed  = Float(model_name[3])
+        end
+
+        cores = cpu_info.scan(/core id\s+: \d+/).uniq.size
+        @cpu_count = cores > 0 ? cores : 1
+        @distribution = discover_distribution
+      else
+        @cpu_type = @cpu_vendor = @cpu_speed = @cpu_count = nil
+      end
+
+      case RUBY_ENGINE
+      when 'ruby'
+        @ruby_platform = "ruby #{RUBY_VERSION}"
+      when 'jruby'
+        @ruby_platform = "jruby #{JRUBY_VERSION}"
+      when 'rbx'
+        @ruby_platform = "rbx #{Rubinius::VERSION}"
+      else
+        @ruby_platform = RUBY_ENGINE
+      end
+    end
+
+    def platform; RUBY_PLATFORM; end
+    def ruby_engine; RUBY_ENGINE; end
+    def ruby_version; RUBY_VERSION; end
+
+    def load_averages(uptime_string = `uptime`)
+      matches = uptime_string.match(UPTIME_REGEX)
+      unless matches
+        Logger.warn "Couldn't parse uptime output: #{uptime_string}"
+        return
+      end
+
+      averages = matches[4].strip
+      averages.split(/,? /).map(&:to_f)
+    end
+    alias_method :load_average, :load_averages
+
+    def uptime(uptime_string = `uptime`)
+      matches = uptime_string.match(UPTIME_REGEX)
+      unless matches
+        Logger.warn "Couldn't parse uptime output: #{uptime_string}"
+        return
+      end
+
+      uptime = matches[1]
+      days_string = uptime[/^(\d+) days/, 1]
+      days_string ? Integer(days_string) : 0
+    end
+
+    def discover_distribution
+      `lsb_release -d`[/Description:\s+(.*)\s*$/, 1]
+    rescue Errno::ENOENT
+    end
+
+    def to_hash
+      uptime_string = `uptime`
+
+      {
+        :os            => os,
+        :os_version    => os_version,
+        :hostname      => hostname,
+        :platform      => platform,
+        :distribution  => distribution,
+        :ruby_version  => ruby_version,
+        :ruby_engine   => ruby_engine,
+        :ruby_platform => ruby_platform,
+        :load_averages => load_averages(uptime_string),
+        :uptime        => uptime(uptime_string),
+        :cpu => {
+          :arch   => cpu_arch,
+          :type   => cpu_type,
+          :vendor => cpu_vendor,
+          :speed  => cpu_speed,
+          :count  => cpu_count
+        }
+      }
+    end
+  end
+end

data/lib/dcell/mailbox_proxy.rb

@@ -0,0 +1,53 @@
+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(address)
+      mailbox_id, node_id = address.split("@")
+
+      # Create a proxy to the mailbox on the remote node
+      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.async.send_message Message::Relay.new(self, message)
+    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(address)
+      if mailbox = DCell::Router.find(address)
+        mailbox
+      else
+        DCell::MailboxProxy.new(address)
+      end
+    end
+  end
+end

data/lib/dcell/messages.rb

@@ -0,0 +1,65 @@
+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
+
+    # Heartbeat messages inform other nodes this node is healthy
+    class Heartbeat < Message
+      def initialize
+        @id = DCell.id
+      end
+
+      def dispatch
+        node = DCell::Node[@id]
+        node.handle_heartbeat if node
+      end
+    end
+
+    # Query a node for the address of an actor
+    class Find < Message
+      attr_reader :sender, :name
+
+      def initialize(sender, name)
+        super()
+        @sender, @name = sender, name
+      end
+
+      def dispatch
+        @sender << SuccessResponse.new(@id, Celluloid::Actor[@name])
+      end
+    end
+
+    # List all registered actors
+    class List < Message
+      attr_reader :sender
+
+      def initialize(sender)
+        super()
+        @sender = sender
+      end
+
+      def dispatch
+        @sender << 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
+        @recipient << @message
+      end
+    end
+  end
+end

data/lib/dcell/node.rb

@@ -0,0 +1,138 @@
+module DCell
+  # A node in a DCell cluster
+  class Node
+    include Celluloid
+    include Celluloid::FSM
+    attr_reader :id, :addr
+
+    finalizer :shutdown
+
+    NODE_DISCOVERY_TIMEOUT = 5
+
+    # 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
+      @heartbeat.cancel
+      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, :[], :remove, :update
+      def_delegators "Celluloid::Actor[:node_manager]", :heartbeat_rate, :heartbeat_timeout
+    end
+
+    def initialize(id, addr)
+      @id, @addr = id, addr
+      @socket = nil
+      @heartbeat = nil
+
+      # Total hax to accommodate the new Celluloid::FSM API
+      attach self
+    end
+
+    def update_client_address( addr )
+      @addr = addr
+      send_heartbeat
+    end
+
+    def update_server_address(addr)
+      @addr = addr
+    end
+
+    def shutdown
+      transition :shutdown
+      @socket.close if @socket
+    end
+
+    # Obtain the node's 0MQ socket
+    def socket
+      return @socket if @socket
+
+      @socket = Celluloid::ZMQ::PushSocket.new
+      begin
+        @socket.connect addr
+      rescue IOError
+        @socket.close
+        @socket = nil
+        raise
+      end
+
+      transition :connected
+      @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(NODE_DISCOVERY_TIMEOUT) do |msg|
+        msg.respond_to?(:request_id) && msg.request_id == request.id
+      end
+
+      return nil if response.nil?
+      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
+        message = Marshal.dump(message)
+      rescue => ex
+        abort ex
+      end
+
+      socket << message
+    end
+    alias_method :<<, :send_message
+    
+    # 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 heartbeat for this node
+    def handle_heartbeat
+      transition :connected
+      transition :partitioned, :delay => self.class.heartbeat_timeout
+    end
+
+    # Friendlier inspection
+    def inspect
+      "#<DCell::Node[#{@id}] @addr=#{@addr.inspect}>"
+    end
+  end
+end

data/lib/dcell/node_manager.rb

@@ -0,0 +1,79 @@
+module DCell
+  # Manage nodes we're connected to
+  class NodeManager
+    include Celluloid::ZMQ
+    include Enumerable
+
+    trap_exit :node_died
+
+    attr_reader :heartbeat_rate, :heartbeat_timeout
+
+    def initialize
+      @nodes = {}
+
+      @heartbeat_rate    = 5  # How often to send heartbeats in seconds
+      @heartbeat_timeout = 10 # How soon until a lost heartbeat triggers a node partition
+    end
+
+    # 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 = @nodes[id]
+      return node if node
+
+      addr = Directory[id]
+      return unless addr
+
+      if id == DCell.id
+        node = DCell.me
+      else
+        node = Node.new(id, addr)
+        self.link node
+      end
+
+      @nodes[id] ||= node
+      @nodes[id]
+    end
+    alias_method :[], :find
+
+    def node_died(node, reason)
+      if reason.nil? # wtf?
+        # this wtf error seems to come from node socket writes
+        # when the socket is not reachable anymore
+        Celluloid::logger.debug "wtf?"
+        return
+      end
+      # Handle dead node???
+    end
+
+    def update(id)
+      addr = Directory[id]
+      return unless addr
+      if ( node = @nodes[id] ) and node.alive?
+        node.update_client_address( addr )
+      else
+        @nodes[id] = Node.new( id, addr )
+      end
+    end
+
+    def remove(id)
+      if @nodes[id]
+        @nodes[id].terminate if @nodes[id].alive?
+        @nodes.delete(id)
+      end
+    end
+  end
+end