iodine 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5fa1a23166127d28f5115a2a26d9f1065a0ebbe6
-  data.tar.gz: a649b5fcb56decc43c8de19af7d6e8f60a594769
+  metadata.gz: 015d21e31dd393be87f10ecb19fe9d94f565255c
+  data.tar.gz: 8919757b4d844e02b110496fff6d8e84dc87f60f
 SHA512:
-  metadata.gz: fea7a37cad21a33383709ba16af7d871eb6478fec9809aa1a4a562e965bb4f0b2a7193b76548b6c4a5940ac2ef0d0a11561d0c64f0e0d5aa15241b4d81a9764e
-  data.tar.gz: dfd9f61e71a8b37d5e76feb234f544797585bd6b46cfecf2ecb253247ed34cb3bc9abc032a1e30e771d15a76e7180bd46a2c28ffa18f244438075df666f2084a
+  metadata.gz: 6198a6eaa862ce000905693bad9afb670359ab20b80987713f95df11eefe8d1b951f243f761bac2546701eb10c215e5cea157f215eb3fd48f4bc229d50927e6a
+  data.tar.gz: e96c344aad2a559a5af5b4f2f6365f876335ad3fc741f5cf212eede1002ec3a87751dc78f51d3b0228fdf16d729369f05cde90aaa573af521e25315fb5086ff4

data/CHANGELOG.md

@@ -8,6 +8,22 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ***
 
+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).
+
+**Fix** fixed an issue where manually setting the number of threads for Rack applications (when using Iodine as a Rack server), the setting was mistakenly ignored.
+
+**Fix** fixed an issue where sometimes extractin the Http response's body would fail (if body is `nil`).
+
+**Feature**: session objects are now aware of the session id. The seesion id is available by calling `response.session.id`
+
+**Fix** fixed an issue where Http streaming wasn't chunk encoding after connection error handling update.
+
+**Fix** fixed an issue where Http streaming would disconnect while still processing. Streaming timeout now extended to 15 seconds between response writes.
+
+***
+
 Change log v.0.1.7
 
 Removed a deprecation notice for blocking API. Client API will remain blocking due to use-case requirements.

data/README.md

@@ -1,6 +1,7 @@
 # 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)
+[![GitHub](https://img.shields.io/badge/GitHub-Open%20Source-blue.svg)](https://github.com/boazsegev/iodine)
 
 Iodine makes writing Object Oriented evented server applications easy to write.
 
@@ -249,6 +250,16 @@ end if Process.respond_to? :fork
 exit
 ```
 
+## Cuncurrency?
+
+Iodine maintains the idea of: "yes" to concurrency between objects but "no" to concurrency within objects.
+
+Iodine applies this concept when running in Task mode (or timer mode), by defaulting to single threaded mode, preventing multi-threading race conditions in an unknown environment. Also, each task runs in a single thread from the thread-pool, so unless it tries to set or manipulate global data, it's safe from race conditions.
+
+Iodine applies this concept when running in Server mode by locking the Protocol instance whenever Iodine calls for actions related to that 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).
+
 ## 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/bin/hello_world

@@ -51,6 +51,14 @@ Process.fork do
   Iodine.ssl = true
 	Iodine.port = 3030
 	Iodine::Http.on_http do |req, res|
+    if req.path == '/stream'
+      res.stream_async { sleep 0.2; res << "I was sleeping..."}
+      next
+    end
+    if req.path == '/stream2'
+      res.stream_async { sleep 2; res << "I was sleeping..."}
+      next
+    end
 		res.session[:count] ||= 0
 		res.session[:count] += 1
     res['content-type'] = 'text/plain'

data/lib/iodine/core.rb

@@ -45,7 +45,8 @@ module Iodine
 	@stop = true
 	@done = false
 	@logger = Logger.new(STDOUT)
-	@spawn_count = @thread_count = 1
+	@spawn_count = 1
+	@thread_count = nil
 	@ios = {}
 	@io_in = Queue.new
 	@io_out = Queue.new
@@ -73,7 +74,7 @@ module Iodine
 
 	def startup use_rescue = false, hide_message = false
 		threads = []
-		@thread_count.times { threads << Thread.new {  cycle } }
+		(@thread_count ||= 1).times { threads << Thread.new {  cycle } }
 		unless @stop
 			if use_rescue
 				sleep rescue true

data/lib/iodine/http/http1.rb

@@ -122,6 +122,7 @@ module Iodine
 				log_finished response
 			end
 			def stream_response response, finish = false
+				timeout = 15
 				unless response.headers.frozen?
 					response['transfer-encoding'.freeze] = 'chunked'
 					response.headers['connection'.freeze] = 'close'.freeze
@@ -131,7 +132,7 @@ module Iodine
 				return if response.request.head?
 				body = response.extract_body
 				until body.eof?
-					written = write(body.read 65_536)
+					written = stream_data(body.read 65_536)
 					return Iodine.warn("Http/1 couldn't send response because connection was lost.") && body.close unless written
 					response.bytes_written += written
 				end if body

data/lib/iodine/http/rack_support.rb

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

data/lib/iodine/http/response.rb

@@ -317,7 +317,8 @@ module Iodine
 				elsif @body.is_a?(String)
 					return (@body = nil) if body.empty?
 					StringIO.new @body
-				elsif body.nil?
+				elsif @body.nil?
+					return nil
 					nil
 				elsif  @body.is_a?(File) || @body.is_a?(Tempfile) || @body.is_a?(StringIO)
 					@body

data/lib/iodine/http/session.rb

@@ -4,9 +4,19 @@ module Iodine
 		module SessionManager
 
 			module MemSessionStorage
+				class SessionObject < Hash
+					def initialize id
+						super()
+						self[:__session_id] = id		
+					end
+					# returns the session id (the session cookie value).
+					def id
+						self[:__session_id]
+					end
+				end
 				@mem_storage = {}
 				def self.fetch key
-					@mem_storage[key] ||= {}
+					@mem_storage[key] ||= SessionObject.new(key)
 				end
 			end
 			module FileSessionStorage
@@ -15,6 +25,11 @@ module Iodine
 					def initialize id
 						@filename = File.join Dir.tmpdir, "iodine_#{Iodine::Http.session_token}_#{id}"
 						@data ||= {}
+						@id = id
+					end
+					# returns the session id (the session cookie value).
+					def id
+						@id
 					end
 					# Get a key from the session data store.
 					#
@@ -94,9 +109,8 @@ module Iodine
 			# A Session Storage system must answer only one methods:
 			# fetch(id):: returns a Hash like session object with all the session's data or a fresh session object if the session object did not exist before
 			#
-			# The Session Object should update itself in the storage whenever data is saved to the session Object.
-			# This is important also because websocket 'session' could exist simultaneously with other HTTP requests and the data should be kept updated at all times.
-			# If there are race conditions that apply for multi-threading / multi processing, the Session Object should manage them as well as possible.
+			# The Session Object should update the storage whenever data is saved to the session Object.
+			# This is important also because a websocket 'session' could exist simultaneously with other HTTP requests (multiple browser windows) and the data should be kept updated at all times.
 			def storage= session_storage = nil
 				case session_storage
 				when :file, nil
@@ -116,6 +130,9 @@ module Iodine
 	end
 end
 # A hash like interface for storing request session data.
-# The store must implement: store(key, value) (aliased as []=);
+# The store must implement:
+# store(key, value) (aliased as []=);
 # fetch(key, default = nil) (aliased as []);
-# delete(key); clear;
+# delete(key);
+# clear;
+# id(); (returns the session id)

data/lib/iodine/http/websocket_client.rb

@@ -96,9 +96,9 @@ module Iodine
 				@io.close if @io
 			end
 
-			# checks if the socket is open (if the websocket was terminated abnormally, this might returs true when it should be false).
+			# checks if the socket is open (if the websocket was terminated abnormally, this might return true for a while after it should be false).
 			def closed?
-				@io.io.closed? if @io && @io.io
+				(@io && @io.io) ? @io.io.closed? : true
 			end
 
 			# checks if this is an SSL websocket connection.

data/lib/iodine/http/websockets.rb

@@ -16,7 +16,7 @@ module Iodine
 			end
 			# handle broadcasts.
 			def on_broadcast data
-				@handler.on_broadcast(data) if @handler.respond_to? :on_broadcast
+				@locker.synchronize { @handler.on_broadcast(data) if @handler.respond_to? :on_broadcast }
 			end
 			# cleanup after closing.
 			def on_close

data/lib/iodine/protocol.rb

@@ -47,6 +47,11 @@ module Iodine
 		# the argument or options Hash passed to the initializer as a second argument (the first argument MUST be the IO object).
 		# the value is usually `nil` unless the protocol instance was created by a different protocol while "upgrading" from one protocol to the next.
 		attr_reader :options
+		# The protocol's Mutex locker. It should be locked whenever your code is runing, unless you are
+		# writing asynchronouse code.
+		#
+		# Use with care (or, better yet, don't use).
+		attr_reader :locker
 
 		# Sets the timeout in seconds for IO activity (set timeout within {#on_open}).
 		#

data/lib/iodine/settings.rb

@@ -14,6 +14,11 @@ module Iodine
 		@thread_count = count
 	end
 
+	# Gets the number of threads in the thread pool used for executing the tasks. Returns `nil` unless previously set or Iodine is running.
+	def threads
+		@thread_count
+	end
+
 	# Sets the number of processes that should be spawned in Server mode. Defaults to 1 (no processes spawned).
 	#
 	# * Forking (spwaning processes) might NOT work on all systems (forking is supported by Ruby on Unix systems).

data/lib/iodine/version.rb

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

metadata

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