dripdrop 0.10.0-java

data/lib/dripdrop.rb

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

data/lib/dripdrop/agent.rb

@@ -0,0 +1,40 @@
+require 'dripdrop/message'
+#Check if we're in 1.8.7
+unless defined?(RUBY_ENGINE)
+  require 'zmq'
+  ZMQGEM = :rbzmq
+else
+  require 'ffi-rzmq'
+  ZMQGEM = :ffirzmq
+end
+require 'uri'
+
+class DripDrop
+  #The Agent class is a simple ZMQ Pub client. It uses DripDrop::Message messages
+  class Agent
+    attr_reader :address, :context, :socket
+    
+    #address should be a string like tcp://127.0.0.1
+    def initialize(sock_type,address,sock_ctype)
+      @context = ZMQ::Context.new(1)
+      @socket  = @context.socket(sock_type)
+      if sock_ctype == :bind
+        @socket.bind(address)
+      else
+        @socket.connect(address)
+      end
+    end
+
+    #Sends a DripDrop::Message to the socket
+    def send_message(name,body,head={})
+      message = DripDrop::Message.new(name,:body => body, :head => head).encoded
+      if ZMQGEM == :rbzmq
+        @socket.send name, ZMQ::SNDMORE
+        @socket.send message
+      else
+        @socket.send_string name, ZMQ::SNDMORE
+        @socket.send_string message
+      end
+    end
+  end
+end

data/lib/dripdrop/handlers/base.rb

@@ -0,0 +1,42 @@
+class DripDrop
+  class BaseHandler
+    
+    def on_error(&block)
+      @err_cbak = block
+    end
+
+    def handle_error(exception,*extra)
+      if @err_cbak
+        begin
+          @err_cbak.call(exception,*extra)
+        rescue StandardError => e
+          print_exception(e)
+        end
+      else
+        print_exception(exception)
+      end
+    end
+
+    def print_exception(exception)
+      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,klass=DripDrop::Message)
+      if message.is_a?(Hash)
+        return klass.from_hash(message)
+      elsif message.is_a?(DripDrop::Message)
+        return message
+      else
+        return message
+      end
+    end
+
+  end
+end

data/lib/dripdrop/handlers/http_client.rb

@@ -0,0 +1,38 @@
+class DripDrop
+  class HTTPClientHandler < BaseHandler
+    attr_reader :address, :opts
+    
+    def initialize(uri, opts={})
+      @uri     = uri
+      @address = @uri.to_s
+      @opts    = opts
+      @message_class = @opts[:message_class] || DripDrop.default_message_class
+    end
+    
+    def send_message(message,&block)
+      dd_message = dd_messagify(message)
+      if dd_message.is_a?(DripDrop::Message)
+        uri_path = @uri.path.empty? ? '/' : @uri.path
+        
+        req = EM::Protocols::HttpClient.request(
+          :host => @uri.host, :port => @uri.port,
+          :request => uri_path, :verb => 'POST',
+          :contenttype => 'application/json',
+          :content => dd_message.encode_json
+        )
+        req.callback do |response|
+          begin
+            # Hack to fix evma http
+            response[:content] =~ /(\{.*\})/ 
+            fixed_body = $1
+            block.call(@message_class.decode(fixed_body)) if block
+          rescue StandardError => e
+            handle_error(e)
+          end
+        end
+      else
+        raise "Unsupported message type '#{dd_message.class}'"
+      end
+    end
+  end
+end

data/lib/dripdrop/handlers/http_server.rb

@@ -0,0 +1,59 @@
+require 'evma_httpserver'
+
+class DripDrop
+  class HTTPServerHandlerResponse < BaseHandler
+    attr_reader :em_response, :message_class
+    def initialize(em_response)
+      @em_response   = em_response
+    end
+
+    def send_message(message)
+      message = dd_messagify(message)
+      @em_response.status = 200
+      @em_response.content      = message.json_encoded
+      @em_response.send_response
+    end
+  end
+   
+  class HTTPEMServer < EM::Connection
+    include EM::HttpServer
+    
+    def initialize(dd_handler)
+      @dd_handler = dd_handler
+    end
+     
+    def post_init
+      super
+      no_environment_strings
+    end
+    
+    def process_http_request
+      begin
+        message     = @dd_handler.message_class.decode_json(@http_post_content)
+        response    = EM::DelegatedHttpResponse.new(self)
+        dd_response = HTTPServerHandlerResponse.new(response)
+        @dd_handler.recv_cbak.call(message, dd_response) if @dd_handler.recv_cbak
+      rescue StandardError => e
+        handler_error(e)
+      end
+    end
+  end
+
+  class HTTPServerHandler < BaseHandler
+    attr_reader :address, :opts, :message_class, :uri, :recv_cbak
+    
+    def initialize(uri,opts={})
+      @uri      = uri
+      @uri_path = @uri.path.empty? ? '/' : @uri.path
+      @address  = uri.to_s
+      @opts     = opts
+      @message_class = @opts[:message_class] || DripDrop.default_message_class
+    end
+    
+    def on_recv(msg_format=:dripdrop_json,&block)
+      @recv_cbak = block
+      @conn = EM.start_server(@uri.host, @uri.port, HTTPEMServer, self)
+      self
+    end
+  end
+end

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/websocket_server.rb

@@ -0,0 +1,86 @@
+require 'em-websocket'
+
+
+class DripDrop
+  class WebSocketHandler < BaseHandler
+    class SocketError < StandardError; attr_accessor :reason, :connection end
+    
+    attr_reader :ws, :address, :thread
+   
+    def initialize(address,opts={})
+      @opts = opts
+      @raw           = false #Deal in strings or ZMQ::Message objects
+      host, port     = address.host, address.port.to_i
+      @message_class = @opts[:message_class] || DripDrop.default_message_class
+      @debug         = @opts[:debug] || false
+
+      EventMachine::WebSocket.start(:host => host,:port => port,:debug => @debug) do |ws|
+        #A WebSocketHandler:Connection gets passed to all callbacks 
+        dd_conn = Connection.new(ws)
+          
+        ws.onopen  { @onopen_handler.call(dd_conn) if @onopen_handler }
+        ws.onclose { @onclose_handler.call(dd_conn) if @onclose_handler }
+        ws.onerror {|reason|
+          begin
+            raise SocketError, reason
+          rescue SocketError => e
+            e.reason     = reason
+            e.connection = dd_conn
+            handle_error(e,dd_conn)
+          end
+        }
+        
+        ws.onmessage { |message|
+          if @onmessage_handler
+            begin
+              message = @message_class.decode(message) unless @raw
+              @onmessage_handler.call(message,dd_conn)
+            rescue StandardError => e
+              handle_error(e,dd_conn)
+            end
+          end
+        }
+      end
+    end
+
+    def on_recv(&block)
+      @raw = false
+      @onmessage_handler = block
+      self
+    end
+
+    def on_recv_raw(&block)
+      @raw = true
+      @onmessage_handler = block
+      self
+    end
+
+    def on_open(&block)
+      @onopen_handler = block
+      self
+    end
+  
+    def on_close(&block)
+      @onclose_handler = block
+      self
+    end
+  end
+  
+  class WebSocketHandler::Connection < BaseHandler
+    attr_reader :ws, :signature, :handler
+    
+    def initialize(ws)
+      @ws = ws
+      @signature = @ws.signature
+    end
+
+    def send_message(message)
+      begin
+        encoded_message = dd_messagify(message).encoded
+        @ws.send(encoded_message)
+      rescue StandardError => e
+        handle_error(e)
+      end
+    end
+  end
+end

data/lib/dripdrop/handlers/zeromq.rb

@@ -0,0 +1,300 @@
+require 'ffi-rzmq'
+require 'em-zeromq'
+
+class DripDrop
+  SEQ_CTR_KEY = '_dd/xctr'
+  
+  #Setup the default message class handler first
+  class << self
+    attr_accessor :default_message_class
+
+    DripDrop.default_message_class = DripDrop::Message
+  end
+
+  class ZMQBaseHandler < BaseHandler
+    attr_reader :connection
+
+    def initialize(opts={})
+      @opts         = opts
+      @connection   = nil
+      @msg_format   = opts[:msg_format] || :dripdrop
+      @message_class = @opts[:message_class] || DripDrop.default_message_class
+    end
+
+    def add_connection(connection)
+      @connection = connection
+    end
+
+    def read_connection
+      @connection
+    end
+
+    def write_connection
+      @connection
+    end
+
+    def on_recv(msg_format=:dripdrop,&block)
+      @recv_cbak = block
+      self
+    end
+
+    def address
+      self.connection.address
+    end
+
+    #Triggered after a handler is setup
+    def post_setup; end
+  end
+
+  module ZMQWritableHandler
+    def initialize(*args)
+      super(*args)
+      @send_queue = []
+      @send_queue_enabled = false
+    end
+
+    def on_writable(conn)
+      unless @send_queue.empty?
+        message = @send_queue.shift
+
+        conn.send_msg(*message)
+      else
+        conn.deregister_writable if @send_queue_enabled
+      end
+    end
+
+    # Sends a message, accepting either a DripDrop::Message,
+    # a hash that looks like a DripDrop::Message (has keys :name, :head, :body),
+    # or your own custom messages. Custom messages should either be a String, or
+    # for multipart messages, an Array of String objects.
+    def send_message(message)
+      dd_message = dd_messagify(message)
+      if dd_message.is_a?(DripDrop::Message)
+        @send_queue.push([dd_message.encoded])
+      elsif message.class == Array
+        @send_queue.push(message)
+      else
+        @send_queue.push([message])
+      end
+      
+      self.write_connection.register_writable if @send_queue_enabled
+         
+      EM::next_tick {
+        on_writable(self.write_connection)
+      }
+    end
+  end
+
+  module ZMQReadableHandler
+    attr_accessor :message_class
+     
+    def decode_message(msg)
+      @message_class.decode(msg)
+    end
+
+    def on_readable(socket, messages)
+      begin
+        case @msg_format
+        when :raw
+          @recv_cbak.call(messages)
+        when :dripdrop
+          if messages.length > 1
+            raise "Expected message in one part for #{self.inspect}, got #{messages.map(&:copy_out_string)}"
+          end
+          
+          body  = messages.shift.copy_out_string
+          @recv_cbak.call(decode_message(body))
+        else
+          raise "Unknown message format '#{@msg_format}'"
+        end
+      rescue StandardError => e
+        handle_error(e)
+      end
+    end
+  end
+
+  class ZMQSubHandler < ZMQBaseHandler
+    include ZMQReadableHandler
+
+    attr_accessor :topic_filter
+    
+    def initialize(*args)
+      super(*args)
+      self.topic_filter = @opts[:topic_filter]
+    end
+
+    def on_readable(socket, messages)
+      begin
+        if @msg_format == :dripdrop
+          unless messages.length == 2
+            return false
+          end
+          topic = messages.shift.copy_out_string
+          if @topic_filter.nil? || topic.match(@topic_filter)
+            body  = messages.shift.copy_out_string
+            @recv_cbak.call(decode_message(body))
+          end
+        else
+          super(socket,messages)
+        end
+      rescue StandardError => e
+        handle_error(e)
+      end
+    end
+
+    def post_setup
+      super
+      @connection.socket.setsockopt(ZMQ::SUBSCRIBE, '')
+    end
+  end
+
+  class ZMQPubHandler < ZMQBaseHandler
+    include ZMQWritableHandler
+
+    #Sends a message along
+    def send_message(message)
+      dd_message = dd_messagify(message,@message_class)
+      if dd_message.is_a?(DripDrop::Message)
+        super([dd_message.name, dd_message.encoded])
+      else
+        super(message)
+      end
+    end
+  end
+
+  class ZMQPullHandler < ZMQBaseHandler
+    include ZMQReadableHandler
+  end
+
+  class ZMQPushHandler < ZMQBaseHandler
+    include ZMQWritableHandler
+  end
+
+  class ZMQXRepHandler < ZMQBaseHandler
+    include ZMQWritableHandler
+    include ZMQReadableHandler
+
+    def initialize(*args)
+      super(*args)
+    end
+
+    def on_readable(socket,messages)
+      if @msg_format == :dripdrop
+        begin
+          if messages.length < 3
+            raise "Expected message in at least 3 parts, got #{messages.map(&:copy_out_string).inspect}"
+          end
+           
+          message_strings = messages.map(&:copy_out_string)
+          
+          # parse the message into identities, delimiter and body
+          identities = []
+          delimiter  = nil
+          body       = nil
+          # It's an identitiy if it isn't an empty string
+          # Once we hit the delimiter, we know the rest after is the body
+          message_strings.each_with_index do |ms,i|
+            unless ms.empty?
+              identities << ms
+            else
+              delimiter = ms
+               
+              unless message_strings.length == i+2
+                raise "Expected body in 1 part got '#{message_strings.inspect}'"
+              end
+               
+              body  = message_strings[i+1]
+              break
+            end
+          end
+          
+          raise "Received xreq message with no body!" unless body
+          message    = decode_message(body)
+          raise "Received nil message! #{body}" unless message
+          seq        = message.head[SEQ_CTR_KEY]
+          response   = ZMQXRepHandler::Response.new(self,identities,seq,@message_class)
+          @recv_cbak.call(message,response) if @recv_cbak
+        rescue StandardError => e
+          handle_error(e)
+        end
+      else
+        super(socket,messages)
+      end
+    end
+
+    def send_message(message,identities,seq)
+      if message.is_a?(DripDrop::Message)
+        message.head[SEQ_CTR_KEY] = seq
+         
+        resp  = identities + ['', message.encoded]
+        super(resp)
+      else
+        resp  = identities + ['', message]
+        super(resp)
+      end
+    end
+  end
+  
+  class ZMQXRepHandler::Response < ZMQBaseHandler
+    attr_accessor :xrep, :seq, :identities
+    
+    def initialize(xrep,identities,seq,message_class)
+      @xrep = xrep
+      @seq  = seq
+      @identities    = identities
+      @message_class = message_class
+    end
+    
+    def send_message(message)
+      dd_message = dd_messagify(message,@message_class)
+      @xrep.send_message(dd_message,identities,seq)
+    end
+  end
+
+  class ZMQXReqHandler < ZMQBaseHandler
+    include ZMQWritableHandler
+    include ZMQReadableHandler
+
+    def initialize(*args)
+      super(*args)
+      #Used to keep track of responses
+      @seq_counter = 0
+      @promises = {}
+
+      self.on_recv do |message|
+        begin
+          seq = message.head[SEQ_CTR_KEY]
+          raise "Missing Seq Counter" unless seq
+          promise = @promises.delete(seq)
+          promise.call(message) if promise
+        rescue StandardError => e
+          handle_error(e)
+        end
+      end
+    end
+
+    def send_message(message,&block)
+      begin
+        dd_message = dd_messagify(message,@message_class)
+        if dd_message.is_a?(DripDrop::Message)
+          @seq_counter += 1
+          dd_message.head[SEQ_CTR_KEY] = @seq_counter
+          @promises[@seq_counter] = block if block
+          message = dd_message
+        end
+      rescue StandardError => e
+        handle_error(e)
+      end
+      super(['', message.encoded])
+    end
+
+    def on_readable(socket, messages)
+      begin
+        # Strip out empty delimiter
+        super(socket, messages[1..-1])
+      rescue StandardError => e
+        handle_error(e)
+      end
+    end
+  end
+end