dripdrop 0.3.1 → 0.4.0

data/lib/dripdrop/node.rb

@@ -5,23 +5,25 @@ require 'eventmachine'
 require 'uri'
 
 require 'dripdrop/message'
+require 'dripdrop/node/nodelet'
+require 'dripdrop/handlers/base'
 require 'dripdrop/handlers/zeromq'
 require 'dripdrop/handlers/websockets'
 require 'dripdrop/handlers/http'
 
 class DripDrop
   class Node
-    attr_reader   :zm_reactor
+    attr_reader   :zm_reactor, :routing
     attr_accessor :debug
     
     def initialize(opts={},&block)
-      @handlers = {}
-      @debug    = opts[:debug]
-      @recipients_for = {}
+      @zm_reactor = nil # The instance of the zmq_machine reactor
+      @block      = block
+      @thread     = nil # Thread containing the reactors
+      @routing    = {}  # Routing table
+      @debug      = opts[:debug]
+      @recipients_for       = {}
       @handler_default_opts = {:debug => @debug}
-      @zm_reactor = nil
-      @block = block
-      @thread = nil
     end
 
     # Starts the reactors and runs the block passed to initialize.
@@ -60,24 +62,93 @@ class DripDrop
       EM.stop
     end
 
-    # Creates a ZMQ::SUB type socket. Can only receive messages via +on_recv+
+    # Defines a new route. Routes are the recommended way to instantiate
+    # handlers. For example:
+    #
+    #    route :stats_pub, :zmq_publish, 'tcp://127.0.0.1:2200', :bind
+    #    route :stats_sub, :zmq_subscribe, stats_pub.address, :connect
+    #
+    # Will make the following methods available within the reactor block:
+    #    stats_pub  # A regular zmq_publish handler
+    #    :stats_sub # A regular zmq_subscribe handler
+    #
+    # See the docs for +routes_for+ for more info in grouping routes for
+    # nodelets and maintaining sanity in larger apps
+    def route(name,handler_type,*handler_args)
+      # If we're in a route_for block, prepend appropriately
+      full_name = @route_prepend ? "#{@route_prepend}_#{name}".to_sym : name
+      
+      handler = self.send(handler_type, *handler_args)
+      @routing[full_name] = handler
+      
+      # Define the route name as a singleton method
+      (class << self; self; end).class_eval do
+        define_method(full_name) { handler }
+      end
+      
+      handler
+    end
+
+    # Defines a group of +route+s, to be used as the interface for a +nodelet+
+    # later on.
+    # 
+    # All routes defined with the +route_for+ block will be prepended with the
+    # +nodelet_name+ and an underscore. So, the following routes:
+    # 
+    #    routes_for :forwarder do
+    #      route :input,  :zmq_subscribe, 'tcp://127.0.0.1:2200', :bind
+    #      route :output, :zmq_publish,   f.in.address, :connect
+    #    end
+    # 
+    # Will yield the routes: +forwarder_input+ and +forwarder_output+ globally.
+    # Within the block scope of the +forwarder+ nodelet however, the routes are additionally
+    # available with their own short names. See the +nodelet+ method for details.
+    def routes_for(nodelet_name,&block)
+      @route_prepend = nodelet_name #This feels ugly. Blech.
+      block.call
+      @route_prepend = nil
+    end
+
+    # Nodelets are a way of segmenting a DripDrop::Node. This can be used
+    # for both organization and deployment. One might want the production
+    # deployment of an app to be broken across multiple servers or processes
+    # for instance. Additionally, by combining nodelets with +routes_for+
+    # managing routes becomes a little easier.
+    #
+    # Nodelets can be used thusly:
+    #    routes_for :heartbeat do
+    #      route :ticker, :zmq_publish, 'tcp://127.0.0.1', :bind
+    #    end
+    #
+    #    nodelet :heartbeat do
+    #      zm_reactor.periodical_timer(500) do
+    #      ticker.send_message(:name => 'tick')
+    #    end
+    def nodelet(name,&block)
+      nlet_obj = Nodelet.new(name,routing)
+      block.call(nlet_obj)
+    end
+    
+    # Creates a ZMQ::SUB type socket. Can only receive messages via +on_recv+.
+    # zmq_subscribe sockets have a +topic_filter+ option, which restricts which
+    # messages they can receive. It takes a regexp as an option.
     def zmq_subscribe(address,socket_ctype,opts={},&block)
-      zmq_handler(DripDrop::ZMQSubHandler,:sub_socket,address,socket_ctype,opts={})
+      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={})
-      zmq_handler(DripDrop::ZMQPubHandler,:pub_socket,address,socket_ctype,opts={})
+      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)
-      zmq_handler(DripDrop::ZMQPullHandler,:pull_socket,address,socket_ctype,opts={})
+      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={})
-      zmq_handler(DripDrop::ZMQPushHandler,:push_socket,address,socket_ctype,opts={})
+      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
@@ -85,29 +156,36 @@ class DripDrop
     # to the original source of the message.
     #
     # Receiving with XREP sockets in DripDrop is different than other types of sockets, on_recv
-    # passes 3 arguments to its callback, +identities+, +seq+, and +message+. Identities is the 
-    # socket identity, seq is the sequence number of the message (all messages received at the socket
-    # get a monotonically incrementing +seq+, and +message+ is the message itself.
-    # 
-    # 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+.
+    # passes 2 arguments to its callback, +message+, and +response+. A minimal example is shown below:
+    #
+    #    
+    #    zmq_xrep(z_addr, :bind).on_recv do |message,response|
+    #      response.send_message(message)
+    #    end
+    #
     def zmq_xrep(address,socket_ctype,opts={})
-      zmq_handler(DripDrop::ZMQXRepHandler,:xrep_socket,address,socket_ctype,opts={})
+      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={})
-      zmq_handler(DripDrop::ZMQXReqHandler,:xreq_socket,address,socket_ctype,opts={})
+      zmq_handler(DripDrop::ZMQXReqHandler,:xreq_socket,address,socket_ctype,opts)
     end
 
     # 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)}
+    #    websocket(addr).on_open {|ws|
+    #      ws.send_message(:name => 'ws_open_ack')
+    #    }.on_recv {|msg,ws|
+    #      ws.send(msg)
+    #    }.on_close {|ws|
+    #    }.on_error {|ws|
+    #    }
     #
-    # All other events only receive the +websocket+ object, which corresponds
-    # not to the +DripDrop::WebSocketHandler+ object, but to an em-websocket object.
+    # The +ws+ object that's passed into the handlers is not
+    # the +DripDrop::WebSocketHandler+ object, but an em-websocket object.
     def websocket(address,opts={})
       uri     = URI.parse(address)
       h_opts  = handler_opts_given(opts)
@@ -116,8 +194,8 @@ class DripDrop
     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)}
+    # Can have an +on_recv+ handler that gets passed +msg+ and +response+ args.
+    #    http_server(addr) {|msg,response| response.send_message(msg)}
     def http_server(address,opts={},&block)
       uri     = URI.parse(address)
       h_opts  = handler_opts_given(opts)

data/spec/gimite-websocket.rb

@@ -0,0 +1,442 @@
+# Copyright: Hiroshi Ichikawa <http://gimite.net/en/>
+# Lincense: New BSD Lincense
+# Reference: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol
+
+require "socket"
+require "uri"
+require "digest/md5"
+require "openssl"
+
+
+class WebSocket
+
+    class << self
+
+        attr_accessor(:debug)
+
+    end
+
+    class Error < RuntimeError
+
+    end
+
+    def initialize(arg, params = {})
+      if params[:server] # server
+
+        @server = params[:server]
+        @socket = arg
+        line = gets().chomp()
+        if !(line =~ /\AGET (\S+) HTTP\/1.1\z/n)
+          raise(WebSocket::Error, "invalid request: #{line}")
+        end
+        @path = $1
+        read_header()
+        if @header["sec-websocket-key1"] && @header["sec-websocket-key2"]
+          @key3 = read(8)
+        else
+          # Old Draft 75 protocol
+          @key3 = nil
+        end
+        if !@server.accepted_origin?(self.origin)
+          raise(WebSocket::Error,
+            ("Unaccepted origin: %s (server.accepted_domains = %p)\n\n" +
+              "To accept this origin, write e.g. \n" +
+              "  WebSocketServer.new(..., :accepted_domains => [%p]), or\n" +
+              "  WebSocketServer.new(..., :accepted_domains => [\"*\"])\n") %
+            [self.origin, @server.accepted_domains, @server.origin_to_domain(self.origin)])
+        end
+        @handshaked = false
+
+      else # client
+
+        uri = arg.is_a?(String) ? URI.parse(arg) : arg
+
+        if uri.scheme == "ws"
+          default_port = 80
+        elsif uri.scheme = "wss"
+          default_port = 443
+        else
+          raise(WebSocket::Error, "unsupported scheme: #{uri.scheme}")
+        end
+
+        @path = (uri.path.empty? ? "/" : uri.path) + (uri.query ? "?" + uri.query : "")
+        host = uri.host + (uri.port == default_port ? "" : ":#{uri.port}")
+        origin = params[:origin] || "http://#{uri.host}"
+        key1 = generate_key()
+        key2 = generate_key()
+        key3 = generate_key3()
+
+        socket = TCPSocket.new(uri.host, uri.port || default_port)
+
+        if uri.scheme == "ws"
+          @socket = socket
+        else
+          @socket = ssl_handshake(socket)
+        end
+
+        write(
+          "GET #{@path} HTTP/1.1\r\n" +
+          "Upgrade: WebSocket\r\n" +
+          "Connection: Upgrade\r\n" +
+          "Host: #{host}\r\n" +
+          "Origin: #{origin}\r\n" +
+          "Sec-WebSocket-Key1: #{key1}\r\n" +
+          "Sec-WebSocket-Key2: #{key2}\r\n" +
+          "\r\n" +
+          "#{key3}")
+        flush()
+
+        line = gets().chomp()
+        raise(WebSocket::Error, "bad response: #{line}") if !(line =~ /\AHTTP\/1.1 101 /n)
+        read_header()
+        if (@header["sec-websocket-origin"] || "").downcase() != origin.downcase()
+          raise(WebSocket::Error,
+            "origin doesn't match: '#{@header["sec-websocket-origin"]}' != '#{origin}'")
+        end
+        reply_digest = read(16)
+        expected_digest = security_digest(key1, key2, key3)
+        if reply_digest != expected_digest
+          raise(WebSocket::Error,
+            "security digest doesn't match: %p != %p" % [reply_digest, expected_digest])
+        end
+        @handshaked = true
+
+      end
+      @received = []
+      @buffer = ""
+      @closing_started = false
+    end
+
+    attr_reader(:server, :header, :path)
+
+    def handshake(status = nil, header = {})
+      if @handshaked
+        raise(WebSocket::Error, "handshake has already been done")
+      end
+      status ||= "101 Web Socket Protocol Handshake"
+      sec_prefix = @key3 ? "Sec-" : ""
+      def_header = {
+        "#{sec_prefix}WebSocket-Origin" => self.origin,
+        "#{sec_prefix}WebSocket-Location" => self.location,
+      }
+      header = def_header.merge(header)
+      header_str = header.map(){ |k, v| "#{k}: #{v}\r\n" }.join("")
+      if @key3
+        digest = security_digest(
+          @header["Sec-WebSocket-Key1"], @header["Sec-WebSocket-Key2"], @key3)
+      else
+        digest = ""
+      end
+      # Note that Upgrade and Connection must appear in this order.
+      write(
+        "HTTP/1.1 #{status}\r\n" +
+        "Upgrade: WebSocket\r\n" +
+        "Connection: Upgrade\r\n" +
+        "#{header_str}\r\n#{digest}")
+      flush()
+      @handshaked = true
+    end
+
+    def send(data)
+      if !@handshaked
+        raise(WebSocket::Error, "call WebSocket\#handshake first")
+      end
+      data = force_encoding(data.dup(), "ASCII-8BIT")
+      write("\x00#{data}\xff")
+      flush()
+    end
+
+    def receive()
+      if !@handshaked
+        raise(WebSocket::Error, "call WebSocket\#handshake first")
+      end
+      packet = gets("\xff")
+      return nil if !packet
+      if packet =~ /\A\x00(.*)\xff\z/nm
+        return force_encoding($1, "UTF-8")
+      elsif packet == "\xff" && read(1) == "\x00" # closing
+        if @server
+          @socket.close()
+        else
+          close()
+        end
+        return nil
+      else
+        raise(WebSocket::Error, "input must be either '\\x00...\\xff' or '\\xff\\x00'")
+      end
+    end
+
+    def tcp_socket
+      return @socket
+    end
+
+    def host
+      return @header["host"]
+    end
+
+    def origin
+      return @header["origin"]
+    end
+
+    def location
+      return "ws://#{self.host}#{@path}"
+    end
+    
+    # Does closing handshake.
+    def close()
+      return if @closing_started
+      write("\xff\x00")
+      @socket.close() if !@server
+      @closing_started = true
+    end
+    
+    def close_socket()
+      @socket.close()
+    end
+
+  private
+
+    NOISE_CHARS = ("\x21".."\x2f").to_a() + ("\x3a".."\x7e").to_a()
+
+    def read_header()
+      @header = {}
+      while line = gets()
+        line = line.chomp()
+        break if line.empty?
+        if !(line =~ /\A(\S+): (.*)\z/n)
+          raise(WebSocket::Error, "invalid request: #{line}")
+        end
+        @header[$1] = $2
+        @header[$1.downcase()] = $2
+      end
+      if !(@header["upgrade"] =~ /\AWebSocket\z/i)
+        raise(WebSocket::Error, "invalid Upgrade: " + @header["upgrade"])
+      end
+      if !(@header["connection"] =~ /\AUpgrade\z/i)
+        raise(WebSocket::Error, "invalid Connection: " + @header["connection"])
+      end
+    end
+
+    def gets(rs = $/)
+      line = @socket.gets(rs)
+      $stderr.printf("recv> %p\n", line) if WebSocket.debug
+      return line
+    end
+
+    def read(num_bytes)
+      str = @socket.read(num_bytes)
+      $stderr.printf("recv> %p\n", str) if WebSocket.debug
+      return str
+    end
+
+    def write(data)
+      if WebSocket.debug
+        data.scan(/\G(.*?(\n|\z))/n) do
+          $stderr.printf("send> %p\n", $&) if !$&.empty?
+        end
+      end
+      @socket.write(data)
+    end
+
+    def flush()
+      @socket.flush()
+    end
+
+    def security_digest(key1, key2, key3)
+      bytes1 = websocket_key_to_bytes(key1)
+      bytes2 = websocket_key_to_bytes(key2)
+      return Digest::MD5.digest(bytes1 + bytes2 + key3)
+    end
+
+    def generate_key()
+      spaces = 1 + rand(12)
+      max = 0xffffffff / spaces
+      number = rand(max + 1)
+      key = (number * spaces).to_s()
+      (1 + rand(12)).times() do
+        char = NOISE_CHARS[rand(NOISE_CHARS.size)]
+        pos = rand(key.size + 1)
+        key[pos...pos] = char
+      end
+      spaces.times() do
+        pos = 1 + rand(key.size - 1)
+        key[pos...pos] = " "
+      end
+      return key
+    end
+
+    def generate_key3()
+      return [rand(0x100000000)].pack("N") + [rand(0x100000000)].pack("N")
+    end
+
+    def websocket_key_to_bytes(key)
+      num = key.gsub(/[^\d]/n, "").to_i() / key.scan(/ /).size
+      return [num].pack("N")
+    end
+
+    def force_encoding(str, encoding)
+      if str.respond_to?(:force_encoding)
+        return str.force_encoding(encoding)
+      else
+        return str
+      end
+    end
+
+    def ssl_handshake(socket)
+      ssl_context = OpenSSL::SSL::SSLContext.new()
+      ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
+      ssl_socket.sync_close = true
+      ssl_socket.connect()
+      return ssl_socket
+    end
+
+end
+
+
+class WebSocketServer
+
+    def initialize(params_or_uri, params = nil)
+      if params
+        uri = params_or_uri.is_a?(String) ? URI.parse(params_or_uri) : params_or_uri
+        params[:port] ||= uri.port
+        params[:accepted_domains] ||= [uri.host]
+      else
+        params = params_or_uri
+      end
+      @port = params[:port] || 80
+      @accepted_domains = params[:accepted_domains]
+      if !@accepted_domains
+        raise(ArgumentError, "params[:accepted_domains] is required")
+      end
+      if params[:host]
+        @tcp_server = TCPServer.open(params[:host], @port)
+      else
+        @tcp_server = TCPServer.open(@port)
+      end
+    end
+
+    attr_reader(:tcp_server, :port, :accepted_domains)
+
+    def run(&block)
+      while true
+        Thread.start(accept()) do |s|
+          begin
+            ws = create_web_socket(s)
+            yield(ws) if ws
+          rescue => ex
+            print_backtrace(ex)
+          ensure
+            begin
+              ws.close_socket() if ws
+            rescue
+            end
+          end
+        end
+      end
+    end
+
+    def accept()
+      return @tcp_server.accept()
+    end
+
+    def accepted_origin?(origin)
+      domain = origin_to_domain(origin)
+      return @accepted_domains.any?(){ |d| File.fnmatch(d, domain) }
+    end
+
+    def origin_to_domain(origin)
+      if origin == "null" || origin == "file://"  # local file
+        return "null"
+      else
+        return URI.parse(origin).host
+      end
+    end
+
+    def create_web_socket(socket)
+      ch = socket.getc()
+      if ch == ?<
+        # This is Flash socket policy file request, not an actual Web Socket connection.
+        send_flash_socket_policy_file(socket)
+        return nil
+      else
+        socket.ungetc(ch)
+        return WebSocket.new(socket, :server => self)
+      end
+    end
+
+  private
+
+    def print_backtrace(ex)
+      $stderr.printf("%s: %s (%p)\n", ex.backtrace[0], ex.message, ex.class)
+      for s in ex.backtrace[1..-1]
+        $stderr.printf("        %s\n", s)
+      end
+    end
+
+    # Handles Flash socket policy file request sent when web-socket-js is used:
+    # http://github.com/gimite/web-socket-js/tree/master
+    def send_flash_socket_policy_file(socket)
+      socket.puts('<?xml version="1.0"?>')
+      socket.puts('<!DOCTYPE cross-domain-policy SYSTEM ' +
+        '"http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd">')
+      socket.puts('<cross-domain-policy>')
+      for domain in @accepted_domains
+        next if domain == "file://"
+        socket.puts("<allow-access-from domain=\"#{domain}\" to-ports=\"#{@port}\"/>")
+      end
+      socket.puts('</cross-domain-policy>')
+      socket.close()
+    end
+
+end
+
+
+if __FILE__ == $0
+  Thread.abort_on_exception = true
+
+  if ARGV[0] == "server" && ARGV.size == 3
+
+    server = WebSocketServer.new(
+      :accepted_domains => [ARGV[1]],
+      :port => ARGV[2].to_i())
+    puts("Server is running at port %d" % server.port)
+    server.run() do |ws|
+      puts("Connection accepted")
+      puts("Path: #{ws.path}, Origin: #{ws.origin}")
+      if ws.path == "/"
+        ws.handshake()
+        while data = ws.receive()
+          printf("Received: %p\n", data)
+          ws.send(data)
+          printf("Sent: %p\n", data)
+        end
+      else
+        ws.handshake("404 Not Found")
+      end
+      puts("Connection closed")
+    end
+
+  elsif ARGV[0] == "client" && ARGV.size == 2
+
+    client = WebSocket.new(ARGV[1])
+    puts("Connected")
+    Thread.new() do
+      while data = client.receive()
+        printf("Received: %p\n", data)
+      end
+    end
+    $stdin.each_line() do |line|
+      data = line.chomp()
+      client.send(data)
+      printf("Sent: %p\n", data)
+    end
+
+  else
+
+    $stderr.puts("Usage:")
+    $stderr.puts("  ruby web_socket.rb server ACCEPTED_DOMAIN PORT")
+    $stderr.puts("  ruby web_socket.rb client ws://HOST:PORT/")
+    exit(1)
+
+  end
+end

data/spec/message_spec.rb

@@ -81,6 +81,11 @@ describe DripDrop::Message do
       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 set the msg_class using a symbol, not a string when using JSON" do
+        msg = DripDrop::Message.decode_json(DripDrop::Message.new('test').json_encoded)
+        msg.head['msg_class'].should be_nil
+        msg.head[:msg_class].should  == 'DripDrop::Message'
+      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

data/spec/node/http_spec.rb

@@ -6,7 +6,7 @@ describe "http" do
     client = nil
     server = nil
     
-    @ddn = DripDrop::Node.new do
+    @node = run_reactor(1) do
       addr = rand_addr
       
       zmq_subscribe(rand_addr, :bind) do |message|
@@ -29,11 +29,7 @@ describe "http" do
       end
     end
     
-    @ddn.start
-    sleep 0.1
-    @ddn.stop
-    
-    {:responses => responses, :handlers => {:server => [server] }}
+   {:responses => responses, :handlers => {:server => [server] }}
   end
   describe "basic sending and receiving" do
     before(:all) do
@@ -45,8 +41,6 @@ describe "http" do
                               :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