plezi 0.9.2 → 0.10.1

data/lib/plezi/common/logging.rb

@@ -1,60 +0,0 @@
-
-module Plezi
-
-	#######################
-	## Logging
-	module_function
-
-	# the logger object
-	@logger = ::Logger.new(STDOUT)
-
-	# gets the active logger
-	def logger
-		@logger
-	end
-	# gets the active STDOUT copy, if exists
-	def logger_copy
-		@copy_to_stdout
-	end
-
-	# create and set the logger object. accepts:
-	# log_file:: a log file name to be used for logging
-	# copy_to_stdout:: if false, log will only log to file. defaults to true.
-	def create_logger log_file = STDOUT, copy_to_stdout = false
-		@copy_to_stdout = ( copy_to_stdout ? (::Logger.new(STDOUT)) : false )
-		@logger = ::Logger.new(log_file)
-	end
-	alias :set_logger :create_logger
-
-	# writes a raw line to the log\
-	def log_raw line
-		@logger << line
-		@copy_to_stdout << line if @copy_to_stdout
-	end
-
-	# logs info
-	def log data
-		@logger.info data
-		@copy_to_stdout.info data if @copy_to_stdout
-	end
-	# logs info
-	def info data
-		@logger.info data
-		@copy_to_stdout.info data if @copy_to_stdout
-	end
-	# logs warning
-	def warn data
-		@logger.warn data
-		@copy_to_stdout.warn data if @copy_to_stdout
-	end
-	# logs errors
-	def error data
-		@logger.error data
-		@copy_to_stdout.error data if @copy_to_stdout
-	end
-	# logs a fatal error
-	def fatal data
-		@logger.fatal data
-		@copy_to_stdout.fatal data if @copy_to_stdout
-	end
-end

data/lib/plezi/eventmachine/connection.rb

@@ -1,190 +0,0 @@
-# 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?
-				close
-				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
-
-			# the proc used to remove the connection from the IO stack.
-			REMOVE_CONNECTION_PROC = Proc.new {|old_io| EventMachine.remove_io old_io }
-			# 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
-				begin				
-					@locker.synchronize do
-						unless @out_que.empty?
-							@out_que.each { |d| _send d }
-							@out_que.clear					
-						end
-						(_send data rescue disconnect) if data
-					end
-				rescue => e
-					EventMachine.queue( [@socket], REMOVE_CONNECTION_PROC)
-				end
-				true
-			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 rescue true
-			end
-
-			# called once the connection is closed.
-			#
-			def on_disconnect
-				@locker.synchronize do
-					EventMachine.queue [], protocol.method(:on_disconnect) if protocol && !protocol.is_a?(Class)
-					@protocol = false
-				end
-			end
-
-			# the non-blocking proc used for send_nonblock
-			FLUSH_AND_CLOSE_PROC = Proc.new {|c| c.flush; EventMachine.remove_io c.socket}
-
-			# Closes the connection. This is always asynchronous and will return immidiately.
-			def close
-				EventMachine.queue [self], FLUSH_AND_CLOSE_PROC
-			end
-			alias :disconnect :close
-
-			# status markers
-
-			# returns true if the service is disconnected
-			def disconnected?
-				(@socket.closed? || socket.stat.mode != 0140666) rescue true # if mode is read only, it's the same as closed.
-			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
-				i = act = @socket.send data, 0
-				while len > act && i!=0
-					act += (i = @socket.send data.byteslice(act..-1) , 0)
-				end
-				touch
-			end
-
-		end
-	end
-end

data/lib/plezi/eventmachine/em.rb

@@ -1,98 +0,0 @@
-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.each {|w| w.stop }
-			@workers.each {|w| w.join }
-			@workers_lock.synchronize { @workers.clear }
-		end
-
-		def stop
-			@workers.each {|w| w.stop }
-			@workers_lock.synchronize { @workers.clear;}
-		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
-			old_timeout = io_timeout
-			io_timeout = 0.001
-			stop_and_wait rescue false
-			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

@@ -1,272 +0,0 @@
-module Plezi
-	module EventMachine
-
-		# a basic IO listening socket wrapper.
-		class BasicIO
-
-			# attribute readers
-			attr_reader :io, :params, :protocol
-			# initialize the listener with the actual socket and the properties.
-			def initialize io, params
-				@io, @params, @protocol = io, params, false
-			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
-			def on_disconnect
-				true
-			end
-			def close
-				false
-			end
-			alias :disconnect :close
-		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
-
-		# the proc for async IO removal, in case of IO exceptions raised by unexpectedly closed sockets.
-		IO_CLEAR_ASYNC_PROC = Proc.new {|c| c.on_disconnect rescue false }
-		# removes an IO from the event machine.
-		def remove_io io
-			IO_LOCKER.synchronize { queue [(EM_IO.delete io)], IO_CLEAR_ASYNC_PROC; (io.close unless io.closed? 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| c.close } }
-		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
-
-		# 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 "** Deprecation Warning:\n- The current code for default error pages will be changed in version 0.9.0.\n- Default error pages will follow a different naming and location conventions.\n- The updated design will be part of the updated `plezi` helper script.\nPlease review your code before upgrading to the 0.9.0 version.\n"
-				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