iodine 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 015d21e31dd393be87f10ecb19fe9d94f565255c
-  data.tar.gz: 8919757b4d844e02b110496fff6d8e84dc87f60f
+  metadata.gz: 0b1ab6392f66ca513bb10c39e27ede18cf3588f8
+  data.tar.gz: 138fe6afa9327403a8811d036dccc5f3d91b66b9
 SHA512:
-  metadata.gz: 6198a6eaa862ce000905693bad9afb670359ab20b80987713f95df11eefe8d1b951f243f761bac2546701eb10c215e5cea157f215eb3fd48f4bc229d50927e6a
-  data.tar.gz: e96c344aad2a559a5af5b4f2f6365f876335ad3fc741f5cf212eede1002ec3a87751dc78f51d3b0228fdf16d729369f05cde90aaa573af521e25315fb5086ff4
+  metadata.gz: 79797e0676d69aa78131e911b65d88fd1dd65305dc39d1ee62f4aecbeab96ae4d80ee021d01d337e78a84ddce23ac8a3dcebc03a9934df88f9168e1b4b2bb4e6
+  data.tar.gz: 16a7dfe4bfc94c03718ab69c40f8ea207a7f5ea57c986b118da08eb7afc144554266cfe42a88760a555cc69ea65ddb16081e9830cba8c74e1b3ca8fd1a7946d3

data/CHANGELOG.md

@@ -8,6 +8,16 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ***
 
+Change log v.0.1.9
+
+**Fix**: WebsocketClient connection renewal will now keep the same WebsocketClient instance object.
+
+**Update** Creating a TimedEvent before Iodine starts running will automatically 'nudge' Iodine into "Task polling" mode, cycling until the user signals a stop.
+
+**Update**: repeatedly calling `Iodine.force_start!` will now be ignored, as might have been expected. Once Iodine had started, `force_start!` cannot be called until Iodine had finished (and even than, Iodine might never be as fresh nor as young as it was).
+
+***
+
 Change log v.0.1.8
 
 **Fix**: Websocket broadcasts are now correctly executed within the IO's mutex locker. This maintains the idea that only one thread at a time should be executing code on behald of any given Protocol object ("yes" to concurrency between objects but "no" to concurrency within objects).

data/README.md

@@ -62,7 +62,7 @@ In this mode, Iodine will continue running until all the tasks have completed an
 
 This mode of operation is effective if want Iodine to periodically initiates new tasks, for instance if you cannot use `cron`.
 
-To initiate this mode, simply set: `Iodine.protocol = :timers`
+To initiate this mode, simply set: `Iodine.protocol = :timers` OR create a TimedEvent.
 
 In example:
 
@@ -260,6 +260,8 @@ Iodine applies this concept when running in Server mode by locking the Protocol
 
 For instance, in Iodine's implementation for the Websocket protocol: Websocket messages to different connections can run concurrently, however multiple messages to the same connection are only executed one at a time, maintaining their order (lately a fix in version 0.1.8 made sure that also websocket broadcasting will be executed within the Protocol lock, preventing concurrency within the same connection).
 
+The exception to the rule is the `ping` implementation. Your protocol's `ping` method will execute in parallel with other parts of your protocol's code. Pinging is a machanism that is often time sensitive and is required to maintain an open connection. For this reason, if your code is working hard on a long task, a ping will still occure automatically in the background and offset any connection timeout. 
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/iodine.rb

@@ -1,7 +1,17 @@
 require 'logger'
 require 'socket'
 require 'openssl'
-# require 'securerandom'
+
+require "iodine/version"
+require "iodine/settings"
+require "iodine/logging"
+require "iodine/core"
+require "iodine/timers"
+require "iodine/protocol"
+require "iodine/ssl_connector"
+require "iodine/io"
+require "iodine/core_init"
+
 
 
 # Iodine is an easy Object-Oriented library for writing network applications (servers) with your own
@@ -57,13 +67,5 @@ module Iodine
 end
 
 
-require "iodine/version"
-require "iodine/settings"
-require "iodine/logging"
-require "iodine/core"
-require "iodine/timers"
-require "iodine/protocol"
-require "iodine/ssl_connector"
-require "iodine/io"
 
 # require 'iodine/http'

data/lib/iodine/core.rb

@@ -31,29 +31,26 @@ module Iodine
 		nil
 	end
 
-	# forces Iodine to start prematurely and asyncronously. This might case Iodine to exit abruptly, depending how the hosting application behaves.
+	# forces Iodine to start prematurely and asyncronously. This might cause Iodine's exit sequence to end abruptly, depending how the hosting application behaves.
+	#
+	# calling this method repeatedly will be ignored unless Iodine's threads have all died.
+	#
+	# @return [Iodine] the method will allways return `self` (Iodine).
 	def force_start!
-		thread = Thread.new { startup true }
+		return self if @force_running
+		@force_running = true
+		thread = Thread.new do
+			startup true
+			@force_running = false
+			initialize_tasks
+			@stop = false if @protocol
+		end
 		Kernel.at_exit {thread.raise("stop"); thread.join}
 		self
 	end
 
 	protected
 
-	@queue = Queue.new
-	@shutdown_queue = Queue.new
-	@stop = true
-	@done = false
-	@logger = Logger.new(STDOUT)
-	@spawn_count = 1
-	@thread_count = nil
-	@ios = {}
-	@io_in = Queue.new
-	@io_out = Queue.new
-	@shutdown_mutex = Mutex.new
-	@servers = {}
-
-
 	def cycle
 		work until @stop && @queue.empty?
 		@shutdown_mutex.synchronize { shutdown }
@@ -73,17 +70,18 @@ module Iodine
 	end
 
 	def startup use_rescue = false, hide_message = false
+		@force_running = true
 		threads = []
 		(@thread_count ||= 1).times { threads << Thread.new {  cycle } }
 		unless @stop
 			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 }
+				old_int_trap = trap('INT') { throw :stop; old_int_trap.respond_to?(:call) && old_int_trap.call }
+				old_term_trap = trap('TERM') { throw :stop; old_term_trap.respond_to?(:call) && old_term_trap.call }
 				catch(:stop) { sleep }
 			end
-			log "\nShutting down Iodine. Setting shutdown timeout to 25 seconds.\n" unless hide_message
+			log "\nShutting down #{self == Iodine ? 'Iodine' : "#{self.name} (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 } }
@@ -91,10 +89,6 @@ 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/core_init.rb

@@ -0,0 +1,143 @@
+module Iodine
+	protected
+
+	def extended base
+		base.instance_exec do
+			initialize_core
+			initialize_io
+			initialize_timers
+			initialize_tasks
+		end
+		base.protocol = :cycle unless base == Iodine
+	end
+
+	def initialize_core
+		# initializes all the core components
+		# referenced in `core.rb`
+		@queue = Queue.new
+		@shutdown_queue = Queue.new
+		@stop = true
+		@done = false
+		@logger = Logger.new(STDOUT)
+		@spawn_count = 1
+		@thread_count = nil
+		@ios = {}
+		@io_in = Queue.new
+		@io_out = Queue.new
+		@shutdown_mutex = Mutex.new
+		@servers = {}
+		Kernel.at_exit do
+			if self == Iodine
+				startup
+			else
+				Iodine.protocol ||= :cycle if @timers.any? || @protocol
+				thread = Thread.new { startup true }
+				Iodine.on_shutdown { thread.raise 'stop' ; thread.join }
+			end
+		end
+	end
+
+	def initialize_io
+		# initializes all the IO components
+		# referenced in `io.rb`
+		@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
+		@ssl_context = nil
+		@ssl_protocols = {}
+		@time = Time.now
+
+		@timeout_proc = Proc.new {|prot| prot.timeout?(@time) }
+		@status_loop = Proc.new {|io|  @io_out << io if io.closed? || !(io.stat.readable? rescue false) }
+		@close_callback = Proc.new {|prot| prot.on_close if prot }
+		@reactor = [ (Proc.new do
+			if @queue.empty?
+				#clear any closed IO objects.
+				@time = Time.now
+				@ios.keys.each &@status_loop
+				@ios.values.each &@timeout_proc
+				until @io_in.empty?
+					n_io = @io_in.pop
+					@ios[n_io[0]] = n_io[1]
+				end
+				until @io_out.empty?
+					o_io = @io_out.pop
+					o_io.close unless o_io.closed?
+					run @ios.delete(o_io), &@close_callback
+				end
+				# react to IO events
+				begin
+					r = IO.select(@ios.keys, nil, nil, 0.15)
+					r[0].each {|io| @queue << [@ios[io]] } if r
+				rescue => e
+					
+				end
+				unless @stop && @queue.empty?
+					# @ios.values.each &@timeout_loop
+					@check_timers && (@queue << @check_timers)
+					@queue << @reactor
+				end
+			else
+				@queue << @reactor
+			end
+		end )]
+	end
+
+	def initialize_timers
+		@timer_locker = Mutex.new
+		@timers = []
+		# cycles through timed jobs, executing and/or deleting them if their time has come.
+		@check_timers = [(Proc.new do
+			@timer_locker.synchronize { @timers.delete_if {|t| t.done? } }
+		end)]
+	end
+
+	def initialize_tasks
+		# initializes actions to be taken when starting to run
+		run do
+			@protocol ||= :cycle if @timers.any?
+			next unless @protocol
+			if @protocol.is_a?( ::Class ) && @protocol.ancestors.include?( ::Iodine::Protocol )
+				begin
+					@server = ::TCPServer.new(@bind, @port)
+				rescue => e
+					fatal e.message
+					fatal "Running existing tasks and exiting."
+					@queue << @reactor
+					Process.kill("INT", 0)
+					next
+				end
+				on_shutdown do
+					log "Stopping to listen on port #{@port} and shutting down.\n"
+					@server.close unless @server.closed?
+				end
+				::Iodine::Base::Listener.accept(@server, false)
+				log "Iodine #{VERSION} is listening on port #{@port}#{ ' to SSL/TLS connections.' if @ssl}\n"
+				if @spawn_count && @spawn_count.to_i > 1 && Process.respond_to?(:fork)
+					log "Server will run using #{@spawn_count.to_i} processes - Spawning #{@spawn_count.to_i - 1 } more processes.\n"
+					(@spawn_count.to_i - 1).times do
+						Process.fork do
+							log "Spawned process: #{Process.pid}.\n"
+							on_shutdown { log "Shutting down process #{Process.pid}.\n" }
+							@queue.clear
+							@queue << @reactor
+							startup false, true
+						end
+					end
+					
+				end
+				log "Press ^C to stop the server.\n"
+			else
+				log "#{self == Iodine ? 'Iodine' : "#{self.name} (Iodine)"} #{VERSION} is running.\n"
+				log "Press ^C to stop the cycling.\n"
+			end
+			on_shutdown do
+				shut_down_proc = Proc.new {|prot| prot.on_shutdown ; prot.close }
+				@ios.values.each {|p| run p, &shut_down_proc }
+				@queue << @reactor
+			end
+			@queue << @reactor
+		end
+	end
+end

data/lib/iodine/http/rack_support.rb

@@ -6,10 +6,7 @@ module Iodine
 			module_function
 			def run(app, options = {})
 				@app = app
-
-				puts "reading threads = #{Iodine.threads.to_s}"
-
-				Iodine.threads = 18 unless Iodine.threads
+				Iodine.threads ||= 18
 				Iodine.port = options[:Port]
 				Iodine.protocol ||= Iodine::Http::Http1
 				@pre_rack_handler = Iodine::Http.on_http unless Iodine::Http.on_http == Iodine::Http::NOT_IMPLEMENTED

data/lib/iodine/http/websocket_client.rb

@@ -10,15 +10,19 @@ module Iodine
 		
 			attr_accessor :response, :request, :params
 
-			def initialize request
+			def initialize options
 				@response = nil
-				@request = request
-				@params = request[:ws_client_params]
-				@on_message = @params[:on_message]
+				@options = options
+				@on_message = @options[:on_message]
 				raise "Websocket client must have an #on_message Proc or handler." unless @on_message && @on_message.respond_to?(:call)
-				@on_open = @params[:on_open]
-				@on_close = @params[:on_close]
-				@renew = @params[:renew].to_i
+				@on_open = @options[:on_open]
+				@on_close = @options[:on_close]
+				@on_error = @options[:on_error]
+				@renew = @options[:renew].to_i
+				@options[:url] = URI.parse(@options[:url]) unless @options[:url].is_a?(URI)
+				@connection_lock = Mutex.new
+				raise TypeError, "Websocket Client `:send` should be either a String or a Proc object." if @options[:send] && !(@options[:send].is_a?(String) || @options[:send].is_a?(Proc))
+				on_close && (@io || raise("Connection error, cannot create websocket client")) unless connect
 			end
 
 			def on event_name, &block
@@ -39,17 +43,25 @@ module Iodine
 					@on_message = block if block
 					return @on_message
 				end
-				instance_exec( data, &@on_message) 
+				begin
+					instance_exec( data, &@on_message) 
+				rescue => e
+					@on_error ? @on_error.call(e) : raise(e)
+				end
 			end
 
 			def on_open
 				raise 'The on_open even is invalid at this point.' if block_given?
+				@renew = @options[:renew].to_i
 				@io = @request[:io]
 				Iodine::Http::Request.parse @request
-				instance_exec(&@on_open) if @on_open
-				if request[:ws_client_params][:every] && @params[:send]
-					raise TypeError, "Websocket Client `:send` should be either a String or a Proc object." unless @params[:send].is_a?(String) || @params[:send].is_a?(Proc)
-					Iodine.run_every @params[:every], self, @params do |ws, client_params, timer|
+				begin
+					instance_exec(&@on_open) if @on_open
+				rescue => e
+					@on_error ? @on_error.call(e) : raise(e)
+				end
+				if @options[:every] && @options[:send]
+					Iodine.run_every @options[:every], self, @options do |ws, client_params, timer|
 						if ws.closed?
 							timer.stop!
 							next
@@ -57,7 +69,11 @@ module Iodine
 						if client_params[:send].is_a?(String)
 							ws.write client_params[:send]
 						elsif client_params[:send].is_a?(Proc)
-							ws.instance_exec(&client_params[:send])
+							begin
+								ws.instance_exec(&client_params[:send])
+							rescue => e
+								@on_error ? @on_error.call(e) : raise(e)
+							end							
 						end
 					end
 				end
@@ -67,25 +83,35 @@ module Iodine
 				return @on_close = block if block
 				if @renew > 0
 					renew_proc = Proc.new do
+						@io = nil
 						begin
-							Iodine::Http::WebsocketClient.connect(@params[:url], @params)
+							raise unless connect
 						rescue
 							@renew -= 1
 							if @renew <= 0
-								Iodine.fatal "WebsocketClient renewal FAILED for #{@params[:url]}"
-								instance_exec(&@on_close) if @on_close
+								Iodine.fatal "WebsocketClient renewal FAILED for #{@options[:url]}"
+								on_close
 							else
-								Iodine.run_after 2, &renew_proc
-								Iodine.warn "WebsocketClient renewal failed for #{@params[:url]}, #{@renew} attempts left"
+								Iodine.warn "WebsocketClient renewal failed for #{@options[:url]}, #{@renew} attempts left"
+								renew_proc.call
 							end
 							false
 						end
 					end
-					renew_proc.call
+					@connection_lock.synchronize { renew_proc.call }
 				else
-					instance_exec(&@on_close) if @on_close
+					begin
+						instance_exec(&@on_close) if @on_close
+					rescue => e
+						@on_error ? @on_error.call(e) : raise(e)
+					end
 				end
 			end
+			def on_error(error = nil, &block)
+				return @on_error = block if block
+				instance_exec(error, &@on_error) if @on_error
+				on_close unless @io # if the connection was initialized, :on_close will be called by Iodine
+			end
 
 			def on_shutdown
 				@renew = 0
@@ -120,7 +146,6 @@ module Iodine
 			# @return [true, false] Returns the true if the data was actually sent or nil if no data was sent.
 			def write data, op_code = nil, fin = true, ext = 0
 				return false if !data || data.empty?
-				return false if @io.closed?
 				data = data.dup # needed?
 				unless op_code # apply extenetions to the message as a whole
 					op_code = (data.encoding == ::Encoding::UTF_8 ? 1 : 2) 
@@ -129,8 +154,8 @@ module Iodine
 				byte_size = data.bytesize
 				if byte_size > (::Iodine::Http::Websockets::FRAME_SIZE_LIMIT+2)
 					sections = byte_size/FRAME_SIZE_LIMIT + (byte_size % ::Iodine::Http::Websockets::FRAME_SIZE_LIMIT ? 1 : 0)
-					send_data( data.slice!( 0...::Iodine::Http::Websockets::FRAME_SIZE_LIMIT ), op_code, data.empty?, ext) && (ext = op_code = 0) until data.empty?
-					return true # avoid sending an empty frame.
+					ret = write( data.slice!( 0...::Iodine::Http::Websockets::FRAME_SIZE_LIMIT ), op_code, data.empty?, ext) && (ext = op_code = 0) until data.empty?
+					return ret # avoid sending an empty frame.
 				end
 				# @ws_extentions.each { |ex| ext |= ex.edit_frame data } if @ws_extentions
 				header = ( (fin ? 0b10000000 : 0) | (op_code & 0b00001111) | ext).chr.force_encoding(::Encoding::ASCII_8BIT)
@@ -147,74 +172,22 @@ module Iodine
 				@@make_mask_proc ||= Proc.new {Random.rand(251) + 1}
 				mask = Array.new(4, &(@@make_mask_proc))
 				header << mask.pack('C*'.freeze)
-				@io.write header
-				i = -1;
-				@io.write(data.bytes.map! {|b| (b ^ mask[i = (i + 1)%4]) } .pack('C*'.freeze)) && true
+				@connection_lock.synchronize do
+					return false if @io.nil? || @io.closed?
+					@io.write header
+					i = -1;
+					@io.write(data.bytes.map! {|b| (b ^ mask[i = (i + 1)%4]) } .pack('C*'.freeze)) && true
+				end
 			end
 			alias :<< :write
 
-			# 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 the connection's details (i.e. ssl etc') and the Websocket callbacks (i.e. on_open(ws), on_close(ws), on_message(ws))
-			# &block:: an optional block that accepts one parameter (data) and will be used as the `#on_message(data)`
-			#
-			# Acceptable options are:
-			# on_open:: the on_open callback. Must be an objects that answers `call(ws)`, usually a Proc.
-			# on_message:: the on_message callback. Must be an objects that answers `call(ws)`, usually a Proc.
-			# on_close:: the on_close callback - this will ONLY be called if the connection WASN'T renewed. Must be an objects that answers `call(ws)`, usually a Proc.
-			# headers:: a Hash of custom HTTP headers to be sent with the request. Header data, including cookie headers, should be correctly encoded.
-			# cookies:: a Hash of cookies to be sent with the request. cookie data will be encoded before being sent.
-			# timeout:: the number of seconds to wait before the connection is established. Defaults to 5 seconds.
-			# every:: this option, together with `:send` and `:renew`, implements a polling websocket. :every is the number of seconds between each polling event. without `:send`, this option will be ignored. defaults to nil.
-			# send:: a String to be sent or a Proc to be performed each polling interval. This option, together with `:every` and `:renew`, implements a polling websocket. without `:every`, this option will be ignored. defaults to nil. If `:send` is a Proc, it will be executed within the context of the websocket client object, with acess to the websocket client's instance variables and methods.
-			# renew:: the number of times to attempt to renew the connection if the connection is terminated by the remote server. Attempts are made in 2 seconds interval. The default for a polling websocket is 5 attempts to renew. For all other clients, the default is 0 (no renewal).
-			#
-			# The method will block until the connection is established or until 5 seconds have passed (the timeout). The method will either return a WebsocketClient instance object or raise an exception it the connection was unsuccessful.
-			#
-			# Use Iodine::Http.ws_connect for a non-blocking initialization.
-			#
-			# An #on_close callback will only be called if the connection isn't or cannot be renewed. If the connection is renewed,
-			# the #on_open callback will be called again for a new Websocket client instance - but the #on_close callback will NOT be called.
-			#
-			# Due to this design, the #on_open and #on_close methods should NOT be used for opening IO resources (i.e. file handles) nor for cleanup IF the `:renew` option is enabled.
-			#
-			# An on_message Proc must be defined, or the method will fail.
-			#
-			# The on_message Proc can be defined using the optional block:
-			#
-			#      Iodine::Http::WebsocketClient.connect("ws://localhost:3000/") {|data| write data} #echo example
-			#
-			# OR, the on_message Proc can be defined using the options Hash: 
-			#
-			#      Iodine::Http::WebsocketClient.connect("ws://localhost:3000/", on_open: -> {}, on_message: -> {|data| write data })
-			#
-			# The #on_message(data), #on_open and #on_close methods will be executed within the context of the WebsocketClient
-			# object, and will have native acess to the Websocket response object.
-			#
-			# After the WebsocketClient had been created, it's possible to update the #on_message and #on_close 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 vulnerable to a possible man in the middle attack.
-			#
-			# @return [Iodine::Http::WebsocketClient] this method returns the connected {Iodine::Http::WebsocketClient} or raises an exception if something went wrong (such as a connection timeout).
-			def self.connect url, options={}, &block
+			protected
+
+			def connect
+				return false if @io && !@io.closed?
 				socket = nil
-				options = options.dup
-				options[:on_message] ||= block
-				raise "No #on_message handler defined! please pass a block or define an #on_message handler!" unless options[:on_message]
-				url = URI.parse(url) unless url.is_a?(URI)
-				options[:url] = url
-				options[:renew] ||= 5 if options[:every] && options[:send]
+				url = @options[:url]
+				@options[:renew] ||= 5 if @options[:every] && @options[:send]
 
 				ssl = url.scheme == "https" || url.scheme == "wss"
 
@@ -225,33 +198,32 @@ module Iodine
 					context = OpenSSL::SSL::SSLContext.new
 					context.cert_store = OpenSSL::X509::Store.new
 					context.cert_store.set_default_paths
-					context.set_params verify_mode: (options[:verify_mode] || OpenSSL::SSL::VERIFY_NONE) # OpenSSL::SSL::VERIFY_PEER #OpenSSL::SSL::VERIFY_NONE
+					context.set_params verify_mode: (@options[:verify_mode] || OpenSSL::SSL::VERIFY_NONE) # OpenSSL::SSL::VERIFY_PEER #OpenSSL::SSL::VERIFY_NONE
 					ssl = OpenSSL::SSL::SSLSocket.new(socket, context)
 					ssl.sync_close = true
 					ssl.connect
 				end
 				# prep custom headers
 				custom_headers = ''
-				custom_headers = options[:headers] if options[:headers].is_a?(String)
-				options[:headers].each {|k, v| custom_headers << "#{k.to_s}: #{v.to_s}\r\n"} if options[:headers].is_a?(Hash)
-				options[:cookies].each {|k, v| raise 'Illegal cookie name' if k.to_s.match(/[\x00-\x20\(\)<>@,;:\\\"\/\[\]\?\=\{\}\s]/); custom_headers << "Cookie: #{ k }=#{ Iodine::Http::Request.encode_url v }\r\n"} if options[:cookies].is_a?(Hash)
+				custom_headers = @options[:headers] if @options[:headers].is_a?(String)
+				@options[:headers].each {|k, v| custom_headers << "#{k.to_s}: #{v.to_s}\r\n"} if @options[:headers].is_a?(Hash)
+				@options[:cookies].each {|k, v| raise 'Illegal cookie name' if k.to_s.match(/[\x00-\x20\(\)<>@,;:\\\"\/\[\]\?\=\{\}\s]/); custom_headers << "Cookie: #{ k }=#{ Iodine::Http::Request.encode_url v }\r\n"} if @options[:cookies].is_a?(Hash)
 
 				# send protocol upgrade request
 				websocket_key = [(Array.new(16) {rand 255} .pack 'c*' )].pack('m0*')
-				(ssl || socket).write "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\nOrigin: #{options[:ssl_client] ? 'https' : 'http'}://#{url.host}\r\nSec-WebSocket-Key: #{websocket_key}\r\nSec-WebSocket-Version: 13\r\n#{custom_headers}\r\n"
+				(ssl || socket).write "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\nOrigin: #{ssl ? 'https' : 'http'}://#{url.host}\r\nSec-WebSocket-Key: #{websocket_key}\r\nSec-WebSocket-Version: 13\r\n#{custom_headers}\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(::Encoding::ASCII_8BIT)
-				stop_time = Time.now + (options[:timeout] || 5)
+				stop_time = Time.now + (@options[:timeout] || 5)
 				stop_reply = "\r\n\r\n"
-				sleep 0.2
 				until reply[-4..-1] == stop_reply
 					begin
 						reply << ( ssl ? ssl.read_nonblock(1) : socket.recv_nonblock(1) )
-					rescue Errno::EWOULDBLOCK => e
+					rescue Errno::EWOULDBLOCK, OpenSSL::SSL::SSLErrorWaitReadable => e
 						raise "Websocket client handshake timed out (HTTP reply not recieved)\n\n Got Only: #{reply}" if Time.now >= stop_time
-						IO.select [socket], nil, nil, (options[:timeout] || 5)
+						IO.select [socket], nil, nil, (@options[:timeout] || 5)
 						retry
 					end
 					raise "Connection failed" if socket.closed?
@@ -260,22 +232,22 @@ module Iodine
 				raise "Connection Refused. Reply was:\r\n #{reply}" 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')
 				# read the body's data and parse any incoming data.
-				request = Iodine::Http::Request.new
-				request[:method] = 'GET'
-				request['host'] = "#{url.host}:#{url.port}"
-				request[:query] = url.path
-				request[:version] = '1.1'
+				@request = Iodine::Http::Request.new
+				@request[:method] = 'GET'
+				@request['host'] = "#{url.host}:#{url.port}"
+				@request[:query] = url.path
+				@request[:version] = '1.1'
 				reply = StringIO.new reply
 				reply.gets
 
 				until reply.eof?
-					until request[:headers_complete] || (l = reply.gets).nil?
+					until @request[:headers_complete] || (l = reply.gets).nil?
 						if l.include? ':'
 							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])
+							@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
+							@request[:headers_complete] = true
 						else
 							#protocol error
 							raise 'Protocol Error, closing connection.'
@@ -285,15 +257,80 @@ module Iodine
 				end
 				reply.string.clear
 
-				request[:ws_client_params] = options
-				client = self.new(request)
-				Iodine::Http::Websockets.new( ( ssl || socket), handler: client, request: request )
+				return Iodine::Http::Websockets.new( ( ssl || socket), handler: self, request: @request )
 
-				return client	
+			rescue => e
+				(ssl || socket).tap {|io| next if io.nil?; io.close unless io.closed?}
+				if @options[:on_error]
+					@options[:on_error].call(e)
+					return false
+				end
+				raise e unless @io
+			end
 
-				rescue => e
-					(ssl || socket).tap {|io| next if io.nil?; io.close unless io.closed?}
-					raise e
+			# 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 the connection's details (i.e. ssl etc') and the Websocket callbacks (i.e. on_open(ws), on_close(ws), on_message(ws))
+			# &block:: an optional block that accepts one parameter (data) and will be used as the `#on_message(data)`
+			#
+			# Acceptable options are:
+			# on_open:: the on_open callback - Must be an objects that answers `call()`, usually a Proc.
+			# on_message:: the on_message callback - Must be an objects that answers `call(data)`, usually a Proc.
+			# on_close:: the on_close callback - Must be an objects that answers `call()`, usually a Proc. The method is called when the connection is closed and isn't renewed.
+			# on_error:: the on_error callback - Must be an objects that answers `call(err)`, usually a Proc. This is called whenever a connection fails to be established or an exception is raised by any of the callbacks. This is NOT the disconnection websocket message. dafaults to raising the error (error pass-through).
+			# headers:: a Hash of custom HTTP headers to be sent with the request. Header data, including cookie headers, should be correctly encoded.
+			# cookies:: a Hash of cookies to be sent with the request. cookie data will be encoded before being sent.
+			# timeout:: the number of seconds to wait before the connection is established. Defaults to 5 seconds.
+			# every:: this option, together with `:send` and `:renew`, implements a polling websocket. :every is the number of seconds between each polling event. without `:send`, this option will be ignored. defaults to nil.
+			# send:: a String to be sent or a Proc to be performed each polling interval. This option, together with `:every` and `:renew`, implements a polling websocket. without `:every`, this option will be ignored. defaults to nil. If `:send` is a Proc, it will be executed within the context of the websocket client object, with acess to the websocket client's instance variables and methods.
+			# renew:: the number of times to attempt to renew the connection if the connection is terminated by the remote server. Attempts are made in 2 seconds interval. The default for a polling websocket is 5 attempts to renew. For all other clients, the default is 0 (no renewal).
+			#
+			# The method will block until the connection is established or until 5 seconds have passed (the timeout). The method will either return a WebsocketClient instance object or raise an exception it the connection was unsuccessful.
+			#
+			# Use Iodine::Http.ws_connect for a non-blocking initialization.
+			#
+			# An #on_close callback will only be called if the connection isn't or cannot be renewed. If the connection is renewed,
+			# the #on_open callback will be called again for a new Websocket client instance - but the #on_close callback will NOT be called.
+			#
+			# Due to this design, the #on_open and #on_close methods should NOT be used for opening IO resources (i.e. file handles) nor for cleanup IF the `:renew` option is enabled.
+			#
+			# An on_message Proc must be defined, or the method will fail.
+			#
+			# The on_message Proc can be defined using the optional block:
+			#
+			#      Iodine::Http::WebsocketClient.connect("ws://localhost:3000/") {|data| write data} #echo example
+			#
+			# OR, the on_message Proc can be defined using the options Hash: 
+			#
+			#      Iodine::Http::WebsocketClient.connect("ws://localhost:3000/", on_open: -> {}, on_message: -> {|data| write data })
+			#
+			# The #on_message(data), #on_open and #on_close methods will be executed within the context of the WebsocketClient
+			# object, and will have native acess to the Websocket response object.
+			#
+			# After the WebsocketClient had been created, it's possible to update the #on_message and #on_close 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 vulnerable to a possible man in the middle attack.
+			#
+			# @return [Iodine::Http::WebsocketClient] this method returns the connected {Iodine::Http::WebsocketClient} or raises an exception if something went wrong (such as a connection timeout).
+			def self.connect url, options={}, &block
+				options = url if url.is_a?(Hash) && options.empty?
+				options[:renew] ||= 5 if options[:every] && options[:send]
+				options[:url] ||= url
+				options[:on_message] ||= block
+				client = self.new(options)
+				return client unless client.closed?
+				false
 			end
 		end
 	end

data/lib/iodine/io.rb

@@ -26,48 +26,6 @@ module Iodine
 
 	protected
 
-	@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
-	@ssl_context = nil
-	@ssl_protocols = {}
-	@time = Time.now
-
-	@timeout_proc = Proc.new {|prot| prot.timeout?(@time) }
-	@status_loop = Proc.new {|io|  @io_out << io if io.closed? || !(io.stat.readable? rescue false) }
-	@close_callback = Proc.new {|prot| prot.on_close if prot }
-	REACTOR = [ (Proc.new do
-		if @queue.empty?
-			#clear any closed IO objects.
-			@time = Time.now
-			@ios.keys.each &@status_loop
-			@ios.values.each &@timeout_proc
-			until @io_in.empty?
-				n_io = @io_in.pop
-				@ios[n_io[0]] = n_io[1]
-			end
-			until @io_out.empty?
-				o_io = @io_out.pop
-				o_io.close unless o_io.closed?
-				run @ios.delete(o_io), &@close_callback
-			end
-			# react to IO events
-			begin
-				r = IO.select(@ios.keys, nil, nil, 0.15)
-				r[0].each {|io| @queue << [@ios[io]] } if r
-			rescue => e
-				
-			end
-			unless @stop && @queue.empty?
-				# @ios.values.each &@timeout_loop
-				@check_timers && (@queue << @check_timers)
-				@queue << REACTOR
-			end
-		else
-			@queue << REACTOR
-		end
-	end )]
 	# internal helper methods and classes.
 	module Base
 		# the server listener Protocol.
@@ -95,50 +53,4 @@ module Iodine
 			end
 		end
 	end
-
-	########
-	## remember to set traps (once) when 'listen' is called.
-	run do
-		next unless @protocol
-		if @protocol.is_a?( ::Class ) && @protocol.ancestors.include?( ::Iodine::Protocol )
-			begin
-				@server = ::TCPServer.new(@bind, @port)
-			rescue => e
-				fatal e.message
-				fatal "Running existing tasks and exiting."
-				@queue << REACTOR
-				Process.kill("INT", 0)
-				next
-			end
-			on_shutdown do
-				log "Stopping to listen on port #{@port} and shutting down.\n"
-				@server.close unless @server.closed?
-			end
-			::Iodine::Base::Listener.accept(@server, false)
-			log "Iodine #{VERSION} is listening on port #{@port}#{ ' to SSL/TLS connections.' if @ssl}\n"
-			if @spawn_count && @spawn_count.to_i > 1 && Process.respond_to?(:fork)
-				log "Server will run using #{@spawn_count.to_i} processes - Spawning #{@spawn_count.to_i - 1 } more processes.\n"
-				(@spawn_count.to_i - 1).times do
-					Process.fork do
-						log "Spawned process: #{Process.pid}.\n"
-						on_shutdown { log "Shutting down process #{Process.pid}.\n" }
-						@queue.clear
-						@queue << REACTOR
-						startup false, true
-					end
-				end
-				
-			end
-			log "Press ^C to stop the server.\n"
-		else
-			log "Iodine #{VERSION} is running.\n"
-			log "Press ^C to stop the cycling.\n"
-		end
-		on_shutdown do
-			shut_down_proc = Proc.new {|prot| prot.on_shutdown ; prot.close }
-			@ios.values.each {|p| run p, &shut_down_proc }
-			@queue << REACTOR
-		end
-		@queue << REACTOR
-	end
 end

data/lib/iodine/ssl_connector.rb

@@ -3,8 +3,9 @@ module Iodine
 	# This is a mini-protocol used only to implement the SSL Handshake in a non-blocking manner,
 	# allowing for a hardcoded timeout (which you can monkey patch) of 3 seconds.
 	class SSLConnector < Protocol
-		def initialize io, protocol
+		def initialize io, protocol, options = nil
 			@protocol = protocol
+			@options = options
 			super(io)		
 		end
 		TIMEOUT = 3 # hardcoded SSL/TLS handshake timeout
@@ -34,7 +35,7 @@ module Iodine
 			ensure
 				@locker.unlock
 			end
-			( (@ssl_socket.npn_protocol && ::Iodine.ssl_protocols[@ssl_socket.npn_protocol]) || @protocol).new @ssl_socket
+			( (@ssl_socket.npn_protocol && ::Iodine.ssl_protocols[@ssl_socket.npn_protocol]) || @protocol).new @ssl_socket, @options
 		end
 		def on_close
 			# inform

data/lib/iodine/timers.rb

@@ -17,10 +17,11 @@ module Iodine
 
 		# Initialize a timed event.
 		def initialize reactor, interval, repeat_limit = -1, args=[], job=nil
+			@reactor = reactor
 			@interval = interval
 			@repeat_limit = repeat_limit ? repeat_limit.to_i : -1
 			@job = job || (Proc.new { stop! })
-			@next = Iodine.time + interval
+			@next = @reactor.time + interval
 			args << self
 			@args = args
 		end
@@ -37,11 +38,11 @@ module Iodine
 		# If the timed event is due, this method will also add the event to the queue.
 		# @return [true, false]
 		def done?
-			return false unless @next <= Iodine.time
+			return false unless @next <= @reactor.time
 			return true if @repeat_limit == 0
 			@repeat_limit -= 1 if @repeat_limit.to_i > 0
-			Iodine.run *@args, &@job
-			@next = Iodine.time + @interval
+			@reactor.run *@args, &@job
+			@next = @reactor.time + @interval
 			@repeat_limit == 0
 		end
 	end
@@ -85,17 +86,9 @@ module Iodine
 	end
 
 	protected
-	@timer_locker = Mutex.new
-	@timers = []
 
 	# Creates a TimedEvent object and adds it to the Timers stack.
 	def timed_job seconds, limit = false, args = [], block = nil
 		@timer_locker.synchronize {@timers << TimedEvent.new(self, seconds, limit, args, block); @timers.last}
 	end
-	# cycles through timed jobs, executing and/or deleting them if their time has come.
-	@check_timers = Proc.new do
-		@timer_locker.synchronize { @timers.delete_if {|t| t.done? } }
-	end
-	@check_timers = [@check_timers]
-
 end

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-30 00:00:00.000000000 Z
+date: 2015-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,6 +76,7 @@ files:
 - lib/iodine.rb
 - lib/iodine/client.rb
 - lib/iodine/core.rb
+- lib/iodine/core_init.rb
 - lib/iodine/http.rb
 - lib/iodine/http/hpack.rb
 - lib/iodine/http/http1.rb