iodine 0.0.2 → 0.0.3

data/lib/iodine/http/websockets.rb

@@ -1,24 +1,29 @@
 module Iodine
 	class Http < Iodine::Protocol
 		class Websockets < ::Iodine::Protocol
+			# initialize the websocket protocol.
 			def initialize io, handler, request, ws_extentions = nil
 				@handler = handler
 				@ws_extentions = ws_extentions
 				request[:io] = self
 				super(io)
 			end
+			# continue to initialize the websocket protocol.
 			def on_open
 				set_timeout 45
 				@parser = {body: '', stage: 0, step: 0, mask_key: [], len_bytes: []}
 				set_timeout = self.class.default_timeout
-				@handler.on_open self if @handler.respond_to? :on_open
+				@handler.on_open if @handler.respond_to? :on_open
 			end
+			# parse and handle messages.
 			def on_message data
 				extract_message StringIO.new(data)
 			end
+			# handle broadcasts.
 			def on_broadcast data
 				@handler.on_broadcast(data) if @handler.respond_to? :on_broadcast
 			end
+			# cleanup after closing.
 			def on_close
 				@handler.on_close if @handler.respond_to? :on_close
 				if @ws_extentions
@@ -27,13 +32,28 @@ module Iodine
 				end
 			end
 
+			# a politer disconnection.
+			def go_away
+				write CLOSE_FRAME
+				close
+			end
+
+			# a politer disconnection during shutdown.
+			def on_shutdown
+				go_away
+			end
+
+			# allow Http responses to be used for sending Websocket data.
 			def send_response response, finish = false
 				body = response.extract_body
 				send_data body
 			end
 			alias :stream_response :send_response
 
-			# sends the data as one (or more) Websocket frames
+			# Sends the data as one (or more) Websocket frames.
+			#
+			# Use THIS method to send data using the Websocket protocol.
+			# Using {Iodine::Protocol#write} will bypass the Websocket data framing and send the raw data, breaking the connection.
 			def send_data data, op_code = nil, fin = true, ext = 0
 				return false if !data || data.empty?
 				return false if @io.closed?
@@ -142,8 +162,7 @@ module Iodine
 				end
 				response['Sec-WebSocket-Accept'.freeze] = Digest::SHA1.base64digest(request['sec-websocket-key'.freeze] + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'.freeze)
 				response.session
-				# Iodine.logger << "#{@request[:client_ip]} [#{Time.now.utc}] - #{@connection.object_id} Upgraded HTTP to WebSockets.\n"
-				# request.io.handler.send_response response 
+				# Iodine.log "#{@request[:client_ip]} [#{Time.now.utc}] - #{@connection.object_id} Upgraded HTTP to WebSockets.\n"
 				response.finish
 				self.new(io.io, handler, request, ws_extentions)
 				return true

data/lib/iodine/io.rb

@@ -102,52 +102,37 @@ module Iodine
 			begin
 				@server = ::TCPServer.new(@bind, @port)
 			rescue => e
-				Iodine.fatal e.message
-				Iodine.fatal "Running existing tasks and exiting."
-				@stop = true
+				fatal e.message
+				fatal "Running existing tasks and exiting."
+				Process.kill("INT", 0)
 				next
 			end
 			shut_down_proc = Proc.new {|protocol| protocol.on_shutdown ; protocol.close }
 			on_shutdown do
-				@logger << "Stopping to listen on port #{@port} and shutting down.\n"
+				log "Stopping to listen on port #{@port} and shutting down.\n"
 				@server.close unless @server.closed?
 				@ios.values.each {|p| run p, &shut_down_proc }
 			end
 			::Iodine::Base::Listener.accept(@server, false)
-			@logger << "Iodine #{VERSION} is listening on port #{@port}#{ ' to SSL/TLS connections.' if @ssl}\n"
+			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)
-				@logger << "Server will run using #{@spawn_count.to_i} processes - Spawning #{@spawn_count.to_i - 1 } more processes.\n"
+				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
-						@logger << "Spawned process: #{Process.pid}.\n"
-						on_shutdown { @logger << "Shutting down process #{Process.pid}.\n" }
-						threads = []
+						log "Spawned process: #{Process.pid}.\n"
+						on_shutdown { log "Shutting down process #{Process.pid}.\n" }
 						@queue.clear
 						@queue << REACTOR
-						@thread_count.times { threads << Thread.new {  cycle } }
-						unless @stop
-							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 }
-							@stop = true
-							# setup exit timeout.
-							threads.each {|t| Thread.new {sleep 25; t.kill; t.kill } }
-						end
-						threads.each {|t| t.join rescue true }
+						startup false, true
 					end
 				end
 				
 			end
-			@logger << "Press ^C to stop the server.\n"
+			log "Press ^C to stop the server.\n"
 		else
-			@logger << "Iodine #{VERSION} is running.\n"
-			on_shutdown do
-				@logger << "Iodine says goodbye.\n"
-			end
-			@logger << "Press ^C to stop the cycling.\n"			
+			log "Iodine #{VERSION} is running.\n"
+			log "Press ^C to stop the cycling.\n"
 		end
-		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 }
 		@queue << REACTOR
 	end
 end

data/lib/iodine/logging.rb

@@ -2,7 +2,7 @@ module Iodine
 	public
 
 	# Gets the logging object and allows you to call logging methods (i.e. `Iodine.log.info "Running"`).
-	def logger log = nil
+	def logger
 		@logger
 	end
 
@@ -36,6 +36,12 @@ module Iodine
 		@logger.fatal data, &block if @logger
 		data
 	end
+	# logs a raw text
+	# @return [String] always returns the Object sent to the log.
+	def log raw_text
+		@logger << raw_text if @logger
+		raw_text
+	end
 
 
 	protected

data/lib/iodine/protocol.rb

@@ -71,6 +71,9 @@ module Iodine
 			nil
 		end
 		alias :disconnect :close
+		def closed?
+			@io.closed?
+		end
 
 		# reads from the IO up to the specified number of bytes (defaults to ~2Mb).
 		def read size = 2_097_152
@@ -103,7 +106,7 @@ module Iodine
 		#
 		# This can be used locally but not across processes.
 		def id
-			@id ||= @io.to_io.to_s(16)
+			@id ||= @io.to_io.object_id.to_s(16)
 		end
 
 		# returns an [Enumerable](http://ruby-doc.org/core-2.2.3/Enumerable.html) with all the active connections.

data/lib/iodine/timers.rb

@@ -12,6 +12,8 @@ module Iodine
 		# Sets/gets how many times a timed event repeats.
 		# If set to false or -1, the timed event will repead until the application quits.
 		attr_accessor :repeat_limit
+		# Allows you to acess or change the timer's Proc object.
+		attr_accessor :job
 
 		# Initialize a timed event.
 		def initialize reactor, interval, repeat_limit = -1, args=[], job=nil
@@ -68,7 +70,6 @@ module Iodine
 	#
 	# accepts:
 	# seconds:: the minimal amount of seconds to wait before calling the handler's `call` method.
-	# limit:: the amount of times the event should repeat itself. The event will repeat every x amount of `seconds`. The event will repeat forever if limit is set to false.
 	# *arg:: any arguments that will be passed to the handler's `call` method.
 	# &block:: the block to execute.
 	#
@@ -79,8 +80,8 @@ module Iodine
 	# Timed event's time of execution is dependant on the workload and continuous uptime of the process (timed events AREN'T persistent unless you save and reload them yourself).
 	#
 	# @return [Iodine::TimedEvent] returns the new TimedEvent object.
-	def run_every seconds, limit = -1, *args, &block
-		timed_job seconds, limit, args, block
+	def run_every seconds, *args, &block
+		timed_job seconds, -1, args, block
 	end
 
 	protected

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/rack/handler/iodine.rb

@@ -1,3 +1,3 @@
 require 'iodine/http'
 
-::Rack::Handler.register( 'iodine', 'Iodine::Base::Rack') if defined?(::Rack)
+::Rack::Handler.register( 'iodine', 'Iodine::Http::Rack') if defined?(::Rack)

data/manual tests/hello_world

@@ -20,28 +20,25 @@ require "iodine/http"
 Iodine.protocol.on_http { "Hello World!" }
 
 
-class WSChatServer
-	def initialize nickname
-		@nickname = nickname || "unknown"
-	end
-	def on_open protocol
-		@io = protocol
-		@io.broadcast "#{@nickname} has joined the chat!"
-		@io << "Welcome #{@nickname}, you have joined the chat!"
-	end
-	def on_message data
-		@io.broadcast "#{@nickname} >> #{data}"
-		@io << ">> #{data}"
-	end
-	def on_broadcast data
-		@io << data
-	end
-	def on_close
-		@io.broadcast "#{@nickname} has left the chat!"
-	end
+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 { |request, response| WSChatServer.new request.params[:name]}
+Iodine::Http.on_websocket WSChatServer
 
 Process.fork do
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-19 00:00:00.000000000 Z
+date: 2015-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler