dripdrop 0.2.0 → 0.3.0

data/README.md

@@ -45,10 +45,19 @@ Here's an example of the kind of thing DripDrop makes easy, from [examples/pubsu
 
 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.
 
-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:
+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).
+
+#RDoc
+
+RDocs can be found [here](http://www.rdoc.info/github/andrewvc/dripdrop/master/frames). Most of the interesting stuff is in the [Node](http://www.rdoc.info/github/andrewvc/dripdrop/master/DripDrop/Node) and [Message](http://www.rdoc.info/github/andrewvc/dripdrop/master/DripDrop/Message) classes.
 
 #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 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.
 
+#Contributors
+
+Andrew Cholakian: [andrewvc](http://github.com/andrewvc)
+John W Higgins: [wishdev](http://github.com/wishdev)
+
 Copyright (c) 2010 Andrew Cholakian. See LICENSE for details.

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/dripdrop.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dripdrop}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Andrew Cholakian"]
-  s.date = %q{2010-10-10}
+  s.date = %q{2010-10-21}
   s.description = %q{0MQ App stats}
   s.email = %q{andrew@andrewvc.com}
   s.extra_rdoc_files = [
@@ -29,6 +29,7 @@ Gem::Specification.new do |s|
      "example/http.rb",
      "example/pubsub.rb",
      "example/pushpull.rb",
+     "example/subclass.rb",
      "example/xreq_xrep.rb",
      "js/dripdrop.html",
      "js/dripdrop.js",
@@ -42,8 +43,10 @@ Gem::Specification.new do |s|
      "lib/dripdrop/handlers/zeromq.rb",
      "lib/dripdrop/message.rb",
      "lib/dripdrop/node.rb",
-     "spec/node/zmq_pushpull.rb",
-     "spec/node/zmq_xrepxreq.rb",
+     "spec/message_spec.rb",
+     "spec/node/http_spec.rb",
+     "spec/node/zmq_pushpull_spec.rb",
+     "spec/node/zmq_xrepxreq_spec.rb",
      "spec/node_spec.rb",
      "spec/spec_helper.rb"
   ]
@@ -53,10 +56,12 @@ Gem::Specification.new do |s|
   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"
+    "spec/spec_helper.rb",
+     "spec/node/http_spec.rb",
+     "spec/node/zmq_xrepxreq_spec.rb",
+     "spec/node/zmq_pushpull_spec.rb",
+     "spec/message_spec.rb",
+     "spec/node_spec.rb"
   ]
 
   if s.respond_to? :specification_version then

data/example/agent_test.rb

@@ -1,12 +1,13 @@
+##
+##TODO: This badly needs to be rewritten
+##
+
 require 'rubygems'
 require 'dripdrop/agent'
 
 agent = DripDrop::Agent.new(ZMQ::PUB,'tcp://127.0.0.1:2900',:connect)
 
 loop do
-  #Test is the message name, this is the first part of the 0MQ message, used for filtering
-  #at the 0MQ sub socket level, :head is always a hash,  :body is freeform
-  #EVERYTHING must be serializable to BERT
   agent.send_message('test', :body => 'hello', :head => {:key => 'value'})
   puts "SEND"
   sleep 1

data/example/http.rb

@@ -5,7 +5,7 @@ DripDrop::Node.new do
   addr = 'http://127.0.0.1:2200'
   
   i = 0 
-  http_server(addr).on_recv do |response,msg|
+  http_server(addr).on_recv do |msg,response|
     i += 1
     response.send_message(msg)
   end

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
+    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}"
+    sleep 1
+    push2.send_message(msg)
+  end
+
+  pull2.on_recv do |msg|
+    puts "Pull 2 #{msg.head}"
+  end
+
+  push1.send_message(TimestampedMessage.create_message(:name => 'test', :body => "Hello there"))
+end
+
+node.start
+sleep 5
+node.stop

data/example/xreq_xrep.rb

@@ -5,9 +5,9 @@ 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|
+  rep.on_recv do |message,identities,seq|
     puts "REP #{message.body}"
-    rep.send_message(identities,seq,message)
+    rep.send_message(message,identities,seq)
   end
 
   req = zmq_xreq(z_addr, :connect)

data/lib/dripdrop/handlers/http.rb

@@ -46,7 +46,7 @@ class DripDrop
           when :dripdrop_json
             msg = DripDrop::Message.decode_json(env['rack.input'].read)
             msg.head[:http_env] = env
-            @recv_cbak.call(body,msg)
+            @recv_cbak.call(msg,body)
           else
             raise "Unsupported message type #{@msg_format}"
           end
@@ -69,8 +69,8 @@ class DripDrop
       #Rack middleware was not meant to be used this way...
       #Thin's error handling only rescues stuff w/o a backtrace
       begin
-        Thin::Logging.debug = true
-        Thin::Logging.trace = true
+        Thin::Logging.debug = false
+        Thin::Logging.trace = false
         Thin::Server.start(@address.host, @address.port) do
           map '/' do
             run HTTPApp.new(msg_format,&block)

data/lib/dripdrop/handlers/zeromq.rb

@@ -1,6 +1,13 @@
 require 'ffi-rzmq'
 
 class DripDrop
+  #Setup the default message class handler first
+  class << self
+    attr_accessor :default_message_class
+
+    DripDrop.default_message_class = DripDrop::Message
+  end
+
   class ZMQBaseHandler
     attr_reader :address, :socket_ctype, :socket
 
@@ -9,6 +16,7 @@ class DripDrop
       @zm_reactor   = zm_reactor
       @socket_ctype = socket_ctype # :bind or :connect
       @debug        = opts[:debug] # TODO: Start actually using this
+      @opts         = opts
     end
 
     def on_attach(socket)
@@ -91,8 +99,15 @@ class DripDrop
   end
 
   module ZMQReadableHandler
+    attr_accessor :message_class
+
     def initialize(*args)
       super(*args)
+      @message_class = @opts[:msg_class] || DripDrop.default_message_class
+    end
+
+    def decode_message(msg)
+      @message_class.decode(msg)
     end
 
     def on_readable(socket, messages)
@@ -102,7 +117,7 @@ class DripDrop
       when :dripdrop
         raise "Expected message in one part" if messages.length > 1
         body  = messages.shift.copy_out_string
-        @recv_cbak.call(DripDrop::Message.decode(body))
+        @recv_cbak.call(decode_message(body))
       else
         raise "Unknown message format '#{@msg_format}'"
       end
@@ -129,7 +144,7 @@ class DripDrop
         topic = messages.shift.copy_out_string
         if @topic_filter.nil? || topic.match(@topic_filter)
           body  = messages.shift.copy_out_string
-          msg   = @recv_cbak.call(DripDrop::Message.decode(body))
+          msg   = @recv_cbak.call(decode_message(body))
         end
       else
         super(socket,messages)
@@ -173,15 +188,15 @@ class DripDrop
       if @msg_format == :dripdrop
         identities = messages[0..-2].map {|m| m.copy_out_string}
         body  = messages.last.copy_out_string
-        message = DripDrop::Message.decode(body)
+        message = decode_message(body)
         seq     = message.head['_dripdrop/x_seq_counter']
-        @recv_cbak.call(identities,seq,message)
+        @recv_cbak.call(message,identities,seq)
       else
         super(socket,messages)
       end
     end
 
-    def send_message(identities,seq,message)
+    def send_message(message,identities,seq)
       if message.is_a?(DripDrop::Message)
         message.head['_dripdrop/x_seq_counter'] = seq
         super(identities + [message.encoded])

data/lib/dripdrop/message.rb

@@ -3,61 +3,93 @@ require 'bert'
 require 'json'
 
 class DripDrop
-  #DripDrop::Message messages are exchanged between all tiers in the architecture
-  #A Message is composed of a name, head, and body, and should be restricted to types that
-  #can be readily encoded to JSON, that means hashes, arrays, strings, integers, and floats
-  #internally, they're just stored as BERT
+  # DripDrop::Message messages are exchanged between all tiers in the architecture
+  # A Message is composed of a name, head, and body, and should be restricted to types that
+  # can be readily encoded to JSON.
+  # name: Any string
+  # head: A hash containing anything (should be used for metadata)
+  # body: anything you'd like, it can be null even
   #
-  #The basic message format is built to mimic HTTP. Why? Because I'm a dumb web developer :)
-  #The name is kind of like the URL, its what kind of message this is.
-  #head should be used for metadata, body for the actual data.
-  #These definitions are intentionally loose, because protocols tend to be used loosely.
+  # Hashes, arrays, strings, integers, symbols, and floats are probably what you should stick to.
+  # Internally, they're just stored as BERT, which is great because if you don't use JSON
+  # things like symbols and binary data are transmitted more efficiently and transparently.
+  #
+  # The basic message format is built to mimic HTTP (s/url_path/name/). Why? Because I'm a dumb web developer :)
+  # The name is kind of like the URL, its what kind of message this is, but it's a loose definition,
+  # use it as you see fit.
+  # head should be used for metadata, body for the actual data.
+  # These definitions are intentionally loose, because protocols tend to be used loosely.
   class Message
     attr_accessor :name, :head, :body
-    
-    #Create a new message.
-    #example:
-    #  Message.new('mymessage', :head => {:timestamp => Time.now}, 
-    #    :body => {:mykey => :myval,  :other_key => ['complex']})
+
+    # Creates a new message.
+    # example:
+    #   DripDrop::Message.new('mymessage', :head => {:timestamp => Time.now},
+    #     :body => {:mykey => :myval,  :other_key => ['complex']})
     def initialize(name,extra={})
-      raise "No null chars allowed in message names!" if name.include?("\0")
-       
+      raise ArgumentError, "Message names may not be empty or null!" if name.nil? || name.empty?
+
       @head = extra[:head] || {}
-      raise "Message head must be a hash!" unless @head.is_a?(Hash)
-      
+      raise ArgumentError, "Invalid head #{@head}. Head must be a hash!" unless @head.is_a?(Hash)
+      @head[:msg_class] = self.class.to_s
+
       @name = name
       @body = extra[:body]
     end
-    
-    #The encoded message, ready to be sent across the wire via ZMQ
+
+    # The encoded message, ready to be sent across the wire via ZMQ
     def encoded
       BERT.encode(self.to_hash)
     end
-    
-    def encode_json
+
+    # Encodes the hash represntation of the message to JSON
+    def json_encoded
       self.to_hash.to_json
     end
+    # (Deprecated, use json_encoded)
+    def encode_json; json_encoded; end
 
-    #Convert the Message to a hash like:
-    #{:name => @name, :head => @head, :body => @body}
+    # Convert the Message to a hash like:
+    # {:name => @name, :head => @head, :body => @body}
     def to_hash
       {:name => @name, :head => @head, :body => @body}
     end
 
-    #Parses an already encoded string
-    def self.decode(*args); self.parse(*args) end
-    def self.parse(msg)
+    # Build a new Message from a hash that looks like
+    #    {:name => name, :body => body, :head => head}
+    def self.from_hash(hash)
+      self.new(hash[:name],:head => hash[:head], :body => hash[:body])
+    end
+
+    def self.create_message(*args)
+      case args[0]
+        when Hash then self.from_hash(args[0])
+        else self.new(args)
+      end
+    end
+
+    def self.recreate_message(hash)
+      raise ArgumentError, "Wrong message class #{hash[:head][:msg_class]} for #{self.to_s}" unless hash[:head][:msg_class] == self.to_s
+      self.from_hash(hash)
+    end
+
+    # Parses an already encoded string
+    def self.decode(msg)
       return nil if msg.nil? || msg.empty?
       #This makes parsing ZMQ messages less painful, even if its ugly here
       #We check the class name as a string in case we don't have ZMQ loaded
       if msg.class.to_s == 'ZMQ::Message'
-        msg = msg.copy_out_string 
+        msg = msg.copy_out_string
         return nil if msg.empty?
       end
       decoded = BERT.decode(msg)
-      self.new(decoded[:name], :head => decoded[:head], :body => decoded[:body])
+      self.recreate_message(decoded)
     end
 
+    # (Deprecated). Use decode instead
+    def self.parse(msg); self.decode(msg) end
+
+    # Decodes a string containing a JSON representation of a message
     def self.decode_json(str)
       begin
         json_hash = JSON.parse(str)
@@ -67,12 +99,57 @@ class DripDrop
       end
       self.new(json_hash['name'], :head => json_hash['head'], :body => json_hash['body'])
     end
+  end
+
+  #Use of this "metaclass" allows for the automatic recognition of the message's
+  #base class
+  class AutoMessageClass < Message
+    def initialize(*args)
+      raise "Cannot create an instance of this class - please use create_message class method"
+    end
+
+    class << self
+      attr_accessor :message_subclasses
+
+      DripDrop::AutoMessageClass.message_subclasses = {'DripDrop::Message' => DripDrop::Message}
+
+      def verify_args(*args)
+        head =
+          case args[0]
+            when Hash then args[0][:head]
+            else args[1]
+          end
+        raise ArgumentError, "Invalid head #{head}. Head must be a hash!" unless head.is_a?(Hash)
+
+        msg_class = head[:msg_class]
+        unless DripDrop::AutoMessageClass.message_subclasses.has_key?(msg_class)
+          raise ArgumentError, "Unknown AutoMessage message class #{msg_class}"
+        end
+
+        DripDrop::AutoMessageClass.message_subclasses[msg_class]
+      end
+
+      def create_message(*args)
+        klass = verify_args(*args)
+        klass.create_message(*args)
+      end
+
+      def recreate_message(*args)
+        klass = verify_args(*args)
+        klass.recreate_message(*args)
+      end
+
+      def register_subclass(klass)
+        DripDrop::AutoMessageClass.message_subclasses[klass.to_s] = klass
+      end
+    end
+  end
 
-    private
-    
-    #Sanitize a string so it'll look good for JSON, BERT, and MongoDB
-    def sanitize_structure(structure)
-      #TODO: Make this work, and called for head, and body
+  #Including this module into your subclass will automatically register the class
+  #with AutoMessageClass
+  module SubclassedMessage
+    def self.included(base)
+      DripDrop::AutoMessageClass.register_subclass base
     end
   end
 end

data/lib/dripdrop/node.rb

@@ -24,6 +24,8 @@ class DripDrop
       @thread = nil
     end
 
+    # Starts the reactors and runs the block passed to initialize.
+    # This is non-blocking.
     def start
       @thread = Thread.new do
         EM.run do
@@ -35,6 +37,9 @@ class DripDrop
       end
     end
 
+    # If the reactor has started, this blocks until the thread 
+    # running the reactor joins. This should block forever
+    # unless +stop+ is called.
     def join
       if @thread
         @thread.join
@@ -43,55 +48,38 @@ class DripDrop
       end
     end
 
-    #Blocking version of start, equivalent to +start+ then +join+
+    # Blocking version of start, equivalent to +start+ then +join+
     def start!
       self.start
       self.join
     end
 
+    # Stops the reactors. If you were blocked on #join, that will unblock.
     def stop
       @zm_reactor.stop
       EM.stop
     end
 
-    #TODO: All these need to be majorly DRYed up
-     
     # Creates a ZMQ::SUB type socket. Can only receive messages via +on_recv+
     def zmq_subscribe(address,socket_ctype,opts={},&block)
-      zm_addr = str_to_zm_address(address)
-      h_opts  = handler_opts_given(opts)
-      handler = DripDrop::ZMQSubHandler.new(zm_addr,@zm_reactor,socket_ctype,h_opts)
-      @zm_reactor.sub_socket(handler)
-      handler
+      zmq_handler(DripDrop::ZMQSubHandler,:sub_socket,address,socket_ctype,opts={})
     end
 
     # Creates a ZMQ::PUB type socket, can only send messages via +send_message+
     def zmq_publish(address,socket_ctype,opts={})
-      zm_addr = str_to_zm_address(address)
-      h_opts  = handler_opts_given(opts)
-      handler = DripDrop::ZMQPubHandler.new(zm_addr,@zm_reactor,socket_ctype,h_opts)
-      @zm_reactor.pub_socket(handler)
-      handler
+      zmq_handler(DripDrop::ZMQPubHandler,:pub_socket,address,socket_ctype,opts={})
     end
 
     # Creates a ZMQ::PULL type socket. Can only receive messages via +on_recv+
     def zmq_pull(address,socket_ctype,opts={},&block)
-      zm_addr = str_to_zm_address(address)
-      h_opts  = handler_opts_given(opts)
-      handler = DripDrop::ZMQPullHandler.new(zm_addr,@zm_reactor,socket_ctype,h_opts)
-      @zm_reactor.pull_socket(handler)
-      handler
+      zmq_handler(DripDrop::ZMQPullHandler,:pull_socket,address,socket_ctype,opts={})
     end
 
     # Creates a ZMQ::PUSH type socket, can only send messages via +send_message+
     def zmq_push(address,socket_ctype,opts={})
-      zm_addr = str_to_zm_address(address)
-      h_opts  = handler_opts_given(opts)
-      handler = DripDrop::ZMQPushHandler.new(zm_addr,@zm_reactor,socket_ctype,h_opts)
-      @zm_reactor.push_socket(handler)
-      handler
+      zmq_handler(DripDrop::ZMQPushHandler,:push_socket,address,socket_ctype,opts={})
     end
-    
+
     # Creates a ZMQ::XREP type socket, both sends and receivesc XREP sockets are extremely
     # powerful, so their functionality is currently limited. XREP sockets in DripDrop can reply
     # to the original source of the message.
@@ -104,29 +92,32 @@ class DripDrop
     # To reply from an xrep handler, be sure to call send messages with the same +identities+ and +seq+
     # arguments that +on_recv+ had. So, send_message takes +identities+, +seq+, and +message+.
     def zmq_xrep(address,socket_ctype,opts={})
-      zm_addr = str_to_zm_address(address)
-      h_opts  = handler_opts_given(opts)
-      handler = DripDrop::ZMQXRepHandler.new(zm_addr,@zm_reactor,socket_ctype,h_opts)
-      @zm_reactor.xrep_socket(handler)
-      handler
+      zmq_handler(DripDrop::ZMQXRepHandler,:xrep_socket,address,socket_ctype,opts={})
     end
  
     # See the documentation for +zmq_xrep+ for more info
     def zmq_xreq(address,socket_ctype,opts={})
-      zm_addr = str_to_zm_address(address)
-      h_opts  = handler_opts_given(opts)
-      handler = DripDrop::ZMQXReqHandler.new(zm_addr,@zm_reactor,socket_ctype,h_opts)
-      @zm_reactor.xreq_socket(handler)
-      handler
+      zmq_handler(DripDrop::ZMQXReqHandler,:xreq_socket,address,socket_ctype,opts={})
     end
-    
-    def websocket(address,opts={},&block)
+
+    # Binds an EM websocket 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_recv {|msg,websocket| ws.send(msg)}
+    #
+    # All other events only receive the +websocket+ object, which corresponds
+    # not to the +DripDrop::WebSocketHandler+ object, but to an em-websocket object.
+    def websocket(address,opts={})
       uri     = URI.parse(address)
       h_opts  = handler_opts_given(opts)
       handler = DripDrop::WebSocketHandler.new(uri,h_opts)
       handler
     end
     
+    # Starts a new Thin HTTP server listening on address.
+    # Can have an +on_recv+ handler that gets passed a single +response+ arg.
+    #    http_server(addr) {|response,msg| response.send_message(msg)}
     def http_server(address,opts={},&block)
       uri     = URI.parse(address)
       h_opts  = handler_opts_given(opts)
@@ -134,6 +125,12 @@ class DripDrop
       handler
     end
     
+    # An EM HTTP client.
+    # Example:
+    #    client = http_client(addr)
+    #    client.send_message(:name => 'name', :body => 'hi') do |resp_msg|
+    #      puts resp_msg.inspect
+    #    end
     def http_client(address,opts={})
       uri     = URI.parse(address)
       h_opts  = handler_opts_given(opts)
@@ -141,6 +138,15 @@ class DripDrop
       handler
     end
 
+    # An inprocess pub/sub queue that works similarly to EM::Channel, 
+    # but has manually specified identifiers for subscribers letting you
+    # more easily delete subscribers without crazy id tracking.
+    #  
+    # This is useful for situations where you want to broadcast messages across your app,
+    # but need a way to properly delete listeners.
+    # 
+    # +dest+ is the name of the pub/sub channel.
+    # +data+ is any type of ruby var you'd like to send.
     def send_internal(dest,data)
       return false unless @recipients_for[dest]
       blocks = @recipients_for[dest].values
@@ -150,6 +156,9 @@ class DripDrop
       end
     end
 
+    # Defines a subscriber to the channel +dest+, to receive messages from +send_internal+.
+    # +identifier+ is a unique identifier for this receiver.
+    # The identifier can be used by +remove_recv_internal+ 
     def recv_internal(dest,identifier,&block)
       if @recipients_for[dest]
         @recipients_for[dest][identifier] =  block
@@ -158,6 +167,8 @@ class DripDrop
       end
     end
 
+    # Deletes a subscriber to the channel +dest+ previously identified by a
+    # reciever created with +recv_internal+
     def remove_recv_internal(dest,identifier)
       return false unless @recipients_for[dest]
       @recipients_for[dest].delete(identifier)
@@ -165,10 +176,14 @@ class DripDrop
 
     private
     
-    def str_to_zm_address(str)
-      addr_uri = URI.parse(str)
-      ZM::Address.new(addr_uri.host,addr_uri.port.to_i,addr_uri.scheme.to_sym)
-    end
+    def zmq_handler(klass, zm_sock_type, address, socket_ctype, opts={})
+      addr_uri = URI.parse(address)
+      zm_addr  = ZM::Address.new(addr_uri.host,addr_uri.port.to_i,addr_uri.scheme.to_sym)
+      h_opts   = handler_opts_given(opts)
+      handler  = klass.new(zm_addr,@zm_reactor,socket_ctype,h_opts)
+      @zm_reactor.send(zm_sock_type,handler)
+      handler
+    end   
     
     def handler_opts_given(opts)
       @handler_default_opts.merge(opts)

data/lib/dripdrop.rb

@@ -1 +1,2 @@
+require 'dripdrop/message'
 require 'dripdrop/node'

data/spec/message_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+class SpecMessageClass < DripDrop::Message
+  include DripDrop::SubclassedMessage
+end
+
+describe DripDrop::Message do
+  describe "basic message" do
+    def create_basic
+      attrs = {
+        :name => 'test',
+        :head => {:foo => :bar},
+        :body => [:foo, :bar, :baz]
+      }
+      message = DripDrop::Message.new(attrs[:name],:head => attrs[:head],
+                                                   :body => attrs[:body])
+      [message, attrs]
+    end
+    it "should create a basic message without raising an exception" do
+      lambda {
+        message, attrs = create_basic
+      }.should_not raise_exception
+    end
+    describe "with minimal attributes" do
+      it "should create a message with only a name" do
+        lambda {
+          DripDrop::Message.new('nameonly')
+        }.should_not raise_exception
+      end
+      it "should set the head to a single key hash containing message class if nil provided" do
+        DripDrop::Message.new('nilhead', :head => nil).head.should == {:msg_class => 'DripDrop::Message'}
+      end
+      it "should raise an exception if a non-hash, non-nil head is provided" do
+        lambda {
+          DripDrop::Message.new('arrhead', :head => [])
+        }.should raise_exception(ArgumentError)
+      end
+    end
+    describe "encoding" do
+      before(:all) do
+        @message, @attrs = create_basic
+      end
+      it "should encode to valid BERT hash without error" do
+        enc = @message.encoded
+        enc.should be_a(String)
+        BERT.decode(enc).should be_a(Hash)
+      end
+      it "should decode encoded messages without errors" do
+        DripDrop::Message.decode(@message.encoded).should be_a(DripDrop::Message)
+      end
+      it "should encode to valid JSON without error" do
+        enc = @message.json_encoded
+        enc.should be_a(String)
+        JSON.parse(enc).should be_a(Hash)
+      end
+      it "should decode JSON encoded messages without errors" do
+        DripDrop::Message.decode_json(@message.json_encoded).should be_a(DripDrop::Message)
+      end
+      it "should convert messages to Hash representations" do
+        @message.to_hash.should be_a(Hash)
+      end
+      it "should be able to turn hash representations back into Message objs" do
+        DripDrop::Message.from_hash(@message.to_hash).should be_a(DripDrop::Message)
+      end
+    end
+    describe "subclassing" do
+      def create_auto_message
+        attrs = {
+          :name => 'test',
+          :head => {:foo => :bar, :msg_class => 'SpecMessageClass'},
+          :body => [:foo, :bar, :baz]
+        }
+
+        message = DripDrop::AutoMessageClass.create_message(attrs)
+
+        [message, attrs]
+      end
+      before(:all) do
+        @message, @attrs = create_auto_message
+      end
+      it "should be added to the subclass message class hash if SubclassedMessage included" do
+        DripDrop::AutoMessageClass.message_subclasses.should include('SpecMessageClass' => SpecMessageClass)
+      end
+      it "should throw an exception if we try to recreate a message of the wrong class" do
+        msg = DripDrop::Message.new('test')
+        lambda{SpecMessageClass.recreate_message(msg.to_hash)}.should raise_exception
+      end
+
+      describe "DripDrop::AutoMessageClass" do
+        it "should create a properly classed message based on head[:msg_class]" do
+          @message.should be_a(SpecMessageClass)
+        end
+        it "should recreate a message based on head[:msg_class]" do
+          DripDrop::AutoMessageClass.recreate_message(@message.to_hash).should be_a(SpecMessageClass)
+        end
+      end
+    end
+  end
+end

data/spec/node/http_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe "http" do
+  def http_send_messages(to_send,&block)
+    responses = []
+    client = nil
+    server = nil
+    
+    @ddn = DripDrop::Node.new do
+      addr = rand_addr
+      
+      zmq_subscribe(rand_addr, :bind) do |message|
+      end
+      
+      client = http_client(addr)
+      
+      server = http_server(addr).on_recv do |message,response|
+        $stdout.flush
+        responses << message
+        response.send_message(message)
+      end
+      
+      to_send.each do |message|
+        EM::next_tick do
+          http_client(addr).send_message(message) do |resp_message|
+            block.call(message,resp_message)
+          end
+        end
+      end
+    end
+    
+    @ddn.start
+    sleep 0.1
+    @ddn.stop
+    
+    {: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}
+      end
+      @responses     = http_info[:responses]
+      @push_handler  = http_info[:handlers][:push]
+      @pull_handlers = http_info[:handlers][:pull]
+    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
+      end
+    end
+  end
+end

data/spec/node/{zmq_pushpull.rb → zmq_pushpull_spec.rb}

@@ -29,7 +29,7 @@ describe "zmq push/pull" do
     
     @ddn.start
     sleep 0.1
-    @ddn.stop
+    @ddn.stop rescue nil
     
     {:responses => responses, :handlers => { :push => push, :pull => [pull] }}
   end
@@ -43,10 +43,9 @@ describe "zmq push/pull" do
       @pull_handlers = pp_info[:handlers][:pull]
     end
 
-    it "should receive all sent messages in order" do
-      @sent.zip(@responses).each do |sent,response|
-        sent.name.should == response.name
-      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 receive messages on both pull sockets" do

data/spec/node/{zmq_xrepxreq.rb → zmq_xrepxreq_spec.rb}

@@ -12,7 +12,7 @@ describe "zmq xreq/xrep" do
       rep = zmq_xrep(addr, :bind)
       req = zmq_xreq(addr, :connect)
       
-      rep.on_recv do |identities,seq,message|
+      rep.on_recv do |message,identities,seq|
         yield(identities,seq,message) if block
         responses << {:identities => identities, :seq => seq, :message => message}
       end
@@ -22,7 +22,7 @@ describe "zmq xreq/xrep" do
     
     @ddn.start
     sleep 0.1
-    @ddn.stop
+    @ddn.stop rescue nil
     
     {:responses => responses, :handlers => {:req => req, :rep => rep}}
   end
@@ -64,8 +64,8 @@ describe "zmq xreq/xrep" do
         req1 = zmq_xreq(addr, :connect)
         req2 = zmq_xreq(addr, :connect)
         
-        rep.on_recv do |identities,seq,message|
-          rep.send_message(identities,seq,message)
+        rep.on_recv do |message,identities,seq|
+          rep.send_message(message,identities,seq)
         end
          
         r1_msg = DripDrop::Message.new("REQ1 Message")

data/spec/node_spec.rb

@@ -2,17 +2,21 @@ require 'spec_helper'
 
 describe DripDrop::Node do
   describe "initialization" do
-    before do
-      @ddn = DripDrop::Node.new {}
+    before(:all) do
+      @ddn = DripDrop::Node.new {
+        zmq_subscribe(rand_addr,:bind) #Keeps ZMQMachine Happy
+      }
       @ddn.start
-      sleep 0.1
+      sleep 1
     end
     
     it "should start EventMachine" do
+      pending "This is not repeatedly reliable"
       EM.reactor_running?.should be_true
     end
     
     it "should start ZMQMachine" do
+      pending "This is not repeatedly reliable"
       @ddn.zm_reactor.running?.should be_true
     end
     
@@ -23,10 +27,12 @@ describe DripDrop::Node do
 
   describe "shutdown" do
     before do
-      @ddn = DripDrop::Node.new {}
+      @ddn = DripDrop::Node.new {
+        zmq_subscribe(rand_addr,:bind) #Keeps ZMQMachine Happy
+      }
       @ddn.start
-      sleep 0.1 
-      @ddn.stop
+      sleep 0.1
+      @ddn.stop rescue nil
       sleep 0.1
     end
   

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Andrew Cholakian
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-10 00:00:00 -04:00
+date: 2010-10-21 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -91,6 +91,7 @@ files:
 - example/http.rb
 - example/pubsub.rb
 - example/pushpull.rb
+- example/subclass.rb
 - example/xreq_xrep.rb
 - js/dripdrop.html
 - js/dripdrop.js
@@ -104,8 +105,10 @@ files:
 - lib/dripdrop/handlers/zeromq.rb
 - lib/dripdrop/message.rb
 - lib/dripdrop/node.rb
-- spec/node/zmq_pushpull.rb
-- spec/node/zmq_xrepxreq.rb
+- spec/message_spec.rb
+- spec/node/http_spec.rb
+- spec/node/zmq_pushpull_spec.rb
+- spec/node/zmq_xrepxreq_spec.rb
 - spec/node_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
@@ -141,7 +144,9 @@ signing_key:
 specification_version: 3
 summary: 0MQ App Stats
 test_files: 
-- spec/node/zmq_pushpull.rb
-- spec/node/zmq_xrepxreq.rb
-- spec/node_spec.rb
 - spec/spec_helper.rb
+- spec/node/http_spec.rb
+- spec/node/zmq_xrepxreq_spec.rb
+- spec/node/zmq_pushpull_spec.rb
+- spec/message_spec.rb
+- spec/node_spec.rb