iodine 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 51d03f6b35a78289c742fbed134a68963bc5ddd6
+  data.tar.gz: 8d541074dd1f8fbde916034e659b28816417e863
+SHA512:
+  metadata.gz: 3365f3efe45797ab9fef24fd61e003425debbc680dc190ca14ffc7797fda812e520c1849a95232f199e3a50b220d04f37e8e922d8a72a8cc65bc1eaa605cfec7
+  data.tar.gz: 3cb5df7d237484fe18fd8828f33a682d210339821322b7c2e709a826bde3cb66c9e0d638a5843b46e28fbab56cf09a0203bed7848ec3383174d3399ab2190c8f

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in iodine.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Boaz Segev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,75 @@
+# Iodine
+
+Iodine makes writing evented server applications easy to write.
+
+Iodine is intended to replace the use of a generic reacor, such as EventMachine or GReactor and it hides all the nasty details of creating the event loop.
+
+To use Iodine, you just set up your tasks - including a single server, if you want one. Iodine will start running once your application is finished and it won't stop runing until all the tasks have completed.
+
+Iodine v. 0.0.1 isn't well tested just yet... but I'm releasing it anyway, to reserve the name and because initial testing shows that it works.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'iodine'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install iodine
+
+## Simple Usage
+
+Iodine starts to work once you app is finished with setting all the tasks up (upon exit).
+
+To see how that works, open your `irb` terminal an try this:
+
+```ruby
+require 'iodine'
+
+# Iodine supports shutdown hooks
+Iodine.on_shutdown { puts "Done!" }
+# The last hook is the first scheduled for execution
+Iodine.on_shutdown { puts "Finishing up :-)" }
+
+# Setup tasks using the `run` or `callback` methods
+Iodine.run do
+    # tasks can create more tasks...
+    Iodine.run { puts "Task 2 completed!" }
+    puts "Task 1 completed!"
+end
+
+# set concurrency level (defaults to a single thread).
+Iodine.threads = 5
+
+# Iodine will start executing tasks once your script is done.
+exit
+```
+
+## Server Usage
+
+Iodine is designed to help write network services (Servers) where each script is intended to implement a single server.
+
+This is not a philosophy based on any idea or preferences, but rather a response to real-world design where each Ruby script is usually assigned a single port for network access (hence, a single server).
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/iodine.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'benchmark'
+$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), __FILE__ )
+require "bundler/setup"
+require "iodine"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/echo

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+Root ||= Pathname.new(File.dirname(__FILE__)).expand_path
+Dir.chdir Root.join('..').to_s
+
+require "bundler/setup"
+require "iodine"
+require 'stringio'
+
+# ab -n 10000 -c 200 -k http://127.0.0.1:3000/ctrl
+# ~/ruby/wrk/wrk -c400 -d10 -t12 http://localhost:3000/ctrl
+
+
+
+class EchoServer < Iodine::Protocol
+	def on_message data
+		write("-- Closing connection, goodbye.\n") && close if data =~ /^(bye|close|exit|stop)/i
+		write(">> #{data.chomp}\n")
+	end
+
+	def ping
+		write "-- Are you still there?\n"
+	end
+
+	def on_close
+		Iodine.info "Closed connection."
+	end
+	def on_open
+		Iodine.info "Opened connection."
+		set_timeout 5
+	end
+end
+
+
+Iodine.protocol = EchoServer

data/bin/em playground

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+#encoding: UTF-8
+
+require 'eventmachine'
+require 'stringio'
+
+
+module MiniServer
+	def post_init
+	 comm_inactivity_timeout = 5
+	 @headers = {}
+	 # start_tls :private_key_file => 'server.key', :cert_chain_file => 'server.crt', :verify_peer => false
+	end
+
+	def receive_data data
+		# EventMachine.defer do 
+			data = ::StringIO.new data
+			l = nil
+			headers = @headers
+			while (l = data.gets)
+				unless l =~ /^[\r]?\n/
+					if l.include? ':'
+						l = l.strip.downcase.split(':', 2)
+						headers[l[0]] = l[1]
+					else
+						headers[:method], headers[:query], headers[:version] = l.split(/[\s]+/, 3)
+					end
+					next
+				end
+				if headers['connection'] =~ /keep/i || headers[:version] =~ /1\.1/
+					send_data "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 12\r\nConnection: keep-alive\r\nKeep-Alive: 5\r\n\r\nhello world\n"
+				else
+					send_data "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 12\r\nConnection: close\r\n\r\nhello world\n"
+					close_connection true
+				end
+				headers.clear
+			end
+			data.string.clear
+		# end
+	end
+
+	def unbind
+	end
+end
+
+# Note that this will block current thread.
+EventMachine.run {
+	trap("TERM") { EventMachine.stop_event_loop }
+	trap("INT")  { EventMachine.stop_event_loop }
+	EventMachine.start_server "127.0.0.1", 3000, MiniServer
+}
+
+
+# ab -n 10000 -c 200 -k http://127.0.0.1:3000/ctrl
+# ~/ruby/wrk/wrk -c400 -d10 -t12 http://localhost:3000/ctrl
+

data/bin/http_test

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+Root ||= Pathname.new(File.dirname(__FILE__)).expand_path
+Dir.chdir Root.join('..').to_s
+
+require "bundler/setup"
+require "iodine"
+require 'stringio'
+
+# ab -n 10000 -c 200 -k http://127.0.0.1:3000/
+# ab -n 10000 -c 200 -k http://localhost:3000/
+# ~/ruby/wrk/wrk -c400 -d10 -t12 http://localhost:3000/
+
+
+
+class MiniServer < Iodine::SSLProtocol
+	def on_open
+		@headers = {}
+		set_timeout 1
+	end
+
+	def on_message data
+		data = ::StringIO.new data
+		l = nil
+		headers = @headers
+		while (l = data.gets)
+			unless l =~ /^[\r]?\n/
+				if l.include? ':'
+					l = l.strip.downcase.split(':', 2)
+					headers[l[0]] = l[1]
+				else
+					headers[:method], headers[:query], headers[:version] = l.strip.split(/[\s]+/, 3)
+				end
+				next
+			end
+			if headers['connection'] =~ /keep/i || headers[:version] =~ /1\.1/
+				write "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 12\r\nConnection: keep-alive\r\nKeep-Alive: 5\r\n\r\nhello world\n"
+			else
+				write "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 12\r\nConnection: close\r\n\r\nhello world\n"
+				close
+			end
+			headers.clear
+		end
+	end
+
+end
+
+Iodine.protocol = MiniServer

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/iodine.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'iodine/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "iodine"
+  spec.version       = Iodine::VERSION
+  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.homepage      = "https://github.com/boazsegev/iodine"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+end

data/lib/iodine.rb

@@ -0,0 +1,17 @@
+require "logger"
+require 'socket'
+
+
+module Iodine
+  extend self
+end
+
+
+require "iodine/version"
+require "iodine/settings"
+require "iodine/logging"
+require "iodine/core"
+require "iodine/timers"
+require "iodine/protocol"
+require "iodine/ssl_protocol"
+require "iodine/io"

data/lib/iodine/core.rb

@@ -0,0 +1,112 @@
+module Iodine
+	public
+
+	#######################
+	## Events
+
+	# Accepts a block and runs it asynchronously. This method runs asynchronously and returns immediately.
+	#
+	# use:
+	#
+	#      GReactor.run_async(arg1, arg2, arg3 ...) { |arg1, arg2, arg3...| do_something }
+	#
+	# the block will be run within the current context, allowing access to current methods and variables.
+	#
+	# @return [GReactor] always returns the reactor object.
+	def run *args, &block
+		queue block, args
+	end
+	alias :run_async :run
+
+	# This method runs an object's method asynchronously and returns immediately. This method will also run an optional callback if a block is supplied.
+	#
+	# This method accepts:
+	# object:: an object who's method will be called.
+	# method:: the method's name to be called. type: Symbol.
+	# *args:: any arguments to be passed to the method.
+	# block (optional):: If a block is supplied, it will be used as a callback and the method's return value will be passed on to the block.
+	#
+	# @return [GReactor] always returns the reactor object.
+	def callback object, method_name, *args, &block
+		block ? queue(@callback_proc, [object.method(method_name), args, block]) : queue(object.method(method_name), args)
+	end
+
+	# Adds a job OR a block to the queue. {GReactor.run_async} and {GReactor.callback} extend this core method.
+	#
+	# This method accepts two possible arguments:
+	# job:: An object that answers to `call`, usually a Proc or Lambda.
+	# args:: (optional) An Array of arguments to be passed on to the executed method.
+	#
+	# @return [GReactor] always returns the reactor object.
+	#
+	# The callback will NOT be called if the executed job failed (raised an exception).
+	# @see .run_async
+	#
+	# @see .callback
+	def queue job, args = nil
+		@queue << [job, args]
+		self
+	end
+
+	# Adds a shutdown tasks. These tasks should be executed in order of creation.
+	def on_shutdown *args, &block
+		@shutdown_queue << [block, args]
+		self
+	end
+
+	protected
+
+	@queue = Queue.new
+	@shutdown_queue = Queue.new
+	@stop = true
+	@done = false
+	@logger = Logger.new(STDOUT)
+	@thread_count = 1
+	@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 }
+		work until @queue.empty?
+		run { true }
+	end
+
+	def work
+		job = @queue && @queue.pop
+		if job && job[0]
+			begin
+				job[0].call *job[1]
+			rescue => e
+				error e
+			end
+		end
+	end
+
+	Kernel.at_exit do
+		threads = []
+		@thread_count.times { threads << Thread.new {  cycle } }
+		unless @stop
+			catch(:stop) { sleep }
+			@logger << "\nShutting down Iodine. Setting shutdown timeout to 30 seconds.\n"
+			@stop = true
+			# setup exit timeout.
+			threads.each {|t| Thread.new {sleep 30; t.kill; t.kill } }
+		end
+		threads.each {|t| t.join rescue true }
+	end
+
+	def shutdown
+		return if @done
+		@stop = @done = true
+		arr = []
+		arr.push @shutdown_queue.pop until @shutdown_queue.empty?
+		@queue.push arr.pop while arr[0]
+		@thread_count.times {  run { true } }
+	end
+
+end

data/lib/iodine/io.rb

@@ -0,0 +1,110 @@
+module Iodine
+
+	public
+
+	# Gets the last time at which the IO Reactor was last active (last "tick").
+	def time
+		@time
+	end
+
+	# replaces an IO's protocol object.
+	#
+	# accepts:
+	# io:: the raw IO object.
+	# protocol:: a protocol instance - should be a Protocol or SSLProtocol (subclass) instance. type will NOT be checked - but Iodine could break if there is a type mismatch.
+	# 
+	def switch_protocol *args
+		@io_in << args
+	end
+
+
+	protected
+
+	@port = (ARGV.index('-p') && ARGV[ARGV.index('-p') + 1]) || ENV['PORT'] || 3000
+	@bind = (ARGV.index('-ip') && ARGV[ARGV.index('-ip') + 1]) || ENV['IP'] || "0.0.0.0"
+	@protocol = nil
+	@ssl_context = nil
+	@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?
+				queue @close_callback, @ios.delete(o_io)
+			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.
+		class Listener < ::Iodine::Protocol
+			def on_open
+				@protocol = Iodine.protocol
+			end
+			def call
+				begin
+					n_io = nil
+					loop do
+						n_io = @io.accept_nonblock
+						@protocol.accept(n_io)
+					end
+				rescue Errno::EWOULDBLOCK => e
+
+				rescue OpenSSL::SSL::SSLError => e
+					warn "SSL Error - Self-signed Certificate?".freeze
+					n_io.close if n_io && !n_io.closed?
+				rescue => e
+					n_io.close if n_io && !n_io.closed?
+					@stop = true
+					raise e
+				end
+			end
+		end
+	end
+
+	########
+	## remember to set traps (once) when 'listen' is called.
+	run do
+		next unless @protocol
+
+		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"
+			@server.close unless @server.closed?
+			@ios.values.each {|p| queue shut_down_proc, p }
+		end
+		@server = ::TCPServer.new(@bind, @port)
+		::Iodine::Base::Listener.accept(@server)
+		@logger << "Iodine #{VERSION} is listening on port #{@port}\n"
+		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 }
+		@logger << "Press ^C to stop the server.\n"
+		queue REACTOR
+	end
+end

data/lib/iodine/logging.rb

@@ -0,0 +1,45 @@
+module Iodine
+	public
+
+	# Gets the logging object and allows you to call logging methods (i.e. `Iodine.log.info "Running"`).
+	def logger log = nil
+		@logger
+	end
+
+	# logs info
+	# @return [String, Exception, Object] always returns the Object sent to the log.
+	def info data, &block
+		@logger.info data, &block if @logger
+		data
+	end
+	# logs debug info
+	# @return [String, Exception, Object] always returns the Object sent to the log.
+	def debug data, &block
+		@logger.debug data, &block if @logger
+		data
+	end
+	# logs warning
+	# @return [String, Exception, Object] always returns the Object sent to the log.
+	def warn data, &block
+		@logger.warn data, &block if @logger
+		data
+	end
+	# logs errors
+	# @return [String, Exception, Object] always returns the Object sent to the log.
+	def error data, &block
+		@logger.error data, &block if @logger
+		data
+	end
+	# logs a fatal error
+	# @return [String, Exception, Object] always returns the Object sent to the log.
+	def fatal data, &block
+		@logger.fatal data, &block if @logger
+		data
+	end
+
+
+	protected
+
+	@logger = Logger.new(STDOUT)
+
+end

data/lib/iodine/protocol.rb

@@ -0,0 +1,155 @@
+module Iodine
+
+	# This is the Basic Iodine server unit - a network protocol.
+	#
+	# A new protocol instance will be created for every network connection.
+	#
+	# The recommended use is to inherit this class (or {SSLProtocol}) and override any of the following:
+	# on_open:: called whenever the Protocol is initialized. Override this to initialize the Protocol object.
+	# on_message(data):: called whenever data is received from the IO. Override this to implement the actual network protocol.
+	# on_close:: called AFTER the Protocol's IO is closed.
+	# on_shutdown:: called when the server's shutdown process had started and BEFORE the Protocol's IO is closed. It allows graceful shutdown for network protocols.
+	# ping::
+	#
+	# Once the network protocol class was created, remember to tell Iodine about it:
+	#       class MyProtocol << Iodine::Protocol
+	#           # your code here
+	#       end
+	#       # tell Iodine
+	#       Iodine.protocol = MyProtocol
+	#
+	class Protocol
+
+		# returns the raw IO object. Using one of the Protocol methods {#write}, {#read}, {#close} is prefered over direct access.
+		attr_reader :io
+
+		# Sets the timeout in seconds for IO activity (set timeout within {#on_open}).
+		#
+		# After timeout is reached, {#ping} will be closed. The connection will be closed if {#ping} returns `false` or `nil`.
+		def set_timeout seconds
+			@timeout = seconds
+		end
+
+		# This method is called whenever the Protocol is initialized - i.e.:
+		# a new connection is established or an old connection switches to this protocol.
+		def on_open
+		end
+		# This method is called whenever data is received from the IO.
+		def on_message data
+		end
+
+		# This method is called AFTER the Protocol's IO is closed - it will only be called once.
+		def on_close
+		end
+
+		# This method is called when the server's shutdown process had started and BEFORE the Protocol's IO is closed. It allows graceful shutdown for network protocols.
+		def on_shutdown
+		end
+
+		# This method is called whenever a timeout has occurred. Either implement a ping or return `false` to disconnect.
+		#
+		# A `false` or `nil` return value will cause disconnection
+		def ping
+			false
+		end
+
+
+		# Closes the IO object.
+		# @return [nil]
+		def close
+			@io.close unless @io.closed?
+			nil
+		end
+		alias :disconnect :close
+
+		# reads from the IO up to the specified number of bytes (defaults to ~2Mb).
+		def read size = 2_097_152
+			touch
+			@io.recv_nonblock( size  )
+		rescue => e
+			nil
+		end
+
+		# this method, writes data to the socket / io object.
+		def write data
+			begin
+				@send_locker.synchronize do
+					r = @io.write data
+					touch
+					r
+				end
+			rescue => e
+				# GReactor.warn e
+				close
+			end
+		end
+
+
+		# This method allows switiching the IO's protocol that will be used the NEXT time
+		# Iodine receives data using this protocol's IO.
+		#
+		# Switing protocols bypasses the {#on_close} method. Override this method for any cleanup needed (if at any),
+		# but remember to call `super` for the actual protocol switching implementation.
+		def switch_protocol new_protocol
+			Iodine.switch_protocol @io, new_protocol
+		end
+
+		#################
+		## the following are Iodine's "system" methods, used internally. Don't override.
+
+
+		# This method is used by Iodine to initialized the Protocol.
+		#
+		# Normally you won't need to override this method. Override {#on_open} instead.
+		def initialize io
+			@timeout ||= nil
+			@send_locker = Mutex.new
+			@locker = Mutex.new
+			@io = io
+			switch_protocol self
+			touch
+			on_open
+		end
+
+		# Called by Iodine whenever there is data in the IO's read buffer.
+		#
+		# Normally you won't need to override this method. Override {#on_message} instead.
+		def call
+			return unless @locker.try_lock
+			begin
+				data = read
+				if data
+					on_message(data)
+					data.clear
+				end
+			ensure
+				@locker.unlock
+			end
+		end
+
+
+		# This method is used by Iodine to ask whether a timeout has occured.
+		#
+		# Normally you won't need to override this method. See {#ping}
+		def timeout? time
+			(ping || close) if @timeout && !@send_locker.locked? && ( (time - @last_active) > @timeout )
+		end
+
+
+
+		# This method is used by Iodine to create the IO handler whenever a new connection is established.
+		#
+		# Normally you won't need to override this method.
+		def self.accept io
+			self.new(io)
+		end
+
+		protected
+
+		# This methos updates the timeout "watch", signifying the IO was active.
+		def touch
+			@last_active = Iodine.time
+		end
+	end
+
+end

data/lib/iodine/settings.rb

@@ -0,0 +1,98 @@
+module Iodine
+	public
+
+	#######################
+	## Settings - methods that change the way Iodine behaves should go here.
+
+	# Sets the logging object, which needs to act like `Logger`. The default logger is `Logger.new(STDOUT)`.
+	def logger= obj
+		@logger = obj
+	end
+
+	# Sets the number of threads in the thread pool used for executing the tasks. Defaults to 1 thread.
+	def threads= count
+		@thread_count = count
+	end
+
+	# Sets the server port. Defaults to the runtime `-p` argument, or the ENV['PORT'] or 3000 (in this order).
+	def port= port
+		@port = port
+	end
+	# Sets the IP binding address. Defaults to the runtime `-ip` argument, or the ENV['IP'] or 0.0.0.0 (in this order).
+	def bind= address
+		@bind = address
+	end
+
+	# Sets the Protocol the Iodine Server will use. Should be a child of Protocol or SSLProtocol. Defaults to nil (no server).
+	def protocol= protocol
+		@stop = protocol ? false : true
+		@protocol = protocol
+	end
+	# Returns the cutrently active Iodine protocol (if exists).
+	def protocol
+		@protocol
+	end
+
+	# Sets the SSL Context to be used when using an SSLProtocol. Defaults to a self signed certificate.
+	def ssl_context= context
+		@ssl_context = context
+	end
+	# Gets the SSL Context to be used when using an SSLProtocol.
+	def ssl_context
+		@ssl_context ||= init_ssl_context
+	end
+
+
+	protected
+
+	#initializes a default SSLContext
+	def init_ssl_context
+		ssl_context = OpenSSL::SSL::SSLContext.new
+		ssl_context.set_params verify_mode: OpenSSL::SSL::VERIFY_NONE
+		ssl_context.cert_store = OpenSSL::X509::Store.new
+		ssl_context.cert_store.set_default_paths
+		ssl_context.session_cache_mode = OpenSSL::SSL::SSLContext::SESSION_CACHE_NO_INTERNAL #SESSION_CACHE_OFF
+		ssl_context.cert, ssl_context.key = create_cert
+		ssl_context
+	end
+
+	#creates a self-signed certificate
+	def create_cert bits=2048, cn=nil, comment='a self signed certificate for when we only need encryption and no more.'
+		unless cn
+			host_name = Socket::gethostbyname(Socket::gethostname)[0].split('.')
+			cn = ''
+			host_name.each {|n| cn << "/DC=#{n}"}
+			cn << "/CN=Iodine.#{host_name.join('.')}"
+		end			
+		# cn ||= "CN=#{Socket::gethostbyname(Socket::gethostname)[0] rescue Socket::gethostname}"
+
+		time = Time.now
+		rsa = OpenSSL::PKey::RSA.new(bits)
+		cert = OpenSSL::X509::Certificate.new
+		cert.version = 2
+		cert.serial = 1
+		name = OpenSSL::X509::Name.parse(cn)
+		cert.subject = name
+		cert.issuer = name
+		cert.not_before = time
+		cert.not_after = time + (365*24*60*60)
+		cert.public_key = rsa.public_key
+
+		ef = OpenSSL::X509::ExtensionFactory.new(nil,cert)
+		ef.issuer_certificate = cert
+		cert.extensions = [
+		ef.create_extension("basicConstraints","CA:FALSE"),
+		ef.create_extension("keyUsage", "keyEncipherment"),
+		ef.create_extension("subjectKeyIdentifier", "hash"),
+		ef.create_extension("extendedKeyUsage", "serverAuth"),
+		ef.create_extension("nsComment", comment),
+		]
+		aki = ef.create_extension("authorityKeyIdentifier",
+		                        "keyid:always,issuer:always")
+		cert.add_extension(aki)
+		cert.sign(rsa, OpenSSL::Digest::SHA1.new)
+
+		return cert, rsa
+	end
+
+end

data/lib/iodine/ssl_protocol.rb

@@ -0,0 +1,108 @@
+module Iodine
+
+	# This class inherits from Protocol, but it includes some adjustments related to SSL connection handling.
+	class SSLProtocol < Protocol
+
+		# 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 SSLWait < Protocol
+			TIMEOUT = 3 # hardcoded SSL/TLS handshake timeout
+			def on_open
+				timeout = TIMEOUT
+				@ssl_socket = OpenSSL::SSL::SSLSocket.new(@io, Iodine.ssl_context)
+				@ssl_socket.sync_close = true
+			end
+
+			# atempt an SSL Handshale
+			def call
+				return if @locker.locked?
+				return unless @locker.try_lock
+				begin
+					@ssl_socket.accept_nonblock
+					@locker.unlock
+				rescue IO::WaitReadable, IO::WaitWritable
+					@locker.unlock
+					return
+				rescue OpenSSL::SSL::SSLError
+					@e = Exception.new "Self-signed Certificate?".freeze
+					@locker.unlock
+					return
+				rescue => e
+					Iodine.warn "SSL Handshake failed with: #{e.message}".freeze
+					@e = e
+					close
+					@locker.unlock
+					return
+				end
+				Iodine.protocol.new @ssl_socket
+			end
+			def on_close
+				# inform
+				Iodine.warn "SSL Handshake #{@e ? "failed with: #{@e.message} (#{@e.class.name})" : 'timed-out.'}".freeze
+				# the core @io is already closed, but let's make sure the SSL object is closed as well.
+				@ssl_socket.close unless @ssl_socket.closed?
+			end
+		end
+
+
+		attr_reader :ssl_socket
+
+
+
+		# reads from the IO up to the specified number of bytes (defaults to ~1Mb).
+		def read size = 1048576
+			@send_locker.synchronize do
+				data = ''
+				begin
+					 (data << @ssl_socket.read_nonblock(size).to_s) until data.bytesize >= size
+				rescue OpenSSL::SSL::SSLErrorWaitReadable, IO::WaitReadable, IO::WaitWritable
+
+				rescue IOError
+					close
+				rescue => e
+					Iodine.warn "SSL Protocol read error: #{e.class.name} #{e.message} (closing connection)"
+					close
+				end
+				return false if data.to_s.empty?
+				touch
+				data
+			end
+		end
+
+		def write data
+			begin
+				@send_locker.synchronize do
+					r = @ssl_socket.write data
+					touch
+					r
+				end				
+			rescue => e
+				close
+				false
+			end
+		end
+		alias :send :write
+		alias :<< :write
+
+		def on_close
+			@ssl_socket.close unless @ssl_socket.closed?
+			super
+		end
+
+
+
+
+
+		# This method initializes the SSL Protocol
+		def initialize ssl_socket
+			@ssl_socket = ssl_socket
+			super(ssl_socket.io)
+		end
+
+		def self.accept io
+			SSLWait.new(io)
+		end
+
+
+	end
+end

data/lib/iodine/timers.rb

@@ -0,0 +1,116 @@
+module Iodine
+
+	#######################
+	## Timers
+
+
+	# Every timed event is a member of the TimedEvent class and responds to it's methods. 
+	class TimedEvent
+
+		# Sets/gets how often a timed event repeats, in seconds.
+		attr_accessor :interval
+		# 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
+
+		# Initialize a timed event.
+		def initialize reactor, interval, repeat_limit = -1, args=[], job=nil
+			@interval = interval
+			@repeat_limit = repeat_limit ? repeat_limit.to_i : -1
+			@job = job || (Proc.new { stop! })
+			@next = Iodine.time + interval
+			args << self
+			@args = args
+		end
+
+		# stops a timed event.
+		# @return [GReactor::TimedEvent] returns the TimedEvent object.
+		def stop!
+			@repeat_limit = 0
+			self
+		end
+
+		# Returns true if the timer is finished.
+		#
+		# 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 true if @repeat_limit == 0
+			@repeat_limit -= 1 if @repeat_limit.to_i > 0
+			Iodine.queue @job, @args
+			@next = Iodine.time + @interval
+			@repeat_limit == 0
+		end
+	end
+
+	public
+
+	# pushes a timed event to the timers's stack
+	#
+	# accepts:
+	# seconds:: the minimal amount of seconds to wait before calling the handler's `call` method.
+	# *arg:: any arguments that will be passed to the handler's `call` method.
+	# &block:: the block to execute.
+	#
+	# A block is required.
+	#
+	# On top of the arguments passed to the `run_after` method, the timer object will be passed as the last agrument to the receiving block.
+	#
+	# Timed event's time of execution is dependant on the workload and continuous uptime of the process (timed events AREN'T persistent).
+	#
+	# @return [GReactor::TimedEvent] returns the new TimedEvent object.
+	def run_after seconds, *args, &block
+		timed_job seconds, 1, args, block
+	end
+
+	# pushes a timed event to the timers's stack
+	#
+	# accepts:
+	# time:: the time at which the job should be executed.
+	# *arg:: any arguments that will be passed to the handler's `call` method.
+	# &block:: the block to execute.
+	#
+	# A block is required.
+	#
+	# On top of the arguments passed to the `run_after` method, the timer object will be passed as the last agrument to the receiving block.
+	#
+	# Timed event's time of execution is dependant on the workload and continuous uptime of the process (timed events AREN'T persistent).
+	#
+	# @return [GReactor::TimedEvent] returns the new TimedEvent object.
+	def run_at run_time, *args, &block
+		timed_job( (@time - run_time), 1, args, block)
+	end
+	# pushes a repeated timed event to the timers's stack
+	#
+	# 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.
+	#
+	# A block is required.
+	#
+	# On top of the arguments passed to the `run_after` method, the timer object will be passed as the last agrument to the receiving block.
+	#
+	# 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 [GReactor::TimedEvent] returns the new TimedEvent object.
+	def run_every seconds, limit = -1, *args, &block
+		timed_job seconds, limit, args, block
+	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
+
+end

data/lib/iodine/version.rb

@@ -0,0 +1,3 @@
+module Iodine
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: iodine
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Boaz Segev
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: " IOdine is a super easy way to write network services and tasking scripts."
+email:
+- Boaz@2be.co.il
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/echo
+- bin/em playground
+- bin/http_test
+- bin/setup
+- iodine.gemspec
+- lib/iodine.rb
+- lib/iodine/core.rb
+- lib/iodine/io.rb
+- lib/iodine/logging.rb
+- lib/iodine/protocol.rb
+- lib/iodine/settings.rb
+- lib/iodine/ssl_protocol.rb
+- lib/iodine/timers.rb
+- lib/iodine/version.rb
+homepage: https://github.com/boazsegev/iodine
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: IOdine makes writing evented server applications easy to write.
+test_files: []