dripdrop 0.10.0-java

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 |msg,response|
+    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: #{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

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'dripdrop/node'
+Thread.abort_on_exception = true
+
+#Define our handlers
+DripDrop::Node.new do
+  route :pub,  :zmq_publish,   'tcp://localhost:2200', :bind
+  route :sub1, :zmq_subscribe, pub.address, :connect, :topic_filter => /[13579]$/
+  route :sub2, :zmq_subscribe, pub.address, :connect, :topic_filter => /[02468]$/
+  route :sub3, :zmq_subscribe, pub.address, :connect
+    
+  sub1.on_recv do |message|
+    puts "Receiver 1 #{message.inspect}"
+  end
+
+  sub2.on_recv do |message|
+    puts "Receiver 2 #{message.inspect}"
+  end
+
+  sub3.on_recv do |message|
+    puts "Receiver 3 #{message.inspect}"
+  end
+  
+  zm_reactor.periodical_timer(500) do
+    puts "Sending!"
+    #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.start! #Start the reactor and block until complete

data/example/pushpull.rb

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

data/example/subclass.rb

@@ -0,0 +1,54 @@
+require 'dripdrop'
+Thread.abort_on_exception = true
+
+#We will create a subclass of the Message class
+#which will add a timestamp to the header every
+#time it is passed around
+
+#First our subclass
+
+class TimestampedMessage < DripDrop::Message
+  def self.create_message(*args)
+    obj = super
+    obj.head['timestamps'] = []
+    obj.head['timestamps'] << Time.now.to_s
+    obj
+  end
+
+  def self.recreate_message(*args)
+    obj = super
+    obj.head['timestamps'] << Time.now.to_s
+    obj
+  end
+end
+
+#Define our handlers
+#We'll create a batch of 5 push/pull queues them to
+#show the timestamp array getting larger
+#as we go along
+
+DripDrop.default_message_class = TimestampedMessage
+
+node = DripDrop::Node.new do
+  push1 = zmq_push("tcp://127.0.0.1:2201", :bind)
+  push2 = zmq_push("tcp://127.0.0.1:2202", :bind)
+
+  pull1 = zmq_pull("tcp://127.0.0.1:2201", :connect)
+  pull2 = zmq_pull("tcp://127.0.0.1:2202", :connect)
+
+  pull1.on_recv do |msg|
+    puts "Pull 1 #{msg.head.inspect}"
+    sleep 1
+    push2.send_message(msg)
+  end
+
+  pull2.on_recv do |msg|
+    puts "Pull 2 #{msg.head.inspect}"
+  end
+
+  push1.send_message(TimestampedMessage.create_message(:name => 'test', :body => "Hello there"))
+end
+
+node.start
+sleep 5
+node.stop

data/example/xreq_xrep.rb

@@ -0,0 +1,24 @@
+require 'dripdrop/node'
+Thread.abort_on_exception = true
+
+DripDrop::Node.new do
+  route :xrep_server, :zmq_xrep, 'tcp://127.0.0.1:2200', :bind
+  route :xreq_client, :zmq_xreq, xrep_server.address,    :connect
+   
+  xrep_server.on_recv do |message,response|
+    puts "REP #{message.body}"
+    response.send_message(message)
+  end
+
+  i = 0; k = 0
+  EM::PeriodicTimer.new(1) do
+    i += 1; k += 1
+     
+    xreq_client.send_message(:name => 'test', :body => "Test Payload i#{i}") do |message|
+      puts "RECV I RESP #{message.inspect}"
+    end
+    xreq_client.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,107 @@
+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.stringify({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;
+      return this;
+    };
+    
+    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;
+      return this;
+    };
+
+    this.onError = function(callback) {
+      this.socket.onerror = callback;
+      return this;
+    };
+
+    this.sendMessage = function(message) {
+      this.socket.send(message.jsonEncoded());
+      return this;
+    };
+  };
+
+  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;