iodine 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4562f69fd3e73d156c4007d70400f07973c143ea
-  data.tar.gz: 14264f438e3e200ad52f18f63881087854da88b1
+  metadata.gz: 75cc90d10afaecdc798bdf39ec5d4a1063431faf
+  data.tar.gz: da27288f1c90ac8604c07c8f3d2ffb796c09e453
 SHA512:
-  metadata.gz: ab840a1c507e08b328b257e42038ec1dad3eaaaaad8703b1d0d1085707a20dddfb21b7e290eeec80008eb49c8beb8eb94901a17e0c9efa5648a9107c1d36d943
-  data.tar.gz: e4f5a83897e9bf8eb33225278010abc1be7bb0787eeec3eed77704b7f2f383448becad6c0b870988c77aecec5e3edba1248b1c46765376bff07cfc3f2ba9a406
+  metadata.gz: ce19f80d81def9ad8784648625007cca05a9513d6498dbff030b10a28a43e96ab7c3a54553c275393c2803b9bc5e47b47307ac03b2c1a7fc127646d396eeb017
+  data.tar.gz: 145b4f0cb2aeec486af8a09d3cf0d91819a7e97449a3bbb8a5a56e7324a2e9c4977a1a8119c52ac780a7b34b338ee8d3e934dd5a48bc0d0da757588b80e1a99a

data/README.md

@@ -1,4 +1,6 @@
 # Iodine
+[![Gem Version](https://badge.fury.io/rb/iodine.svg)](https://badge.fury.io/rb/iodine)
+[![Inline docs](http://inch-ci.org/github/boazsegev/iodine.svg?branch=master)](http://www.rubydoc.info/github/boazsegev/iodine/master/frames)
 
 Iodine makes writing Object Oriented evented server applications easy to write.
 
@@ -30,6 +32,7 @@ Iodine starts to work once you app is finished setting all the tasks up (upon ex
 
 To see how that works, open your `irb` terminal an try this:
 
+
 ```ruby
 require 'iodine'
 
@@ -62,6 +65,7 @@ To initiate this mode, simply set: `Iodine.protocol = :timers`
 
 In example:
 
+
 ```ruby
 require 'iodine'
 
@@ -83,9 +87,45 @@ exit
 
 In this mode, Iodine will continue running until it receives a kill signal (i.e. `^C`). Once the kill signal had been received, Iodine will start shutting down, allowing up to ~20-25 seconds to complete any pending tasks (timeout).
 
-## Server Usage: an Http and Websocket (as well as Rack) server
+## Server Usage: an Http and Websocket server
+
+Using Iodine and leveraging Ruby's Object Oriented approach, is super fun to write our own network protocols and servers... This is Ioding itself includes an _optional_ Http and websocket server. Say "Hello World":
+
+```ruby
+# require the 'iodine/http' module if you want to use Iodine's Http server.
+require 'iodine/http'
+# returning a string will automatically append it to the response.
+Iodine::Http.on_http = { |request, response| "Hello World!" }
+```
 
+Iodine's Http server includes experimental support for Http/2 right out of the box as well as a Websocket server.
 
+Here's a quick chatroom server (use [www.websocket.org](http://www.websocket.org/echo.html) to check it out):
+
+```ruby
+# require the 'iodine/http' module if you want to use Iodine's Websocket server.
+require 'iodine/http'
+# create an object that will follow the Iodine Websocket API.
+class WSChatServer < Iodine::Http::WebsocketHandler
+  def on_open
+     @nickname = request.params[:nickname] || "unknown"
+     broadcast "#{@nickname} has joined the chat!"
+     write "Welcome #{@nickname}, you have joined the chat!"
+  end
+  def on_message data
+     broadcast "#{@nickname} >> #{data}"
+     write ">> #{data}"
+  end
+  def on_broadcast data
+     write data
+  end
+  def on_close
+     broadcast "#{@nickname} has left the chat!"
+  end
+end
+
+Iodine::Http.on_websocket WSChatServer
+```
 
 ## Server Usage: Plug in your network protocol
 

data/lib/iodine/core.rb

@@ -25,6 +25,18 @@ module Iodine
 		self
 	end
 
+	# @return [nil] Signals Iodine to exit if it was running on Server or Timer mode. Tasks will rundown pending timeout.
+	def signal_exit
+		Process.kill("INT", 0) unless @stop
+		nil
+	end
+
+	# forces Iodine to start prematurely and asyncronously. This might case Iodine to exit abruptly, depending how the hosting application behaves.
+	def force_start!
+		thread = Thread.new { startup true }
+		Kernel.at_exit {thread.raise("stop"); thread.join}
+	end
+
 	protected
 
 	@queue = Queue.new
@@ -58,12 +70,18 @@ module Iodine
 		end
 	end
 
-	Kernel.at_exit do
+	def startup use_rescue = false, hide_message = false
 		threads = []
 		@thread_count.times { threads << Thread.new {  cycle } }
 		unless @stop
-			catch(:stop) { sleep }
-			@logger << "\nShutting down Iodine. Setting shutdown timeout to 25 seconds.\n"
+			if use_rescue
+				sleep rescue true
+			else
+				old_int_trap = trap('INT') { throw :stop; trap('INT', old_int_trap) if old_int_trap }
+				old_term_trap = trap('TERM') { throw :stop; trap('TERM', old_term_trap) if old_term_trap }
+				catch(:stop) { sleep }
+			end
+			log "\nShutting down Iodine. Setting shutdown timeout to 25 seconds.\n" unless hide_message
 			@stop = true
 			# setup exit timeout.
 			threads.each {|t| Thread.new {sleep 25; t.kill; t.kill } }
@@ -71,6 +89,10 @@ module Iodine
 		threads.each {|t| t.join rescue true }
 	end
 
+	Kernel.at_exit do
+		startup
+	end
+
 	# performed once - the shutdown sequence.
 	def shutdown
 		return if @done

data/lib/iodine/http.rb

@@ -18,7 +18,7 @@ require 'iodine/http/hpack'
 require 'iodine/http/http2'
 
 require 'iodine/http/websockets'
-# require 'iodine/http/websockets_handler'
+require 'iodine/http/websocket_handler'
 require 'iodine/http/websocket_client'
 
 require 'iodine/http/rack_support'
@@ -39,11 +39,14 @@ module Iodine
 	#
 	#       require 'iodine/http'
 	#       class WSChatServer
-	#          def initialize nickname
+	#          def initialize nickname, response
 	#              @nickname = nickname || "unknown"
+	#              @response = response
+	#              # @response.io # => Http Protocol
 	#          end
-	#          def on_open protocol
-	#              @io = protocol
+	#          def on_open
+	#              # only now is the response.io pointing at the Websocket Protocol
+	#              @io = @response.io
 	#              @io.broadcast "#{@nickname} has joined the chat!"
 	#              @io << "Welcome #{@nickname}, you have joined the chat!"
 	#          end
@@ -52,14 +55,17 @@ module Iodine
 	#              @io << ">> #{data}"
 	#          end
 	#          def on_broadcast data
-	#              @io << data
+	#              # the http response can also be used to send websocket data.
+	#              @response << data
 	#          end
 	#          def on_close
 	#              @io.broadcast "#{@nickname} has left the chat!"
 	#          end
 	#       end
 	#
-	#       Iodine::Http.on_websocket { |request, response| WSChatServer.new request.params[:name]}
+	#       Iodine::Http.on_websocket { |request, response| WSChatServer.new request.params[:name], response}
+	#
+	# See {Iodine::Http::WebsocketHandler} for a good starting point or inherit {Iodine::Http::WebsocketHandler} in your handler.
 	#
 	class Http < Iodine::Protocol
 		# Sets or gets the Http callback.
@@ -98,17 +104,23 @@ module Iodine
 		# i.e.:
 		#
 		#       require 'iodine/http'
+		#       # don't start the server
+		#       Iodine.protocol = :timer
 		#       options = {}
 		#       options[:on_open] = Proc.new { write "Hello there!"}
 		#       options[:on_message] = Proc.new do |data|
 		#           puts ">> #{data}";
 		#           write "Bye!";
 		#           # It's possible to update the callback midstream.
-		#           on_message {|data| puts "-- Goodbye message: #{data}"; close}
+		#           on_message {|data| puts "-- Goodbye message: #{data}"; close;}
 		#       end
-		#       options[:on_close] = Proc.new { puts "disconnected"}
+		#       # After closing we will call `Iodine.signal_exit` to signal Iodine to finish up.
+		#       options[:on_close] = Proc.new { puts "disconnected"; Iodine.signal_exit }
 		#       
 		#       Iodine::Http.ws_connect "ws://echo.websocket.org", options
+		#
+		#       #if running from irb:
+		#       exit
 		#     
 		def self.ws_connect url, options={}, &block
 			::Iodine.run { ::Iodine::Http::WebsocketClient.connect url, options, &block }

data/lib/iodine/http/http1.rb

@@ -121,11 +121,6 @@ module Iodine
 		HTTP_METHODS = %w{GET HEAD POST PUT DELETE TRACE OPTIONS CONNECT PATCH}
 		HTTP_METHODS_REGEXP = /\A#{HTTP_METHODS.join('|')}/i
 
-		def parse data
-			
-		end
-
-
 		def dispatch request, data
 			return data.string.clear if @io.closed? || @refuse_requests
 			::Iodine::Http::Request.parse request
@@ -209,7 +204,7 @@ module Iodine
 			request = response.request
 			return if Iodine.logger.nil? || request[:no_log]
 			t_n = Time.now
-			Iodine.logger << "#{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"
+			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

data/lib/iodine/http/http2.rb

@@ -122,6 +122,8 @@ module Iodine
 				self.new(io).on_message data
 				true
 			end
+
+			
 			protected
 
 			# logs the sent response.
@@ -129,7 +131,7 @@ module Iodine
 				request = response.request
 				return if Iodine.logger.nil? || request[:no_log]
 				t_n = Time.now
-				Iodine.logger << "#{request[:client_ip]} [#{t_n.utc}] #{request[:method]} #{request[:original_path]} #{request[:scheme]}\/2 #{response.status} #{response.bytes_written.to_s} #{((t_n - request[:time_recieved])*1000).round(2)}ms\n"
+				Iodine.log("#{request[:client_ip]} [#{t_n.utc}] #{request[:method]} #{request[:original_path]} #{request[:scheme]}\/2 #{response.status} #{response.bytes_written.to_s} #{((t_n - request[:time_recieved])*1000).round(2)}ms\n").clear
 			end
 
 			# Sends an HTTP frame with the requested payload
@@ -368,7 +370,7 @@ module Iodine
 				# Iodine.info "Should Process request #{request.select { |k,v| k != :io } }"
 				@last_stream = request[:sid] if request[:sid] > @last_stream
 				# emit_frame [HTTP_1_1_REQUIRED].pack('N'), request[:sid], 0x3, 0
-				Iodine.run request, &(::Iodine::Http::Http2.dispatch)
+				::Iodine.run request, &(::Iodine::Http::Http2.dispatch)
 
 			end
 
@@ -407,7 +409,7 @@ module Iodine
 			#
 			# @return [true, false, nil] returns true if connection handling can continue of false (or nil) for a fatal error.
 			def connection_error type
-				Iodine.warn "HTTP/2 error #{type}."
+				::Iodine.warn "HTTP/2 error #{type}."
 				go_away type
 				# case type
 				# when NO_ERROR

data/lib/iodine/http/rack_support.rb

@@ -1,6 +1,6 @@
 module Iodine
 
-	module Base
+	class Http < ::Iodine::Protocol
 		# This (will be) a Rack handler for the Iodine HTTP server.
 		module Rack
 			module_function
@@ -90,7 +90,7 @@ begin
 rescue Exception => e
 
 end
-::Rack::Handler.register( 'iodine', 'Iodine::Base::Rack') if defined?(::Rack)
+::Rack::Handler.register( 'iodine', 'Iodine::Http::Rack') if defined?(::Rack)
 
 ######
 ## example requests

data/lib/iodine/http/request.rb

@@ -332,7 +332,7 @@ module Iodine
 			# read the body's data and parse any incoming data.
 			def self.read_body request
 				# save body for Rack, if applicable
-				request[:rack_input] = StringIO.new(request[:body].dup.force_encoding(::Encoding::ASCII_8BIT)) if request[:io].params[:http_handler] == ::Iodine::Base::Rack
+				request[:rack_input] = StringIO.new(request[:body].dup.force_encoding(::Encoding::ASCII_8BIT)) if ::Iodine::Http.on_http == ::Iodine::Http::Rack
 				# parse content
 				case request['content-type'.freeze].to_s
 				when /x-www-form-urlencoded/

data/lib/iodine/http/response.rb

@@ -14,8 +14,6 @@ module Iodine
 			attr_reader :flash
 			# the response's body buffer container (an array). This object is removed once the headers are sent and all write operations hang after that point.
 			attr_accessor :body
-			# the io through which the response will be sent.
-			attr_reader :io
 			# the request.
 			attr_accessor :request
 			# Logs the number of bytes written.
@@ -34,7 +32,6 @@ module Iodine
 				@body = content || []
 				@request.cookies.set_response self
 				@cookies = {}
-				@io = request.io
 				@bytes_written = 0
 				@keep_alive = @http_sblocks_count = false
 				# propegate flash object
@@ -46,6 +43,11 @@ module Iodine
 				end
 			end
 
+			# returns the active protocol for the request.
+			def io
+				@request[:io]
+			end
+
 			# returns true if headers were already sent
 			def headers_sent?
 				@headers.frozen?
@@ -79,7 +81,7 @@ module Iodine
 				raise "Block required." unless block
 				start_streaming unless @http_sblocks_count
 				@http_sblocks_count += 1
-				@stream_proc ||= Proc.new { |block| raise "IO closed. Streaming failed." if io.io.closed?; block.call; @http_sblocks_count -= 1; finish_streaming }
+				@stream_proc ||= Proc.new { |block| raise "IO closed. Streaming failed." if request[:io].io.closed?; block.call; @http_sblocks_count -= 1; finish_streaming }
 				Iodine.run block, &@stream_proc
 			end
 
@@ -150,7 +152,7 @@ module Iodine
 			#
 			# If the headers were already sent, this will also send the data and hang until the data was sent.
 			def << str
-				( @body ? @body.push(str) : ( (@body = str.dup) && @io.stream_response(self) ) ) if str
+				( @body ? @body.push(str) : ( (@body = str.dup) && request[:io].stream_response(self) ) ) if str
 				self
 			end
 
@@ -234,12 +236,12 @@ module Iodine
 
 			# attempts to write a non-streaming response to the IO. This can be done only once and will quitely fail subsequently.
 			def finish
-				@io.send_response self
+				request[:io].send_response self
 			end
 
 			# Returns the connection's UUID.
 			def uuid
-				io.id
+				request[:io].id
 			end
 			
 			# response status codes, as defined.
@@ -338,7 +340,7 @@ module Iodine
 			def start_streaming
 				raise "Cannot start streaming after headers were sent!" if headers_sent?
 				@http_sblocks_count ||= 0
-				@io.stream_response self
+				request[:io].stream_response self
 			end
 
 			# Sends the complete response signal for a streaming response.
@@ -346,7 +348,7 @@ module Iodine
 			# Careful - sending the completed response signal more than once might case disruption to the HTTP connection.
 			def finish_streaming
 				return unless @http_sblocks_count == 0
-				@io.stream_response self, true
+				request[:io].stream_response self, true
 			end
 		end
 	end

data/lib/iodine/http/session.rb

@@ -1,78 +1,78 @@
 module Iodine
-	module Base
-		module MemSessionStorage
-			@mem_storage = {}
-			def self.fetch key
-				@mem_storage[key] ||= {}
-			end
-		end
-		module FileSessionStorage
-			class SessionObject
-				# called by the Plezi framework to initiate a session with the id requested
-				def initialize id
-					@filename = File.join Dir.tmpdir, "iodine_#{Iodine::Http.session_token}_#{id}"
-					@data ||= {}
-				end
-				# Get a key from the session data store.
-				#
-				# Due to different considirations, all keys will be converted to strings, so that `"name" == :name` and `1234 == "1234"`.
-				# If you store two keys that evaluate as the same string, they WILL override each other.
-				def [] key
-					key = key.to_s
-					load
-					@data[key]
-				end
-				alias :fetch :[]
+	class Http < ::Iodine::Protocol
+		module SessionManager
 
-				# Stores a key in the session's data store.
-				#
-				# Due to different considirations, all keys will be converted to strings, so that `"name" == :name` and `1234 == "1234"`.
-				# If you store two keys that evaluate as the same string, they WILL override each other.
-				def []= key, value
-					key = key.to_s
-					load
-					@data[key] = value
-					save
-					value
+			module MemSessionStorage
+				@mem_storage = {}
+				def self.fetch key
+					@mem_storage[key] ||= {}
 				end
-				alias :store :[]=
+			end
+			module FileSessionStorage
+				class SessionObject
+					# called by the Plezi framework to initiate a session with the id requested
+					def initialize id
+						@filename = File.join Dir.tmpdir, "iodine_#{Iodine::Http.session_token}_#{id}"
+						@data ||= {}
+					end
+					# Get a key from the session data store.
+					#
+					# Due to different considirations, all keys will be converted to strings, so that `"name" == :name` and `1234 == "1234"`.
+					# If you store two keys that evaluate as the same string, they WILL override each other.
+					def [] key
+						key = key.to_s
+						load
+						@data[key]
+					end
+					alias :fetch :[]
 
-				# @return [Hash] returns a shallow copy of the current session data as a Hash.
-				def to_h
-					load
-					@data.dup
-				end
+					# Stores a key in the session's data store.
+					#
+					# Due to different considirations, all keys will be converted to strings, so that `"name" == :name` and `1234 == "1234"`.
+					# If you store two keys that evaluate as the same string, they WILL override each other.
+					def []= key, value
+						key = key.to_s
+						load
+						@data[key] = value
+						save
+						value
+					end
+					alias :store :[]=
 
-				# Removes a key from the session's data store.
-				def delete key
-					load
-					ret = @data.delete key
-					save
-					ret
-				end
+					# @return [Hash] returns a shallow copy of the current session data as a Hash.
+					def to_h
+						load
+						@data.dup
+					end
 
-				# Clears the session's data.
-				def clear
-					@data.clear
-					save
-					nil
-				end
-				protected
-				def save
-					# save data to tmp-file
-					IO.write @filename, @data.to_yaml
+					# Removes a key from the session's data store.
+					def delete key
+						load
+						ret = @data.delete key
+						save
+						ret
+					end
+
+					# Clears the session's data.
+					def clear
+						@data.clear
+						save
+						nil
+					end
+					protected
+					def save
+						# save data to tmp-file
+						IO.write @filename, @data.to_yaml
+					end
+					def load
+						@data = YAML.load IO.read(@filename) if File.exists?(@filename)
+					end
 				end
-				def load
-					@data = YAML.load IO.read(@filename) if File.exists?(@filename)
+				def self.fetch key
+					SessionObject.new key
 				end
 			end
-			def self.fetch key
-				SessionObject.new key
-			end
-		end
-	end
-	class Http < Iodine::Protocol
-		module SessionManager
+
 			module_function
 			# returns a session object
 			def get id
@@ -89,9 +89,9 @@ module Iodine
 			def storage= session_storage = nil
 				case session_storage
 				when :file, nil
-					@storage = Iodine::Base::FileSessionStorage
+					@storage = Iodine::Http::SessionManager::FileSessionStorage
 				when :mem
-					@storage = Iodine::Base::MemSessionStorage
+					@storage = Iodine::Http::SessionManager::MemSessionStorage
 				else
 					@storage = session_storage
 				end
@@ -99,7 +99,7 @@ module Iodine
 
 			# returns the current session storage system.
 			def storage
-				@storage ||= Iodine::Base::FileSessionStorage
+				@storage ||= Iodine::Http::SessionManager::FileSessionStorage
 			end
 		end
 	end