dripdrop 0.3.1 → 0.4.0

data/spec/node/nodelet_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe "nodelets" do
+  before(:all) do
+    nodelets = {}
+    
+    @node = run_reactor do
+      routes_for :distributor do
+        route :output, :zmq_push, rand_addr, :bind
+      end
+      routes_for :worker_cluster do
+        route :worker1,     :zmq_pull, distributor_output.address, :connect
+        route :worker2,     :zmq_pull, distributor_output.address, :connect
+      end
+      
+      nodelet :distributor do |d|
+        nodelets[:distributor] = d
+      end
+      
+      nodelet :worker_cluster do |wc|
+        nodelets[:worker_cluster] = wc
+      end
+    end
+    
+    @nodelets = nodelets
+  end
+  
+  it "should create the nodelets" do
+    @nodelets.length.should == 2
+  end
+  
+  it "should pass a DripDrop::Node::Nodelet to the block" do
+    @nodelets.values.each do |nlet|
+      nlet.should be_instance_of(DripDrop::Node::Nodelet)
+    end
+  end
+    
+  it "should give access to the full routing table to nodelets" do
+    @node.routing.each do |route_name,handler|
+      @nodelets.values.each do |nlet|
+        nlet.send(route_name).should == handler
+      end
+    end
+  end
+  
+  it "should define prefix-less versions of nodelet specific routes" do
+    {
+      @nodelets[:worker_cluster] => {:worker1 => :worker_cluster_worker1, 
+                                     :worker2 => :worker_cluster_worker2},
+      @nodelets[:distributor]    => {:output  => :distributor_output}
+    }.each do |nlet, mapping|
+      mapping.each do |short,long|
+        nlet.send(short).should == nlet.send(long)
+      end
+    end
+  end
+end

data/spec/node/routing_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe "routing" do
+  shared_examples_for "all routing" do
+    it "should define all routes in the table" do
+      @expected_routing.keys.each do |route_name|
+        @node.routing.keys.should include(route_name)
+      end
+    end
+    
+    it "should define a handler in the routing table for each route" do
+      @expected_routing.keys.each do |route_name|
+        @node.routing[route_name].should be_kind_of(DripDrop::BaseHandler)
+      end
+    end    
+
+    it "should define a singleton method for each entry in the routing table" do
+      @expected_routing.keys.each do |route_name|
+        @node.send(route_name).should == @node.routing[route_name]
+      end
+    end
+
+    it "should create handlers with the correct properties" do
+      @expected_routing.each do |route_name,expected_props|
+        handler = @node.send(route_name)
+        handler.class.should == expected_props[:class]
+        handler.socket_ctype.should == expected_props[:socket_ctype]
+      end
+    end
+  end
+  
+  context "with no groups" do
+    before(:all) do
+      @expected_routing = {
+        :distributor => {:class => DripDrop::ZMQPushHandler, :socket_ctype => :bind},
+        :worker1     => {:class => DripDrop::ZMQPullHandler, :socket_ctype => :connect},
+        :worker2     => {:class => DripDrop::ZMQPullHandler, :socket_ctype => :connect}
+      }
+      @node = run_reactor do
+        route :distributor, :zmq_push, rand_addr, :bind
+        route :worker1,     :zmq_pull, distributor.address, :connect
+        route :worker2,     :zmq_pull, distributor.address, :connect
+      end
+    end
+
+    it_should_behave_like "all routing"
+  end
+  context "with groups" do
+    before(:all) do
+      @expected_routing = {
+        :distributor_output     => {:class => DripDrop::ZMQPushHandler, :socket_ctype => :bind},
+        :worker_cluster_worker1 => {:class => DripDrop::ZMQPullHandler, :socket_ctype => :connect},
+        :worker_cluster_worker2 => {:class => DripDrop::ZMQPullHandler, :socket_ctype => :connect}
+      }
+      @node = run_reactor do
+        routes_for :distributor do
+          route :output, :zmq_push, rand_addr, :bind
+        end
+        routes_for :worker_cluster do
+          route :worker1,     :zmq_pull, distributor_output.address, :connect
+          route :worker2,     :zmq_pull, distributor_output.address, :connect
+        end
+      end
+    end
+    
+    it_should_behave_like "all routing"
+  end
+end

data/spec/node/websocket_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe "websockets" do
+  def websockets_send_messages(to_send,&block)
+    received  = []
+    responses = []
+    server = nil
+    
+    open_message  = DripDrop::Message.new('open',  :body => 'test')
+    open_received = false
+    
+    close_occured = false
+    
+    error_occured = false
+    
+    @node = run_reactor(1) do
+      addr = rand_addr('ws')
+      
+      server = websocket(addr)
+      server.on_open do |conn|
+        conn.send_message(open_message)
+      end.on_recv do |message,conn|
+        received << message
+        conn.send_message(message)
+      end.on_close do |conn|
+        close_occured = true
+      end.on_error do |conn|
+        error_occured = true
+      end
+      
+      EM.defer do
+        client = WebSocket.new(addr)
+        open_received = DripDrop::Message.decode_json(client.receive)
+        to_send.each do |message|
+          client.send(message.json_encoded)
+        end
+        
+        recvd_count = 0
+        while recvd_count < to_send.length && (message = client.receive)
+          responses << DripDrop::Message.decode_json(message)
+          recvd_count += 1
+        end
+        client.close
+      end
+      
+      zmq_subscribe(rand_addr, :bind) {} #Keep zmqmachine happy
+    end
+    
+    {:received => received, :responses => responses, 
+     :open_message => open_message,   :open_received => open_received,
+     :close_occured => close_occured, :error_occured => error_occured, 
+     :handlers => {:server => server }}
+  end
+  describe "basic sending and receiving" do
+    before(:all) do
+      @sent = []
+      10.times {|i| @sent << DripDrop::Message.new("test-#{i}")}
+      @ws_info = websockets_send_messages(@sent)
+    end
+
+    it "should receive all sent messages" do
+      recvd_names = @ws_info[:received].map(&:name).inject(Set.new) {|memo,rn| memo << rn}
+      @sent.map(&:name).each {|sn| recvd_names.should include(sn)}
+    end
+    
+    it "should return to the client as many responses as sent messages" do
+      @ws_info[:responses].length.should == @sent.length
+    end
+    
+    it "should return to the client an identical message to that which was sent" do
+      @ws_info[:received].zip(@ws_info[:responses]).each do |recvd,resp|
+        recvd.name.should == resp.name
+      end
+    end
+
+    it "should generate an on open message" do
+      @ws_info[:open_received].to_hash.should == @ws_info[:open_message].to_hash
+    end
+    
+    it "should generate a close event" do
+      @ws_info[:close_occured].should be_true
+    end
+
+    it "should not generate an error event" do
+      @ws_info[:error_occured].should be_false
+    end
+  end
+end

data/spec/node/zmq_pushpull_spec.rb

@@ -6,7 +6,7 @@ describe "zmq push/pull" do
     push = nil
     pull = nil
     
-    @ddn = DripDrop::Node.new do
+    @node = run_reactor do
       addr = rand_addr
       
       push = zmq_push(addr, :bind)
@@ -26,11 +26,7 @@ describe "zmq push/pull" do
        
       to_send.each {|message| push.send_message(message)}
     end
-    
-    @ddn.start
-    sleep 0.1
-    @ddn.stop rescue nil
-    
+     
     {:responses => responses, :handlers => { :push => push, :pull => [pull] }}
   end
   describe "basic sending and receiving" do

data/spec/node/zmq_xrepxreq_spec.rb

@@ -2,70 +2,73 @@ require 'spec_helper'
 
 describe "zmq xreq/xrep" do
   def xr_tranceive_messages(to_send,&block)
-    responses = []
+    recvd = []
     req = nil
     rep = nil
     
-    @ddn = DripDrop::Node.new do
+    @node = run_reactor do
       addr = rand_addr
       
       rep = zmq_xrep(addr, :bind)
       req = zmq_xreq(addr, :connect)
       
-      rep.on_recv do |message,identities,seq|
-        yield(identities,seq,message) if block
-        responses << {:identities => identities, :seq => seq, :message => message}
+      rep.on_recv do |message,response|
+        recvd << {:message => message, :response => response}
       end
        
       to_send.each {|message| req.send_message(message)}
     end
     
-    @ddn.start
-    sleep 0.1
-    @ddn.stop rescue nil
-    
-    {:responses => responses, :handlers => {:req => req, :rep => rep}}
+    {:recvd => recvd, :handlers => {:req => req, :rep => rep}}
   end
   describe "basic sending and receiving" do
     before(:all) do
       @sent = []
       10.times {|i| @sent << DripDrop::Message.new("test-#{i}")}
       xr_info = xr_tranceive_messages(@sent)
-      @responses = xr_info[:responses]
+      @recvd  = xr_info[:recvd]
       @req_handler  = xr_info[:handlers][:req]
       @rep_handler  = xr_info[:handlers][:rep]
     end
 
     it "should receive all sent messages in order" do
-      @sent.zip(@responses).each do |sent,response|
-        sent.name.should == response[:message].name
+      @sent.zip(@recvd).each do |sent,recvd|
+        sent.name.should == recvd[:message].name
+      end
+    end
+    
+    it "should pass a ZMQXrepHandler::Response object to the response callback" do
+      @recvd.each do |recvd_item|
+        recvd_item[:response].should be_instance_of(DripDrop::ZMQXRepHandler::Response)
       end
     end
 
     it "should have a monotonically incrementing seq for responses" do
       last_seq = 0
-      @responses.each do |resp|
-        resp[:seq].should == last_seq + 1
-        last_seq = resp[:seq]
+      @recvd.each do |recvd_item|
+        recvd_item[:response].seq.should == last_seq + 1
+        last_seq = recvd_item[:response].seq
       end
     end
     
     it "should include the identity of the sending socket" do
-      @responses.each {|resp| resp[:identities].should_not be_nil}
+      @recvd.each do |recvd_item|
+        recvd_item[:response].identities.should_not be_nil
+      end
     end
     
     it "should send responses back to the proper xreq sender" do
       received_count = 0
       
-      ddn = DripDrop::Node.new do
+      run_reactor(0.2) do
         addr = rand_addr
         
         rep  = zmq_xrep(addr, :bind)
         req1 = zmq_xreq(addr, :connect)
         req2 = zmq_xreq(addr, :connect)
         
-        rep.on_recv do |message,identities,seq|
-          rep.send_message(message,identities,seq)
+        rep.on_recv do |message,response|
+          response.send_message(message)
         end
          
         r1_msg = DripDrop::Message.new("REQ1 Message")
@@ -82,10 +85,7 @@ describe "zmq xreq/xrep" do
         end
         end
       end
-      ddn.start 
-      sleep 0.2
-      ddn.stop rescue nil #This should work...
-      
+       
       received_count.should == 20
     end
   end

data/spec/node_spec.rb

@@ -11,7 +11,6 @@ describe DripDrop::Node do
     end
     
     it "should start EventMachine" do
-      pending "This is not repeatedly reliable"
       EM.reactor_running?.should be_true
     end
     

data/spec/spec_helper.rb

@@ -1,6 +1,20 @@
-require File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib dripdrop]))
+require File.expand_path(File.join(File.dirname(__FILE__), %w[. .. lib dripdrop]))
 Thread.abort_on_exception = true
 
-def rand_addr
-  "tcp://127.0.0.1:#{rand(10_000) + 20_000}"
+# Used to test websocket clients. 
+require 'gimite-websocket'
+
+def rand_addr(scheme='tcp')
+  "#{scheme}://127.0.0.1:#{rand(10_000) + 20_000}"
+end
+
+def run_reactor(time=0.1,opts={},&block)
+  ddn = DripDrop::Node.new(opts,&block)
+  ddn.start
+  sleep time
+  ddn.stop
+  sleep 0.1
+  ddn
 end
+
+

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 1
-  version: 0.3.1
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Andrew Cholakian
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-21 00:00:00 -07:00
+date: 2010-11-15 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -127,25 +127,43 @@ files:
 - doc_img/topology.png
 - dripdrop.gemspec
 - example/agent_test.rb
+- example/combined.rb
 - example/http.rb
 - example/pubsub.rb
 - example/pushpull.rb
+- example/stats_app/core.rb
+- example/stats_app/public/.sass-cache/b48b4299d80c05f528daf63fe51d85e5e3c10d98/stats.scssc
+- example/stats_app/public/backbone.js
+- example/stats_app/public/build_templates.rb
+- example/stats_app/public/json2.js
+- example/stats_app/public/protovis-r3.2.js
+- example/stats_app/public/stats.css
+- example/stats_app/public/stats.haml
+- example/stats_app/public/stats.html
+- example/stats_app/public/stats.js
+- example/stats_app/public/stats.scss
+- example/stats_app/public/underscore.js
 - example/subclass.rb
 - example/xreq_xrep.rb
 - js/dripdrop.html
 - js/dripdrop.js
-- js/jack.js
 - js/qunit.css
 - js/qunit.js
 - lib/dripdrop.rb
 - lib/dripdrop/agent.rb
+- lib/dripdrop/handlers/base.rb
 - lib/dripdrop/handlers/http.rb
 - lib/dripdrop/handlers/websockets.rb
 - lib/dripdrop/handlers/zeromq.rb
 - lib/dripdrop/message.rb
 - lib/dripdrop/node.rb
+- lib/dripdrop/node/nodelet.rb
+- spec/gimite-websocket.rb
 - spec/message_spec.rb
 - spec/node/http_spec.rb
+- spec/node/nodelet_spec.rb
+- spec/node/routing_spec.rb
+- spec/node/websocket_spec.rb
 - spec/node/zmq_pushpull_spec.rb
 - spec/node/zmq_xrepxreq_spec.rb
 - spec/node_spec.rb
@@ -184,8 +202,12 @@ specification_version: 3
 summary: Evented framework for ZeroMQ and EventMachine Apps.
 test_files: 
 - spec/spec_helper.rb
+- spec/gimite-websocket.rb
 - spec/node/http_spec.rb
+- spec/node/routing_spec.rb
 - spec/node/zmq_xrepxreq_spec.rb
 - spec/node/zmq_pushpull_spec.rb
+- spec/node/nodelet_spec.rb
+- spec/node/websocket_spec.rb
 - spec/message_spec.rb
 - spec/node_spec.rb