plezi 0.7.7 → 0.8.1

data/lib/plezi/handlers/route.rb

@@ -218,7 +218,7 @@ module Plezi
 		# flash:: an amazing Hash object that sets temporary cookies for one request only - greate for saving data between redirect calls.
 		#
 		def self.make_controller_magic(controller)
-			new_class_name = "Plezi__#{controller.name.gsub /[\:\-]/, '_'}"
+			new_class_name = "Plezi__#{controller.name.gsub /[\:\-\#\<\>\{\}\(\)\s]/, '_'}"
 			return Module.const_get new_class_name if Module.const_defined? new_class_name
 			# controller.include Plezi::ControllerMagic
 			controller.instance_eval { include Plezi::ControllerMagic }
@@ -252,11 +252,11 @@ module Plezi
 					# make sure this is a websocket controller
 					return false unless self.class.public_instance_methods.include?(:on_message)
 					# call the controller's original method, if exists, and check connection.
-					return false if (defined?(super) && !super) 
+					return false if (defined?(super) && !super)
 					# finish if the response was sent
 					return true if response.headers_sent?
 					# complete handshake
-					return false unless WSProtocol.new( request.service, request.service.parameters).http_handshake request, response, self
+					return false unless WSProtocol.new( request.service, request.service.params).http_handshake request, response, self
 					# set up controller as WebSocket handler
 					@response = WSResponse.new request
 					# create the redis connection (in case this in the first instance of this class)

data/lib/plezi/server/{helpers/http.rb → http.rb}

@@ -7,62 +7,6 @@ module Plezi
 	# includes general helper methods for HTTP protocol and related (url encoding etc')
 	module HTTP
 		module_function
-		# decode html form data stream
-		# def decode_form_data encoded
-		# 	scanner = StringScanner.new encoded.gsub('+', '%20')
-		# 	decoded = ''
-		# 	until scanner.eos? do
-		# 		decoded << scanner.scan(/[^%]+/)
-		# 		if scanner.scan(/\%[0-9a-fA-F][0-9a-fA-F]/)
-		# 			decoded << scanner.matched[1,2].to_i(16).chr
-		# 		elsif !scanner.eos?
-		# 			decoded << scanner.scan(/./)
-		# 		end
-		# 	end
-		# 	decoded
-		# end
-		# # encode html form data stream
-		# def encode_form_data exposed
-		# 	scanner = StringScanner.new exposed
-		# 	encoded = ''
-
-		# 	# HTML form encoding
-		# 	until scanner.eos? do
-		# 		encoded << scanner.scan(/[a-zA-Z0-9\*\.\_\-]+/)				
-		# 		encoded << "%#{scanner.matched.ord <= 16 ? "0" : ""} #{ scanner.matched.ord.to_s(16) }" if scanner.scan(/./)
-		# 	end
-
-		# 	# HTTP encoding
-		# 	# until scanner.eos? do
-		# 	# 	encoded << scanner.scan(/[^\:\/\?\#\[\]\@\!\$\&\'\(\)\*\+\,\;\=]+/)
-		# 	# 	encoded << "%#{scanner.matched.ord <= 16 ? "0" : ""} #{ scanner.matched.ord.to_s(16) }" if scanner.scan(/./)
-		# 	# end
-		# 	encoded
-		# end
-		# # decode HTTP URI data stream
-		# def decode_uri encoded
-		# 	scanner = StringScanner.new encoded.gsub('+', '%20') #? is this true here?
-		# 	decoded = ''
-		# 	until scanner.eos? do
-		# 		decoded << scanner.scan(/[^%]+/)
-		# 		if scanner.scan(/\%[0-9a-fA-F][0-9a-fA-F]/)
-		# 			decoded << scanner.matched[1,2].to_i(16).chr
-		# 		elsif !scanner.eos?
-		# 			decoded << scanner.scan(/./)
-		# 		end
-		# 	end
-		# 	decoded
-		# end
-		# # encode HTTP URI data stream
-		# def encode_uri_data exposed
-		# 	scanner = StringScanner.new exposed
-		# 	encoded = ''
-		# 	until scanner.eos? do
-		# 		encoded << scanner.scan(/[^\:\/\?\#\[\]\@\!\$\&\'\(\)\*\+\,\;\=]+/)
-		# 		encoded << "%#{scanner.matched.ord <= 16 ? "0" : ""} #{ scanner.matched.ord.to_s(16) }" if scanner.scan(/.|[\s]/)
-		# 	end
-		# 	encoded
-		# end
 
 		# Based on the WEBRick source code, escapes &, ", > and < in a String object
 		def escape(string)
@@ -170,7 +114,7 @@ module Plezi
 		# Changes String to a Ruby Object, if it's a special string
 		def rubyfy!(string)
 			return false unless string
-			make_utf8! string
+			# make_utf8! string
 			if string == 'true'
 				string = true
 			elsif string == 'false'

data/lib/plezi/server/{protocols/http_protocol.rb → http_protocol.rb}

@@ -4,64 +4,47 @@ module Plezi
 	#
 	#
 	# to do: implemet logging, support body types: multipart (non-ASCII form data / uploaded files), json & xml
-	class HTTPProtocol
+	class HTTPProtocol < EventMachine::Protocol
 
 		HTTP_METHODS = %w{GET HEAD POST PUT DELETE TRACE OPTIONS}
 		HTTP_METHODS_REGEXP = /^#{HTTP_METHODS.join('|')}/
+		HTTP_FIRE_REQUEST = Proc.new {|handler, request| handler.on_request request}
 
-		attr_accessor :service
-
-		def initialize service, params
-			@service = service
+		def initialize connection, params
+			super
 			@parser_stage = 0
 			@parser_data = {}
 			@parser_body = ''
 			@parser_chunk = ''
 			@parser_length = 0
-			@locker = Mutex.new
 			@@rack_dictionary ||= {'HOST'.freeze => :host_name, 'REQUEST_METHOD'.freeze => :method,
 								'PATH_INFO'.freeze => :path, 'QUERY_STRING'.freeze => :query,
 								'SERVER_NAME'.freeze => :host_name, 'SERVER_PORT'.freeze => :port,
 								'rack.url_scheme'.freeze => :requested_protocol}
 		end
 
-		# called when connection is initialized.
-		def on_connect service
-		end
-
 		# called when data is recieved.
 		#
-		# this method is called within a lock on the service (Mutex) - craeful from double locking.
+		# this method is called within a lock on the connection (Mutex) - craeful from double locking.
 		#
 		# typically returns an Array with any data not yet processed (to be returned to the in-que)... but here it always processes (or discards) the data.
-		def on_message(service)
+		def on_message
 			# parse the request
-			@locker.synchronize { parse_message }
+			parse_message
 			if (@parser_stage == 1) && @parser_data[:version] >= 1.1
 				# send 100 continue message????? doesn't work! both Crome and Safari go crazy if this is sent after the request was sent (but before all the packets were recieved... msgs over 1 Mb).
-				# Plezi.push_event Proc.new { Plezi.info "sending continue signal."; service.send_nonblock "100 Continue\r\n\r\n" }
-				# service.send_unsafe_interrupt "100 Continue\r\n\r\n" # causes double lock on service
+				# Plezi.push_event Proc.new { Plezi.info "sending continue signal."; connection.send_nonblock "100 Continue\r\n\r\n" }
+				# connection.send_unsafe_interrupt "100 Continue\r\n\r\n" # causes double lock on connection
 			end
 			true
 		end
 
-		# # called when a disconnect is fired
-		# # (socket was disconnected / service should be disconnected / shutdown / socket error)
-		def on_disconnect service
-		end
-
-		# called when an exception was raised
-		# (socket was disconnected / service should be disconnected / shutdown / socket error)
-		def on_exception service, e
-			Plezi.error e
-		end
-
 
 		# Protocol specific helper methods.
 
 		# parses incoming data
 		def parse_message data = nil
-			data ||= service.read.to_s.lines.to_a
+			data ||= connection.read.to_s.lines.to_a
 			# require 'pry'; binding.pry
 			if 	@parser_stage == 0
 				return false unless parse_method data
@@ -85,7 +68,7 @@ module Plezi
 			@parser_data[:query] = ''
 			@parser_data[:original_path] = ''
 			@parser_data[:path] = ''
-			if defined? Rack
+			if defined? ::Rack
 				@parser_data['rack.version'] = Rack::VERSION
 				@parser_data['rack.multithread'] = true
 				@parser_data['rack.multiprocess'] = false
@@ -167,7 +150,7 @@ module Plezi
 		def complete_request
 			#finalize params and query properties
 			m = @parser_data[:query].match /(([a-z0-9A-Z]+):\/\/)?(([^\/\:]+))?(:([0-9]+))?([^\?\#]*)(\?([^\#]*))?/
-			@parser_data[:requested_protocol] = m[1] || (service.ssl? ? 'https' : 'http')
+			@parser_data[:requested_protocol] = m[1] || (connection.ssl? ? 'https' : 'http')
 			@parser_data[:host_name] = m[4] || (@parser_data['host'] ? @parser_data['host'].match(/^[^:]*/).to_s : nil)
 			@parser_data[:port] = m[6] || (@parser_data['host'] ? @parser_data['host'].match(/:([0-9]*)/).to_a[1] : nil)
 			@parser_data[:original_path] = HTTP.decode(m[7], :uri) || '/'
@@ -190,12 +173,12 @@ module Plezi
 			HTTP.make_utf8! @parser_data[:host_name] if @parser_data[:host_name]
 			HTTP.make_utf8! @parser_data[:query]
 
-			@parser_data[:client_ip] = @parser_data['x-forwarded-for'].to_s.split(/,[\s]?/)[0] || (service.socket.remote_address.ip_address) rescue 'unknown IP'
+			@parser_data[:client_ip] = @parser_data['x-forwarded-for'].to_s.split(/,[\s]?/)[0] || (connection.socket.remote_address.ip_address) rescue 'unknown IP'
 
 			@@rack_dictionary.each {|k,v| @parser_data[k] = @parser_data[v]}
 
 			#create request
-			request = HTTPRequest.new service
+			request = HTTPRequest.new connection
 			request.update @parser_data
 
 			#clear current state
@@ -210,7 +193,7 @@ module Plezi
 			when 'TRACE'
 				return true
 			when 'OPTIONS'
-				Plezi.push_event Proc.new do
+				Plezi.run_async do
 					response = HTTPResponse.new request
 					response[:Allow] = 'GET,HEAD,POST,PUT,DELETE,OPTIONS'
 					response['access-control-allow-origin'] = '*'
@@ -221,10 +204,10 @@ module Plezi
 			end
 
 			#pass it to the handler or decler error.
-			if service && service.handler
-				Plezi.callback service.handler, :on_request, request
+			if connection && connection.handler
+				EventMachine.queue [connection.handler, request], HTTP_FIRE_REQUEST
 			else
-				Plezi.error 'No Handler for this HTTP service.'
+				Plezi.error 'No Handler for this HTTP connection.'
 			end
 		end
 

data/lib/plezi/server/{protocols/http_request.rb → http_request.rb}

@@ -132,7 +132,7 @@ end
 ## example requests
 
 # GET / HTTP/1.1
-# Host: localhost:2000
+# Host: localhost:3000
 # Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
 # Cookie: user_token=2INa32_vDgx8Aa1qe43oILELpSdIe9xwmT8GTWjkS-w
 # User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10) AppleWebKit/600.1.25 (KHTML, like Gecko) Version/8.0 Safari/600.1.25

data/lib/plezi/server/{protocols/http_response.rb → http_response.rb}

@@ -33,11 +33,12 @@ module Plezi
 		#
 		# use, at the very least `HTTPResponse.new request`
 		def initialize request, status = 200, headers = {}, body = []
-			@request, @status, @headers, @body, @service = request, status, headers, body, (defined?(PLEZI_ON_RACK) ? false : request.service)
+			@request, @status, @headers, @body, @service = request, status, headers, body, request[:plezi_service]
 			@http_version = 'HTTP/1.1' # request.version
 			@bytes_sent = 0
 			@finished = @streaming = false
 			@cookies = {}
+			@chunked = false
 			# propegate flash object
 			@flash = Hash.new do |hs,k|
 				hs["plezi_flash_#{k.to_s}".to_sym] if hs.has_key? "plezi_flash_#{k.to_s}".to_sym
@@ -70,7 +71,7 @@ module Plezi
 		# If HTTP streaming is set, you will need to manually call `response.finish`
 		# of the connection will not close properly.
 		def start_http_streaming
-			@streaming = true
+			@streaming = @chunked = true
 		end
 
 		# pushes data to the body of the response. this is the preferred way to add data to the response.
@@ -155,7 +156,7 @@ module Plezi
 			body << str if str && body.is_a?(Array)
 			send_headers
 			return if request.head?
-			if headers['transfer-encoding'] == 'chunked'
+			if @chunked
 				body.each do |s|
 					service.send "#{s.bytesize.to_s(16)}\r\n"
 					service.send s
@@ -171,17 +172,30 @@ module Plezi
 			@body.is_a?(Array) ? @body.clear : ( @body = [] )
 		end
 
-		# sends the response and flags the response as complete. future data should not be sent. the flag will only be enforced be the Plezi router. your code might attempt sending data (which would probbaly be ignored by the client or raise an exception).
-		def finish
-			@headers['content-length'] ||= body[0].bytesize if !headers_sent? && body.is_a?(Array) && body.length == 1
-			return self if defined?(PLEZI_ON_RACK)
-			raise 'HTTPResponse SERVICE MISSING: cannot send http response without a service.' unless service
-			self.send
-			service.send( (headers['transfer-encoding'] == 'chunked') ? "0\r\n\r\n" : nil)
-			@finished = true
-			# service.disconnect unless headers['keep-alive']
-			# log
-			Plezi.log_raw "#{request[:client_ip]} [#{Time.now.utc}] \"#{request[:method]} #{request[:original_path]} #{request[:requested_protocol]}\/#{request[:version]}\" #{status} #{bytes_sent.to_s} #{"%0.3f" % ((Time.now - request[:time_recieved])*1000)}ms\n"
+		# prep for rack response
+		def prep_rack
+			@headers['content-length'] ||= body[0].bytesize.to_s if !headers_sent? && body.is_a?(Array) && body.length == 1
+			fix_cookie_headers
+		end
+
+
+		if defined?(PLEZI_ON_RACK)
+			# does nothing.
+			def finish
+				false
+			end
+		else
+			# sends the response and flags the response as complete. future data should not be sent. the flag will only be enforced be the Plezi router. your code might attempt sending data (which would probbaly be ignored by the client or raise an exception).
+			def finish
+				@headers['content-length'] ||= body[0].bytesize if !headers_sent? && body.is_a?(Array) && body.length == 1
+				self.send
+				service.send( (@chunked) ? "0\r\n\r\n" : nil)
+				@finished = true
+				# service.disconnect unless headers['keep-alive']
+				# log
+				Plezi.log_raw "#{request[:client_ip]} [#{Time.now.utc}] \"#{request[:method]} #{request[:original_path]} #{request[:requested_protocol]}\/#{request[:version]}\" #{status} #{bytes_sent.to_s} #{"%0.3f" % ((Time.now - request[:time_recieved])*1000)}ms\n"
+			end
+			
 		end
 
 		# Danger Zone (internally used method, use with care): attempts to finish the response - if it was not flaged as streaming or completed.
@@ -190,12 +204,7 @@ module Plezi
 		end
 
 		# Danger Zone (internally used method, use with care): fix response's headers before sending them (date, connection and transfer-coding).
-		def fix_headers
-			headers['keep-alive'] ||= "timeout=5" unless headers['connection']
-			headers['connection'] ||= "Keep-Alive"
-			headers['date'] = Time.now.httpdate
-			headers['transfer-encoding'] ||= 'chunked' unless headers['content-length']
-			headers['cache-control'] ||= 'no-cache'
+		def fix_cookie_headers
 			# remove old flash cookies
 			request.cookies.keys.each do |k|
 				if k.to_s.start_with? 'plezi_flash_'
@@ -211,8 +220,22 @@ module Plezi
 		# Danger Zone (internally used method, use with care): fix response's headers before sending them (date, connection and transfer-coding).
 		def send_headers
 			return false if @headers.frozen?
-			fix_headers
-			service.send "#{@http_version} #{status} #{STATUS_CODES[status] || 'unknown'}\r\n"
+			fix_cookie_headers
+			headers['cache-control'] ||= 'no-cache'
+
+			service.send "#{@http_version} #{status} #{STATUS_CODES[status] || 'unknown'}\r\nDate: #{Time.now.httpdate}\r\n"
+
+			unless headers['connection']
+				service.send "Connection: Keep-Alive\r\nKeep-Alive: timeout=5\r\n"
+			end
+
+			if headers['content-length']
+				@chunked = false
+			else
+				@chunked = true
+				service.send "Transfer-Encoding: chunked\r\n"
+			end
+
 			headers.each {|k,v| service.send "#{k.to_s}: #{v}\r\n"}
 			@cookies.each {|k,v| service.send "Set-Cookie: #{k.to_s}=#{v.to_s}\r\n"}
 			service.send "\r\n"

data/lib/plezi/server/{protocols/websocket.rb → websocket.rb}

@@ -4,7 +4,7 @@ module Plezi
 	#
 	#
 	# to do: implemet logging, support body types: multipart (non-ASCII form data / uploaded files), json & xml
-	class WSProtocol
+	class WSProtocol < EventMachine::Protocol
 
 		SUPPORTED_EXTENTIONS = {}
 		# SUPPORTED_EXTENTIONS['x-webkit-deflate-frame'] = Proc.new {|body, params| }
@@ -12,60 +12,53 @@ module Plezi
 
 		# get the timeout interval for this websockt (the number of seconds the socket can remain with no activity - will be reset every ping, message etc').
 		def timeout_interval
-			@timeout_interval
+			connection.timeout
 		end
 		# set the timeout interval for this websockt (the number of seconds the socket can remain with no activity - will be reset every ping, message etc').
 		def timeout_interval= value
-			@timeout_interval = value
-			Plezi.callback service, :set_timeout, @timeout_interval
+			connection.timeout = value
 		end
 
-		# the service (holding the socket) over which this protocol is running.
-		attr_reader :service
 		# the extentions registered for the websockets connection.
 		attr_reader :extentions
 
-		def initialize service, params
-			@params = params
-			@service = service
+		def initialize connection, params
+			super
 			@extentions = []
 			@locker = Mutex.new
 			@parser_stage = 0
 			@parser_data = {}
 			@parser_data[:body] = []
 			@parser_data[:step] = 0
-			@in_que = []
 			@message = ''
-			@timeout_interval = 60
 		end
 
+		# a proc object that calls #on_connect for the handler passed.
+		ON_CONNECT_PROC = Proc.new {|handler| handler.on_connect}
 		# called when connection is initialized.
-		def on_connect service
-			# cancel service timeout? (for now, reset to 60 seconds)
-			service.timeout = @timeout_interval
-			# Plezi.callback service, :timeout=, @timeout_interval
-			Plezi.callback @service.handler, :on_connect if @service.handler.methods.include?(:on_connect)
-			Plezi.info 'Upgraded HTTP to WebSockets. Logging only errors.'
+		def on_connect
+			# set timeout to 60 seconds
+			Plezi.log_raw "#{@request[:client_ip]} [#{Time.now.utc}] - #{@connection.object_id} Upgraded HTTP to WebSockets.\n"
+			Plezi::EventMachine.queue [@connection.handler], ON_CONNECT_PROC if @connection.handler && @connection.handler.methods.include?(:on_connect)
+			@connection.touch
+			Plezi.run_after(2) { @connection.timeout = 60 }
 		end
 
 		# called when data is recieved
 		# returns an Array with any data not yet processed (to be returned to the in-que).
-		def on_message(service)
+		def on_message
 			# parse the request
-			return @locker.synchronize {extract_message service.read.bytes}
+			extract_message connection.read.to_s.bytes
 			true
 		end
 
+		# a proc object that calls #on_disconnect for the handler passed.
+		ON_DISCONNECT_PROC = Proc.new {|handler| handler.on_disconnect}
 		# called when a disconnect is fired
-		# (socket was disconnected / service should be disconnected / shutdown / socket error)
-		def on_disconnect service
-			Plezi.callback @service.handler, :on_disconnect if @service.handler.methods.include?(:on_disconnect)
-		end
-
-		# called when an exception was raised
-		# (socket was disconnected / service should be disconnected / shutdown / socket error)
-		def on_exception service, e
-			Plezi.error e
+		# (socket was disconnected / connection should be disconnected / shutdown / socket error)
+		def on_disconnect
+			Plezi.log_raw "#{@request[:client_ip]} [#{Time.now.utc}] - #{@connection.object_id} Websocket disconnected.\n"
+			Plezi::EventMachine.queue [@connection.handler], ON_DISCONNECT_PROC if @connection.handler.methods.include?(:on_disconnect)
 		end
 
 		########
@@ -77,11 +70,12 @@ module Plezi
 			# should consider adopting the websocket gem for handshake and framing:
 			# https://github.com/imanel/websocket-ruby
 			# http://www.rubydoc.info/github/imanel/websocket-ruby
-			return request.service.handler.hosts[request[:host] || :default].send_by_code request, 400 , response.headers.merge('sec-websocket-extensions' => SUPPORTED_EXTENTIONS.keys.join(', ')) unless request['upgrade'].to_s.downcase == 'websocket' && 
+			return connection.handler.hosts[request[:host] || :default].send_by_code request, 400 , response.headers.merge('sec-websocket-extensions' => SUPPORTED_EXTENTIONS.keys.join(', ')) unless request['upgrade'].to_s.downcase == 'websocket' && 
 									request['sec-websocket-key'] &&
 									request['connection'].to_s.downcase == 'upgrade' &&
 									# (request['sec-websocket-extensions'].split(/[\s]*[,][\s]*/).reject {|ex| ex == '' || SUPPORTED_EXTENTIONS[ex.split(/[\s]*;[\s]*/)[0]] } ).empty? &&
 									(request['sec-websocket-version'].to_s.downcase.split(/[, ]/).map {|s| s.strip} .include?( '13' ))
+			@request = request
 			response.status = 101
 			response['upgrade'] = 'websocket'
 			response['content-length'] = '0'
@@ -95,9 +89,9 @@ module Plezi
 			response['Sec-WebSocket-Accept'] = Digest::SHA1.base64digest(request['sec-websocket-key'] + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
 			response.finish
 			@extentions.freeze
-			response.service.protocol = self
-			response.service.handler = handler
-			Plezi.callback self, :on_connect, response.service
+			connection.protocol = self
+			connection.handler = handler
+			Plezi::EventMachine.queue [self], ON_CONNECT_PROC
 			return true
 		end
 
@@ -160,6 +154,9 @@ module Plezi
 			bytes.pop ^ (merge_bytes(*bytes) << 8)
 		end
 
+		# The proc queued whenever a frame is complete.
+		COMPLETE_FRAME_PROC = Proc.new {|handler, message| handler.on_message message}
+
 		# handles the completed frame and sends a message to the handler once all the data has arrived.
 		def complete_frame
 			@extentions.each {|ex| SUPPORTED_EXTENTIONS[ex[0]][1].call(@parser_data[:body], ex[1..-1]) if SUPPORTED_EXTENTIONS[ex[0]]}
@@ -167,18 +164,18 @@ module Plezi
 			case @parser_data[:op_code]
 			when 9, 10
 				# handle @parser_data[:op_code] == 9 (ping) / @parser_data[:op_code] == 10 (pong)
-				Plezi.callback @service, :send_nonblock, WSResponse.frame_data(@parser_data[:body].pack('C*'), 10)
+				Plezi.callback @connection, :send_nonblock, WSResponse.frame_data(@parser_data[:body].pack('C*'), 10) # unless @parser_data[:op_code] == 10
 				@parser_op_code = nil if @parser_op_code == 9 || @parser_op_code == 10
 			when 8
 				# handle @parser_data[:op_code] == 8 (close)
-				Plezi.callback( @service, :send_nonblock, WSResponse.frame_data('', 8) ) { @service.disconnect }
+				Plezi.callback( @connection, :send_nonblock, WSResponse.frame_data('', 8) ) { @connection.disconnect }
 				@parser_op_code = nil if @parser_op_code == 8
 			else
 				@message << @parser_data[:body].pack('C*')
 				# handle @parser_data[:op_code] == 0 / fin == false (continue a frame that hasn't ended yet)
 				if @parser_data[:fin]
 					HTTP.make_utf8! @message if @parser_op_code == 1
-					Plezi.callback @service.handler, :on_message, @message
+					Plezi::EventMachine.queue [@connection.handler, @message], COMPLETE_FRAME_PROC
 					@message = ''
 					@parser_op_code = nil
 				end
@@ -194,10 +191,10 @@ end
 ######
 ## example requests
 
-# GET /?encoding=text HTTP/1.1
+# GET /nickname HTTP/1.1
 # Upgrade: websocket
 # Connection: Upgrade
-# Host: localhost:3001
+# Host: localhost:3000
 # Origin: https://www.websocket.org
 # Cookie: test=my%20cookies; user_token=2INa32_vDgx8Aa1qe43oILELpSdIe9xwmT8GTWjkS-w
 # Pragma: no-cache