em-websocket-server 0.13 → 0.15

data/README.markdown

@@ -9,48 +9,108 @@
 ##Dependencies
 - eventmachine http://github.com/eventmachine/eventmachine
 
-##Docs
+##Explain
+To leverage em-websocket-server, you simply need to extend EM::WebSocket::Server
+and register the server with eventmachine.  When a client connects, EventMachine will
+create a new instance of your class, and allow your application specific code to be
+executed in the context of said instance.
+
+##Methods to override:
+  
+    #called on exception
+    on_error error
+  
+    #called when a client sends a message
+    on_receive msg
+  
+    #called when a client connects
+    on_connect
+  
+    #called when a client is disconnected
+    on_disconnect
+  
+##Other useful methods
+
+    #send a message
+    send_message msg
+  
+    #close the connection
+    unbind
+
+##Macros
+macros are used to configure your application server.
+
+    class MySweetHandler < EM::WebSocket::Server
+    
+      #secure incoming connections
+      secure
+  
+      #secure incoming connections, with given key/cert
+      secure {
+        :private_key_file => "/path/to/private/key",
+        :cert_chain_file => "/path/to/ssl/certificate"
+      }
+  
+      #provide a flash socket policy
+      flash_policy "/usr/local/policies/domain.com/crossdomain.xml"    
+    
+    end
 
-Not yet... coming soon
 
 ##Quick Example
 
-	require 'rubygems'
-	require 'em-websocket-server'
-	require 'json'
+    require "rubygems"
+    require "em-websocket-server"
 
-	#create a channel for pub sub
-	$chatroom = EM::Channel.new
-	
-	class ChatServer < WebSocket::Server
-	
-		#subscribe to the channel on client connect
-		def on_connect
-			@sid = $chatroom.subscribe do |msg|
-				send_message msg
-			end
-		end
-		
-		#unsubscribe on client disconnect
-		def on_disconnect
-			$chatroom.unsubscribe(@sid)
-		end
-		
-		#publish the message to the channel on
-		#client message received
-		def on_receive msg
-			$chatroom.push msg
-		end
-	
-	end
-	
-	#start the event machine on port 8000 and have
-	#it instantiate ChatServer objects for each
-	#client connection
-	EM.run do
-		EM.start_server "0.0.0.0", 8000, ChatServer
-	end
+    class EchoServer < EM::WebSocket::Server
+
+      def on_connect
+        EM::WebSocket::Log.debug "Connected"
+      end
+
+      def on_receive msg
+        send_message msg
+      end
+
+    end
+
+    EM.run do
+    	EM.start_server "0.0.0.0", 8000, EchoServer
+    end
+
+##SSL
+
+    class SecureEchoServer < EM::WebSocket::Server
+
+      #provide cert and key
+      secure {
+        :private_key_file => "/path/to/private/key",
+        :cert_chain_file => "/path/to/ssl/certificate"
+      }
+    
+      ...
+  
+    end
+
+    EM.run do
+    	EM.start_server "0.0.0.0", 443, SecureEchoServer
+    end
+
+##Custom Flash Policy
+
+    class FlashyEchoServer < EM::WebSocket::Server
+      flash_policy "/usr/local/policies/domain.com/crossdomain.xml"
+    end
+
+    EM.run do
+    	EM.start_server "0.0.0.0", 8000, FlashyEchoServer
+    end
+
+##Todo
+  * Testing
+  * Better inline documentation
+  * Web client library with flash based fallback
 	
 ##Thanks
-sidonath
-TheBreeze
+  * sidonath
+  * TheBreeze

data/em-websocket-server.gemspec

@@ -1,32 +1,22 @@
 spec = Gem::Specification.new do |s|
-	s.name = 'em-websocket-server'
-	s.version = '0.13'
-	s.date = '2009-12-14'
-	s.summary = 'An evented ruby websocket server built on top of EventMachine'
-	s.email = "dan.simpson@gmail.com"
-	s.homepage = "http://github.com/dansimpson/em-websocket-server"
-	s.description = "An evented ruby websocket server built on top of EventMachine"
-	s.has_rdoc = false
-	
+  s.name = 'em-websocket-server'
+  s.version = '0.15'
+  s.date = '2010-08-30'
+  s.summary = 'An evented ruby websocket server built on top of EventMachine'
+  s.email = "dan.simpson@gmail.com"
+  s.homepage = "http://github.com/dansimpson/em-websocket-server"
+  s.description = "An evented ruby websocket server built on top of EventMachine"
 
-	s.authors = ["Dan Simpson"]
-	s.add_dependency('eventmachine', '>= 0.12.4')
+  s.authors = ["Dan Simpson"]
+  s.add_dependency('eventmachine', '>= 0.12.10')
 
 
-	s.files = [
-		"README.markdown",
-		"em-websocket-server.gemspec",
-		"examples/chat.rb",
-		"examples/chat.html",
-		"examples/timesync.html",
-		"examples/timesync.rb",
-		"examples/tictactoe/tictactoe.html",
-		"examples/tictactoe/tictactoe.js",
-		"examples/tictactoe/tictactoe.rb",
-		"lib/web_socket.rb",
-		"lib/web_socket/client.rb",
-		"lib/web_socket/server.rb",
-		"lib/web_socket/frame.rb",
-		"lib/web_socket/util.rb"
-	]
+  s.files = [
+    "README.markdown",
+    "em-websocket-server.gemspec",
+    "lib/em-websocket-server.rb",
+    "lib/em-websocket-server/server.rb",
+    "lib/em-websocket-server/request.rb",
+    "lib/em-websocket-server/protocol/version76.rb"
+  ]
 end

data/lib/em-websocket-server.rb

@@ -0,0 +1,15 @@
+require "rubygems"
+require "eventmachine"
+require "logger"
+require "digest"
+
+module EM
+  module WebSocket
+    Version = 0.50
+    Log = Logger.new STDOUT  
+  end
+end
+
+require "em-websocket-server/server.rb"
+require "em-websocket-server/request.rb"
+require "em-websocket-server/protocol/version76.rb"

data/lib/em-websocket-server/protocol/version76.rb

@@ -0,0 +1,49 @@
+module EM
+  module WebSocket
+    module Protocol
+      module Version76
+      
+        # generate protocol 76 compatible response headers
+        def response
+          response = "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
+          response << "Upgrade: WebSocket\r\n"
+          response << "Connection: Upgrade\r\n"
+          response << "Sec-WebSocket-Origin: #{origin}\r\n"
+          response << "Sec-WebSocket-Location: #{scheme}://#{host}#{path}\r\n"
+  
+          if protocol
+            response << "Sec-WebSocket-Protocol: #{protocol}\r\n"
+          end
+
+          response << "\r\n"
+          response << Digest::MD5.digest(keyset)
+
+          response
+        end
+
+        protected
+        
+        # generate a keyset from the 3 secure keys
+        def keyset
+          [:sec_websocket_key1,:sec_websocket_key2].collect { |k| 
+            partify(@headers[k])
+          }.push(@headers[:sec_websocket_key3]).join
+        end
+
+        # decode a websocket key and create a token for
+        # use in the response
+        # +key+ the key value to decode
+        def partify key
+          nums   = key.scan(/[0-9]/).join.to_i
+          spaces = key.scan(/ /).size
+  
+          raise "Key Error: #{key} has no spaces" if spaces == 0
+          raise "Key Error: #{key} nums #{nums} is not an integral multiple of #{spaces}" if (nums % spaces) != 0
+
+          [nums / spaces].pack("N*")
+        end
+              
+      end
+  	end
+  end
+end

data/lib/em-websocket-server/request.rb

@@ -0,0 +1,109 @@
+module EM
+  module WebSocket
+
+    class Request
+
+      Path    = /^GET (\/[^\s]*) HTTP\/[\d|\.]+$/.freeze
+      Header  = /^([^:]+):\s*(.+)$/.freeze
+
+      # create a new request object
+      # +data+ the string value of the HTTP headers for parsing
+      def initialize data=nil
+        parse(data) if data
+      end
+    
+      # parse the HTTP headers from an incoming
+      # request into actionable information
+      # +data+ The header data as a string
+      def parse data
+
+        lines = data.split("\r\n")
+      
+        if Path =~ lines.shift
+          @headers = {
+            :path => $1
+          }
+        else
+          raise "Invalid request: #{data}"
+        end
+      
+        #breaks when we get to the empty line
+        while((line = lines.shift) && !line.empty?)
+          if Header =~ line
+            self[$1] = $2
+          else
+            raise "Invalid header: #{line}"
+          end
+        end
+
+        if is_secure?
+          if lines.empty?
+            raise "Key 3 is required for protocol version 76"
+          end
+          @headers[:sec_websocket_key3] = lines.last
+          extend Protocol::Version76
+        end
+
+      end
+             
+      # generate a response for this request
+      # may be overridden by other protocol modules
+      def response
+        response = "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
+        response << "Upgrade: WebSocket\r\n"
+        response << "Connection: Upgrade\r\n"
+        response << "WebSocket-Origin: #{origin}\r\n"
+        response << "WebSocket-Location: #{scheme}://#{host}#{path}\r\n"
+        response << "\r\n"
+        response
+      end  
+    
+    
+      # returns a header value
+      # +key+ the symbol value of the header field
+      def [](key)
+        @headers[key.to_sym]
+      end
+    
+      # sets the header value
+      # +key+ the header field name
+      # +val+ the value of said field
+      def []=(key,val)
+        @headers[key.downcase.gsub(/-/,"_").to_sym] = val
+      end
+    
+      # is the websocket connection supplying secure
+      # web socket fields in the header
+      def is_secure?
+        @headers.has_key? :sec_websocket_key1
+      end
+    
+      # the websocket protocol that is used
+      def protocol
+        @headers[:sec_websocket_protocol]
+      end
+    
+      # the origin domain of the connected client
+      def origin
+        @headers[:origin]
+      end
+  
+      # the host which the client connected to
+      def host
+        @headers[:host]
+      end
+    
+      # the request path portion of the request URI
+      def path
+        @headers[:path]
+      end
+      
+      # the websocket scheme, either ws, or wss for
+      # a TLS secured connection
+      def scheme
+        "ws"
+      end
+    
+    end
+  end
+end

data/lib/em-websocket-server/server.rb

@@ -0,0 +1,157 @@
+module EM
+  module WebSocket
+    class Server < EM::Connection
+  
+      Pack  = /\000([^\377]*)\377/.freeze
+      Frame = /^[\x00]|[\xff]$/.freeze
+  
+      attr_accessor :connected, :request
+  
+      def initialize *args
+        super
+        @request   = nil
+        @buffer    = ""
+        @connected = false
+      end
+
+      # do not override!
+      def post_init
+        start_tls(self.class.tls_opts) if self.class.secure?
+      end
+
+      # close the connection
+      def unbind
+        on_disconnect
+      end
+
+      # send a message to the websocket client
+      # +msg+ the message the client should receive
+      def send_message msg
+        send_data "\x00#{msg}\xff"
+      end
+
+      protected
+
+      # override
+      def on_receive msg
+      end
+  
+      # override this method
+      def on_connect
+      end
+  
+      # override this method
+      def on_disconnect
+      end
+      
+      # override this method
+      def on_error ex
+        Log.fatal ex
+      end
+  
+      private
+  
+      # called when the web socket connection
+      # is fully ready
+      def on_ready
+        @connected = true
+        on_connect
+      end
+  
+      # when the connection receives data from the client
+      # we either handshake or handle the message at 
+      # the app layer
+      def receive_data data
+        
+        if @connected
+          #parse each frame and dispatch
+          while msg = data.slice!(Pack)
+            on_receive msg.gsub(Frame, "")
+          end
+        else        
+          if data =~ /</
+            Log.debug "Sending flash policy #{self.class.policy_content}"
+            send_data self.class.policy
+            close_connection_after_writing
+          else
+            handshake data
+          end
+        end
+      end
+  
+      # parse the request, validate the origin and path
+      # and respond with appropiate headers for a 
+      # healthy relationship with the client
+      def handshake data
+        begin
+          @request = Request.new(data)
+          send_data @request.response
+          on_ready
+        rescue Exception => ex
+          on_error ex
+          close_connection
+        end
+      end
+    
+      class << self
+
+        # set the flash policy this is sent to flash clients
+        # +policy+ either a string containing XML or a
+        # path to a XML policy file
+        def flash_policy policy
+          if policy =~ /\.xml$/
+              @policy = File.read(policy)
+          else
+              @policy = policy
+          end
+        end
+        
+        # get the flash policy content
+        def policy_content
+          @policy || default_policy
+        end
+        
+        # secure any instance of this connection
+        # with TLS
+        # +opts+ the EM specific options hash for starting
+        # tls on the connection.  Important options:
+        # :private_key_file
+        # :cert_chain_file
+        def secure opts={}
+          @tls_opts = opts
+        end
+      
+        # is the connection secured with TLS?
+        def secure?
+          @tls_opts != nil
+        end
+      
+        # the TLS options used for the secured connection
+        def tls_opts
+          @tls_opts
+        end
+      
+        # add a domain to the list of allowable domains
+        # +domain+ the domain that is allowed eg: cnet.com
+        def accept_domain domain
+          @accepted = [] unless @accepted
+          @accepted << domain
+        end
+      
+        # the set of domains that the server should
+        # accept the connection from.  If the list is
+        # empty, the server will accept all connections
+        def accept_domains
+          @accepted || []
+        end
+        
+        # the default flash policy content, which accepts
+        # from all domains to all ports (maybe not a good thing)
+        def default_policy
+          "<?xml version=\"1.0\"?><cross-domain-policy><allow-access-from domain=\"*\" to-ports=\"*\"/></cross-domain-policy>"
+        end
+            
+      end
+    end
+  end
+end