dripdrop 0.1.0 → 0.2.0

data/README.md

@@ -6,29 +6,49 @@ DripDrop is ZeroMQ(using zmqmachine) + Event Machine simplified for the general
 
 Here's an example of the kind of thing DripDrop makes easy, from [examples/pubsub.rb](http://github.com/andrewvc/dripdrop/blob/master/example/pubsub.rb)
  
-    DripDrop::Node.new do |node|
+    require 'dripdrop/node'
+    Thread.abort_on_exception = true
+
+    #Define our handlers
+    DripDrop::Node.new do
       z_addr = 'tcp://127.0.0.1:2200'
+        
+      #Create a publisher
+      pub = zmq_publish(z_addr,:bind)
 
-      pub = node.zmq_publish(z_addr,:bind)
-      sub = node.zmq_subscribe(z_addr,:connect).on_recv do |message|
+      #Create two subscribers
+      zmq_subscribe(z_addr,:connect).on_recv do |message|
         puts "Receiver 1 #{message.inspect}"
       end
-      sub = node.zmq_subscribe(z_addr, :connect).on_recv do |message|
+      zmq_subscribe(z_addr, :connect).on_recv do |message|
         puts "Receiver 2 #{message.inspect}"
       end
+      
+      zm_reactor.periodical_timer(5) do
+        #Sending a hash as a message implicitly transforms it into a DripDrop::Message
+        pub.send_message(:name => 'test', :body => 'Test Payload')
+      end
+      
+      http_server(addr).on_recv do |response,msg|
+        i += 1
+        response.send_message(msg)
+      end
 
-      node.zm_reactor.periodical_timer(5) do
-        pub.send_message(DripDrop::Message.new('test', :body => 'Test Payload'))
+      EM::PeriodicTimer.new(1) do
+        client = http_client(addr)
+        msg = DripDrop::Message.new('http/status', :body => "Success #{i}")
+        client.send_message(msg) do |resp_msg|
+          puts resp_msg.inspect
+        end
       end
-    end
-   
+    end.start! #Start the reactor and block until complete
 
-Want to see a longer example encapsulating both zmqmachine and eventmachine functionality? Check out [this file](http://github.com/andrewvc/dripdrop-webstats/blob/master/lib/dripdrop-webstats.rb), which encapsulates all the functionality of the diagram below:
+Note that these aren't regular ZMQ sockets, and that the HTTP server isn't a regular server. They only speak and respond using DripDrop::Message formatted messages. For HTTP/WebSockets it's JSON that looks like {name: 'name', head: {}, body: anything}, for ZeroMQ it means BERT. There is a raw made that you can use for other message formats, but using DripDrop::Messages makes things easier, and for some socket types (like XREQ/XREP) the predefined format is very useful in matching requests to replies.
 
-![topology](http://github.com/andrewvc/dripdrop/raw/master/doc_img/topology.png "Topology")
+Want to see a longer example encapsulating both zmqmachine and eventmachine functionality? Check out [this file](http://github.com/andrewvc/dripdrop-webstats/blob/master/lib/dripdrop-webstats.rb), which encapsulates all the functionality of the diagram below:
 
 #How It Works
 
-DripDrop encapsulates both zmqmachine, and eventmachine. It provides some sane default messaging choices, using [BERT](http://github.com/blog/531-introducing-bert-and-bert-rpc) (A binary, JSON, like serialization format) and JSON to automatically. zmqmachine and eventmachine have some good APIs, some convoluted ones, the goal here is to smooth over the bumps, and make writing highly concurrent programs both as terse and beautiful as possible.
+DripDrop encapsulates both zmqmachine, and eventmachine. It provides some sane default messaging choices, using [BERT](http://github.com/blog/531-introducing-bert-and-bert-rpc) (A binary, JSON, like serialization format) and JSON for serialization. While zmqmachine and eventmachine APIs, some convoluted ones, the goal here is to smooth over the bumps, and make them play together nicely.
 
 Copyright (c) 2010 Andrew Cholakian. See LICENSE for details.

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/dripdrop.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dripdrop}
-  s.version = "0.1.0"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Andrew Cholakian"]
-  s.date = %q{2010-09-05}
+  s.date = %q{2010-10-10}
   s.description = %q{0MQ App stats}
   s.email = %q{andrew@andrewvc.com}
   s.extra_rdoc_files = [
@@ -26,20 +26,38 @@ Gem::Specification.new do |s|
      "doc_img/topology.png",
      "dripdrop.gemspec",
      "example/agent_test.rb",
+     "example/http.rb",
      "example/pubsub.rb",
      "example/pushpull.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/http.rb",
      "lib/dripdrop/handlers/websockets.rb",
      "lib/dripdrop/handlers/zeromq.rb",
      "lib/dripdrop/message.rb",
-     "lib/dripdrop/node.rb"
+     "lib/dripdrop/node.rb",
+     "spec/node/zmq_pushpull.rb",
+     "spec/node/zmq_xrepxreq.rb",
+     "spec/node_spec.rb",
+     "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/andrewvc/dripdrop}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{0MQ App Stats}
+  s.test_files = [
+    "spec/node/zmq_pushpull.rb",
+     "spec/node/zmq_xrepxreq.rb",
+     "spec/node_spec.rb",
+     "spec/spec_helper.rb"
+  ]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION

data/example/http.rb

@@ -0,0 +1,23 @@
+require 'dripdrop/node'
+Thread.abort_on_exception = true
+
+DripDrop::Node.new do
+  addr = 'http://127.0.0.1:2200'
+  
+  i = 0 
+  http_server(addr).on_recv do |response,msg|
+    i += 1
+    response.send_message(msg)
+  end
+
+  EM::PeriodicTimer.new(1) do
+    client = http_client(addr)
+    msg = DripDrop::Message.new('http/status', :body => "Success #{i}")
+    client.send_message(msg) do |resp_msg|
+      puts resp_msg.inspect
+    end
+  end
+
+  #Keep zmqmachine from spinning around using up all our CPU by creating a socket
+  req = zmq_xreq('tcp://127.0.0.1:2091', :connect)
+end.start!

data/example/pubsub.rb

@@ -1,18 +1,36 @@
 require 'dripdrop/node'
 Thread.abort_on_exception = true
 
-DripDrop::Node.new do |node|
+#Define our handlers
+DripDrop::Node.new do
   z_addr = 'tcp://127.0.0.1:2200'
     
-  pub = node.zmq_publish(z_addr,:bind)
-  sub = node.zmq_subscribe(z_addr,:connect).on_recv do |message|
+  #Create a publisher
+  pub = zmq_publish(z_addr,:bind)
+
+  #Create three subscribers
+  sub1 = zmq_subscribe(z_addr,:connect)
+
+  sub1.on_recv do |message|
     puts "Receiver 1 #{message.inspect}"
   end
-  sub = node.zmq_subscribe(z_addr, :connect).on_recv do |message|
+
+  sub1.topic_filter = /[13579]$/
+
+  sub2 = zmq_subscribe(z_addr,:connect)
+
+  sub2.on_recv do |message|
     puts "Receiver 2 #{message.inspect}"
   end
+
+  sub2.topic_filter = /[02468]$/
+
+  zmq_subscribe(z_addr, :connect).on_recv do |message|
+    puts "Receiver 3 #{message.inspect}"
+  end
   
-  node.zm_reactor.periodical_timer(5) do
-    pub.send_message(DripDrop::Message.new('test', :body => 'Test Payload'))
+  zm_reactor.periodical_timer(5) do
+    #Sending a hash as a message implicitly transforms it into a DripDrop::Message
+    pub.send_message(:name => Time.now.to_i.to_s, :body => 'Test Payload')
   end
-end
+end.start! #Start the reactor and block until complete

data/example/pushpull.rb

@@ -1,21 +1,21 @@
 require 'dripdrop/node'
 Thread.abort_on_exception = true
 
-DripDrop::Node.new do |node|
+DripDrop::Node.new do
   z_addr = 'tcp://127.0.0.1:2200'
    
-  node.zmq_pull(z_addr, :connect).on_recv do |message|
+  zmq_pull(z_addr, :connect).on_recv do |message|
     puts "Receiver 2 #{message.body}"
   end
-  node.zmq_pull(z_addr, :connect).on_recv do |message|
+  zmq_pull(z_addr, :connect).on_recv do |message|
     puts "Receiver 1 #{message.body}"
   end
-  push = node.zmq_push(z_addr, :bind)
+  push = zmq_push(z_addr, :bind)
 
   i = 0
-  node.zm_reactor.periodical_timer(800) do
+  zm_reactor.periodical_timer(800) do
     i += 1
     puts i
-    push.send_message(DripDrop::Message.new('test', :body => "Test Payload #{i}"))
+    push.send_message(:name => 'test', :body => "Test Payload #{i}")
   end
-end
+end.start!

data/example/xreq_xrep.rb

@@ -0,0 +1,26 @@
+require 'dripdrop/node'
+Thread.abort_on_exception = true
+
+DripDrop::Node.new do
+  z_addr = 'tcp://127.0.0.1:2200'
+   
+  rep = zmq_xrep(z_addr, :bind)
+  rep.on_recv do |identities,seq,message|
+    puts "REP #{message.body}"
+    rep.send_message(identities,seq,message)
+  end
+
+  req = zmq_xreq(z_addr, :connect)
+  
+  i = 0
+  k = 0
+
+  zm_reactor.periodical_timer(1000) do
+    req.send_message(:name => 'test', :body => "Test Payload i#{i}") do |message|
+      puts "RECV I RESP #{message.inspect}"
+    end
+    req.send_message(:name => 'test', :body => "Test Payload k#{i}") do |message|
+      puts "RECV K RESP #{message.inspect}"
+    end
+  end
+end.start!

data/js/dripdrop.html

@@ -0,0 +1,186 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
+                    "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+  <script src="../jquery.js"></script>
+  <script src="../jquery.json.js"></script>
+  <script src="../dripdrop.js"></script>
+  
+  <link rel="stylesheet" href="qunit.css" type="text/css" media="screen" />
+  <script type="text/javascript" src="qunit.js"></script>
+  <script type="text/javascript" src="jack.js"></script>
+
+<script>
+$(document).ready(function(){
+
+/* Test Helpers */
+function TSock()  {return new DD.WebSocket('ws://localhost:2702')};
+function THTTP()  {return new DD.HTTP('http://localhost:2703')};
+
+//Faked message to for a websocket
+function FakeWSMessage(ddMessage) {
+  var msg = (ddMessage === undefined) ? new DD.Message('test') : ddMessage;
+  this.data = msg.jsonEncoded();
+}
+
+/* Tests */
+
+test("The DD Singleton should be constructed from DripDrop", function() {
+  equals( DripDrop, DD.constructor, "Match");
+});
+
+module("DD.Message");
+
+  var msgVals = {
+    name: 'foo',
+    body: 'bar',
+    head: {key: 'baz'}
+  }
+  test("Creation: Name Only", function() {
+    var msg = new DD.Message(msgVals.name);
+    equals(msg.name, msgVals.name, "name");
+  });
+  test("Creation: Name + Body", function() {
+    var msg = new DD.Message(msgVals.name, {body : msgVals.body});
+    equals(msg.name, msgVals.name, "name");
+    equals(msg.body, msgVals.body, "body");
+  });
+  test("Creation: Name + Head + Body", function() {
+    var msg = new DD.Message(msgVals.name,
+                {body : msgVals.body, head : msgVals.head});
+    expect(3);
+    equals(msg.name, msgVals.name, "name");
+    equals(msg.head, msgVals.head, "head");
+    equals(msg.body, msgVals.body, "body");
+  });
+  test("Creation: No Head should still have head as an object", function() {
+    var msg = new DD.Message(msgVals.name);
+    equals(msg.head.constructor, Object, "head");
+  });
+
+  test("JSON Export", function() {
+    var msg = new DD.Message(msgVals.name,
+                {body : msgVals.body, head : msgVals.head});
+    equals(msg.jsonEncoded().constructor, String, "jsonEncoded");
+  });
+
+module("DD.WebSocket");
+  
+  test("Creating a websocket should make available the raw socket", function() {
+    var tSock = new TSock;
+    equals(tSock.socket.constructor, WebSocket,'raw socket');
+  });
+   
+  $([['onOpen','onopen'],
+     ['onClose','onclose'],
+     ['onError','onerror']]).each(function(i,pair) {
+    var dd_func = pair[0];
+    var ws_func = pair[1];
+    
+    test("DD function " + dd_func + " should set WS func " + ws_func, function() {
+      var tSock = new TSock;
+      var tFunc = function() {};
+      tSock[dd_func](tFunc);
+      equals(tSock.socket[ws_func], tFunc, "Func Set");
+    });
+  });
+  
+  test("onRecv should trigger the passed in callback", function() {
+    expect(3);
+    
+    var expectedMsg = new DD.Message('foo');
+    
+    var tSock = new TSock; 
+    tSock.onRecv(function(msg) {
+      ok(true, "Function executed");
+      equals(msg.constructor,DD.Message, "Is a DD.Message");
+      equals(msg.name, expectedMsg.name);
+    });
+    
+    tSock.socket.onmessage(new FakeWSMessage(expectedMsg));
+  });
+  
+  test("sendMessage should send a string to the websocket", function() {
+    expect(1);
+    
+    var tSock = new TSock;
+    var tMsg  = new DD.Message('foo');
+    tSock.socket.send = function(message) {
+      equals(tMsg.jsonEncoded(), message);
+    }
+    console.log(tSock.sendMessage)
+    tSock.sendMessage(tMsg);
+  });
+
+module("DD.HTTP");
+
+  test("Creation", function() {
+    var dht = new DD.HTTP;
+    equals(dht.constructor, DD.HTTP, "Constructor Match");
+  });
+  
+  test("Sending a message should call a get posting a JSON representation of the data",function() {
+    expect(1);
+    var tHTTP = new THTTP;
+    tHTTP.sendMessage();
+  });
+
+
+module("DD.Pipeline");
+
+  test("Creation", function() {
+    var pl = new DD.Pipeline;
+    equals(pl.constructor, DD.Pipeline, "Constructor Match");
+  });
+
+  test("Should expose the pipeline stages as an array", function() {
+    var pl = new DD.Pipeline;
+    equals(pl.stages.constructor, Array, "Constructor Match");
+  });
+
+  test("Should return null when no stages", function() {
+    equals((new DD.Pipeline).execute(new DD.Message('test')), null);
+  });
+
+  test("Should return null when no stages", function() {
+    equals((new DD.Pipeline).execute(new DD.Message('test')), null);
+  });
+
+  //This tests too many things at once, should be broken apart
+  test("Execution, Order, Message Transformation", function() {
+    expect(5);
+
+    var pl = new DD.Pipeline;
+    
+    var s1 = new DD.PipelineStage('t1','Test1',function(message) {
+               ok(true,"Test1 Executed");
+               equals(message.name,0,"Executed first job first");
+               message.name = 1;
+               return message;
+             });
+    var s2 = new DD.PipelineStage('t2','Test2',function(message) {
+               ok(true,"Test2 Executed");
+               equals(message.name,1,"Executed second job after first");
+               message.name = 2;
+               
+               return message;
+             });
+    pl.stages = [s1,s2];
+    
+    var resMsg = pl.execute(new DD.Message('0'));
+    equals(resMsg.name,2);
+  });
+
+}); //End of tests
+
+</script>
+  
+</head>
+<body>
+  <h1 id="qunit-header">DripDrop Tests</h1>
+ <h2 id="qunit-banner"></h2>
+ <h2 id="qunit-userAgent"></h2>
+ <ol id="qunit-tests"></ol>
+ <div id="qunit-fixture">test markup, will be hidden</div>
+</body>
+</html>

data/js/dripdrop.js

@@ -0,0 +1,103 @@
+function DripDrop() { 
+  /* JavaScript object for DripDrop Messages */
+  this.Message = function(name,opts) {
+    this.name = name;
+    if (opts && opts.body) {
+      this.body = opts.body;
+    };
+    
+    this.head = (opts && opts.head !== undefined) ? opts.head : {empty:''};
+
+    this.jsonEncoded = function() {
+      return $.JSON.encode({name: this.name, head: this.head, body: this.body});
+    };   
+  };
+  
+  /* A DripDrop friendly WebSocket Object. 
+     This automatically converts messages to DD.Message objects.
+     Additionally, this uses friendlier callback methods, closer to the DripDrop
+     server-side API, like onOpen, onRecv, onError, and onClose. */
+  this.WebSocket = function(url) {
+    this.socket = new WebSocket(url);
+    
+    this.onOpen = function(callback) {
+      this.socket.onopen = callback;
+    };
+    
+    this.onRecv = function(callback) {
+      this.socket.onmessage = function(wsMessage) {
+        var json = $.parseJSON(wsMessage.data)
+        var message = new DD.Message(json.name, {head: json.head, body: json.body});
+        
+        callback(message);
+        return this;
+      }
+    };
+    
+    this.onClose = function(callback) {
+      this.socket.onclose = callback;
+    };
+
+    this.onError = function(callback) {
+      this.socket.onerror = callback;
+    };
+
+    this.sendMessage = function(message) {
+      this.socket.send(message.jsonEncoded());
+    };
+  };
+
+  this.HTTPResponse = function() {
+    
+  };
+   
+  /* A DripDrop friendly HTTP Request. */
+  this.HTTP = function(url) {
+    this.url = url;
+     
+    this.onRecv = function(data) {};
+    this.sendMessage = function() {
+      var response = new this.HTTPResponse;
+      $.post(this.url, function(json) {
+        this.onRecv(new DD.Message(json.name, {head: json.head, body: json.body}));
+      });
+    };
+  };
+
+  /* An Object for reperesenting pipeline processing. 
+     Ex:
+     var mypl = new DD.Pipeline; 
+     mypl.stages.push(new DD.PipelineStage{'namecapper','Name Capper', 
+                    function(message) { message.name = message.name.toUpperCase() });
+     mypl.execute(message); //Message must be a valid DD.Message
+
+  
+     All functions must either return a message, or false.
+     If false is returned the pipeline short-circuits and returns false, not running
+     subsequent stages */
+  this.PipelineStage = function(id,name,action) {
+    this.id     = id;
+    this.name   = name;
+    this.action = action;
+  };
+  
+  this.Pipeline = function() {
+    this.stages = [];
+    
+    this.execute = function(message) {
+      if (this.stages.length == 0) {
+        return null;
+      };
+      
+      for (var i=0,l=this.stages.length; i < l; i++) {
+        var stage = this.stages[i];
+        message = stage.action(message);
+      };
+      
+      return message;
+    };
+  };
+};
+
+//Use this as shorthand
+DD = new DripDrop;