iodine 0.1.21 → 0.2.0

data/lib/iodine/logging.rb

@@ -1,46 +0,0 @@
-module Iodine
-	public
-
-	# Gets the logging object and allows you to call logging methods (i.e. `Iodine.log.info "Running"`).
-	def logger
-		@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
-	# 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
-
-end

data/lib/iodine/settings.rb

@@ -1,158 +0,0 @@
-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
-
-	# 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).
-	# * Please make sure your code is safe to fork into different processes. For instance, Websocket broadcasting and unicasting won't work across different processes unless synced using an external Pub/Sub service/database such as Redis.
-	# * Forking might cause some tasks (such as time based tasks) to be performed twice (once for each process). This is a feature. To avoid duplicated task performance, use a task (delayed execution) to initialize any tasks you want to perform only once. While the initial time based tasks and the server are shared across processes, the initial task stack will only run on the main process.
-	def processes= count
-		@spawn_count = count
-	end
-
-	# Gets the number of processes that should be spawned in Server mode. Defaults to 1 (no processes spawned). See {Iodine#processes=}.
-	def processes
-		@spawn_count
-	end
-
-	# Sets Iodine's server port. Defaults to the command line `-p` argument, or the ENV['PORT'] or 3000 (in this order).
-	def port= port
-		@port = port
-	end
-	# Gets Iodine's server port. Defaults to the command line `-p` argument, or the ENV['PORT'] or 3000 (in this order).
-	def port
-		@port
-	end
-	# Sets the IP binding address. Defaults to the command line `-ip` argument, or the ENV['IP'] or 0.0.0.0 (in this order).
-	def bind= address
-		@bind = address
-	end
-	# Gets the IP binding address. Defaults to the command line `-ip` argument, or the ENV['IP'] or 0.0.0.0 (in this order).
-	def bind
-		@bind
-	end
-
-	# Sets the Protocol the Iodine Server will use. Should be a child of {Iodine::Protocol}. Defaults to nil (no server).
-	#
-	# If the protocol passed does NOT inherit from {Iodine::Protocol}, Iodine will cycle without initiating a server until stopped (TimedEvent mode).
-	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 flag, so that Iodine will require that new connection be encrypted.
-	# Defaults to false unless the `ssl` command line flag is present.
-	def ssl= required
-		@ssl = required && true
-	end
-	# Returns true if Iodine will require that new connection be encrypted.
-	def ssl
-		@ssl
-	end
-
-	# Sets the SSL Context to be used when using an encrypted connection. Defaults to a self signed certificate and no verification.
-	#
-	# Manually setting the context will automatically set the SSL flag,
-	# so that Iodine will require encryption for new incoming connections.
-	def ssl_context= context
-		@ssl = true
-		@ssl_context = context
-	end
-
-	# Gets the SSL Context to be used when using an encrypted connection.
-	def ssl_context
-		@ssl_context ||= init_ssl_context
-	end
-
-	# Sets the an SSL Protocol Hash (`'name' => Protocol`), allowing dynamic Protocol Negotiation.
-	# At the moment only NPN is supported. ALPN support should be established in a future release.
-	#
-	# * please notice that using allowing dynamic Protocol Negotiation could cause unexpected protocol choices when attempting to implement Opportunistic Encryption with {Iodine::SSLConnector}.
-	def ssl_protocols= protocol_hash
-		raise TypeError, "Iodine.ssl_protocols should be a Hash with Strings for keys (protocol identifiers) and Classes as values (Protocol classes)." unless protocol_hash.is_a?(Hash)
-		@ssl = true
-		ssl_context.npn_protocols = protocol_hash.keys
-		@ssl_protocols = protocol_hash
-	end
-
-	# Gets the SSL Protocol Hash used for 
-	def ssl_protocols
-		@ssl_protocols
-	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 = String.new
-			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_connector.rb

@@ -1,48 +0,0 @@
-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, options = nil
-			@protocol = protocol
-			@options = options
-			super(io)		
-		end
-		TIMEOUT = 3 # hardcoded SSL/TLS handshake timeout
-		def on_open
-			set_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
-			rescue ::IO::WaitReadable, ::IO::WaitWritable
-				return
-			rescue ::OpenSSL::SSL::SSLError
-				@e = ::OpenSSL::SSL::SSLError.new "Self-signed Certificate?".freeze
-				close
-				return
-			rescue => e
-				::Iodine.warn "SSL Handshake failed with: #{e.message}".freeze
-				@e = e
-				close
-				return
-			ensure
-				@locker.unlock
-			end
-			( (@ssl_socket.npn_protocol && ::Iodine.ssl_protocols[@ssl_socket.npn_protocol]) || @protocol).new @ssl_socket, @options
-		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
-
-end

data/lib/iodine/timers.rb

@@ -1,95 +0,0 @@
-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
-		# 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
-			@reactor = reactor
-			@interval = interval
-			@repeat_limit = repeat_limit ? repeat_limit.to_i : -1
-			@job = job || (Proc.new { stop! })
-			@next = @reactor.time + interval
-			args << self
-			@args = args
-		end
-
-		# stops a timed event.
-		# @return [Iodine::TimedEvent] returns the TimedEvent object.
-		def stop!
-			@repeat_limit = 0
-			@next = @reactor.time
-			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 <= @reactor.time
-			return true if @repeat_limit == 0
-			@repeat_limit -= 1 if @repeat_limit.to_i > 0
-			@reactor.run(*@args, &@job)
-			@next = @reactor.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 [Iodine::TimedEvent] returns the new TimedEvent object.
-	def run_after seconds, *args, &block
-		timed_job seconds, 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.
-	# *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 [Iodine::TimedEvent] returns the new TimedEvent object.
-	def run_every seconds, *args, &block
-		timed_job seconds, -1, args, block
-	end
-
-	protected
-
-	# 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
-end