RubyGems - em-websocket-server - Versions diffs - 0.13 → 0.15 - Mend

em-websocket-server 0.13 → 0.15

Files changed (19) hide show

data/README.markdown +98 -38
data/em-websocket-server.gemspec +17 -27
data/lib/em-websocket-server.rb +15 -0
data/lib/em-websocket-server/protocol/version76.rb +49 -0
data/lib/em-websocket-server/request.rb +109 -0
data/lib/em-websocket-server/server.rb +157 -0
metadata +9 -21
data/examples/chat.html +0 -37
data/examples/chat.rb +0 -70
data/examples/tictactoe/tictactoe.html +0 -51
data/examples/tictactoe/tictactoe.js +0 -130
data/examples/tictactoe/tictactoe.rb +0 -213
data/examples/timesync.html +0 -29
data/examples/timesync.rb +0 -37
data/lib/web_socket.rb +0 -13
data/lib/web_socket/client.rb +0 -71
data/lib/web_socket/frame.rb +0 -20
data/lib/web_socket/server.rb +0 -202
data/lib/web_socket/util.rb +0 -55

@@ -1,29 +0,0 @@
-<!doctype html>
-<html>
-<head>
-	<title>em-websocket-server test</title>
-</head>
-<body>
-<h1>em-websocket-server timesync demo</h1>
-<h2 id="time">opening socket</h2>
-<script>
-	var webSocket = new WebSocket('ws://localhost:8000/time');
-	webSocket.onopen = function(event){
-		document.getElementById('time').innerHTML = 'waiting for socket';
-	};
-	webSocket.onmessage = function(event){
-		var object = JSON.parse(event.data);
-		document.getElementById('time').innerHTML = object.time;
-	};
-	webSocket.onclose = function(event){
-		document.getElementById('time').innerHTML = 'socket closed';
-	};
-</script>
-</body>
-</html>

data/examples/timesync.rb DELETED

@@ -1,37 +0,0 @@
-$:.unshift File.dirname(__FILE__) + '/../lib'
-require 'rubygems'
-require 'web_socket'
-require 'json'
-class TimeServer < WebSocket::Server
-	def on_connect
-	  puts "Connection Accepted"
-		@timer = EM.add_periodic_timer(5, EM.Callback(self, :sync_time))
-	end
-	def on_disconnect
-	  puts "Connection released"
-		EM.cancel_timer @timer
-	end
-	def on_receive msg
-	end
-	def sync_time
-	  puts "Hi"
-		send_message({ :time => Time.now }.to_json)
-	end
-end
-EM.epoll  = true if EM.epoll?
-EM.kqueue = true if EM.kqueue?
-EM.set_descriptor_table_size(10240)
-EM.run do
-	EM.start_server "0.0.0.0", 8000, TimeServer
-end

data/lib/web_socket.rb DELETED

@@ -1,13 +0,0 @@
-require 'rubygems'
-require 'eventmachine'
-require 'digest'
-require 'pp'
-module WebSocket
-  VERSION = 0.13
-end
-require 'web_socket/util.rb'
-require 'web_socket/frame.rb'
-require 'web_socket/server.rb'
-require 'web_socket/client.rb'

data/lib/web_socket/client.rb DELETED

@@ -1,71 +0,0 @@
-module WebSocket
-	class Client < EM::Connection
-		def path
-			"/chat"
-		end
-		def host
-			"localhost:8000"
-		end
-		def origin
-			"localhost"
-		end
-		# em override
-		def post_init
-			@connected = false
-		end
-		def connection_completed
-			send_headers
-		end
-		# em override
-		def unbind
-			on_disconnect
-		end
-		def on_disconnect
-		end
-		def send_message msg
-			send_data Frame.encode(msg)
-		end
-		private
-		def receive_data data
-			unless @connected
-				handshake data
-			else
-        while msg = data.slice!(/\000([^\377]*)\377/)
-          on_receive Frame.decode(msg)
-        end
-			end
-		end
-		def handshake data
-			#convert the headers to a hash
-			@headers   = Util.parse_headers(data)
-			@connected = true
-			on_connect
-		end
-		def send_headers
-			result = "GET #{path} HTTP/1.1\r\n"
-			result << "Upgrade: WebSocket\r\n"
-			result << "Connection: Upgrade\r\n"
-			result << "Host: #{host}\r\n"
-			result << "Origin: #{origin}\r\n\r\n"
-			send_data result
-		end
-	end
-end

data/lib/web_socket/frame.rb DELETED

@@ -1,20 +0,0 @@
-module WebSocket
-	class Frame
-		# Frames need to start with 0x00-0x7f byte and end with
-		# an 0xFF byte.  Per spec, we can also set the first
-		# byte to a value betweent 0x80 and 0xFF, followed by
-		# a leading length indicator.  No support yet.
-		def self.encode data
-			"\x00#{data}\xff"
-		end
-		# Strip leading and trailing bytes
-		def self.decode data
-			data.gsub(/^(\x00)|(\xff)$/, "")
-		end
-	end
-end

data/lib/web_socket/server.rb DELETED

@@ -1,202 +0,0 @@
-module WebSocket
-  class Server < EM::Connection
-    @@logger      = nil
-    @@num_connections  = 0
-    @@callbacks     = {}
-    @@accepted_origins  = []
-    attr_accessor  :connected,
-            :headers
-    def initialize *args
-      super
-      @connected = false
-      @protocol_version = 75
-    end
-    def valid_origin?
-      @@accepted_origins.empty? || @@accepted_origins.include?(origin)
-    end
-    #not doing anything with this yet
-    def valid_path?
-      true
-    end
-    def valid_upgrade?
-      @headers[:upgrade] =~ /websocket/i
-    end
-    def origin
-      @headers[:origin]
-    end
-    def host
-      @headers[:host]
-    end
-    def path
-      @headers[:path]
-    end
-    def cookies
-      @headers[:cookie]
-    end
-    def protocol
-      @headers[:protocol]
-    end
-    def self.path name, &block
-      @@callbacks[name] = block
-    end
-    #tcp connection established
-    def post_init
-      @@num_connections += 1
-    end
-    #must be public for em
-    def unbind
-      @@num_connections -= 1
-      on_disconnect
-    end
-    def send_message msg
-      send_data Frame.encode(msg)
-    end
-    protected
-    #override this method
-    def on_receive msg
-      log msg
-    end
-    #override this method
-    def on_connect
-      log "connected"
-    end
-    #override this method
-    def on_disconnect
-      log "disconnected"
-    end
-    def log msg
-      if @@logger
-        @@logger.info msg
-      else
-        puts msg
-      end
-    end
-    private
-    # when the connection receives data from the client
-    # we either handshake or handle the message at
-    # the app layer
-    def receive_data data
-      unless @connected
-        handshake data
-      else
-        while msg = data.slice!(/\000([^\377]*)\377/)
-          on_receive Frame.decode(msg)
-        end
-      end
-    end
-    # parse the headers, validate the origin and path
-    # and respond with appropiate headers for a
-    # healthy relationship with the client
-    def handshake data
-      #convert the headers to a hash
-      @headers, challenge = Util.parse_headers(data)
-      if challenge
-        @protocol_version = 76
-        key1 = @headers[:'sec-websocket-key1']
-        key2 = @headers[:'sec-websocket-key2']
-        part1 = number_from_key(key1)
-        part2 = number_from_key(key2)
-        unless part1 && part2
-          close_connection
-          return
-        end
-        buffer = []
-        buffer += big_endian_bytes(part1)
-        buffer += big_endian_bytes(part2)
-        buffer += challenge.bytes.to_a
-        md5 = Digest::MD5.new
-        hash = md5.digest(buffer.pack('c*'))
-      end
-      # close the connection if the connection
-      # originates from an invalid source
-      close_connection unless valid_origin?
-      # close the connection if a callback
-      # is not registered for the path
-      close_connection unless valid_path?
-      # don't respond to non-websocket HTTP requests
-      close_connection unless valid_upgrade?
-      #complete the handshake
-      send_headers(hash)
-      @connected = true
-      on_connect
-    end
-    # send the handshake response headers to
-    # complete the initial com
-    def send_headers(hash)
-      response = "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
-      response << "Upgrade: WebSocket\r\n"
-      response << "Connection: Upgrade\r\n"
-      if @protocol_version > 75
-        response << "Sec-WebSocket-Origin: #{origin}\r\n"
-        response << "Sec-WebSocket-Location: ws://#{host}#{path}\r\n"
-        response << "Sec-WebSocket-protocol: ws://#{host}#{path}\r\n"
-      else
-        response << "WebSocket-Origin: #{origin}\r\n"
-        response << "WebSocket-Location: ws://#{host}#{path}\r\n"
-      end
-      response << "\r\n"
-      response << hash if @protocol_version > 75
-      send_data response
-    end
-    def number_from_key(key)
-      digits = key.scan(/\d+/).join.to_i
-      spaces = key.scan(/\s+/).join.length
-      if spaces > 0
-        return digits / spaces
-      else
-        return nil
-      end
-    end
-    def big_endian_bytes(num)
-      bytes = []
-      4.times do
-        bytes.unshift(num & 0xff)
-        num >>= 8
-      end
-      bytes
-    end
-  end
-end

data/lib/web_socket/util.rb DELETED

@@ -1,55 +0,0 @@
-module WebSocket
-  class Util
-    @@path_regex    = /^GET (\/[^\s]*) HTTP\/1\.1$/
-    @@hs_regex      = /^HTTP\/1\.1 101 Web Socket Protocol Handshake$/
-    @@header_regex  = /^([^:]+):\s*([^$]+)/
-    # Parse http style headers into a ruby hash
-    def self.parse_headers data
-      lines = data.split("\r\n")
-      line  = lines.shift
-      headers = {}
-      case line
-      when @@path_regex
-        headers[:path] = @@path_regex.match(line)[1]
-      when @@hs_regex
-        #do nothing
-      else
-        throw "Unrecognized Header!"
-      end
-      while line = lines.shift
-        if line.chomp.empty?
-          break
-        end
-        kvp = @@header_regex.match(line)
-        headers[kvp[1].strip.downcase.to_sym] = kvp[2].strip
-      end
-      challenge = lines.pop if lines
-      [headers, challenge]
-    end
-    # encode ruby hash into HTTP style headers
-    def self.encode_headers data
-      result = ""
-      data.each_pair do |k,v|
-        result << k.to_s
-        result << ": "
-        result << v.to_s
-        result << "\r\n"
-      end
-      result << "\r\n"
-      result
-    end
-  end
-end