iodine 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cbb450cc38cab2612710d70cff54bc0bea8685b0
-  data.tar.gz: 5165d905229eb83143eb0c2fde06a91b8223069d
+  metadata.gz: 9451f837296bd4fecf60df42fd3cfee80d80ef0f
+  data.tar.gz: af0d8bf95137d229b23ee74aef4825f50a9aafa0
 SHA512:
-  metadata.gz: fa8b08cd218f03436b2a82ec5adf5df579108393b51dc5cf199ab11328e55717575102aa7c048d54aaffa2ad2a4f7ba2ed0a2e561630328c783b3fc4e041b704
-  data.tar.gz: c1d9d2a99ca9132a82ddb28df1747fdc2f532b033f344373406b466d99eda0055c753deca2bc9e2802d99416abbc00bd6a3c1caa0532e5ed02d0554682743a26
+  metadata.gz: 6039e844f9b6658326a70fbadc12ebd61007b466a546100670382ce119d2d0bbf193497fc2c40a4fc36945352ad94e2f83f3a1c4f5f1a6a3c88f6c0719bf3dd1
+  data.tar.gz: 608df34266557cb59300dd08321c3dcef74a67c7f7f0eec343ae77ac823f440d2108b40008e8c744fd753199ca73b0dffdfb96fc9bad4a2ce1aaac362319d093

data/lib/iodine/http.rb

@@ -68,14 +68,15 @@ module Iodine
 	#
 	# See {Iodine::Http::WebsocketHandler} for a good starting point or inherit {Iodine::Http::WebsocketHandler} in your handler.
 	#
-	class Http < Iodine::Protocol
+	module Http
+		public
 		# Sets or gets the Http callback.
 		#
 		# An Http callback is a Proc like object that answers to `call(request, response)` and returns either:
 		# `true`:: the response has been set by the callback and can be managed (including any streaming) by the server.
 		# `false`:: the request shouldn't be answered or resource not found (error 404 will be sent as a response).
 		# String:: the String will be appended to the response and the response sent.
-		def self.on_http handler = nil, &block
+		def on_http handler = nil, &block
 			@http_app = handler || block if handler || block
 			@http_app
 		end
@@ -84,29 +85,38 @@ module Iodine
 		# A Websockets callback is a Proc like object that answers to `call(request)` and returns either:
 		# `false`:: the request shouldn't be answered or resource not found (error 404 will be sent as a response).
 		# Websocket Handler:: a Websocket handler is an object that is expected to answer `on_message(data)` and `on_close`. See {} for more data.
-		def self.on_websocket handler = nil, &block
+		def on_websocket handler = nil, &block
 			@websocket_app = handler || block if handler || block
 			@websocket_app
 		end
 
 		# Sets the session token for the Http server (String). Defaults to the name of the script + '_id'.
-		def self.session_token= token
+		def session_token= token
 			@session_token = token
 		end
 		# Sets the session token for the Http server (String). Defaults to the name of the script.
-		def self.session_token
+		def session_token
 			@session_token
 		end
 
 		# Sets whether Iodine will allow connections to the experiemntal Http2 protocol. Defaults to false unless the `http2` command line flag is present.
-		def self.http2= allow
+		def http2= allow
 			@http2 = allow && true
 		end
 		# Returns true if Iodine will require that new connection be encrypted.
-		def self.http2
+		def http2
 			@http2
 		end
 
+		# # Sets whether Iodine will allow connections to the experiemntal Http2 protocol. Defaults to false unless the `http2` command line flag is present.
+		# def self.message_buffer_size= size
+		# 	@message_buffer_size = size
+		# end
+		# # Returns true if Iodine will require that new connection be encrypted.
+		# def self.message_buffer_size
+		# 	@message_buffer_size
+		# end
+
 		# Creates a websocket client within a new task (non-blocking).
 		# 
 		# Make sure to setup all the callbacks (as needed) prior to starting the connection. See {::Iodine::Http::WebsocketClient.connect}
@@ -132,22 +142,25 @@ module Iodine
 		#       #if running from irb:
 		#       exit
 		#     
-		def self.ws_connect url, options={}, &block
+		def ws_connect url, options={}, &block
 			::Iodine.run { ::Iodine::Http::WebsocketClient.connect url, options, &block }
 		end
 
+		protected
+
 		@http2 = (ARGV.index('http2') && true)
 
 		@websocket_app = @http_app = NOT_IMPLEMENTED = Proc.new { |i,o| false }
 		@session_token = "#{File.basename($0, '.*')}_uuid"
+		extend self
 	end
 
 	@queue.tap do |q|
 		arr =[];
 		arr << q.pop until q.empty?;
-		run { Iodine.ssl_protocols = { 'h2' => Iodine::Http::Http2, 'http/1.1' => Iodine::Http } if @ssl && @ssl_protocols.empty? && ::Iodine::Http.http2 }
+		run { ::Iodine.ssl_protocols = { 'h2' => ::Iodine::Http::Http2, 'http/1.1' => ::Iodine::Http::Http1 } if @ssl && @ssl_protocols.empty? && ::Iodine::Http.http2 }
 		run do
-			if Iodine.protocol == ::Iodine::Http && ::Iodine::Http.on_http == ::Iodine::Http::NOT_IMPLEMENTED && ::Iodine::Http.on_websocket == ::Iodine::Http::NOT_IMPLEMENTED
+			if Iodine.protocol == ::Iodine::Http::Http1 && ::Iodine::Http.on_http == ::Iodine::Http::NOT_IMPLEMENTED && ::Iodine::Http.on_websocket == ::Iodine::Http::NOT_IMPLEMENTED
 				::Iodine.protocol = :http_not_initialized
 				q << arr.shift until arr.empty?
 				run { Process.kill("INT", 0) }
@@ -156,4 +169,4 @@ module Iodine
 		q << arr.shift until arr.empty?
 	end
 end
-Iodine.protocol = ::Iodine::Http
+Iodine.protocol = ::Iodine::Http::Http1

data/lib/iodine/http/hpack.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 module Iodine
-	class Http < ::Iodine::Protocol
+	module Http
 		class Http2 < ::Iodine::Protocol
 			class HPACK
 				class IndexTable
@@ -145,10 +145,10 @@ module Iodine
 					buffer
 				rescue
 					puts "HPACK failure data dump:"
-					puts "buffer: #{buffer} - #{buffer.encoding}"
-					puts "value: #{value} - #{value.encoding}"
-					puts "packed #{pack_string(value)} - #{pack_string(value)}"
-					puts "packed #{pack_string(value)} - #{pack_string(value)}"
+					puts "buffer: #{buffer} - #{buffer.encoding}" if buffer
+					puts "name: #{name} - #{name.encoding}"  if name.is_a? String
+					puts "value: #{value} - #{value.encoding}"  if value.is_a? String
+					puts "packed #{pack_string(name)} - #{pack_string(value)}" if value
 					raise
 				end
 				def extract_number data, prefix, prefix_length

data/lib/iodine/http/http1.rb

@@ -1,195 +1,198 @@
 module Iodine
-	class Http < ::Iodine::Protocol
-		def on_open
-			set_timeout 1
-			@refuse_requests = false
-			@bytes_sent = 0
-			@parser = {}
-		end
-		def on_message data
-				return if @refuse_requests
-				@http2_pri_review ||= ( ::Iodine::Http.http2 && ::Iodine::Http::Http2.pre_handshake(self, data) && (return true) ) || true
-
-				data = ::StringIO.new data
-				until data.eof?
-					request = (@request ||= ::Iodine::Http::Request.new(self))
-					unless request[:method]
-						l = data.gets.strip
-						next if l.empty?
-						request[:method], request[:query], request[:version] = l.split(/[\s]+/, 3)
-						return (Iodine.warn('Protocol Error, closing connection.') && close) unless request[:method] =~ HTTP_METHODS_REGEXP
-						request[:version] = (request[:version] || '1.1'.freeze).match(/[\d\.]+/)[0]
-						request[:time_recieved] = Time.now
-					end
-					until request[:headers_complete] || (l = data.gets).nil?
-						if l.include? ':'
-							# n = l.slice!(0, l.index(':')); l.slice! 0
-							# n.strip! ; n.downcase!; n.freeze
-							# request[n] ? (request[n].is_a?(Array) ? (request[n] << l) : request[n] = [request[n], l ]) : (request[n] = l)
-							l = l.strip.split(/:[\s]?/, 2)
-							l[0].strip! ; l[0].downcase!;
-							request[l[0]] ? (request[l[0]].is_a?(Array) ? (request[l[0]] << l[1]) : request[l[0]] = [request[l[0]], l[1] ]) : (request[l[0]] = l[1])
-						elsif l =~ /^[\r]?\n/
-							request[:headers_complete] = true
-						else
-							#protocol error
-							Iodine.warn 'Protocol Error, closing connection.'
-							return close
+	module Http
+		class Http1 < ::Iodine::Protocol
+			def on_open
+				set_timeout 1
+				@refuse_requests = false
+				@bytes_sent = 0
+				@parser = {}
+			end
+			def on_message data
+					return if @refuse_requests
+					@http2_pri_review ||= ( ::Iodine::Http.http2 && ::Iodine::Http::Http2.pre_handshake(self, data) && (return true) ) || true
+
+					data = ::StringIO.new data
+					until data.eof?
+						request = (@request ||= ::Iodine::Http::Request.new(self))
+						unless request[:method]
+							l = data.gets.strip
+							next if l.empty?
+							request[:method], request[:query], request[:version] = l.split(/[\s]+/, 3)
+							return (Iodine.warn('Protocol Error, closing connection.') && close) unless request[:method] =~ HTTP_METHODS_REGEXP
+							request[:version] = (request[:version] || '1.1'.freeze).match(/[\d\.]+/)[0]
+							request[:time_recieved] = Time.now
 						end
-					end
-					until request[:body_complete] && request[:headers_complete]
-						if request['transfer-coding'.freeze] == 'chunked'.freeze
-							# ad mid chunk logic here
-							if @parser[:length].to_i == 0
-								chunk = data.gets
+						until request[:headers_complete] || (l = data.gets).nil?
+							if l.include? ':'
+								# n = l.slice!(0, l.index(':')); l.slice! 0
+								# n.strip! ; n.downcase!; n.freeze
+								# request[n] ? (request[n].is_a?(Array) ? (request[n] << l) : request[n] = [request[n], l ]) : (request[n] = l)
+								l = l.strip.split(/:[\s]?/, 2)
+								l[0].strip! ; l[0].downcase!;
+								request[l[0]] ? (request[l[0]].is_a?(Array) ? (request[l[0]] << l[1]) : request[l[0]] = [request[l[0]], l[1] ]) : (request[l[0]] = l[1])
+							elsif l =~ /^[\r]?\n/
+								request[:headers_complete] = true
+							else
+								#protocol error
+								Iodine.warn 'Protocol Error, closing connection.'
+								return close
+							end
+						end
+						until request[:body_complete] && request[:headers_complete]
+							if request['transfer-coding'.freeze] == 'chunked'.freeze
+								# ad mid chunk logic here
+								if @parser[:length].to_i == 0
+									chunk = data.gets
+									return false unless chunk
+									@parser[:length] = chunk.to_i(16)
+									return (Iodine.warn('Protocol Error, closing connection.') && close) unless @parser[:length]
+									request[:body_complete] = true && break if @parser[:length] == 0
+									@parser[:act_length] = 0
+									request[:body] ||= ''
+								end
+								chunk = data.read(@parser[:length] - @parser[:act_length])
 								return false unless chunk
-								@parser[:length] = chunk.to_i(16)
-								return (Iodine.warn('Protocol Error, closing connection.') && close) unless @parser[:length]
-								request[:body_complete] = true && break if @parser[:length] == 0
-								@parser[:act_length] = 0
+								request[:body] << chunk
+								@parser[:act_length] += chunk.bytesize
+								(@parser[:act_length] = @parser[:length] = 0) && (data.gets) if @parser[:act_length] >= @parser[:length]
+							elsif request['content-length'.freeze] && request['content-length'.freeze].to_i != 0
 								request[:body] ||= ''
+								packet = data.read(request['content-length'.freeze].to_i - request[:body].bytesize)
+								return false unless packet
+								request[:body] << packet
+								request[:body_complete] = true if request['content-length'.freeze].to_i - request[:body].bytesize <= 0
+							elsif request['content-type'.freeze]
+								Iodine.warn 'Body type protocol error.' unless request[:body]
+								line = data.gets
+								return false unless line
+								(request[:body] ||= '') << line
+								request[:body_complete] = true if line =~ EOHEADERS
+							else
+								request[:body_complete] = true
 							end
-							chunk = data.read(@parser[:length] - @parser[:act_length])
-							return false unless chunk
-							request[:body] << chunk
-							@parser[:act_length] += chunk.bytesize
-							(@parser[:act_length] = @parser[:length] = 0) && (data.gets) if @parser[:act_length] >= @parser[:length]
-						elsif request['content-length'.freeze] && request['content-length'.freeze].to_i != 0
-							request[:body] ||= ''
-							packet = data.read(request['content-length'.freeze].to_i - request[:body].bytesize)
-							return false unless packet
-							request[:body] << packet
-							request[:body_complete] = true if request['content-length'.freeze].to_i - request[:body].bytesize <= 0
-						elsif request['content-type'.freeze]
-							Iodine.warn 'Body type protocol error.' unless request[:body]
-							line = data.gets
-							return false unless line
-							(request[:body] ||= '') << line
-							request[:body_complete] = true if line =~ EOHEADERS
-						else
-							request[:body_complete] = true
 						end
+						(@request = ::Iodine::Http::Request.new(self)) && ( (::Iodine::Http.http2 && ::Iodine::Http::Http2.handshake(request, self, data)) || dispatch(request, data) ) if request.delete :body_complete
 					end
-					(@request = ::Iodine::Http::Request.new(self)) && ( (::Iodine::Http.http2 && ::Iodine::Http::Http2.handshake(request, self, data)) || dispatch(request, data) ) if request.delete :body_complete
-				end
-		end
+			end
 
-		def send_response response
-			return false if response.headers.frozen?
+			def send_response response
+				return false if response.headers.frozen?
 
-			request = response.request
-			headers = response.headers
-			body = response.extract_body
+				request = response.request
+				headers = response.headers
+				body = response.extract_body
 
-			headers['content-length'.freeze] ||= body.to_s.bytesize
+				headers['content-length'.freeze] ||= body.to_s.bytesize
 
-			keep_alive = response.keep_alive
-			if (request[:version].to_f > 1 && request['connection'.freeze].nil?) || request['connection'.freeze].to_s =~ /ke/i || (headers['connection'.freeze] && headers['connection'.freeze] =~ /^ke/i)
-				keep_alive = true
-				headers['connection'.freeze] ||= 'Keep-Alive'.freeze
-				headers['keep-alive'.freeze] ||= "timeout=#{(@timeout ||= 3).to_s}"
-			else
-				headers['connection'.freeze] ||= 'close'.freeze
-			end
+				keep_alive = response.keep_alive
+				if (request[:version].to_f > 1 && request['connection'.freeze].nil?) || request['connection'.freeze].to_s =~ /ke/i || (headers['connection'.freeze] && headers['connection'.freeze] =~ /^ke/i)
+					keep_alive = true
+					headers['connection'.freeze] ||= 'keep-alive'.freeze
+					headers['keep-alive'.freeze] ||= "timeout=#{(@timeout ||= 3).to_s}"
+				else
+					headers['connection'.freeze] ||= 'close'.freeze
+				end
 
-			send_headers response
-			return log_finished(response) if request.head?
-			(response.bytes_written += (write(body) || 0)) && (body.frozen? || body.clear) if body
-			close unless keep_alive
-			log_finished response
-		end
-		def stream_response response, finish = false
-			unless response.headers.frozen?
-				response['transfer-encoding'.freeze] = 'chunked'
-				response.headers['connection'.freeze] = 'close'.freeze
 				send_headers response
-				@refuse_requests = true
-			end
-			return if response.request.head?
-			body = response.extract_body
-			response.bytes_written += stream_data(body) if body || finish
-			if finish
-				response.bytes_written += stream_data('') unless body.nil?
+				return log_finished(response) if request.head?
+				(response.bytes_written += (write(body) || 0)) && (body.frozen? || body.clear) if body
+				close unless keep_alive
 				log_finished response
 			end
-			(body.frozen? || body.clear) if body
-			true
-		end
+			def stream_response response, finish = false
+				unless response.headers.frozen?
+					response['transfer-encoding'.freeze] = 'chunked'
+					response.headers['connection'.freeze] = 'close'.freeze
+					send_headers response
+					@refuse_requests = true
+				end
+				return if response.request.head?
+				body = response.extract_body
+				response.bytes_written += stream_data(body) if body || finish
+				if finish
+					response.bytes_written += stream_data('') unless body.nil?
+					log_finished response
+					close unless response.keep_alive
+				end
+				(body.frozen? || body.clear) if body
+				true
+			end
 
-		protected
-
-		HTTP_METHODS = %w{GET HEAD POST PUT DELETE TRACE OPTIONS CONNECT PATCH}
-		HTTP_METHODS_REGEXP = /\A#{HTTP_METHODS.join('|')}/i
-
-		def dispatch request, data
-			return data.string.clear if @io.closed? || @refuse_requests
-			::Iodine::Http::Request.parse request
-			#check for server-responses
-			case request[:method]
-			when 'TRACE'.freeze
-				close
-				data.string.clear
-				return false
-			when 'OPTIONS'.freeze
+			protected
+
+			HTTP_METHODS = %w{GET HEAD POST PUT DELETE TRACE OPTIONS CONNECT PATCH}
+			HTTP_METHODS_REGEXP = /\A#{HTTP_METHODS.join('|')}/i
+
+			def dispatch request, data
+				return data.string.clear if @io.closed? || @refuse_requests
+				::Iodine::Http::Request.parse request
+				#check for server-responses
+				case request[:method]
+				when 'TRACE'.freeze
+					close
+					data.string.clear
+					return false
+				when 'OPTIONS'.freeze
+					response = ::Iodine::Http::Response.new request
+					response[:Allow] = 'GET,HEAD,POST,PUT,DELETE,OPTIONS'.freeze
+					response['access-control-allow-origin'.freeze] = '*'
+					response['content-length'.freeze] = 0
+					send_response response
+					return false
+				end
 				response = ::Iodine::Http::Response.new request
-				response[:Allow] = 'GET,HEAD,POST,PUT,DELETE,OPTIONS'.freeze
-				response['access-control-allow-origin'.freeze] = '*'
-				response['content-length'.freeze] = 0
-				send_response response
-				return false
-			end
-			response = ::Iodine::Http::Response.new request
-			begin
-				if request.websocket?
-					@refuse_requests = true
-					::Iodine::Http::Websockets.handshake request, response, self.class.on_websocket.call(request, response)
-				else
-					ret = self.class.on_http.call(request, response)
-					if ret.is_a?(String)
-						response << ret
-					elsif ret == false
-						response.clear && (response.status = 404) && (response <<  ::Iodine::Http::Response::STATUS_CODES[404])
+				begin
+					if request.websocket?
+						@refuse_requests = true
+						::Iodine::Http::Websockets.handshake request, response, ::Iodine::Http.on_websocket.call(request, response)
+					else
+						ret = ::Iodine::Http.on_http.call(request, response)
+						if ret.is_a?(String)
+							response << ret
+						elsif ret == false
+							response.clear && (response.status = 404) && (response <<  ::Iodine::Http::Response::STATUS_CODES[404])
+						end
 					end
+					send_response response
+				rescue => e
+					Iodine.error e
+					send_response ::Iodine::Http::Response.new(request, 500, {},  ::Iodine::Http::Response::STATUS_CODES[500])
 				end
-				send_response response
-			rescue => e
-				Iodine.error e
-				send_response ::Iodine::Http::Response.new(request, 500, {},  ::Iodine::Http::Response::STATUS_CODES[500])
 			end
-		end
 
-		def send_headers response
-			return false if response.headers.frozen?
-			request = response.request
-			headers = response.headers
+			def send_headers response
+				return false if response.headers.frozen?
+				request = response.request
+				headers = response.headers
 
-			# response['date'.freeze] ||= request[:time_recieved].httpdate
+				# response['date'.freeze] ||= request[:time_recieved].httpdate
 
-			out = "HTTP/#{request[:version]} #{response.status} #{::Iodine::Http::Response::STATUS_CODES[response.status] || 'unknown'}\r\n"
+				out = "HTTP/#{request[:version]} #{response.status} #{::Iodine::Http::Response::STATUS_CODES[response.status] || 'unknown'}\r\n"
 
-			out << request[:time_recieved].utc.strftime("Date: %a, %d %b %Y %H:%M:%S GMT\r\n".freeze) unless headers['date'.freeze]
+				out << request[:time_recieved].utc.strftime("Date: %a, %d %b %Y %H:%M:%S GMT\r\n".freeze) unless headers['date'.freeze]
 
-			# unless @headers['connection'] || (@request[:version].to_f <= 1 && (@request['connection'].nil? || !@request['connection'].match(/^k/i))) || (@request['connection'] && @request['connection'].match(/^c/i))
-			headers.each {|k,v| out << "#{k.to_s}: #{v}\r\n"}
-			out << "Cache-Control: max-age=0, no-cache\r\n".freeze unless headers['cache-control'.freeze]
-			response.extract_cookies.each {|cookie| out << "Set-Cookie: #{cookie}\r\n"}
-			out << "\r\n"
+				# unless @headers['connection'] || (@request[:version].to_f <= 1 && (@request['connection'].nil? || !@request['connection'].match(/^k/i))) || (@request['connection'] && @request['connection'].match(/^c/i))
+				headers.each {|k,v| out << "#{k.to_s}: #{v}\r\n"}
+				out << "cache-control: max-age=0, no-cache\r\n".freeze unless headers['cache-control'.freeze]
+				response.extract_cookies.each {|cookie| out << "set-cookie: #{cookie}\r\n"}
+				out << "\r\n"
 
-			response.bytes_written += (write(out) || 0)
-			out.clear
-			headers.freeze
-			response.raw_cookies.freeze
-		end
-		def stream_data data = nil
-			 write("#{data.to_s.bytesize.to_s(16)}\r\n#{data.to_s}\r\n") || 0
-		end
+				response.bytes_written += (write(out) || 0)
+				out.clear
+				headers.freeze
+				response.raw_cookies.freeze
+			end
+			def stream_data data = nil
+				 write("#{data.to_s.bytesize.to_s(16)}\r\n#{data.to_s}\r\n") || 0
+			end
 
-		def log_finished response
-			@bytes_sent = 0
-			request = response.request
-			return if Iodine.logger.nil? || request[:no_log]
-			t_n = Time.now
-			Iodine.log("#{request[:client_ip]} [#{t_n.utc}] \"#{request[:method]} #{request[:original_path]} #{request[:scheme]}\/#{request[:version]}\" #{response.status} #{response.bytes_written.to_s} #{((t_n - request[:time_recieved])*1000).round(2)}ms\n").clear
+			def log_finished response
+				@bytes_sent = 0
+				request = response.request
+				return if Iodine.logger.nil? || request[:no_log]
+				t_n = Time.now
+				Iodine.log("#{request[:client_ip]} [#{t_n.utc}] \"#{request[:method]} #{request[:original_path]} #{request[:scheme]}\/#{request[:version]}\" #{response.status} #{response.bytes_written.to_s} #{((t_n - request[:time_recieved])*1000).round(2)}ms\n").clear
+			end
 		end
 	end
 end

data/lib/iodine/http/http2.rb

@@ -1,5 +1,5 @@
 module Iodine
-	class Http < Iodine::Protocol
+	module Http
 		class Http2 < ::Iodine::Protocol
 			def initialize io, original_request = nil
 				super(io)

data/lib/iodine/http/rack_support.rb

@@ -1,16 +1,17 @@
 module Iodine
 
-	class Http < ::Iodine::Protocol
+	module Http
 		# This (will be) a Rack handler for the Iodine HTTP server.
 		module Rack
 			module_function
 			def run(app, options = {})
 				@app = app
 
-				Iodine.protocol ||= Iodine::HTTP
 				Iodine.threads = 18
-				@pre_rack_handler = Iodine.protocol.on_http
-				Iodine.protocol.on_http self
+				Iodine.port = options[:Port]
+				Iodine.protocol ||= Iodine::Http::Http1
+				@pre_rack_handler = Iodine::Http.on_http
+				Iodine::Http.on_http self
 				true
 			end
 			def call request, response
@@ -23,10 +24,10 @@ module Iodine
 				raise "Rack app returned an unexpected value: #{res.to_s}" unless res && res.is_a?(Array)
 				response.status = res[0]
 				response.headers.clear
-				response.headers.update res[1]
+				res[1].each {|k, v| response.headers[k.to_s.downcase] = v }
 				response.body = res[2]
 				response.raw_cookies.clear
-				response.headers['Set-Cookie'] = response.headers.delete('Set-Cookie').split("\n").join("\r\nSet-Cookie: ") if response.headers['Set-Cookie']
+				response.headers['set-cookie'] = response.headers.delete('set-cookie').split("\n").join("\r\nset-cookie: ") if request[:io].is_a?(Iodine::Http::Http1) && response.headers['set-cookie']
 				response.request[:no_log] = true
 				true
 			end

data/lib/iodine/http/request.rb

@@ -1,6 +1,6 @@
 module Iodine
 
-	class Http < ::Iodine::Protocol
+	module Http
 
 		# This class is the part of the Iodine server.
 		# The request object is a Hash and the Request provides

data/lib/iodine/http/response.rb

@@ -1,7 +1,5 @@
 module Iodine
-
-	class Http < ::Iodine::Protocol
-
+	module Http
 		# this class handles Http responses.
 		#
 		# The response can be sent in stages but should complete within the scope of the connecton's message. Please notice that headers and status cannot be changed once the response started sending data.

data/lib/iodine/http/session.rb

@@ -1,5 +1,6 @@
 module Iodine
-	class Http < ::Iodine::Protocol
+	module Http
+		# session management for Iodine's Http Server
 		module SessionManager
 
 			module MemSessionStorage

data/lib/iodine/http/websocket_client.rb

@@ -1,6 +1,6 @@
 
 module Iodine
-	class Http < Iodine::Protocol
+	module Http
 		# Create a simple Websocket Client(!).
 		#
 		# This should be done from within an Iodine task, or the callbacks will not be called.

data/lib/iodine/http/websocket_handler.rb

@@ -1,6 +1,6 @@
 
 module Iodine
-	class Http < Iodine::Protocol
+	module Http
 
 		# This class is a good demonstration for creating a Websocket handler with the Iodine API.
 		#

data/lib/iodine/http/websockets.rb

@@ -1,5 +1,5 @@
 module Iodine
-	class Http < Iodine::Protocol
+	module Http
 		class Websockets < ::Iodine::Protocol
 			# initialize the websocket protocol.
 			def initialize io, handler, request, ws_extentions = nil
@@ -159,7 +159,7 @@ module Iodine
 				else
 					ws_extentions = nil
 				end
-				response['Sec-WebSocket-Accept'.freeze] = Digest::SHA1.base64digest(request['sec-websocket-key'.freeze] + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'.freeze)
+				response['sec-websocket-accept'.freeze] = Digest::SHA1.base64digest(request['sec-websocket-key'.freeze] + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'.freeze)
 				response.session
 				# Iodine.log "#{@request[:client_ip]} [#{Time.now.utc}] - #{@connection.object_id} Upgraded HTTP to WebSockets.\n"
 				response.finish

data/lib/iodine/io.rb

@@ -26,7 +26,7 @@ module Iodine
 
 	protected
 
-	@port = (ARGV.index('-p') && ARGV[ARGV.index('-p') + 1]) || ENV['PORT'] || 3000
+	@port = ((ARGV.index('-p') && ARGV[ARGV.index('-p') + 1]) || ENV['PORT'] || 3000).to_i
 	@bind = (ARGV.index('-ip') && ARGV[ARGV.index('-ip') + 1]) || ENV['IP'] || "0.0.0.0"
 	@ssl = (ARGV.index('ssl') && true) || (@port == 443)
 	@protocol = nil
@@ -75,13 +75,15 @@ module Iodine
 			def on_open
 				@protocol = Iodine.protocol
 				@ssl = Iodine.ssl
+				@accept_proc = @protocol.method(:accept)
 			end
 			def call
 				begin
 					n_io = nil
 					loop do
 						n_io = @io.accept_nonblock
-						@protocol.accept(n_io, @ssl)
+						# @protocol.accept(n_io, @ssl)
+						Iodine.run n_io, @ssl, &(@accept_proc)
 					end
 				rescue Errno::EWOULDBLOCK => e
 

data/lib/iodine/protocol.rb

@@ -175,6 +175,9 @@ module Iodine
 		# Normally you won't need to override this method.
 		def self.accept io, ssl
 			ssl ? SSLConnector.new(io, self) :  self.new(io)
+		rescue
+			io.close unless io.closed?
+			raise
 		end
 		# This methos updates the timeout "watch", signifying the IO was active.
 		def touch

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Boaz Segev