dripdrop 0.6.0 → 0.7.1

data/lib/dripdrop/handlers/http.rb

@@ -71,13 +71,15 @@ class DripDrop
       begin
         Thin::Logging.silent = true
          
+        uri_path = @uri.path.empty? ? '/' : @uri.path
+         
         Thin::Server.start(@uri.host, @uri.port) do
-          map '/' do
+          map uri_path do
             run HTTPApp.new(msg_format,&block)
           end
         end
       rescue Exception => e
-        puts "Error in Thin server: #{e.message}\n#{e.backtrace.join("\n")}"
+        $stderr.write "Error in Thin server: #{e.message}\n#{e.backtrace.join("\n")}"
       end
     end
   end
@@ -94,9 +96,11 @@ class DripDrop
     def send_message(message,&block)
       dd_message = dd_messagify(message)
       if dd_message.class == DripDrop::Message
+        uri_path = @uri.path.empty? ? '/' : @uri.path
+        
         req = EM::Protocols::HttpClient.request(
           :host => @uri.host, :port => @uri.port,
-          :request => '/', :verb => 'POST',
+          :request => uri_path, :verb => 'POST',
           :contenttype => 'application/json',
           :content => dd_message.encode_json
         )

data/lib/dripdrop/handlers/websockets.rb

@@ -16,14 +16,14 @@ class DripDrop
           
         ws.onopen { @onopen_handler.call(dd_conn) if @onopen_handler }
         ws.onclose { @onclose_handler.call(dd_conn) if @onclose_handler }
-        ws.onerror { @onerror_handler.call(dd_conn) if @onerror_handler }
+        ws.onerror {|reason| @onerror_handler.call(reason, dd_conn) if @onerror_handler }
         
         ws.onmessage do |message|
           if @onmessage_handler
             begin
               message = DripDrop::Message.decode_json(message) unless @raw
             rescue StandardError => e
-              puts "Could not parse message: #{e.message}"
+              $stderr.write "Could not parse message: #{e.message}" if @debug
             end
              
             @onmessage_handler.call(message,dd_conn)

data/lib/dripdrop/handlers/zeromq.rb

@@ -27,7 +27,7 @@ class DripDrop
       elsif @socket_ctype == :connect
         socket.connect(@zaddress)
       else
-        raise "Unsupported socket ctype '#{@socket_ctype}'. Expected :bind or :connect"
+        EM.next_tick { raise "Unsupported socket ctype '#{@socket_ctype}'. Expected :bind or :connect" }
       end
     end
 
@@ -59,7 +59,7 @@ class DripDrop
             if part.class == String
               socket.send_message_string(part, multipart_flag)
             else
-              raise "Can only send Strings, not #{part.class}: #{part}"
+              $stderr.write "Can only send Strings, not #{part.class}: #{part}" if @debug
             end
           end
         end
@@ -98,16 +98,18 @@ class DripDrop
     end
 
     def on_readable(socket, messages)
-      case @msg_format
-      when :raw
-        @recv_cbak.call(messages)
-      when :dripdrop
-        raise "Expected message in one part" if messages.length > 1
-        body  = messages.shift.copy_out_string
-        @recv_cbak.call(decode_message(body))
-      else
-        raise "Unknown message format '#{@msg_format}'"
-      end
+      EM.next_tick {
+        case @msg_format
+        when :raw
+          @recv_cbak.call(messages)
+        when :dripdrop
+          raise "Expected message in one part" if messages.length > 1
+          body  = messages.shift.copy_out_string
+          @recv_cbak.call(decode_message(body))
+        else
+          raise "Unknown message format '#{@msg_format}'"
+        end
+      }
     end
   end
 
@@ -127,19 +129,21 @@ class DripDrop
     end
 
     def on_readable(socket, messages)
-      if @msg_format == :dripdrop
-        unless messages.length == 2
-          puts "Expected pub/sub message to come in two parts, not #{messages.length}: #{messages.inspect}"
-          return false
-        end
-        topic = messages.shift.copy_out_string
-        if @topic_filter.nil? || topic.match(@topic_filter)
-          body  = messages.shift.copy_out_string
-          msg   = @recv_cbak.call(decode_message(body))
+      EM.next_tick {
+        if @msg_format == :dripdrop
+          unless messages.length == 2
+            puts "Expected pub/sub message to come in two parts, not #{messages.length}: #{messages.inspect}"
+            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)
-      end
+      }
     end
   end
 
@@ -176,16 +180,18 @@ class DripDrop
     end
 
     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['_dripdrop/x_seq_counter']
-        response   = ZMQXRepHandler::Response.new(self, identities,seq)
-        @recv_cbak.call(message,response)
-      else
-        super(socket,messages)
-      end
+      EM.next_tick {
+        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['_dripdrop/x_seq_counter']
+          response   = ZMQXRepHandler::Response.new(self, identities,seq)
+          @recv_cbak.call(message,response)
+        else
+          super(socket,messages)
+        end
+      }
     end
 
     def send_message(message,identities,seq)
@@ -224,10 +230,12 @@ class DripDrop
       @promises = {}
 
       self.on_recv do |message|
-        seq = message.head['_dripdrop/x_seq_counter']
-        raise "Missing Seq Counter" unless seq
-        promise = @promises.delete(seq)
-        promise.call(message) if promise
+        EM.next_tick {
+          seq = message.head['_dripdrop/x_seq_counter']
+          raise "Missing Seq Counter" unless seq
+          promise = @promises.delete(seq)
+          promise.call(message) if promise
+        }
       end
     end
 

data/lib/dripdrop/node.rb

@@ -13,7 +13,7 @@ require 'dripdrop/handlers/http'
 
 class DripDrop
   class Node
-    attr_reader   :zm_reactor, :routing
+    attr_reader   :zm_reactor, :routing, :nodelets
     attr_accessor :debug
     
     def initialize(opts={},&block)
@@ -24,16 +24,24 @@ class DripDrop
       @debug      = opts[:debug]
       @recipients_for       = {}
       @handler_default_opts = {:debug => @debug}
+      @nodelets   = {}  # Cache of registered nodelets
     end
 
     # Starts the reactors and runs the block passed to initialize.
     # This is non-blocking.
     def start
       @thread = Thread.new do
+        EM.error_handler {|e| self.error_handler e}
         EM.run do
           ZM::Reactor.new(:my_reactor).run do |zm_reactor|
             @zm_reactor = zm_reactor
-            self.instance_eval(&@block)
+            if @block
+              self.instance_eval(&@block)
+            elsif self.respond_to?(:action)
+              self.action
+            else
+              raise "Could not start, no block or action specified"
+            end
           end
         end
       end
@@ -75,8 +83,14 @@ class DripDrop
     # See the docs for +routes_for+ for more info in grouping routes for
     # nodelets and maintaining sanity in larger apps
     def route(name,handler_type,*handler_args)
+      route_full(nil, name, handler_type, *handler_args)
+    end
+  
+    # Probably not useful for most, apps. This is used internally to 
+    # create a route for a given nodelet.
+    def route_full(nodelet, name, handler_type, *handler_args)
       # If we're in a route_for block, prepend appropriately
-      full_name = @route_prepend ? "#{@route_prepend}_#{name}".to_sym : name
+      full_name = (nodelet && nodelet.name) ? "#{nodelet.name}_#{name}".to_sym : name
       
       handler = self.send(handler_type, *handler_args)
       @routing[full_name] = handler
@@ -89,46 +103,50 @@ class DripDrop
       handler
     end
 
-    # Defines a group of +route+s, to be used as the interface for a +nodelet+
-    # later on.
-    # 
-    # All routes defined with the +route_for+ block will be prepended with the
-    # +nodelet_name+ and an underscore. So, the following routes:
-    # 
-    #    routes_for :forwarder do
-    #      route :input,  :zmq_subscribe, 'tcp://127.0.0.1:2200', :bind
-    #      route :output, :zmq_publish,   f.in.address, :connect
-    #    end
-    # 
-    # Will yield the routes: +forwarder_input+ and +forwarder_output+ globally.
-    # Within the block scope of the +forwarder+ nodelet however, the routes are additionally
-    # available with their own short names. See the +nodelet+ method for details.
+    # DEPRECATED, will be deleted in 0.8
     def routes_for(nodelet_name,&block)
-      @route_prepend = nodelet_name #This feels ugly. Blech.
-      block.call
-      @route_prepend = nil
+      $stderr.write "routes_for is now deprecated, use nodelet instead"
+      nlet = nodelet(nodelet_name,&block)
+      block.call(nlet)
     end
 
     # Nodelets are a way of segmenting a DripDrop::Node. This can be used
     # for both organization and deployment. One might want the production
     # deployment of an app to be broken across multiple servers or processes
-    # for instance. Additionally, by combining nodelets with +routes_for+
-    # managing routes becomes a little easier.
+    # for instance:
     #
-    # Nodelets can be used thusly:
-    #    routes_for :heartbeat do
-    #      route :ticker, :zmq_publish, 'tcp://127.0.0.1', :bind
+    #    nodelet :heartbeat do |nlet|
+    #      nlet.route :ticker, :zmq_publish, 'tcp://127.0.0.1', :bind
+    #      EM::PeriodicalTimer.new(1) do
+    #        nlet.ticker.send_message(:name => 'tick')
+    #      end
     #    end
     #
-    #    nodelet :heartbeat do
-    #      zm_reactor.periodical_timer(500) do
-    #      ticker.send_message(:name => 'tick')
+    # Nodelets can also be subclassed, for instance:
+    # 
+    #    class SpecialNodelet < DripDrop::Node::Nodelet
+    #      def action
+    #        nlet.route :ticker, :zmq_publish, 'tcp://127.0.0.1', :bind
+    #        EM::PeriodicalTimer.new(1) do
+    #          nlet.ticker.send_message(:name => 'tick')
+    #        end
+    #      end
     #    end
-    def nodelet(name,&block)
-      nlet_obj = Nodelet.new(name,routing)
-      block.call(nlet_obj)
+    #
+    #    nodelet :heartbeat, SpecialNodelet
+    #
+    # If you specify a block, Nodelet#action will be ignored and the block
+    # will be run
+    def nodelet(name,klass=Nodelet,&block)
+      nlet = @nodelets[name] ||= klass.new(self,name,routing)
+      if block
+        block.call(nlet)
+      else
+        nlet.action
+      end
+      nlet
     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.
@@ -176,12 +194,12 @@ class DripDrop
     # +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 {|ws|
+    #    websocket(addr).on_open {|conn|
     #      ws.send_message(:name => 'ws_open_ack')
-    #    }.on_recv {|msg,ws|
-    #      ws.send(msg)
-    #    }.on_close {|ws|
-    #    }.on_error {|ws|
+    #    }.on_recv {|msg,conn|
+    #      conn.send(msg)
+    #    }.on_close {|conn|
+    #    }.on_error {|reason,conn|
     #    }
     #
     # The +ws+ object that's passed into the handlers is not
@@ -189,8 +207,7 @@ class DripDrop
     def websocket(address,opts={})
       uri     = URI.parse(address)
       h_opts  = handler_opts_given(opts)
-      handler = DripDrop::WebSocketHandler.new(uri,h_opts)
-      handler
+      DripDrop::WebSocketHandler.new(uri,h_opts)
     end
     
     # Starts a new Thin HTTP server listening on address.
@@ -199,8 +216,7 @@ class DripDrop
     def http_server(address,opts={},&block)
       uri     = URI.parse(address)
       h_opts  = handler_opts_given(opts)
-      handler = DripDrop::HTTPServerHandler.new(uri, h_opts,&block)
-      handler
+      DripDrop::HTTPServerHandler.new(uri, h_opts,&block)
     end
     
     # An EM HTTP client.
@@ -212,8 +228,7 @@ class DripDrop
     def http_client(address,opts={})
       uri     = URI.parse(address)
       h_opts  = handler_opts_given(opts)
-      handler = DripDrop::HTTPClientHandler.new(uri, h_opts)
-      handler
+      DripDrop::HTTPClientHandler.new(uri, h_opts)
     end
 
     # An inprocess pub/sub queue that works similarly to EM::Channel, 
@@ -252,6 +267,11 @@ class DripDrop
       @recipients_for[dest].delete(identifier)
     end
 
+    # Catch all error handler
+    def error_handler(e)
+      $stderr.write "#{e.class}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+    end
+
     private
     
     def zmq_handler(klass, zm_sock_type, address, socket_ctype, opts={})

data/lib/dripdrop/node/nodelet.rb

@@ -3,27 +3,28 @@ class DripDrop::Node
   class Nodelet
     attr_accessor :name, :routing
     
-    def initialize(name, routes)
-      @name    = name
-      @routing = {}
-      routes.each do |route_name,handler|
-        # Copy the original routing table
-        route route_name, handler
-      
-        # Define short versions of the local routes for
-        # this nodelet's routing table
-        if (route_name.to_s =~ /^#{name}_(.+)$/)
-          short_name = $1
-          route short_name, handler
-        end
-      end
+    def initialize(ctx, name, routes)
+      @ctx              = ctx
+      @name             = name
+      @internal_routing = {}
     end
     
-    def route(name,handler)
-      @routing[name] = handler
+    def route(name,handler_type,*handler_args)
+      handler = @ctx.route_full(self, name, handler_type, *handler_args)
+      @internal_routing[name] = handler
+       
       (class << self; self; end).class_eval do
         define_method(name) { handler }
       end
     end
+
+    # Check for the method as a route in @ctx, if found
+    # memoize it by defining it as a singleton
+    def method_missing(meth,*args)
+      (class << self; self; end).class_eval do
+        define_method(meth) { @ctx.send(meth,*args) }
+      end
+      self.send(meth,*args)
+    end
   end
 end

data/spec/node/http_spec.rb

@@ -1,14 +1,13 @@
 require 'spec_helper'
 
 describe "http" do
-  def http_send_messages(to_send,&block)
+  
+  def http_send_messages(to_send,addr=rand_addr('http'),&block)
     responses = []
     client = nil
     server = nil
     
-    @node = run_reactor(1) do
-      addr = rand_addr
-      
+    @node = run_reactor(2) do
       zmq_subscribe(rand_addr, :bind) do |message|
       end
       
@@ -31,31 +30,44 @@ describe "http" do
     
    {:responses => responses, :handlers => {:server => [server] }}
   end
-  describe "basic sending and receiving" do
-    before(:all) do
-      @sent = []
-      10.times {|i| @sent << DripDrop::Message.new("test-#{i}")}
-      @client_responses = []
-      @http_info = http_send_messages(@sent) do |sent_message,resp_message|
-        @client_responses << {:sent_message  => sent_message,
-                              :resp_message  => resp_message}
+  
+  shared_examples_for "all http nodes" do
+    describe "basic sending and receiving" do
+      before(:all) do
+        @sent = []
+        10.times {|i| @sent << DripDrop::Message.new("test-#{i}")}
+        @client_responses = []
+        @http_info = http_send_messages(@sent,@http_test_addr) do |sent_message,resp_message|
+          @client_responses << {:sent_message  => sent_message,
+                                :resp_message  => resp_message}
+        end
+        @responses     = @http_info[:responses]
       end
-      @responses     = @http_info[:responses]
-    end
 
-    it "should receive all sent messages" do
-      resp_names = @responses.map(&:name).inject(Set.new) {|memo,rn| memo << rn}
-      @sent.map(&:name).each {|sn| resp_names.should include(sn)}
-    end
-    
-    it "should return to the client as many responses as sent messages" do
-      @client_responses.length.should == @sent.length
-    end
-    
-    it "should return to the client an identical message to that which was sent" do
-      @client_responses.each do |resp|
-        resp[:sent_message].name.should == resp[:resp_message].name
+      it "should receive all sent messages" do
+        resp_names = @responses.map(&:name).inject(Set.new) {|memo,rn| memo << rn}
+        @sent.map(&:name).each {|sn| resp_names.should include(sn)}
+      end
+      
+      it "should return to the client as many responses as sent messages" do
+        @client_responses.length.should == @sent.length
+      end
+      
+      it "should return to the client an identical message to that which was sent" do
+        @client_responses.each do |resp|
+          resp[:sent_message].name.should == resp[:resp_message].name
+        end
       end
     end
   end
+  
+  describe "http apps using the URL root (/)" do
+    before(:all) { @http_test_addr = rand_addr('http') }
+    it_should_behave_like "all http nodes"
+  end
+  
+  describe "http apps using a subdirectory of the URL (/subdir)" do
+    before(:all) { @http_test_addr = rand_addr('http') + '/subdir' }
+    it_should_behave_like "all http nodes"
+  end
 end