plezi 0.7.7 → 0.8.1

data/lib/plezi/{base → common}/logging.rb

@@ -33,28 +33,28 @@ module Plezi
 	end
 
 	# logs info
-	def log line
-		@logger.info line
-		@copy_to_stdout.info line if @copy_to_stdout
+	def log data
+		@logger.info data
+		@copy_to_stdout.info data if @copy_to_stdout
 	end
 	# logs info
-	def info line
-		@logger.info line
-		@copy_to_stdout.info line if @copy_to_stdout
+	def info data
+		@logger.info data
+		@copy_to_stdout.info data if @copy_to_stdout
 	end
 	# logs warning
-	def warn line
-		@logger.warn line
-		@copy_to_stdout.warn line if @copy_to_stdout
+	def warn data
+		@logger.warn data
+		@copy_to_stdout.warn data if @copy_to_stdout
 	end
 	# logs errors
-	def error line
-		@logger.error line
-		@copy_to_stdout.error line if @copy_to_stdout
+	def error data
+		@logger.error data
+		@copy_to_stdout.error data if @copy_to_stdout
 	end
 	# logs a fatal error
-	def fatal line
-		@logger.fatal line
-		@copy_to_stdout.fatal line if @copy_to_stdout
+	def fatal data
+		@logger.fatal data
+		@copy_to_stdout.fatal data if @copy_to_stdout
 	end
 end

data/lib/plezi/eventmachine/connection.rb

@@ -0,0 +1,192 @@
+# encoding: UTF-8
+
+
+
+module Plezi
+
+	module EventMachine
+
+		class Connection
+			attr_reader :socket, :params, :active_time, :out_que, :locker
+			attr_accessor :protocol, :handler, :timeout
+
+			# initializes the connection and it's settings.
+			def initialize socket, params
+				@socket, @params, @handler = socket, params, params[:handler]
+				# socket.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, "\n\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" #== [10 sec 0 usec].pack '1_2'
+				@out_que, @locker = [], Mutex.new
+				@protocol = params[:protocol].is_a?(Class) ? (params[:protocol].new self, params) : params[:protocol]
+				@protocol.on_connect if @protocol.is_a?(Protocol)
+				touch
+				@timeout ||= 5
+			end
+
+			# used by the EM when the connection should handle data.
+			def call
+				# don't let competing threads do the same job.
+				return false if @locker.locked?
+				begin
+					@locker.synchronize do
+						return disconnect if disconnected?
+						protocol.on_message
+					end
+
+				rescue Exception => e
+					PL.error e
+					return disconnect
+				end
+			end
+
+			def clear?
+				return false unless timedout? || disconnected?
+				disconnect
+				true
+			end
+
+			# checks if a connection timed out
+			def timedout?
+				Time.now - @active_time > @timeout.to_i
+			end
+
+			# resets the timer for the connection timeout
+			def touch
+				@active_time = Time.now
+			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
+				@socket
+			end
+
+			# sends data immidiately - forcing the data to be sent, flushing any pending messages in the que
+			def send data = nil
+				return false unless @out_que.any? || data
+				@locker.synchronize do
+					unless @out_que.empty?
+						@out_que.each { |d| _send d rescue disconnect }
+						@out_que.clear					
+					end
+					(_send data rescue disconnect) if data
+				end
+			end
+
+			# the non-blocking proc used for send_nonblock
+			SEND_COMPLETE_PROC = Proc.new {|c| c.send }
+
+			# sends data without waiting - data might be sent in a different order then intended.
+			def send_nonblock data
+				touch
+				@locker.synchronize {@out_que << data}
+				EventMachine.queue [self], SEND_COMPLETE_PROC
+			end
+
+			# adds data to the out buffer - but doesn't send the data until a send event is called.
+			def << data
+				touch
+				@locker.synchronize {@out_que << data}
+			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
+				send
+				io.flush
+			end
+
+			# the proc used to remove the connection from the IO stack.
+			REMOVE_CONNECTION_PROC = Proc.new {|old_io| EventMachine.remove_io old_io }
+			# called once a socket is disconnected or needs to be disconnected.
+			def on_disconnect
+				EventMachine.queue [@socket], REMOVE_CONNECTION_PROC
+				@locker.synchronize do
+					@out_que.each { |d| _send d rescue true}
+					@out_que.clear
+					io.flush rescue true
+					io.close rescue true
+				end
+				EventMachine.queue [], protocol.method(:on_disconnect) if protocol && !protocol.is_a?(Class)
+			end
+
+			# status markers
+
+			# closes the connection
+			def close
+				@locker.synchronize do
+					io.flush rescue true
+					io.close rescue true
+				end
+			end
+			# returns true if the service is disconnected
+			def disconnected?
+				(@socket.closed? || socket.stat.mode == 0140222) rescue true # if mode is read only, it's the same as closed.
+			end
+			# the async disconnect proc
+			FIRE_DISCONNECT_PROC = Proc.new {|handler| handler.on_disconnect }
+			# disconects the service.
+			def disconnect
+				@out_que.clear
+				EventMachine.queue [self], FIRE_DISCONNECT_PROC
+			end
+			# returns true if the socket has content to be read.
+			def has_incoming_data?
+				 (@socket.stat.size > 0) rescue false
+			end
+
+
+			# identification markers
+
+			#returns the service type - set to normal
+			def service_type
+				'normal'
+			end
+			#returns true if the service is encrypted using the OpenSSL library.
+			def ssl?
+				false
+			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
+				begin
+					data = @socket.recv_nonblock( size )
+					return nil if data.to_s.empty?
+					touch
+					data
+				rescue Exception => e
+					
+				end
+			end
+			# # 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_line
+			# 	data = @line_data ||= ''
+			# 	begin
+			# 		data << @socket.recv_nonblock( 1 ).to_s until data[-1] == "\n"
+			# 		@line_data = ''
+			# 		return data
+			# 	rescue => e
+			# 		return false
+			# 	ensure
+			# 		touch
+			# 	end
+			# 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
+				len = data.bytesize
+				act = @socket.send data, 0
+				while len > act
+					act += @socket.send data.byteslice(act..-1) , 0
+				end
+				touch
+			end
+
+		end
+	end
+end

data/lib/plezi/eventmachine/em.rb

@@ -0,0 +1,95 @@
+module Plezi
+
+	# This module holds the events, timers and IO logic and workflow (asynchronous workflow).
+	#
+	# Timed events are approximated and their exact time of execution is dependant on the workload and continues uptime of the process (timed events AREN'T persistant)
+	module EventMachine
+
+		module_function
+
+		# sets the amount of worker threads cycling the event machine and starts (or re-starts) the event machine.
+		def start count=12
+			@workers ||= []
+			@workers_lock ||= Mutex.new
+			stop unless @workers.count <= count
+			(count - @workers.count).times {@workers << Worker.new}
+		end
+
+		# runs through all existing events and one idle cycle
+		def run wait = 0.1
+			begin
+				fire_timers
+				do_job while do_job
+				# replace with io
+				review_io || sleep(wait)
+			rescue => e
+				Plezi.error e
+			end
+		end
+
+		def stop_and_wait
+			@workers_lock.synchronize { @workers.each {|w| w.stop }; @workers.each {|w| w.join }; @workers.clear; Worker.reset_wait}
+		end
+
+		def stop
+			@workers_lock.synchronize { @workers.each {|w| w.stop } ; @workers.clear; Worker.reset_wait}
+		end
+
+		def running?
+			@workers && @workers.any?
+		end
+		def count_living_workers
+			(@workers_lock.synchronize { @workers.select {|w| w.alive? } } ).count
+		end
+		def workers_status
+			@workers_lock.synchronize { @workers.map {|w| w.status } }
+		end
+
+		SHUTDOWN_CALLBACKS = []
+		# runs the shutdown queue
+		def shutdown
+			stop_and_wait rescue false
+			old_timeout = io_timeout
+			io_timeout = 0.001
+			run
+			io_timeout = old_timeout
+			do_job while do_job
+			stop_connections
+			do_job while do_job
+			QUEUE_LOCKER.synchronize do
+				SHUTDOWN_CALLBACKS.each { |s_job| s_job[0].call(*s_job[1]) }
+				SHUTDOWN_CALLBACKS.clear
+			end
+			true
+		end
+		# Adds a callback to be called once the services were shut down. see: callback for more info.
+		def on_shutdown object=nil, method=nil, *args, &block
+			if block && !object && !method
+				QUEUE_LOCKER.synchronize {SHUTDOWN_CALLBACKS << [block, args]}
+			elsif block
+				QUEUE_LOCKER.synchronize {SHUTDOWN_CALLBACKS << [(Proc.new {|*a| block.call(object.method(method).call(*a))} ), args]}
+			elsif object && method
+				QUEUE_LOCKER.synchronize {SHUTDOWN_CALLBACKS << [object.method(method), args]}
+			end
+		end
+
+	end
+
+	module_function
+
+	# Plezi event cycle settings: gets how many worker threads Plezi will initially run.
+	def max_threads
+		@max_threads ||= 16
+	end
+	# Plezi event cycle settings: sets how many worker threads Plezi will initially run.
+	def max_threads= value
+		raise "Plezi will hang and do nothing if there isn't at least one (1) working thread. Cannot set Plezi.max_threads = #{value}" if value.to_i <= 0
+		@max_threads = value.to_i
+		start @max_threads if EventMachine.running?
+	end
+
+	# Adds a callback to be called once the services were shut down. see: callback for more info.
+	def on_shutdown object=nil, method=nil, *args, &block
+		EventMachine.on_shutdown object, method, *args, &block
+	end
+end

data/lib/plezi/eventmachine/io.rb

@@ -0,0 +1,265 @@
+module Plezi
+	module EventMachine
+
+		# a basic IO listening socket wrapper.
+		class BasicIO
+
+			# attribute readers
+			attr_reader :io, :params
+			# initialize the listener with the actual socket and the properties.
+			def initialize io, params
+				@io, @params = io, params
+			end
+			# returns true if the socket is closed and the object can be cleared.
+			def clear?
+				@io.closed?
+			end
+			# accepts a new connection, adding it to the IO stack, so that it will be reviewed.
+			def call
+				begin
+					socket = io.accept_nonblock
+					handler = (@params[:ssl] ? SSLConnection : Connection).new socket, @params
+					EventMachine.add_io socket, handler
+				rescue Errno::EWOULDBLOCK => e
+
+				rescue OpenSSL::SSL::SSLError => e
+					Plezi.info "Due to an SSL issue, the connection was refused (maybe untrusted certificate)?"
+
+				rescue => e
+					Plezi.error e
+				end
+			end
+		end
+		module_function
+
+		# the IO stack.
+		EM_IO = {}
+		# the IO Mutex
+		IO_LOCKER = Mutex.new
+
+		# Adds an io object to the Plezi event machine.
+		#
+		# accepts:
+		# io:: an actual IO object (i.e. socket) that can be passed on to IO.select.
+		# job:: an object that answers to #call. job#call will be called whenever the IO object is flagged by IO.select.
+		#
+		def add_io io, job
+			IO_LOCKER.synchronize { EM_IO[io] = job }
+		end
+
+		# removes an IO from the event machine.
+		def remove_io io
+			IO_LOCKER.synchronize { (EM_IO.delete io).close rescue true }
+		end
+
+		# deletes any connections that are closed or timed out.
+		def clear_connections
+			IO_LOCKER.synchronize { EM_IO.delete_if { |io, c| c.clear? } }
+		end
+
+		# forces the event machine to forget all the existing connections (they will not be reviewed any longer).
+		def forget_connections
+			IO_LOCKER.synchronize { EM_IO.clear }
+		end
+
+		# stops all the connections without stopping the lisntener IO's.
+		def stop_connections
+			IO_LOCKER.synchronize { EM_IO.each { |io, c| Plezi.run_async { c.disconnect rescue true }  } }
+		end
+
+		# set the default idle waiting time.
+		@io_timeout = 0.1
+
+		# Plezi event cycle settings: how long to wait for IO activity before forcing another cycle.
+		#
+		# No timing methods will be called during this interval.
+		#
+		# Gets the current idle setting. The default setting is 0.1 seconds.
+		def io_timeout
+			@io_timeout
+		end
+		# Plezi event cycle settings: how long to wait for IO activity before forcing another cycle.
+		#
+		# No timing methods will be called during this interval (#run_after / #run_every).
+		# 
+		# It's rare, but it's one of the reasons for the timeout: some connections might wait for the timeout befor being established.
+		#
+		# set the current idle setting
+		def io_timeout= value
+			@io_timeout = value
+		end
+
+		# the proc for async IO removal, in case of IO exceptions raised by unexpectedly closed sockets.
+		IO_CLEAR_ASYNC_PROC = Proc.new {|c| c.protocol.on_disconnect if (c.protocol rescue false) }
+
+		# hangs for IO data or io_timeout
+		def review_io
+			return false if IO_LOCKER.locked?
+			IO_LOCKER.synchronize do
+				return false unless queue_empty? && EM_IO.any?
+				io_array = EM_IO.keys
+				begin
+					io_r = ::IO.select(io_array, nil, io_array, @io_timeout)
+					return false unless io_r
+					io_r[0].each {|io| queue [], EM_IO[io] }
+					io_r[2].each { |io| EM_IO.delete io }
+				rescue Errno::EWOULDBLOCK => e
+
+				rescue => e
+					EM_IO.keys.each {|io| EventMachine.queue [EM_IO.delete(io)], IO_CLEAR_ASYNC_PROC if io.closed?}
+					raise e
+				end
+				true
+			end
+		end
+
+	end
+
+	module DSL
+		module_function
+
+		# public API to add a service to the framework.
+		# accepts a Hash object with any of the following options (Hash keys):
+		# port:: port number. defaults to 3000 or the port specified when the script was called.
+		# host:: the host name. defaults to any host not explicitly defined (a catch-all).
+		# alias:: a String or an Array of Strings which represent alternative host names (i.e. `alias: ["admin.google.com", "admin.gmail.com"]`).
+		# root:: the public root folder. if this is defined, static files will be served from the location.
+		# assets:: the assets root folder. defaults to nil (no assets support). if the path is defined, assets will be served from `/assets/...` (or the public_asset path defined) before any static files. assets will not be served if the file in the /public/assets folder if up to date (a rendering attempt will be made for systems that allow file writing).
+		# assets_public:: the assets public uri location (uri format, NOT a file path). defaults to `/assets`. assets will be saved (or rendered) to the assets public folder and served as static files.
+		# assets_callback:: a method that accepts one parameters: `request` and renders any custom assets. the method should return `false` unless it has created a response object (`response = Plezi::HTTPResponse.new(request)`) and sent a response to the client using `response.finish`.
+		# save_assets:: saves the rendered assets to the filesystem, under the public folder. defaults to false.
+		# templates:: the templates root folder. defaults to nil (no template support). templates can be rendered by a Controller class, using the `render` method.
+		# ssl:: if true, an SSL service will be attempted. if no certificate is defined, an attempt will be made to create a self signed certificate.
+		# ssl_key:: the public key for the SSL service.
+		# ssl_cert:: the certificate for the SSL service.
+		#
+		# some further options, which are unstable and might be removed in future versions, are:
+		# protocol:: the protocol objects (usually a class, but any object answering `#call` will do).
+		# handler:: an optional handling object, to be called upon by the protocol (i.e. #on_message, #on_connect, etc'). this option is used to allow easy protocol switching, such as from HTTP to Websockets. 
+		#
+		# Duringn normal Plezi behavior, the optional `handler` object will be returned if `listen` is called more than once for the same port.
+		#
+		# assets:
+		#
+		# assets support will render `.sass`, `.scss` and `.coffee` and save them as local files (`.css`, `.css`, and `.js` respectively)
+		# before sending them as static files.
+		#
+		# templates:
+		#
+		# ERB, Slim and Haml are natively supported.
+		#
+		def listen parameters = {}
+			# update default values
+			parameters = {assets_public: '/assets'}.update(parameters)
+
+			# set port if undefined
+			if !parameters[:port] && defined? ARGV
+				if ARGV.find_index('-p')
+					port_index = ARGV.find_index('-p') + 1
+					parameters[:port] ||= ARGV[port_index].to_i
+					ARGV[port_index] = (parameters[:port] + 1).to_s
+				else
+					ARGV << '-p'
+					ARGV << '3001'
+					parameters[:port] ||= 3000
+				end
+			end
+
+			#keeps information of past ports.
+			@listeners ||= {}
+			@listeners_locker = Mutex.new
+
+			# check if the port is used twice.
+			if @listeners[parameters[:port]]
+				puts "WARNING: port aleady in use! returning existing service and attemptin to add host (maybe multiple hosts? use `host` instead)." unless parameters[:host]
+				@active_router = @listeners[parameters[:port]].params[:handler] || @listeners[parameters[:port]].params[:protocol]
+				@active_router.add_host parameters[:host], parameters if @active_router.is_a?(HTTPRouter)
+				return @active_router
+			end
+
+			# make sure the protocol exists.
+			unless parameters[:protocol]
+				parameters[:protocol] = HTTPProtocol
+				parameters[:handler] ||=  HTTPRouter.new
+			end
+
+			# create the EventMachine IO object.
+			io = defined?(PLEZI_ON_RACK) ? parameters : EventMachine::BasicIO.new( TCPServer.new(parameters[:port]), parameters)
+			EventMachine.add_io io.io, io unless defined? PLEZI_ON_RACK
+			@listeners_locker.synchronize { @listeners[parameters[:port]] = io }
+			# set the active router to the handler or the protocol.
+			@active_router = (parameters[:handler] || parameters[:protocol])
+			@active_router.add_host(parameters[:host], parameters) if @active_router.is_a?(HTTPRouter)
+
+			Plezi.run_async { Plezi.info "Started listening on port #{parameters[:port]}." } unless defined?(PLEZI_ON_RACK)
+
+			# return the current handler or the protocol..
+			@active_router
+		end
+
+		# Plezi Engine, DO NOT CALL. creates the thread pool and starts cycling through the events.
+		def start_services
+			if @listeners && @listeners.any?
+				# prepare threads
+				exit_flag = false
+				threads = []
+				Plezi.run_every(5, &EventMachine.method(:clear_connections))
+				Plezi.run_every(3_600) {GC.start; Plezi.info "Refreshing worker threads."; EventMachine.stop; EventMachine.start Plezi.max_threads}
+				# run_every( 1 , Proc.new() { Plezi.info "#{IO_CONNECTION_DIC.length} active connections ( #{ IO_CONNECTION_DIC.select{|k,v| v.protocol.is_a?(WSProtocol)} .length } websockets)." })
+				# run_every 10 , -> {Plezi.info "Cache report: #{CACHE_STORE.length} objects cached." } 
+				puts "Services running Plezi version #{Plezi::VERSION}. Press ^C to stop"
+				EventMachine.start Plezi.max_threads
+
+				# set signal tarps
+				trap('INT'){ exit_flag = true; raise "close Plezi" }
+				trap('TERM'){ exit_flag = true; raise "close Plezi" }
+				# sleep until trap raises exception (cycling might cause the main thread to ignor signals and lose attention)
+				sleep rescue true
+				# avoid refreshing the working threads and stop all timed events.
+				EventMachine.clear_timers
+				# start shutdown.
+				exit_flag = true
+				# set new tarps
+				trap('INT'){ puts 'Forced exit.'; Kernel.exit } #rescue true}
+				trap('TERM'){ puts 'Forced exit.'; Kernel.exit } #rescue true }
+				puts 'Started shutdown process. Press ^C to force quit.'
+				# shut down listening sockets
+				stop_services
+				# cycle down threads
+				Plezi.info "Finishing up and running shutdown tasks."
+			end
+			EventMachine.shutdown
+			Plezi.info "Plezi shutdown as requested."
+			puts "Since we're resting, why not practice Tai Chi?"
+			# return exit code?
+			0
+		end
+		# Closes and removes listening IO's registered by Plezi using #listen
+		def stop_services
+			Plezi.info 'Stopping services'
+			@listeners_locker.synchronize { @listeners.each {|port, io| EventMachine.remove_io(io.io); Plezi.info "Stoped listening on port #{port}" } ; @listeners.clear } if @listeners
+			true
+		end
+	end
+
+	module_function
+
+	# Plezi event cycle settings: how long to wait for IO activity before forcing another cycle.
+	#
+	# No timing methods will be called during this interval.
+	#
+	# Gets the current idle setting. The default setting is 0.1 seconds.
+	def idle_sleep
+		EventMachine.io_timeout
+	end
+	# Plezi event cycle settings: how long to wait for IO activity before forcing another cycle.
+	#
+	# No timing methods will be called during this interval (#run_after / #run_every).
+	# 
+	# It's rare, but it's one of the reasons for the timeout: some connections might wait for the timeout befor being established.
+	#
+	# set the current idle setting
+	def idle_sleep= value
+		EventMachine.io_timeout = value
+	end
+end