dripdrop 0.9.10 → 0.10.0.beta1

data/README.md

@@ -1,54 +1,164 @@
 # DripDrop
 
-DripDrop is a library for structured message-passing async apps using EventMachine, ZeroMQ, and other protocols.
+## INSTALLATION NOTES:
 
-Here's an example of the kind of thing DripDrop makes easy, from [example/combined.rb](http://github.com/andrewvc/dripdrop/blob/master/example/combined.rb)
-  
-    require 'dripdrop'
-    Thread.abort_on_exception = true #Always a good idea in multithreaded apps.
-  
-    # Encapsulates our EM and ZMQ reactors
-    DripDrop::Node.new do
-      # Define all our sockets
-      route :stats_pub,      :zmq_publish,   'tcp://127.0.0.1:2200', :bind
-      route :stats_sub1,     :zmq_subscribe, stats_pub.address, :connect
-      route :stats_sub2,     :zmq_subscribe, stats_pub.address, :connect
-      route :http_collector, :http_server,   'http://127.0.0.1:8080'
-      route :http_agent,     :http_client,   http_collector.address
+1. Install with 'gem install dripdrop --pre' as you probably want the beta gem.
+2. Build eventmachine from [git master](https://github.com/eventmachine/eventmachine). It fixes a ZeroMQ bug that will cause you much pain if you don't have it.
+3. Build zeromq2 from [git master](https://github.com/zeromq/zeromq2)
+4. You probably want the yajl-ruby (or json-java if you're on jRuby) gem installed for optimal JSON generation. You don't have to use JSON with DripDrop, but it is the default.
+5. If you have any problems, open an issue, a lot of stuff is in flux!
+
+## About
+
+DripDrop is a library aiming to help you write better message passing apps. It's a rich toolchest, currently based on EventMachine, which provides async IO. 
+
+DripDrop helps in these ways:
+
+  1. Normalized Communication Interfaces. All protocols, regardless of their using HTTP, ZeroMQ, or WebSockets, have a unified API, with minor differences only to accomodate the reality of the underlying protocol.
+  2. A set of tools to break your app into composable parts--we call them nodelets in dripdrop--ideally communicating with each other with the aforementioned interfaces..
+  3. A simple, yet powerful messaging class, that lets you control the structure, formatting, and serialization of messages sent between nodelets.
+  4. Tools to break your nodelets off when it comes time to deploy, letting you scale your app by delegating roles and scaling out resources
+
+## Normalized Interfaces
+
+Let's start by looking at the normalized communication interface in a simple app.
+    
+    class MyApp < DripDrop::Node
+      def action #Special method that gets executed on Node#start
+        # Define some sockets, here we create an HTTP server, and
+        # a client to it. :my_hts and :my_htc are custom names
+        # that will be available after definition
+        route :my_server, :http_server, 'http://127.0.0.1:2201'
+        route :my_client, :http_client, 'http://127.0.0.1:2201'
+        
+        # Our http server is a simple time server
+        my_server.on_recv do |message,response|
+          response.send_message(:name => 'time', :body => {'time' => Time.now.to_s})
+        end
         
-      stats_sub1.on_recv do |message|
-        puts "Receiver 1: #{message.body}"
+        # Here, we setup a timer, and periodically poll the http server
+        EM::PeriodicTimer.new(1) do
+          # Messages must have a :name. They can optionally have a :body.
+          # Additionally, they can set custom :head properties.
+          my_client.send_message(:name => 'time_request') do |response_message|
+            puts "The time is: #{response_message.body['time']}"
+          end
+        end
       end
-      stats_sub2.on_recv do |message|
-        puts "Receiver 2: #{message.body}"
+    end
+     
+    #Start the app and block
+    MyApp.new.start!
+
+What we've done here is use HTTP as a simple messaging protocol. Yes, we've thrown out a good chunk of what HTTP does, but consider this, that exact same code would work if we replaced the top two lines with:
+
+        route :my_server, :zmq_xrep, 'http://127.0.0.1:2201', :bind
+        route :my_client, :zmq_xreq, 'http://127.0.0.1:2201', :connect
+
+That replaces the HTTP server and client with ultra-high performance zeromq sockets. Now, protocols have varying strengths and weaknesses, and ZeroMQ is not HTTP necessarily, for instance, given a :zmq_pub socket, you can only send_messages, but there is no response message, because :zmq_pub is the publishing end of a request/reply pattern. The messaging API attempts to reduce all methods on sockets to the following set:
+
+  * on_recv (sometimes takes a block with |message,response| if it can send a response)
+  * send_message
+  * on_open  (Websockets only)
+  * on_close (Websockets only)
+
+
+## Composable Parts
+
+The tools mentioned above are useful, but if you try and build a larger app you'll quickly find them lacking. The callbacks get tricky, and mixing your logic up in a single #action method becomes messy. That's why we have nodelets in DripDrop. Here's a trivial example.
+
+    class MyApp < DripDrop::Node
+      # This will instantiate a new StatsCollector object, and define the
+      # stats_raw and stats_filtered methods inside it.
+      nodelet :stats_collector, StatsCollector do |nodelet|
+        nodelet.route :stats_raw,      :zmq_pull, 'tcp://127.0.0.1:2301', :bind
+        nodelet.route :stats_filtered, :zmq_push, 'tcp://127.0.0.1:2302', :bind
       end
       
-      i = 0
-      http_collector.on_recv do |message,response|
-        i += 1
-        stats_pub.send_message(message)
-        response.send_message(:name => 'ack', :body => {:seq => i})
+      nodelet :stats_processor, StatsProcessor do |nodelet|
+        nodelet.route :stats_ingress, :zmq_pull, 'tcp://127.0.0.1:2302', :bind
       end
 
-      EM::PeriodicTimer.new(1) do
-        msg = DripDrop::Message.new('http/status', :body => "Success #{i}")
-        http_agent.send_message(msg) do |resp_msg|
-          puts "RESP: #{resp_msg.body['seq']}"
+      # The nodelets method gives you access to all defined nodelets
+      # We created a #run method on each nodelet we call here.
+      nodelets.each {|n| n.run}
+    end
+
+    # You must subclass Nodelet
+    # The method #run here is merely a convention
+    class StatsCollector < DripDrop::Node::Nodelet
+      def run
+        stats_raw.on_recv do |raw_stat_msg|
+          # Custom filtering code could go here...
+          stats_filtered.send_message(raw_stat_msg)
+        end
+      end
+    end
+  
+    class StatsProcessor < DripDrop::Node::Nodelet
+      # Initialize shouldn't be subclassed on a Nodelet, this gets called
+      # After the nodelet is instantiated
+      def configure
+        @name_counts = Hash.new(0)
+      end
+      
+      def run
+        stats_ingress.on_recv do |message|
+          @name_counts[message.name] += 1
+          puts @name_counts.inspect
         end
       end
-    end.start! #Start the reactor and block until complete
+    end
+    
+    MyApp.new.start!
 
-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 MessagePack. There is a raw mode 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.
+# Custom Messages
 
-#RDoc
+  DripDrop::Message is the parent class of all messages in dripdrop, it's a flexible and freeform way to send data. In more complex apps you'll want to both define custom behaviour on messages, and restrict the data they carry. This is possible by subclassing DripDrop::Message. Before we look at that though, lets see what makes a DripDrop::Message. 
 
-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.
+  The simplest DripDrop::Message you could create would look something like this if dumped into JSON:
+    
+    {name: 'msgname', head: {}, body: null}
+
+  In other words, a dripdrop message *must* provide a name, it must also be able to store arbitrary, nested, keys and values in its head, and it may use the body for any data it wishes.
 
-#How It Works
+  If you'd like to create your own Message format, simply Subclass DripDrop::Message. If you want to restrict your handlers to using a specific message type, it's easily done by passing in the :message_class option. For instance
+
+    class MyMessageClass < DripDrop::Message
+      # Custom code
+    end
+    class MyApp < DripDrop::Node
+      def action
+        route :myhandler, :zmq_publish,   'tcp://127.0.0.1:2200', :bind,    :message_class => MyMessageClass 
+        route :myhandler, :zmq_subscribe, 'tcp://127.0.0.1:2200', :connect, :message_class => MyMessageClass
+      end
+    end
 
-DripDrop encapsulates both zmqmachine, and eventmachine. It provides some sane default messaging choices, using [MessagePack](http://msgpack.org/)(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.
+# Breaking out your nodelets
+  
+One of the core ideas behind dripdrop, is that if your application is composed of a bunch of separate parts, that in production deployment, will run on separate physical servers, it should still be possible for you to develop and test with ease. If you structure your app into separate nodelets, and *only* communicate between them via message passing, you can accomplish this easily. 
+
+While you will have to write your own executable wrappers suitable for your own deployment, one convenenience feature built in is the notion of a +run_list+. By setting the #run_list you can restrict which nodelets actually get initialized. For example:
+
+    class MyApp < DripDrop::Node
+      nodelet :service_one, ServiceOneClass do
+        #nodelet setup
+      end
+      nodelet :service_two, ServiceTwoClass do
+        #nodelet setup
+      end
+    end
+
+    # Only starts :service_two, the setup for :service_one
+    # is skipped as well
+    MyApp.new(:run_list => [:service_two]).start!
+
+#RDocs
+
+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.
 
 #Contributors
 
 * Andrew Cholakian: [andrewvc](http://github.com/andrewvc)
 * John W Higgins: [wishdev](http://github.com/wishdev)
+* Nick Recobra: [oruen](https://github.com/oruen)

data/Rakefile

@@ -10,10 +10,9 @@ begin
     gem.email = "andrew@andrewvc.com"
     gem.homepage = "http://github.com/andrewvc/dripdrop"
     gem.authors = ["Andrew Cholakian"]
-    gem.add_dependency('ffi-rzmq', '>= 0.7.1')
-    gem.add_dependency('eventmachine', '>= 0.12.10')
     gem.add_dependency('em-websocket')
-    gem.add_dependency('em-zeromq', '>= 0.1.2')
+    gem.add_dependency('em-zeromq', '>= 0.2.0.beta1')
+    gem.add_development_dependency('rspec', '>= 2.4.0')
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
@@ -33,3 +32,8 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |t|
+end
+

data/VERSION

@@ -1 +1 @@
-0.9.10
+0.10.0.beta1

data/dripdrop.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dripdrop}
-  s.version = "0.9.10"
+  s.version = "0.10.0.beta1"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Andrew Cholakian"]
-  s.date = %q{2011-02-15}
+  s.date = %q{2011-02-28}
   s.description = %q{Evented framework for ZeroMQ and EventMachine Apps. }
   s.email = %q{andrew@andrewvc.com}
   s.extra_rdoc_files = [
@@ -45,7 +45,8 @@ Gem::Specification.new do |s|
     "lib/dripdrop/handlers/base.rb",
     "lib/dripdrop/handlers/http_client.rb",
     "lib/dripdrop/handlers/http_server.rb",
-    "lib/dripdrop/handlers/websockets.rb",
+    "lib/dripdrop/handlers/mongrel2.rb",
+    "lib/dripdrop/handlers/websocket_server.rb",
     "lib/dripdrop/handlers/zeromq.rb",
     "lib/dripdrop/message.rb",
     "lib/dripdrop/node.rb",
@@ -56,6 +57,7 @@ Gem::Specification.new do |s|
     "spec/node/nodelet_spec.rb",
     "spec/node/routing_spec.rb",
     "spec/node/websocket_spec.rb",
+    "spec/node/zmq_m2_spec.rb",
     "spec/node/zmq_pushpull_spec.rb",
     "spec/node/zmq_xrepxreq_spec.rb",
     "spec/node_spec.rb",
@@ -63,7 +65,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = %q{http://github.com/andrewvc/dripdrop}
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.5.1}
+  s.rubygems_version = %q{1.5.0}
   s.summary = %q{Evented framework for ZeroMQ and EventMachine Apps.}
   s.test_files = [
     "spec/gimite-websocket.rb",
@@ -72,6 +74,7 @@ Gem::Specification.new do |s|
     "spec/node/nodelet_spec.rb",
     "spec/node/routing_spec.rb",
     "spec/node/websocket_spec.rb",
+    "spec/node/zmq_m2_spec.rb",
     "spec/node/zmq_pushpull_spec.rb",
     "spec/node/zmq_xrepxreq_spec.rb",
     "spec/node_spec.rb",
@@ -82,21 +85,18 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<ffi-rzmq>, [">= 0.7.1"])
-      s.add_runtime_dependency(%q<eventmachine>, [">= 0.12.10"])
       s.add_runtime_dependency(%q<em-websocket>, [">= 0"])
-      s.add_runtime_dependency(%q<em-zeromq>, [">= 0.1.2"])
+      s.add_runtime_dependency(%q<em-zeromq>, [">= 0.2.0.beta1"])
+      s.add_development_dependency(%q<rspec>, [">= 2.4.0"])
     else
-      s.add_dependency(%q<ffi-rzmq>, [">= 0.7.1"])
-      s.add_dependency(%q<eventmachine>, [">= 0.12.10"])
       s.add_dependency(%q<em-websocket>, [">= 0"])
-      s.add_dependency(%q<em-zeromq>, [">= 0.1.2"])
+      s.add_dependency(%q<em-zeromq>, [">= 0.2.0.beta1"])
+      s.add_dependency(%q<rspec>, [">= 2.4.0"])
     end
   else
-    s.add_dependency(%q<ffi-rzmq>, [">= 0.7.1"])
-    s.add_dependency(%q<eventmachine>, [">= 0.12.10"])
     s.add_dependency(%q<em-websocket>, [">= 0"])
-    s.add_dependency(%q<em-zeromq>, [">= 0.1.2"])
+    s.add_dependency(%q<em-zeromq>, [">= 0.2.0.beta1"])
+    s.add_dependency(%q<rspec>, [">= 2.4.0"])
   end
 end
 

data/example/complex/server.rb

@@ -8,40 +8,30 @@ class ComplexExample < DripDrop::Node
   end
   
   def action
-    if [:all, :websockets].include?(@mode)
-      route :ws_listener,  :websocket, 'ws://127.0.0.1:8080'
-      route :broadcast_in, :zmq_subscribe, 'tcp://127.0.0.1:2200', :connect
-      route :reqs_out,     :zmq_xreq,      'tcp://127.0.0.1:2201', :connect
-      
-      WSListener.new(:ws => ws_listener, :broadcast_in => broadcast_in, :reqs_out => reqs_out).run
+    nodelet :ws_listener, WSListener do |n|
+      n.route :ws_listener,  :websocket, 'ws://127.0.0.1:8080'
+      n.route :broadcast_in, :zmq_subscribe, 'tcp://127.0.0.1:2200', :connect
+      n.route :reqs_out,     :zmq_xreq,      'tcp://127.0.0.1:2201', :connect
     end
-    
-    if [:all, :coordinator].include?(@mode)
-      route :broadcast_out, :zmq_publish, 'tcp://127.0.0.1:2200', :bind
-      route :reqs_in,       :zmq_xrep,    'tcp://127.0.0.1:2201', :bind
-      route :reqs_htout,    :http_client, 'tcp://127.0.0.1:3000/endpoint'
       
-      Coordinator.new(:broadcast_out => broadcast_out, :reqs_in => reqs_in, :reqs_htout => reqs_htout).run
+    nodelet :coordinator, Coordinator do |n|
+      n.route :broadcast_out, :zmq_publish, 'tcp://127.0.0.1:2200', :bind
+      n.route :reqs_in,       :zmq_xrep,    'tcp://127.0.0.1:2201', :bind
+      n.route :reqs_htout,    :http_client, 'tcp://127.0.0.1:3000/endpoint'
     end
   end
 end
 
-class Coordinator
-  def initialize(opts={})
-    @bc_out  = opts[:broadcast_out]
-    @reqs_in = opts[:reqs_in]
-    @reqs_htout = opts[:reqs_htout]
-  end
-  
+class Coordinator < DripDrop::Node::Nodelet
   def run
     proxy_reqs
     heartbeat
   end
 
   def proxy_reqs
-    @reqs_in.on_recv do |message, response|
+    reqs_in.on_recv do |message, response|
       puts "Proxying #{message.inspect} to htout"
-      @reqs_htout.send_message(message) do |http_response|
+      reqs_htout.send_message(message) do |http_response|
         puts "Received http response #{http_response.inspect} sending back"
         response.send_message(http_response)
       end
@@ -50,18 +40,17 @@ class Coordinator
   
   def heartbeat
     EM::PeriodicTimer.new(1) do
-      @bc_out.send_message :name => 'tick', :body => Time.now.to_s
+      broadcast_out.send_message :name => 'tick', :body => Time.now.to_s
     end
   end
 end
 
-class WSListener
-  def initialize(opts={})
-    @ws       = opts[:ws]
-    @bc_in    = opts[:broadcast_in]
-    @reqs_out = opts[:reqs_out]
+class WSListener < DripDrop::Node::Nodelet
+  def initialize(*args)
+    super
     @client_channel = EM::Channel.new
   end
+  
   def run
     proxy_websockets
     broadcast_to_websockets
@@ -69,15 +58,13 @@ class WSListener
 
   def broadcast_to_websockets
     # Receives messages from Broadcast Out
-    @bc_in.on_recv do |message|
+    broadcast_in.on_recv do |message|
       puts "Broadcast In recv: #{message.inspect}"
       @client_channel.push(message)
     end
   end
 
   def proxy_websockets
-    ws = @ws
-    
     sigs_sids = {} #Map connection signatures to subscriber IDs
      
     ws.on_open do |conn|
@@ -102,7 +89,7 @@ class WSListener
 
     ws.on_recv do |message,conn|
       puts "WS Recv #{message.name}"
-      @reqs_out.send_message(message) do |resp_message|
+      reqs_out.send_message(message) do |resp_message|
         puts "Recvd resp_message #{resp_message.inspect}, sending back to client"
         conn.send_message(resp_message)
       end

data/lib/dripdrop/handlers/base.rb

@@ -13,21 +13,24 @@ class DripDrop
           print_exception(e)
         end
       else
-        print_exception(e)
+        print_exception(exception)
       end
     end
 
     def print_exception(exception)
-      $stderr.write exception.message
-      $stderr.write exception.backtrace.join("\t\n")
+      if exception.is_a?(Exception)
+        $stderr.write exception.message
+        $stderr.write exception.backtrace.join("\t\n")
+      else
+        $stderr.write "Expected an exception, got: #{exception.inspect}"
+      end
     end
      
     private
     # Normalize Hash objs and DripDrop::Message objs into DripDrop::Message objs
-    def dd_messagify(message)
+    def dd_messagify(message,klass=DripDrop::Message)
       if message.is_a?(Hash)
-        return DripDrop::Message.new(message[:name], :head => message[:head],
-                                                     :body => message[:body])
+        return klass.from_hash(message)
       elsif message.is_a?(DripDrop::Message)
         return message
       else

data/lib/dripdrop/handlers/mongrel2.rb

@@ -0,0 +1,163 @@
+=begin
+Large portion of at least the concepts (and plenty of the code) used here come from m2r
+
+https://github.com/perplexes/m2r
+
+Under the following license
+ 
+Copyright (c) 2009 Pradeep Elankumaran
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+=end
+
+class DripDrop
+  class Mongrel2Handler < ZMQBaseHandler
+    include ZMQWritableHandler
+    include ZMQReadableHandler
+    attr_accessor :uuid
+
+    def initialize(*args)
+      super(*args)
+      @connections = []
+      self.uuid = @opts[:uuid]
+    end
+
+    def add_connection(connection)
+      @connections << connection
+    end
+
+    def read_connection
+      @connections[0]
+    end
+
+    def write_connection
+      @connections[1]
+    end
+
+    def address
+      raise "Not applicable for a Mongrel2Handler"
+    end
+
+    def on_readable(socket, messages)
+      req = Mongrel2Request.parse_request(messages[0])
+      @recv_cbak.call(req)
+    end
+
+    def send_resp(uuid, conn_id, msg)
+      header = "%s %d:%s," % [uuid, conn_id.size, conn_id]
+      string = header + ' ' + msg
+      send_message(string)
+    end
+
+    def reply(req, msg)
+      self.send_resp(req.sender, req.conn_id, msg)
+    end
+
+    def reply_http(req, body, code=200, headers={})
+      self.reply(req, http_response(body, code, headers))
+    end
+
+    def http_response(body, code, headers)
+      headers['Content-Length'] = body.size
+      headers_s                 = headers.map { |k, v| "%s: %s" % [k, v] }.join("\r\n")
+
+      "HTTP/1.1 #{code} #{StatusMessage[code.to_i]}\r\n#{headers_s}\r\n\r\n#{body}"
+    end
+
+    # From WEBrick
+    StatusMessage = {
+        100 => 'Continue',
+        101 => 'Switching Protocols',
+        200 => 'OK',
+        201 => 'Created',
+        202 => 'Accepted',
+        203 => 'Non-Authoritative Information',
+        204 => 'No Content',
+        205 => 'Reset Content',
+        206 => 'Partial Content',
+        300 => 'Multiple Choices',
+        301 => 'Moved Permanently',
+        302 => 'Found',
+        303 => 'See Other',
+        304 => 'Not Modified',
+        305 => 'Use Proxy',
+        307 => 'Temporary Redirect',
+        400 => 'Bad Request',
+        401 => 'Unauthorized',
+        402 => 'Payment Required',
+        403 => 'Forbidden',
+        404 => 'Not Found',
+        405 => 'Method Not Allowed',
+        406 => 'Not Acceptable',
+        407 => 'Proxy Authentication Required',
+        408 => 'Request Timeout',
+        409 => 'Conflict',
+        410 => 'Gone',
+        411 => 'Length Required',
+        412 => 'Precondition Failed',
+        413 => 'Request Entity Too Large',
+        414 => 'Request-URI Too Large',
+        415 => 'Unsupported Media Type',
+        416 => 'Request Range Not Satisfiable',
+        417 => 'Expectation Failed',
+        500 => 'Internal Server Error',
+        501 => 'Not Implemented',
+        502 => 'Bad Gateway',
+        503 => 'Service Unavailable',
+        504 => 'Gateway Timeout',
+        505 => 'HTTP Version Not Supported'
+    }
+  end
+end
+
+class Mongrel2Request
+  attr_reader :sender, :conn_id, :path, :headers, :body
+
+  def initialize(sender, conn_id, path, headers, body)
+    @sender  = sender
+    @conn_id = conn_id
+    @path    = path
+    @headers = headers
+    @body    = body
+
+    if headers['METHOD'] == 'JSON'
+      @data = JSON.parse(@body)
+    else
+      @data = {}
+    end
+  end
+
+  def self.parse_netstring(ns)
+    len, rest = ns.split(':', 2)
+    len = len.to_i
+    raise "Netstring did not end in ','" unless rest[len].chr == ','
+    [rest[0...len], rest[(len+1)..-1]]
+  end
+
+  def self.parse_request(msg)
+    sender, conn_id, path, rest = msg.copy_out_string.split(' ', 4)
+    headers, head_rest = parse_netstring(rest)
+    body, _ = parse_netstring(head_rest)
+
+    headers = JSON.parse(headers)
+
+    self.new(sender, conn_id, path, headers, body)
+  end
+end

data/lib/dripdrop/handlers/{websockets.rb → websocket_server.rb}

@@ -72,8 +72,12 @@ class DripDrop
     end
 
     def send_message(message)
-      encoded_message = dd_messagify(message).encoded
-      @ws.send(encoded_message)
+      begin
+        encoded_message = dd_messagify(message).encoded
+        @ws.send(encoded_message)
+      rescue StandardError => e
+        handle_error(e)
+      end
     end
   end
 end