iodine 0.1.20 → 0.1.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5ee2e6d64a08ec88c75a4e0eaed1d15586310e8
-  data.tar.gz: fe61017b3b92e43efb5cf1ca9331e5143940ec8c
+  metadata.gz: 52bb724586bb147b6db24a2a5c5ca7192ac27cc3
+  data.tar.gz: 685c1496be7ec7c13181910c9748d91814345ec0
 SHA512:
-  metadata.gz: a9e83552a00e1799096ef2b0515ed417a18eab511c0460743a4f6f003613ae47114b55abe14ec0dd1243a9dd846032ad30f59b3786c71673192e504fa0a2ebed
-  data.tar.gz: 40989499a5b70e09fb35dcd29ebcc8fd3326ff5b9e886ea7800b6e9f01c4ef01fd99b587ebff92aad9ff03d7d5e5ada3489bc18c9887864be4148e2263cdc3eb
+  metadata.gz: 72420d26e15261d76f196f4d9df9262b675747c468e3b9119adf68ec2bc3e0e5d6a4e57c48421731fb9263c42d542dfceb66c765176cfc4566730bfb8f54f3be
+  data.tar.gz: 535428c459b044ed1ab7ea3caccc4540e01acb32fdb7d57e910ba61f5b87162796052cd494b32ea7274a71b5f0d863a5f5ab7885faed60f32282c26d9b2b3743

data/.gitignore

@@ -7,3 +7,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+
+.ruby-version
+
+*.bundle

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.21
+
+**Optimization**: Minor optimizations. i.e. - creates 1 less Time object per request (The logging still creates a Time object unless disabled using `Iodine.logger = nil`).
+
+**Security**: Http/1 now reviews the Body's size as it grows (similar to Http/2), mitigating any potential attacks related to the size of the data sent.
+
+**Logs**: Log the number of threads utilized when starting up the server.
+
+***
+
 Change log v.0.1.20
 
 **Update/Fix**: Updated the `x-forwarded-for` header recognition, to accommodate an Array formatting sometimes used (`["ip1", "ip2", ...]`).

data/README.md

@@ -11,6 +11,23 @@ To use Iodine, you just set up your tasks - including a single server, if you wa
 
 Iodine is used by [the Plezi Ruby framework for real-time applications](http://www.plezi.io).
 
+## Notice! and limitations...
+
+Iodine 0.1.x is implemented in Ruby, using a `select` system call.
+
+`select` is limited to 1024 open connections! after 1024 connection, `select` could cause "undefined behavior", including a possible "crash"... sometimes it's not important... some hosting environments only allow 1024 connections anyway... EventMachine crashes on my system after 1024 connections too...
+
+...but websockets are connection hungry beasts.
+
+Hence, a move to kqueue/epoll is required.
+
+Iodine 0.2.x will include (hopefully), a kpoll / epoll implementation for Linux/BSD server environments, such as Heroku dynos (which run a flavor of unbuto 14).
+
+However, it is unlikely that Iodine's beautiful API could survive this shift.
+
+The 0.1.x API should be considered deprecated while a new API is under development (assuming I will manage to link some decent C code to Ruby)... I satrted out by displiking EventMachine's API, now it seems they might not have had a choice.
+
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/bin/hello_world

@@ -21,7 +21,10 @@ require "iodine/http"
 
 # Iodine.processes = 4
 
-Iodine::Http.on_http { "Hello World!" }
+HELLO = "Hello World!"
+Iodine::Http.on_http { HELLO }
+
+Iodine.logger = nil
 
 
 class WSChatServer < Iodine::Http::WebsocketHandler

data/iodine.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Boaz Segev"]
   spec.email         = ["Boaz@2be.co.il"]
 
-  spec.summary       = %q{ IOdine makes writing evented server applications easy to write. }
-  spec.description   = %q{ IOdine is a super easy way to write network services and tasking scripts.}
+  spec.summary       = %q{ The Iodine v.0.1.X line and API is deprecated and will not be supported after v. 0.2.0 is released. }
+  spec.description   = %q{ The Iodine v.0.1.X line and API is deprecated and will not be supported after v. 0.2.0 is released. }
   spec.homepage      = "https://github.com/boazsegev/iodine"
   spec.license       = "MIT"
 
@@ -30,4 +30,12 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest"
+
+
+
+  spec.post_install_message = "The Iodine 0.1.x API is now deprecated.\n"+
+                              "Version 0.2.x will include a drastic change and it WILL break existing code.\n" +
+                              "DON'T UPGRADE BEYOND THIS POINT UNLESS YOU'RE PREPARED FOR A HUGE CANGE.\n" +
+                              "Future version of Iodine will be written in C and require a Linux/Unix machine."
+
 end

data/lib/iodine/core_init.rb

@@ -103,7 +103,7 @@ module Iodine
 					@server = ::TCPServer.new(@bind, @port)
 				rescue => e
 					fatal e.message
-					fatal "Running existing tasks and exiting."
+					fatal "Running existing tasks with #{@thread_count} thread(s) and exiting."
 					@queue << @reactor
 					Process.kill("INT", 0)
 					next
@@ -113,7 +113,7 @@ module Iodine
 					log "Stopped listening to port #{@port}.\n"
 				end
 				::Iodine::Base::Listener.accept(@server, false)
-				log "Iodine #{VERSION} is listening on port #{@port}#{ ' to SSL/TLS connections.' if @ssl}\n"
+				log "Iodine #{VERSION} is listening on port #{@port}#{ ' (SSL/TLS)' if @ssl} with #{@thread_count} thread(s).\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
@@ -129,7 +129,7 @@ module Iodine
 				end
 				log "Press ^C to stop the server.\n"
 			else
-				log "#{self == Iodine ? 'Iodine' : "#{self.name} (Iodine)"} #{VERSION} is running.\n"
+				log "#{self == Iodine ? 'Iodine' : "#{self.name} (Iodine)"} #{VERSION} is running with #{@thread_count} thread(s).\n"
 				log "Press ^C to stop the cycling.\n"
 			end
 			on_shutdown do

data/lib/iodine/http/http1.rb

@@ -4,7 +4,6 @@ module Iodine
 			def on_open
 				set_timeout 1
 				@refuse_requests = false
-				@bytes_sent = 0
 				@parser = {}
 			end
 			def on_message data
@@ -25,15 +24,24 @@ module Iodine
 							request[:method], request[:query], request[:version] = l.split(/[\s]+/.freeze, 3)
 							return (Iodine.warn('Http1 Protocol Error, closing connection.'.freeze, l, request) && close) unless request[:method] =~ HTTP_METHODS_REGEXP
 							request[:version] = (request[:version] || '1.1'.freeze).match(/[\d\.]+/.freeze)[0]
-							request[:time_recieved] = Time.now
+							request[:time_recieved] = Iodine.time
 						end
 						until request[:headers_complete] || (l = data.gets).nil?
+							# if l.bytesize > 16_384
+							# 	write "HTTP/1.0 413 Entity Too Large\r\ncontent-length: 16\r\n\r\nEntity Too Large".freeze
+							# 	Iodine.warn "Http/1 Header data too large, closing connection.".freeze
+							# 	return close
+							# end
 							if l.include? ':'.freeze
 								# 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)
 								request[:headers_size] ||= 0
 								request[:headers_size] += l.bytesize
+								if request.length > 2096 || request[:headers_size] > 262_144
+									write "HTTP/1.0 431 Request Header Fields Too Large\r\ncontent-length: 31\r\n\r\nRequest Header Fields Too Large".freeze
+									return (Iodine.warn('Http1 header overloading, closing connection.'.freeze) && close)
+								end
 								l = l.strip.split(/:[\s]?/.freeze, 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])
@@ -44,14 +52,11 @@ module Iodine
 								Iodine.warn 'Protocol Error, closing connection.'.freeze
 								return close
 							end
-							if request.length > 2096 || request[:headers_size] > 262_144
-								write "HTTP/1.0 431 Request Header Fields Too Large\r\ncontent-length: 31\r\n\r\nRequest Header Fields Too Large".freeze
-								return (Iodine.warn('Http1 header overloading, closing connection.'.freeze) && close)
-							end
 						end
-						until request[:body_complete] && request[:headers_complete]
-							if request['transfer-coding'.freeze] == 'chunked'.freeze
-								# ad mid chunk logic here
+						next unless request[:headers_complete]
+						if request['transfer-coding'.freeze] == 'chunked'.freeze
+							until request[:body_complete]
+								# add mid chunk logic here
 								if @parser[:length].to_i == 0
 									chunk = data.gets
 									return false unless chunk
@@ -66,27 +71,28 @@ module Iodine
 								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
+								return if bad_body_size?
+							end
+						elsif request['content-length'.freeze] && request['content-length'.freeze].to_i != 0
+							until request[:body_complete]
 								request[:body] ||= Tempfile.new('iodine'.freeze, :encoding => 'binary'.freeze)
 								packet = data.read(request['content-length'.freeze].to_i - request[:body].size)
 								return false unless packet
 								request[:body] << packet
+								return if bad_body_size?
 								request[:body_complete] = true if request['content-length'.freeze].to_i - request[:body].size <= 0
-							elsif request['content-type'.freeze]
+							end
+						elsif request['content-type'.freeze]
+							until request[:body_complete]
 								Iodine.warn 'Body type protocol error.'.freeze unless request[:body]
 								line = data.gets
 								return false unless line
 								(request[:body] ||= Tempfile.new('iodine'.freeze, :encoding => 'binary'.freeze) ) << line
+								return if bad_body_size?
 								request[:body_complete] = true if line =~ EOHEADERS
-							else
-								request[:body_complete] = true
 							end
-						end
-						if request[:body] && request[:body].size > ::Iodine::Http.max_body_size
-							Iodine.warn("Http1 message body too big, closing connection (Iodine::Http.max_body_size == #{::Iodine::Http.max_body_size} bytes) - #{request[:body].size} bytes.")
-							request.delete(:body).tap {|f| f.close unless f.closed? } rescue false
-							write "HTTP/1.0 413 Payload Too Large\r\ncontent-length: 17\r\n\r\nPayload Too Large".freeze
-							return close
+						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
@@ -219,13 +225,24 @@ module Iodine
 			end
 
 			def log_finished response
-				@bytes_sent = 0
 				request = response.request
 				return if Iodine.logger.nil? || request[:no_log]
 				t_n = Time.now
-				(Thread.current[:log_buffer] ||= String.new).clear
-				Thread.current[:log_buffer] << "#{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(Thread.current[:log_buffer])
+				# (Thread.current[:log_buffer] ||= String.new).clear
+				# Thread.current[:log_buffer] << "#{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(Thread.current[:log_buffer])
+				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
+
+			def bad_body_size?
+				request = @request
+				if request[:body] && request[:body].size > ::Iodine::Http.max_body_size
+					Iodine.warn("Http1 message body too big, closing connection (Iodine::Http.max_body_size == #{::Iodine::Http.max_body_size} bytes) - #{request[:body].size} bytes.")
+					request.delete(:body).tap {|f| f.close unless f.closed? } rescue false
+					write "HTTP/1.0 413 Payload Too Large\r\ncontent-length: 17\r\n\r\nPayload Too Large".freeze
+					return true
+				end
+				false
 			end
 		end
 	end

data/lib/iodine/http/http2.rb

@@ -139,9 +139,10 @@ module Iodine
 				request = response.request
 				return if Iodine.logger.nil? || request[:no_log]
 				t_n = Time.now
-				(Thread.current[:log_buffer] ||= String.new).clear
-				Thread.current[:log_buffer] << "#{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 Thread.current[:log_buffer]
+				# (Thread.current[:log_buffer] ||= String.new).clear
+				# Thread.current[:log_buffer] << "#{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 Thread.current[:log_buffer]
+				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
 
 			def send_headers response, request
@@ -315,7 +316,7 @@ module Iodine
 
 				frame[:stream].update @hpack.decode(@header_buffer) # this is where HPACK comes in
 				return (Iodine.warn('Http2 header overloading, closing connection.') && connection_error( ENHANCE_YOUR_CALM ) ) if frame[:stream].length > 2096
-				frame[:stream][:time_recieved] ||= Time.now
+				frame[:stream][:time_recieved] ||= Iodine.time
 				frame[:stream][:version] ||= '2'.freeze
 
 				process_request(@open_streams.delete frame[:sid]) if @header_end_stream

data/lib/iodine/logging.rb

@@ -43,9 +43,4 @@ module Iodine
 		raw_text
 	end
 
-
-	protected
-
-	@logger = Logger.new(STDOUT)
-
 end

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = "0.1.20"
+  VERSION = "0.1.21"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.1.20
+  version: 0.1.21
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-12-10 00:00:00.000000000 Z
+date: 2016-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,7 +52,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: " IOdine is a super easy way to write network services and tasking scripts."
+description: " The Iodine v.0.1.X line and API is deprecated and will not be supported
+  after v. 0.2.0 is released. "
 email:
 - Boaz@2be.co.il
 executables: []
@@ -101,7 +102,11 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message: |-
+  The Iodine 0.1.x API is now deprecated.
+  Version 0.2.x will include a drastic change and it WILL break existing code.
+  DON'T UPGRADE BEYOND THIS POINT UNLESS YOU'RE PREPARED FOR A HUGE CANGE.
+  Future version of Iodine will be written in C and require a Linux/Unix machine.
 rdoc_options: []
 require_paths:
 - lib
@@ -120,6 +125,6 @@ rubyforge_project:
 rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
-summary: IOdine makes writing evented server applications easy to write.
+summary: The Iodine v.0.1.X line and API is deprecated and will not be supported after
+  v. 0.2.0 is released.
 test_files: []
-has_rdoc: