plezi 0.9.2 → 0.10.1

data/lib/plezi/server/websocket.rb

@@ -1,251 +0,0 @@
-module Plezi
-
-	# this module is the protocol (controller) for the HTTP server.
-	#
-	#
-	# to do: implemet logging, support body types: multipart (non-ASCII form data / uploaded files), json & xml
-	class WSProtocol < EventMachine::Protocol
-
-		SUPPORTED_EXTENTIONS = {}
-		# SUPPORTED_EXTENTIONS['x-webkit-deflate-frame'] = Proc.new {|body, params| }
-		# SUPPORTED_EXTENTIONS['permessage-deflate'] = Proc.new {|body, params| } # client_max_window_bits
-
-		# 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
-			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
-			connection.timeout = value
-		end
-
-		# the extentions registered for the websockets connection.
-		attr_reader :extentions
-
-		def initialize connection, params
-			super
-			@extentions = []
-			@locker = Mutex.new
-			@parser_stage = 0
-			@parser_data = {}
-			@parser_data[:body] = []
-			@parser_data[:step] = 0
-			@message = ''
-		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
-			# 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
-			# parse the request
-			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 / 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
-
-		########
-		# Protocol Specific Helpers
-
-		# perform the HTTP handshake for WebSockets. send a 400 Bad Request error if handshake fails.
-		def http_handshake request, response, handler
-			# review handshake (version, extentions)
-			# 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 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'
-			response['connection'] = 'Upgrade'
-			response['sec-websocket-version'] = '13'
-			# Note that the client is only offering to use any advertised extensions
-			# and MUST NOT use them unless the server indicates that it wishes to use the extension.
-			request['sec-websocket-extensions'].to_s.split(/[\s]*[,][\s]*/).each {|ex| @extentions << ex.split(/[\s]*;[\s]*/) if SUPPORTED_EXTENTIONS[ex.split(/[\s]*;[\s]*/)[0]]}
-			response['sec-websocket-extensions'] = @extentions.map {|e| e[0] } .join (',')
-			response.headers.delete 'sec-websocket-extensions' if response['sec-websocket-extensions'].empty?
-			response['Sec-WebSocket-Accept'] = Digest::SHA1.base64digest(request['sec-websocket-key'] + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
-			response.finish
-			@extentions.freeze
-			connection.protocol = self
-			connection.handler = handler
-			Plezi::EventMachine.queue [self], ON_CONNECT_PROC
-			return true
-		end
-
-		# parse the message and send it to the handler
-		#
-		# test: frame = ["819249fcd3810b93b2fb69afb6e62c8af3e83adc94ee2ddd"].pack("H*").bytes; @parser_stage = 0; @parser_data = {}
-		# accepts:
-		# frame:: an array of bytes
-		def extract_message data
-			until data.empty?
-					if @parser_stage == 0 && !data.empty?
-					@parser_data[:fin] = data[0][7] == 1
-					@parser_data[:rsv1] = data[0][6] == 1
-					@parser_data[:rsv2] = data[0][5] == 1
-					@parser_data[:rsv3] = data[0][4] == 1
-					@parser_data[:op_code] = data[0] & 0b00001111
-					@parser_op_code ||= data[0] & 0b00001111
-					@parser_stage += 1
-					data.shift
-				end
-				if @parser_stage == 1
-					@parser_data[:mask] = data[0][7]
-					@parser_data[:len] = data[0] & 0b01111111
-					data.shift
-					if @parser_data[:len] == 126
-						@parser_data[:len] = merge_bytes( *(data.slice!(0,2)) ) # should be = ?
-					elsif @parser_data[:len] == 127
-						len = 0
-						@parser_data[:len] = merge_bytes( *(data.slice!(0,8)) ) # should be = ?
-					end
-					@parser_data[:step] = 0
-					@parser_stage += 1
-					review_message_size
-				end
-				if @parser_stage == 2 && @parser_data[:mask] == 1
-					@parser_data[:mask_key] = data.slice!(0,4)
-					@parser_stage += 1
-				elsif  @parser_data[:mask] != 1
-					@parser_stage += 1
-				end
-				if @parser_stage == 3 && @parser_data[:step] < @parser_data[:len]
-					# data.length.times {|i| data[0] = data[0] ^ @parser_data[:mask_key][@parser_data[:step] % 4] if @parser_data[:mask_key]; @parser_data[:step] += 1; @parser_data[:body] << data.shift; break if @parser_data[:step] == @parser_data[:len]}
-					slice_length = [data.length, (@parser_data[:len]-@parser_data[:step])].min
-					if @parser_data[:mask_key]
-						masked = data.slice!(0, slice_length)
-						masked.map!.with_index {|b, i|  b ^ @parser_data[:mask_key][ ( i + @parser_data[:step] ) % 4]  }
-						@parser_data[:body].concat masked
-					else
-						@parser_data[:body].concat data.slice!(0, slice_length)
-					end
-					@parser_data[:step] += slice_length
-				end
-				complete_frame unless @parser_data[:step] < @parser_data[:len]
-			end
-			true
-		end
-
-		# takes and Array of bytes and combines them to an int(16 Bit), 32Bit or 64Bit number
-		def merge_bytes *bytes
-			return bytes.pop if bytes.length == 1
-			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]]}
-
-			case @parser_data[:op_code]
-			when 9 # ping
-				# handle @parser_data[:op_code] == 9 (ping)
-				Plezi.callback @connection, :send_nonblock, WSResponse.frame_data(@parser_data[:body].pack('C*'), 10) # "\x8A\x00" can't be used, because body should be returned. # sends pong op_code == 10
-				@parser_op_code = nil if @parser_op_code == 9
-			when 10 #pong
-				# handle @parser_data[:op_code] == 10 (pong)
-				@parser_op_code = nil if @parser_op_code == 10
-			when 8
-				# handle @parser_data[:op_code] == 8 (close)
-				Plezi.callback( @connection, :send_nonblock, "\x88\x00" ) { @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::EventMachine.queue [@connection.handler, @message], COMPLETE_FRAME_PROC
-					@message = ''
-					@parser_op_code = nil
-				end
-			end
-			@parser_stage = 0
-			@parser_data[:body].clear
-			@parser_data[:step] = 0
-		end
-		#reviews the message size and closes the connection if expected message size is over the allowed limit.
-		def review_message_size
-			if ( self.class.message_size_limit.to_i > 0 ) && ( ( @parser_data[:len] + @message.bytesize ) > self.class.message_size_limit.to_i )
-				Plezi.callback @connection, :disconnect
-				@message.clear
-				@parser_data[:step] = 0
-				@parser_data[:body].clear
-				@parser_stage = -1
-				return false
-			end
-			true
-		end
-
-		# Sets the message byte size limit for a Websocket message. Defaults to 0 (no limit)
-		#
-		# Although memory will be allocated for the latest TCP/IP frame,
-		# this allows the websocket to disconnect if the incoming expected message size exceeds the allowed maximum size.
-		#
-		# If the sessage size limit is exceeded, the disconnection will be immidiate as an attack will be assumed. The protocol's normal disconnect sequesnce will be discarded.
-		def self.message_size_limit=val
-			@message_size_limit = val
-		end
-		# Gets the message byte size limit for a Websocket message. Defaults to 0 (no limit)
-		def self.message_size_limit
-			@message_size_limit
-		end
-		message_size_limit = 0
-
-	end
-
-	# Sets the message byte size limit for a Websocket message. Defaults to 0 (no limit)
-	#
-	# Although memory will be allocated for the latest TCP/IP frame,
-	# this allows the websocket to disconnect if the incoming expected message size exceeds the allowed maximum size.
-	#
-	# If the sessage size limit is exceeded, the disconnection will be immidiate as an attack will be assumed. The protocol's normal disconnect sequesnce will be discarded.
-	def self.ws_message_size_limit=val
-		WSProtocol.message_size_limit = val
-	end
-	# Gets the message byte size limit for a Websocket message. Defaults to 0 (no limit)
-	def self.ws_message_size_limit
-		WSProtocol.message_size_limit
-	end
-end
-
-
-######
-## example requests
-
-# GET /nickname HTTP/1.1
-# Upgrade: websocket
-# Connection: Upgrade
-# Host: localhost:3000
-# Origin: https://www.websocket.org
-# Cookie: test=my%20cookies; user_token=2INa32_vDgx8Aa1qe43oILELpSdIe9xwmT8GTWjkS-w
-# Pragma: no-cache
-# Cache-Control: no-cache
-# Sec-WebSocket-Key: 1W9B64oYSpyRL/yuc4k+Ww==
-# Sec-WebSocket-Version: 13
-# Sec-WebSocket-Extensions: x-webkit-deflate-frame
-# 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/websocket_client.rb

@@ -1,178 +0,0 @@
-module Plezi
-
-	# Websocket client objects are members of this class.
-	#
-	# This is a VERY simple Websocket client. It doesn't support cookies, HTTP authentication or... well... anything, really.
-	# It's just a simple client used for the Plezi framework's testing. It's usful for simple WebSocket connections, but no more.
-	class WebsocketClient
-		attr_accessor :response, :request
-
-		class RequestEmulator < Hash
-			def service
-				self[:connection]
-			end
-		end
-
-		def initialize request
-			@response = WSResponse.new request
-			@options = request[:options]
-			@on_message = @options[:on_message]
-			raise "Websocket client must have an #on_message Proc." unless @on_message && @on_message.is_a?(Proc)
-			@on_connect = @options[:on_connect]
-			@on_disconnect = @options[:on_disconnect]
-		end
-
-		def on_message(data = false, &block)
-			unless data
-				@on_message = block if block
-				return @on_message
-			end
-			instance_exec( data, &@on_message) 
-		end
-
-		def on_connect(&block)
-			if block
-				@on_connect = block
-				return @on_connect
-			end
-			instance_exec(&@on_connect) if @on_connect
-		end
-
-		def on_disconnect(&block)
-			if block
-				@on_disconnect = block
-				return @on_disconnect
-			end
-			instance_exec(&@on_disconnect) if @on_disconnect
-		end
-
-		#disconnects the Websocket.
-		def disconnect
-			@response.close if @response
-		end
-		alias :close :disconnect
-
-		# Asynchronously sends data through the socket. a shortcut for ws_client.response <<
-		def << data
-			@response << data
-		end
-
-		# Synchronously sends data through the socket. a shortcut for ws_client.response <<
-		def send data
-			@response.send data
-		end
-
-		# Create a simple Websocket Client(!)
-		#
-		# This method accepts two parameters:
-		# url:: a String representing the URL of the websocket. i.e.: 'ws://foo.bar.com:80/ws/path'
-		# options:: a Hash with options to be used. The options will be used to define
-		# &block:: an optional block that accepts one parameter (data) and will be used as the `#on_message(data)`
-		#
-		# The method will either return a WebsocketClient instance object or it will raise an exception.
-		#
-		# An on_message Proc must be defined, or the method will fail.
-		#
-		# The on_message Proc can be defined using the optional block:
-		#
-		#      WebsocketClient.connect_to("ws://localhost:3000/") {|data| response << data} #echo example
-		#
-		# OR, the on_message Proc can be defined using the options Hash: 
-		#
-		#      WebsocketClient.connect_to("ws://localhost:3000/", on_connect: -> {}, on_message: -> {|data| response << data})
-		#
-		# The #on_message(data), #on_connect and #on_disconnect methods will be executed within the context of the WebsocketClient
-		# object, and will have natice acess to the Websocket response object.
-		#
-		# After the WebsocketClient had been created, it's possible to update the #on_message and #on_disconnect methods:
-		#
-		#      # updates #on_message
-		#      wsclient.on_message do |data|
-		#           response << "I'll disconnect on the next message!"
-		#           # updates #on_message again.
-		#           on_message {|data| disconnect }
-		#      end
-		#
-		#
-		# !!please be aware that the Websockt Client will not attempt to verify SSL certificates,
-		# so that even SSL connections are subject to a possible man in the middle attack.
-		def self.connect_to url, options={}, &block
-			options[:on_message] ||= block
-			options[:handler] = WebsocketClient
-			options[:protocol] = EventMachine::Protocol
-			url = URI.parse(url) unless url.is_a?(URI)
-			connection_type = EventMachine::Connection
-
-			socket = false #implement the connection, ssl vs. no ssl
-			if url.scheme == "https" || url.scheme == "wss"
-				connection_type = EventMachine::SSLConnection
-				options[:ssl_client] = true
-				url.port ||= 443
-			end
-			url.port ||= 80
-			socket = TCPSocket.new(url.host, url.port)
-			connection = connection_type.new socket, options
-			psedo_request = RequestEmulator.new
-			psedo_request[:connection] = connection
-			psedo_request[:client_ip] = 'WS Client'
-			psedo_request[:url] = url
-			psedo_request[:options] = options
-			WSProtocol.client_handshake psedo_request
-			connection.handler
-			rescue => e
-				socket.close if socket
-				raise e
-		end
-
-	end
-
-	class WSProtocol < EventMachine::Protocol
-		def self.client_handshake psedo_request, timeout = 5
-			connection = psedo_request[:connection]
-			url = psedo_request[:url]
-			# send protocol upgrade request
-			websocket_key = [(Array.new(16) {rand 255} .pack 'c*' )].pack('m0*')
-			connection.send "GET #{url.path}#{url.query.to_s.empty? ? '' : ('?' + url.query)} HTTP/1.1\r\nHost: #{url.host}#{url.port ? (':'+url.port.to_s) : ''}\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: #{websocket_key}\r\nSec-WebSocket-Version: 13\r\n\r\n"
-			# wait for answer - make sure we don't over-read
-			# (a websocket message might be sent immidiately after connection is established)
-			reply = ''
-			reply.force_encoding('binary')
-			start_time = Time.now
-			stop_reply = "\r\n\r\n"
-			until reply[-4..-1] == stop_reply
-				(reply << connection.read(1)) rescue (sleep 0.1)
-				raise Timeout::Error, "Websocket client handshake timed out (HTTP reply not recieved)\n\n Got Only: #{reply.dump}" if Time.now >= (start_time + 5)
-			end
-			# review reply
-			raise 'Connection Refused.' unless reply.lines[0].match(/^HTTP\/[\d\.]+ 101/i)
-			raise 'Websocket Key Authentication failed.' unless reply.match(/^Sec-WebSocket-Accept:[\s]*([^\s]*)/i) && reply.match(/^Sec-WebSocket-Accept:[\s]*([^\s]*)/i)[1] == Digest::SHA1.base64digest(websocket_key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
-			# set-up handler response object. 
-			connection.handler = WebsocketClient.new psedo_request
-
-			# raise "not yet implemented"
-
-			# set the connetion's protocol to a new WSProtocol instance
-			connection.protocol = self.new psedo_request[:connection], psedo_request[:options]
-			# add the socket to the EventMachine IO reactor
-			EventMachine.add_io connection.socket, connection
-			true
-		end
-	end
-end
-
-
-######
-## example requests
-
-# GET /nickname HTTP/1.1
-# Upgrade: websocket
-# Connection: Upgrade
-# Host: localhost:3000
-# Origin: https://www.websocket.org
-# Cookie: test=my%20cookies; user_token=2INa32_vDgx8Aa1qe43oILELpSdIe9xwmT8GTWjkS-w
-# Pragma: no-cache
-# Cache-Control: no-cache
-# Sec-WebSocket-Key: 1W9B64oYSpyRL/yuc4k+Ww==
-# Sec-WebSocket-Version: 13
-# Sec-WebSocket-Extensions: x-webkit-deflate-frame
-# 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/ws_response.rb

@@ -1,161 +0,0 @@
-module Plezi
-
-	# this class handles WebSocket response.
-	#
-	# the WSResponse supports only one method - the send method.
-	#
-	# use: `response << data` to send data. data should be a String object.
-	#
-	# the data wil be sent as text if the string is encoded as a UTF-8 string (default encoding).
-	# otherwise, the data will be sent as a binary stream.
-	#
-	# todo: extentions support, support frames longer then 125 bytes.
-	class WSResponse
-
-		#the service through which the response will be sent.
-		attr_reader :service
-		#the request.
-		attr_accessor :request
-
-		# Sets the defalt Websockt auto-ping interval.
-		#
-		# The default ping interval is 45 seconds.
-		#
-		# It's possible to set the ping interval to false, thereby disabling auto-pinging.
-		def self.ping_interval=(val)
-			@ping_interval = val
-		end
-		# Returns the defalt Websockt auto-ping interval.
-		#
-		# Plezi will automatically send a ping frame to keep websocket connections open.
-		# This auto-pinging can be disabled by setting the `ping_interval` to false.
-		def self.ping_interval
-			@ping_interval ||= 45
-		end
-		PING_PROC = Proc.new {|res| EventMachine.timed_job ping_interval, 1, [res.ping], PING_PROC unless res.service.disconnected? || !ping_interval }
-
-		def initialize request
-			@request, @service = request,request.service
-			PING_PROC.call(self)
-		end
-
-		# sends data through the websocket connection in a non-blocking way.
-		#
-		# Plezi will try a best guess at the type of the data (binary vs. clear text).
-		#
-		# This should be the preferred way.
-		def << str
-			service.send_nonblock self.class.frame_data(str)
-			self
-		end
-
-		# sends data through the websocket connection in a blocking way.
-		#
-		# Plezi will try a best guess at the type of the data (binary vs. clear text).
-		#
-		def send str
-			service.send self.class.frame_data(str)
-			self
-		end
-		# sends binary data through the websocket connection in a blocking way.
-		#
-		def binsend str
-			service.send self.class.frame_data(str, 2)
-			self
-		end
-		# sends clear text data through the websocket connection in a blocking way.
-		#
-		def txtsend str
-			service.send self.class.frame_data(str, 1)
-			self
-		end
-
-
-		# makes sure any data held in the buffer is actually sent.
-		def flush
-			service.flush
-			self
-		end
-
-		# pings the connection
-		def ping
-			service.send_nonblock "\x89\x00" # op_code 9
-			self
-		end
-		# pings the connection
-		def pong
-			service.send_nonblock "\x8A\x00" # op_code 10
-			self
-		end
-
-		# a closeing Proc
-		CLOSE_PROC = Proc.new {|c| c.send "\x88\x00"; c.close}
-
-		# sends any pending data and closes the connection.
-		def close
-			service.locker.locked? ? (EventMachine.queue [service], CLOSE_PROC) : (CLOSE_PROC.call(service)) 
-		end
-
-		FRAME_SIZE_LIMIT = 131_072 # javascript to test: str = '0123456789'; bigstr = ""; for(i = 0; i<=1033200; i+=1) {bigstr += str}; ws = new WebSocket('ws://localhost:3000/ws/size') ; ws.onmessage = function(e) {console.log(e.data.length)};ws. onopen = function(e) {ws.send(bigstr)}
-
-		# Dangerzone! use `send` instead: formats the data as one or more WebSocket frames.
-		def self.frame_data data, op_code = nil, fin = true
-			# set up variables
-			frame = ''.force_encoding('binary')
-			op_code ||= (data.encoding.name == 'UTF-8' ? 1 : 2)
-
-
-			if data[FRAME_SIZE_LIMIT] && fin
-				# fragment big data chuncks into smaller frames - op-code reset for 0 for all future frames.
-				data = data.dup
-				data.force_encoding('binary')
-				[frame << frame_data(data.slice!(0...FRAME_SIZE_LIMIT), op_code, false), op_code = 0] while data.length > FRAME_SIZE_LIMIT # 1048576
-				# frame << frame_data(data.slice!(0..1048576), op_code, false)
-				# data = 
-				# op_code = 0
-			end
-
-			# apply extenetions to the frame
-			ext = 0
-			# ext |= call each service.protocol.extenetions with data #changes data and returns flags to be set
-			# service.protocol.extenetions.each { |ex| ext |= WSProtocol::SUPPORTED_EXTENTIONS[ex[0]][2].call data, ex[1..-1]}
-
-			# set 
-			frame << ( (fin ? 0b10000000 : 0) | (op_code & 0b00001111) | ext).chr
-
-			if data.length < 125
-				frame << data.length.chr
-			elsif data.length.bit_length <= 16					
-				frame << 126.chr
-				frame << [data.length].pack('S>')
-			else
-				frame << 127.chr
-				frame << [data.length].pack('Q>')
-			end
-			frame.force_encoding(data.encoding)
-			frame << data
-			frame.force_encoding('binary')
-			frame
-		end
-	end
-
-	module_function
-	# Sets the defalt Websockt auto-ping interval.
-	#
-	# This method accepts one value, which should be either a number in seconds or `false`.
-	#
-	# The default ping interval is 45 seconds.
-	#
-	# It's possible to set the ping interval to false, thereby disabling auto-pinging.
-	def ping_interval=(val)
-		WSResponse.ping_interval = val
-	end
-	# Returns the defalt Websockt auto-ping interval.
-	#
-	# Plezi will automatically send a ping frame to keep websocket connections open.
-	# This auto-pinging can be disabled by setting the `ping_interval` to false.
-	def ping_interval
-		WSResponse.ping_interval
-	end
-
-end