dripdrop 0.9.10 → 0.10.0.beta1

data/lib/dripdrop/handlers/zeromq.rb

@@ -12,16 +12,28 @@ class DripDrop
   end
 
   class ZMQBaseHandler < BaseHandler
-    attr_accessor :connection
+    attr_reader :connection
 
     def initialize(opts={})
       @opts         = opts
       @connection   = nil
       @msg_format   = opts[:msg_format] || :dripdrop
+      @message_class = @opts[:message_class] || DripDrop.default_message_class
+    end
+
+    def add_connection(connection)
+      @connection = connection
+    end
+
+    def read_connection
+      @connection
+    end
+
+    def write_connection
+      @connection
     end
 
     def on_recv(msg_format=:dripdrop,&block)
-      @msg_format = msg_format
       @recv_cbak = block
       self
     end
@@ -41,27 +53,13 @@ class DripDrop
       @send_queue_enabled = false
     end
 
-    def on_writable(socket)
+    def on_writable(conn)
       unless @send_queue.empty?
         message = @send_queue.shift
 
-        num_parts = message.length
-        message.each_with_index do |part,i|
-          # Set the multi-part flag unless this is the last message
-          flags = (i + 1 < num_parts ? ZMQ::SNDMORE : 0) | ZMQ::NOBLOCK
-
-          if part.class == ZMQ::Message
-            socket.send(part, flags)
-          else
-            if part.class == String
-              socket.send_string(part, flags)
-            else
-              $stderr.write "Can only send Strings, not #{part.class}: #{part}" if @debug
-            end
-          end
-        end
+        conn.send_msg(*message)
       else
-        @connection.deregister_writable if @send_queue_enabled
+        conn.deregister_writable if @send_queue_enabled
       end
     end
 
@@ -78,27 +76,18 @@ class DripDrop
       else
         @send_queue.push([message])
       end
-        
       
-      if @send_queue_enabled
-        @connection.register_writable
+      self.write_connection.register_writable if @send_queue_enabled
          
-        # Not sure why this is necessary, this is likely a bug in em-zeromq
-        on_writable(@connection.socket)
-      else
-        on_writable(@connection.socket)
-      end
+      EM::next_tick {
+        on_writable(self.write_connection)
+      }
     end
   end
 
   module ZMQReadableHandler
     attr_accessor :message_class
-
-    def initialize(*args)
-      super(*args)
-      @message_class = @opts[:message_class] || DripDrop.default_message_class
-    end
-
+     
     def decode_message(msg)
       @message_class.decode(msg)
     end
@@ -109,7 +98,10 @@ class DripDrop
         when :raw
           @recv_cbak.call(messages)
         when :dripdrop
-          raise "Expected message in one part" if messages.length > 1
+          if messages.length > 1
+            raise "Expected message in one part for #{self.inspect}, got #{messages.map(&:copy_out_string)}"
+          end
+          
           body  = messages.shift.copy_out_string
           @recv_cbak.call(decode_message(body))
         else
@@ -119,10 +111,6 @@ class DripDrop
         handle_error(e)
       end
     end
-
-    def post_setup
-      @connection.register_readable
-    end
   end
 
   class ZMQSubHandler < ZMQBaseHandler
@@ -136,17 +124,21 @@ class DripDrop
     end
 
     def on_readable(socket, messages)
-      if @msg_format == :dripdrop
-        unless messages.length == 2
-          return false
-        end
-        topic = messages.shift.copy_out_string
-        if @topic_filter.nil? || topic.match(@topic_filter)
-          body  = messages.shift.copy_out_string
-          @recv_cbak.call(decode_message(body))
+      begin
+        if @msg_format == :dripdrop
+          unless messages.length == 2
+            return false
+          end
+          topic = messages.shift.copy_out_string
+          if @topic_filter.nil? || topic.match(@topic_filter)
+            body  = messages.shift.copy_out_string
+            @recv_cbak.call(decode_message(body))
+          end
+        else
+          super(socket,messages)
         end
-      else
-        super(socket,messages)
+      rescue StandardError => e
+        handle_error(e)
       end
     end
 
@@ -161,7 +153,7 @@ class DripDrop
 
     #Sends a message along
     def send_message(message)
-      dd_message = dd_messagify(message)
+      dd_message = dd_messagify(message,@message_class)
       if dd_message.is_a?(DripDrop::Message)
         super([dd_message.name, dd_message.encoded])
       else
@@ -172,8 +164,6 @@ class DripDrop
 
   class ZMQPullHandler < ZMQBaseHandler
     include ZMQReadableHandler
-
-
   end
 
   class ZMQPushHandler < ZMQBaseHandler
@@ -190,12 +180,43 @@ class DripDrop
 
     def on_readable(socket,messages)
       if @msg_format == :dripdrop
-        identities = messages[0..-2].map {|m| m.copy_out_string}
-        body       = messages.last.copy_out_string
-        message    = decode_message(body)
-        seq        = message.head[SEQ_CTR_KEY]
-        response   = ZMQXRepHandler::Response.new(self, identities,seq)
-        @recv_cbak.call(message,response)
+        begin
+          if messages.length < 3
+            raise "Expected message in at least 3 parts, got #{messages.map(&:copy_out_string).inspect}"
+          end
+           
+          message_strings = messages.map(&:copy_out_string)
+          
+          # parse the message into identities, delimiter and body
+          identities = []
+          delimiter  = nil
+          body       = nil
+          # It's an identitiy if it isn't an empty string
+          # Once we hit the delimiter, we know the rest after is the body
+          message_strings.each_with_index do |ms,i|
+            unless ms.empty?
+              identities << ms
+            else
+              delimiter = ms
+               
+              unless message_strings.length == i+2
+                raise "Expected body in 1 part got '#{message_strings.inspect}'"
+              end
+               
+              body  = message_strings[i+1]
+              break
+            end
+          end
+          
+          raise "Received xreq message with no body!" unless body
+          message    = decode_message(body)
+          raise "Received nil message! #{body}" unless message
+          seq        = message.head[SEQ_CTR_KEY]
+          response   = ZMQXRepHandler::Response.new(self,identities,seq,@message_class)
+          @recv_cbak.call(message,response) if @recv_cbak
+        rescue StandardError => e
+          handle_error(e)
+        end
       else
         super(socket,messages)
       end
@@ -217,14 +238,15 @@ class DripDrop
   class ZMQXRepHandler::Response < ZMQBaseHandler
     attr_accessor :xrep, :seq, :identities
     
-    def initialize(xrep,identities,seq)
+    def initialize(xrep,identities,seq,message_class)
       @xrep = xrep
       @seq  = seq
-      @identities = identities
+      @identities    = identities
+      @message_class = message_class
     end
     
     def send_message(message)
-      dd_message = dd_messagify(message)
+      dd_message = dd_messagify(message,@message_class)
       @xrep.send_message(dd_message,identities,seq)
     end
   end
@@ -240,22 +262,30 @@ class DripDrop
       @promises = {}
 
       self.on_recv do |message|
-        seq = message.head[SEQ_CTR_KEY]
-        raise "Missing Seq Counter" unless seq
-        promise = @promises.delete(seq)
-        promise.call(message) if promise
+        begin
+          seq = message.head[SEQ_CTR_KEY]
+          raise "Missing Seq Counter" unless seq
+          promise = @promises.delete(seq)
+          promise.call(message) if promise
+        rescue StandardError => e
+          handle_error(e)
+        end
       end
     end
 
     def send_message(message,&block)
-      dd_message = dd_messagify(message)
-      if dd_message.is_a?(DripDrop::Message)
-        @seq_counter += 1
-        dd_message.head[SEQ_CTR_KEY] = @seq_counter
-        @promises[@seq_counter] = block if block
-        message = dd_message
+      begin
+        dd_message = dd_messagify(message,@message_class)
+        if dd_message.is_a?(DripDrop::Message)
+          @seq_counter += 1
+          dd_message.head[SEQ_CTR_KEY] = @seq_counter
+          @promises[@seq_counter] = block if block
+          message = dd_message
+        end
+      rescue StandardError => e
+        handle_error(e)
       end
-      super(message)
+      super(['', message.encoded])
     end
 
     def on_readable(socket, messages)

data/lib/dripdrop/message.rb

@@ -1,6 +1,6 @@
 require 'rubygems'
 
-if PLATFORM == 'java'
+if RUBY_PLATFORM == 'java'
   require 'json'
 else
   require 'yajl'
@@ -82,7 +82,7 @@ class DripDrop
        
       klass = (hash['head'] && hash['head']['message_class']) ? constantize(hash['head']['message_class']) : nil
       if klass && (!(klass == self) && !self.subclasses.include?(klass))
-        raise DripDrop::WrongMessageClassError, "Wrong message class '#{klass}', expected '#{self}'"
+        raise DripDrop::WrongMessageClassError, "Wrong message class '#{klass}', expected '#{self}' for message #{hash.inspect}"
       end
        
       klass ? klass.from_hash(hash) : self.from_hash(hash)

data/lib/dripdrop/node.rb

@@ -9,28 +9,29 @@ require 'dripdrop/message'
 require 'dripdrop/node/nodelet'
 require 'dripdrop/handlers/base'
 require 'dripdrop/handlers/zeromq'
-require 'dripdrop/handlers/websockets'
+require 'dripdrop/handlers/websocket_server'
+require 'dripdrop/handlers/mongrel2'
 require 'dripdrop/handlers/http_client'
 
 begin
   require 'dripdrop/handlers/http_server'
 rescue LoadError => e
-  $stderr.write "Could not load http server, your probably don't have eventmachine_httpserver installed\n"
-  $stderr.write e.message + "\n"
-  $stderr.write e.backtrace.join("\t\n")
+  $stderr.write "Warning, could not load http server, your probably don't have eventmachine_httpserver installed\n"
 end
 
 class DripDrop
   class Node
     ZCTX = ZMQ::Context.new 1
     
-    attr_reader   :zm_reactor, :routing, :nodelets
+    attr_reader   :zm_reactor, :routing, :nodelets, :run_list
     attr_accessor :debug
     
     def initialize(opts={},&block)
       @block      = block
       @thread     = nil # Thread containing the reactors
       @routing    = {}  # Routing table
+      @run_list   = opts['run_list'] || opts[:run_list] || nil  #List of nodelets to run
+      @run_list   = @run_list.map(&:to_sym) if @run_list
       @debug      = opts[:debug]
       @recipients_for       = {}
       @handler_default_opts = {:debug => @debug}
@@ -42,7 +43,7 @@ class DripDrop
     # This is non-blocking.
     def start
       @thread = Thread.new do
-        EM.error_handler {|e| self.error_handler e}
+        EM.error_handler {|e| self.class.error_handler e}
         EM.run { action }
       end
     end
@@ -146,8 +147,26 @@ class DripDrop
     #
     # If you specify a block, Nodelet#action will be ignored and the block
     # will be run
+    # 
+    # Nodelets are made available as instance methods on the current DripDrop::Nodelet
+    # Object, so the following works as well:
+    #
+    #    nodelet :mynodelet
+    #    
+    #    mynodelet.route :route_name, :zmq_xreq, 'tcp://127.0.0.1:2000', ;bind
     def nodelet(name,klass=Nodelet,*configure_args,&block)
+      # If there's a run list, only run nodes in that list
+      return nil if @run_list && !@run_list.include?(name.to_sym)
+       
       nlet = @nodelets[name] ||= klass.new(self,name,*configure_args)
+      
+      # Define a method returning the nodelet in the current node
+      unless respond_to?(name)
+       (class << self; self; end).class_eval do
+          define_method(name) { nlet }
+        end
+      end
+       
       if block
         block.call(nlet)
       else
@@ -156,6 +175,10 @@ class DripDrop
       nlet
     end
     
+    def zmq_m2(addresses, opts={}, &block)
+      zmq_handler(DripDrop::Mongrel2Handler, [ZMQ::PULL, ZMQ::PUB], addresses, [:connect, :connect], opts)
+    end
+
     # Creates a ZMQ::SUB type socket. Can only receive messages via +on_recv+.
     # zmq_subscribe sockets have a +topic_filter+ option, which restricts which
     # messages they can receive. It takes a regexp as an option.
@@ -199,11 +222,11 @@ class DripDrop
       zmq_handler(DripDrop::ZMQXReqHandler,ZMQ::XREQ,address,socket_ctype,opts)
     end
 
-    # Binds an EM websocket connection to +address+. takes blocks for
+    # Binds an EM websocket server connection to +address+. takes blocks for
     # +on_open+, +on_recv+, +on_close+ and +on_error+.
     #
     # For example +on_recv+ could be used to echo incoming messages thusly:
-    #    websocket(addr).on_open {|conn|
+    #    websocket_server(addr).on_open {|conn|
     #      ws.send_message(:name => 'ws_open_ack')
     #    }.on_recv {|msg,conn|
     #      conn.send(msg)
@@ -213,12 +236,18 @@ class DripDrop
     #
     # The +ws+ object that's passed into the handlers is not
     # the +DripDrop::WebSocketHandler+ object, but an em-websocket object.
-    def websocket(address,opts={})
+    def websocket_server(address,opts={})
       uri     = URI.parse(address)
       h_opts  = handler_opts_given(opts)
       DripDrop::WebSocketHandler.new(uri,h_opts)
     end
     
+    # DEPRECATED: Use websocket_server
+    def websocket(*args)
+      $stderr.write "DripDrop#websocket handler is deprecated, use DripDrop#websocket_server"
+      websocket_server(*args)
+    end
+    
     # Starts a new Thin HTTP server listening on address.
     # Can have an +on_recv+ handler that gets passed +msg+ and +response+ args.
     #    http_server(addr) {|msg,response| response.send_message(msg)}
@@ -285,22 +314,32 @@ class DripDrop
     private
      
     def zmq_handler(klass, sock_type, address, socket_ctype, opts={})
-      addr_uri = URI.parse(address)
-      
-      host_str = addr_uri.host
-      #if addr_uri.scheme == 'tcp'  
-      #  host = Resolv.getaddresses(addr_uri.host).first
-      #  host_addr = Resolv.getaddresses('localhost').map {|a| IPAddr.new(a)}.find {|a| a.ipv4?}
-      #  host_str  = host_addr.ipv6? ? "[#{host_addr.to_s}]" : host_addr.to_s
-      #else
-      #  host_str = addr_uri.host
-      #end
+      h_opts = handler_opts_given(opts)
+
+      sock_type = [sock_type].flatten
+      address = [address].flatten
+      socket_ctype = [socket_ctype].flatten
+
+      handler = klass.new(h_opts)
+
+      sock_type.length.times do |index|
+        addr_uri = URI.parse(address[index])
+
+        host_str = addr_uri.host
+        #if addr_uri.scheme == 'tcp'
+        #  host = Resolv.getaddresses(addr_uri.host).first
+        #  host_addr = Resolv.getaddresses('localhost').map {|a| IPAddr.new(a)}.find {|a| a.ipv4?}
+        #  host_str  = host_addr.ipv6? ? "[#{host_addr.to_s}]" : host_addr.to_s
+        #else
+        #  host_str = addr_uri.host
+        #end
+
+        z_addr = "#{addr_uri.scheme}://#{host_str}:#{addr_uri.port.to_i}"
+
+        connection = EM::ZeroMQ::Context.new(@zctx).create sock_type[index], socket_ctype[index], z_addr, handler
+        handler.add_connection connection
+      end
 
-      z_addr      =  "#{addr_uri.scheme}://#{host_str}:#{addr_uri.port.to_i}"
-      h_opts      = handler_opts_given(opts)
-      connection = EM::ZeroMQ.create @zctx, sock_type, socket_ctype, address, klass.new(h_opts)
-      handler            = connection.handler
-      handler.connection = connection
       handler.post_setup
       handler
     end   

data/spec/node/websocket_spec.rb

@@ -17,7 +17,7 @@ describe "websockets" do
     @node = run_reactor(2) do
       addr = rand_addr('ws')
       
-      server = websocket(addr)
+      server = websocket_server(addr)
       server.on_open do |conn|
         conn.send_message(open_message)
         seen_signatures << conn.signature

data/spec/node/zmq_m2_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+m2_req    = '34f9cfef-dc52-4b7f-b197-098765432112 16 /handlertest 537:{"PATH":"/handlertest","accept-language":"en-us,en;q=0.5","user-agent":"Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.13) Gecko/20110207 Gentoo Firefox/3.6.13","host":"it.wishdev.org:6767","accept-charset":"ISO-8859-1,utf-8;q=0.7,*;q=0.7","accept":"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8","keep-alive":"115","x-forwarded-for":"127.0.0.1","cache-control":"max-age=0","connection":"keep-alive","accept-encoding":"gzip,deflate","METHOD":"GET","VERSION":"HTTP/1.1","URI":"/handlertest","PATTERN":"/handlertest"},0:,'
+dd_resp   = "34f9cfef-dc52-4b7f-b197-098765432112 2:16, HTTP/1.1 200 OK\r\nContent-Length: 19\r\n\r\nHello from DripDrop"
+
+body      = ""
+conn_id   = "16"
+headers   = {"PATH"=>"/handlertest",
+              "accept-language"=>"en-us,en;q=0.5",
+              "user-agent"=>
+                "Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.13) Gecko/20110207 Gentoo Firefox/3.6.13",
+              "host"=>"it.wishdev.org:6767",
+              "accept-charset"=>"ISO-8859-1,utf-8;q=0.7,*;q=0.7",
+              "accept"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+              "keep-alive"=>"115",
+              "x-forwarded-for"=>"127.0.0.1",
+              "cache-control"=>"max-age=0",
+              "connection"=>"keep-alive",
+              "accept-encoding"=>"gzip,deflate",
+              "METHOD"=>"GET",
+              "VERSION"=>"HTTP/1.1",
+              "URI"=>"/handlertest",
+              "PATTERN"=>"/handlertest"}
+path      = "/handlertest"
+sender    = "34f9cfef-dc52-4b7f-b197-098765432112"
+
+describe "zmq m2" do
+  def pp_send_messages(to_send)
+    responses = []
+    requests = []
+    
+    @node = run_reactor(2) do
+      addr = rand_addr
+      addr2 = rand_addr
+      
+      m2_send = zmq_push(addr, :bind, {:msg_format => :raw})
+      m2_recv = zmq_subscribe(addr2, :bind, {:msg_format => :raw})
+      
+      dd = zmq_m2([addr, addr2])
+
+      dd.on_recv do |req|
+        requests << req
+        dd.reply_http req, "Hello from DripDrop"
+      end
+
+      m2_recv.on_recv do |msg|
+        responses << msg
+      end
+
+      sleep 1
+      
+      to_send.each {|message| m2_send.send_message(message)}
+    end
+     
+    {:responses => responses, :requests => requests}
+  end
+  describe "basic sending and receiving" do
+    before(:all) do
+      @sent = [m2_req]
+      pp_info = pp_send_messages(@sent)
+      @responses     = pp_info[:responses]
+      @requests      = pp_info[:requests]
+    end
+
+    it "should parse a request" do
+      @requests[0].body.should == body
+      @requests[0].conn_id.should == conn_id
+      @requests[0].headers.should == headers
+      @requests[0].path.should == path
+      @requests[0].sender.should == sender
+    end
+
+    it "should respond to an http request" do
+      @responses[0][0].copy_out_string.should == dd_resp
+    end
+  end
+end

data/spec/node/zmq_pushpull_spec.rb

@@ -7,7 +7,7 @@ describe "zmq push/pull" do
     push = nil
     pull = nil
     
-    @node = run_reactor do
+    @node = run_reactor(2) do
       addr = rand_addr
       
       push = zmq_push(addr, :bind)
@@ -25,6 +25,8 @@ describe "zmq push/pull" do
         responses << message
       end
        
+      sleep 1
+
       to_send.each {|message| push.send_message(message)}
     end
      

data/spec/node_spec.rb

@@ -72,10 +72,9 @@ describe DripDrop::Node do
     class TestException < StandardError; end
      
     it "should rescue exceptions in the EM reactor" do
-      pending "Not sure if this feature is a good idea"
       expectations = an_instance_of(TestException)
       reactor = run_reactor do
-        self.should_receive(:error_handler).with(expectations)
+        self.class.should_receive(:error_handler).with(expectations)
         EM.next_tick do
           raise TestException, "foo"
         end