plezi 0.7.7 → 0.8.1

data/lib/plezi/eventmachine/protocol.rb

@@ -0,0 +1,54 @@
+module Plezi
+
+
+	module EventMachine
+
+		# this module is the protocol (controller) for the HTTP server.
+		#
+		#
+		# to do: implemet logging, support body types: multipart (non-ASCII form data / uploaded files), json & xml
+		class Protocol
+
+			attr_accessor :connection, :params
+			attr_reader :buffer, :locker
+
+			# initializes the protocol object
+			def initialize connection, params
+				@buffer, @connection, @params, @locker = [], connection, params, connection.locker
+			end
+
+			# called when connection is initialized.
+			def on_connect
+			end
+
+			# called after data is recieved.
+			#
+			# this method is called within a lock on the connection (Mutex) - craeful from double locking.
+			def on_message
+			end
+
+			# # called when a disconnect is fired
+			# # (socket was disconnected / service should be disconnected / shutdown / socket error)
+			def on_disconnect
+			end
+
+			# called when an exception was raised
+			# (socket was disconnected / service should be disconnected / shutdown / socket error)
+			def on_exception
+				EventMachine.remove_io connection.io
+				Plezi.error e
+			end
+		end
+	end
+end
+
+## Heroku/extra headers info
+
+# All headers are considered to be case-insensitive, as per HTTP Specification.
+# X-Forwarded-For: the originating IP address of the client connecting to the Heroku router
+# X-Forwarded-Proto: the originating protocol of the HTTP request (example: https)
+# X-Forwarded-Port: the originating port of the HTTP request (example: 443)
+# X-Request-Start: unix timestamp (milliseconds) when the request was received by the router
+# X-Request-Id: the Heroku HTTP Request ID
+# Via: a code name for the Heroku router
+

data/lib/plezi/eventmachine/queue.rb

@@ -0,0 +1,51 @@
+module Plezi
+	module EventMachine
+		module_function
+
+		QUEUE = []
+		QUEUE_LOCKER = Mutex.new
+
+		def queue args, job
+			raise "Job missing" unless job
+			QUEUE_LOCKER.synchronize { QUEUE << [job, args]}
+			true
+		end
+
+		def do_job
+			job, args = QUEUE_LOCKER.synchronize { QUEUE.shift }
+			job ? (job.call(*args) || true) : false
+		end
+
+		def queue_empty?
+			QUEUE.empty?
+		end
+
+	end
+
+	module_function
+
+	# Accepts a block and runs it asynchronously. This method runs asynchronously and returns immediately.
+	#
+	# use:
+	#
+	#      Plezi.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.
+	def run_async *args, &block
+		EventMachine.queue args, block
+	end
+
+	# This method runs asynchronously and returns immediately.
+	#
+	# 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.
+	#
+	# This method also accepts an optional block which will be run with the method's returned value within the existing context.
+	#
+	def callback object, method, *args, &block
+		block ? EventMachine.queue( args, (proc { |ar| block.call( object.method(method).call(*ar) ) }) ) : EventMachine.queue(args, object.method(method) )
+	end
+
+end

data/lib/plezi/eventmachine/ssl_connection.rb

@@ -0,0 +1,138 @@
+# encoding: UTF-8
+
+
+
+module Plezi
+
+	module EventMachine
+
+		# represents an SSL connection
+		class SSLConnection < Connection
+			#the SSL socket
+			attr_reader :ssl_socket
+
+			def initialize socket, params
+				if params[:ssl] || params[:ssl_key] || params[:ssl_cert]
+					params[:ssl_cert], params[:ssl_key] = SSLConnection.self_cert unless params[:ssl_key] && params[:ssl_cert]
+					context = OpenSSL::SSL::SSLContext.new
+					context.set_params verify_mode: OpenSSL::SSL::VERIFY_NONE # OpenSSL::SSL::VERIFY_PEER #OpenSSL::SSL::VERIFY_NONE
+					# context.options DoNotReverseLookup: true
+					context.cert, context.key = params[:ssl_cert], params[:ssl_key]
+					context.cert_store = OpenSSL::X509::Store.new
+					context.cert_store.set_default_paths
+					@ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, context)
+					@ssl_socket.sync_close = true
+					@ssl_socket.accept
+				end
+				raise "Not an SSL connection or SSL Socket creation failed" unless ssl_socket
+				super
+			end
+
+
+			# returns an IO-like object used for reading/writing (unlike the original IO object, this can be an SSL layer or any other wrapper object).
+			def io
+				@ssl_socket
+			end
+
+			# makes sure any data in the que is send and calls `flush` on the socket, to make sure the buffer is sent.
+			def flush
+				begin
+					send
+					@ssl_socket.flush
+				rescue => e
+					
+				end
+			end
+
+			# returns true if the service is disconnected
+			def disconnected?
+				(@socket.closed? || @ssl_socket.closed? || @socket.stat.mode == 0140222) rescue true # if mode is read only, it's the same as closed.
+			end
+
+			# identification markers
+
+			#returns the service type - set to normal
+			def service_type
+				'ssl'
+			end
+			#returns true if the service is encrypted using the OpenSSL library.
+			def ssl?
+				true
+			end
+
+			#################
+			# overide the followind methods for any child class.
+
+			# this is a public method and it should be used by child classes to implement each
+			# read(_nonblock) action. accepts one argument ::size for an optional buffer size to be read.
+			def read size = 1048576
+				data = ''
+				begin
+					loop { data << @ssl_socket.read_nonblock(size).to_s }
+				rescue => e
+					
+				end
+				return false if data.to_s.empty?
+				touch
+				data
+			end
+
+			protected
+
+			# this is a protected method, it should be used by child classes to implement each
+			# send action.
+			def _send data
+				@active_time += 7200
+				@ssl_socket.write data
+				touch
+			end
+
+			public
+
+			# SSL certificate
+
+			# returns the current self-signed certificate - or creates a new one, if there is no current certificate.
+			def self.self_cert bits=2048, cn=nil, comment='a self signed certificate for when we only need encryption and no more.'
+				@@self_cert ||= create_cert
+				return *@@self_cert
+			end
+			#creates a self-signed certificate
+			def self.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=#{host_name.join('.')}"
+				end			
+				# cn ||= "CN=#{Socket::gethostbyname(Socket::gethostname)[0] rescue Socket::gethostname}"
+
+				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.now
+				cert.not_after = Time.now + (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
+	end
+end

data/lib/plezi/eventmachine/timers.rb

@@ -0,0 +1,117 @@
+module Plezi
+	module EventMachine
+
+		# 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 interval, repeat_limit = -1, args=[], job=nil
+				@interval = interval
+				@repeat_limit = repeat_limit ? repeat_limit.to_i : -1
+				@job = job || (Proc.new { stop! })
+				@next = Time.now + interval
+				@args = args
+			end
+
+			# stops a timed event.
+			def stop!
+				@repeat_limit = 0
+			end
+
+			# Returns true if the timer is finished.
+			#
+			# If the timed event is due, this method will also add the event to the queue.
+			def done?(time = Time.now)
+				return false unless @next <= time
+				return true if @repeat_limit == 0
+				@repeat_limit -= 1 if @repeat_limit.to_i > 0
+				EventMachine.queue @args, @job
+				@next = time + @interval
+				@repeat_limit == 0
+			end
+		end
+
+		module_function
+
+		# the timers stack.
+		TIMERS = []
+		# the timers stack Mutex.
+		TIMERS_LOCK = Mutex.new
+
+		# Creates a TimedEvent object and adds it to the Timers stack.
+		def timed_job seconds, limit = false, args = [], block = nil
+			TIMERS_LOCK.synchronize {TIMERS << TimedEvent.new(seconds, limit, args, block); TIMERS.last}
+		end
+
+		# returns true if there are any unhandled events
+		def timers?
+			TIMERS.any?
+		end
+
+		# cycles through timed jobs, executing and/or deleting them if their time has come.
+		def fire_timers
+			TIMERS_LOCK.synchronize { time = Time.now; TIMERS.delete_if {|t| t.done? time} }
+		end
+		# clears all timers
+		def clear_timers
+			TIMERS_LOCK.synchronize { TIMERS.clear }
+		end
+
+	end
+
+	module_function
+
+	# # returns true if there are any unhandled events
+	# def timers?
+	# 	EventMachine.timers?
+	# end
+
+	# 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.
+	#
+	# Timed event's time of execution is dependant on the workload and continuous uptime of the process (timed events AREN'T persistant).
+	def run_after seconds, *args, &block
+		EventMachine.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.
+	#
+	# Timed event's time of execution is dependant on the workload and continuous uptime of the process (timed events AREN'T persistant).
+
+	def run_at time, *args, &block
+		EventMachine.timed_job( (Time.now - 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.
+	#
+	# Timed event's time of execution is dependant on the workload and continuous uptime of the process (timed events AREN'T persistant).
+	def run_every seconds, limit = -1, *args, &block
+		EventMachine.timed_job seconds, limit, args, block
+	end
+end

data/lib/plezi/eventmachine/workers.rb

@@ -0,0 +1,35 @@
+module Plezi
+	module EventMachine
+
+		# A single worker.
+		class Worker
+			def initialize
+				@stop = false
+				wait = Worker.get_wait
+				@thread = Thread.new { EventMachine.run wait until @stop }
+			end
+			def stop
+				@stop = true
+			end
+			def join
+				stop
+				@thread.join rescue true
+			end
+			def alive?
+				@thread.alive?
+			end
+			def status
+				@thread.status
+			end
+			def self.get_wait
+				@primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37] 
+				@instances ||= -1
+				@instances += 1 if @instances < 7
+				@primes[@instances] / 10.0
+			end
+			def self.reset_wait
+				@instances = -1
+			end
+		end
+	end
+end

data/lib/plezi/handlers/http_host.rb

@@ -13,12 +13,12 @@ module Plezi
 		# parameters are the same (almost) as `add_service` and include `root` for file root, `assets`
 		# and other non service related options.
 		def initialize params = {}
-			@params = params
+			@params = params.dup
 			@routes = []
 			# params[:save_assets] = true unless params[:save_assets] == false
-			params[:index_file] ||= 'index.html'
-			params[:assets_public] ||= '/assets'
-			params[:assets_public].chomp! '/'
+			@params[:index_file] ||= 'index.html'
+			@params[:assets_public] ||= '/assets'
+			@params[:assets_public].chomp! '/'
 
 			@sass_cache = Sass::CacheStores::Memory.new if defined?(::Sass)
 			# @sass_cache_lock = Mutex.new

data/lib/plezi/handlers/magic_helpers.rb

@@ -17,29 +17,9 @@ module Plezi
 			elsif key.is_a?(String) && self.has_key?( key.to_sym)
 				key = key.to_sym
 			end
-			@controller.response.set_cookie key, (val ? val.dup : nil) if @controller
+			@controller.response.set_cookie key, (val ? val.to_s.dup : nil) if @controller
 			super
 		end
 	end
 
-	# tweeks a hash object to read both :symbols and strings (similar to Rails but without).
-	def self.make_hash_accept_symbols hash
-		@magic_hash_proc ||= Proc.new do |hs,k|
-			if k.is_a?(Symbol) && hs.has_key?( k.to_s)
-				hs[k.to_s]
-			elsif k.is_a?(String) && hs.has_key?( k.to_sym)
-				hs[k.to_sym]
-			elsif k.is_a?(Numeric) && hs.has_key?(k.to_s.to_sym)
-				hs[k.to_s.to_sym]
-			end
-		end
-		hash.default_proc = @magic_hash_proc
-		hash.values.each do |v|
-			if v.is_a?(Hash)
-				make_hash_accept_symbols v
-			end
-		end
-	end
-
-
 end