plezi 0.9.2 → 0.10.1

data/lib/plezi/eventmachine/protocol.rb

@@ -1,54 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,144 +0,0 @@
-# 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_client]
-					context = OpenSSL::SSL::SSLContext.new
-					context.set_params verify_mode: OpenSSL::SSL::VERIFY_NONE # OpenSSL::SSL::VERIFY_PEER #OpenSSL::SSL::VERIFY_NONE
-					@ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, context)
-					@ssl_socket.sync_close = true
-					@ssl_socket.connect
-				elsif 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 != 0140666) 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
-					 (data << @ssl_socket.read_nonblock(size).to_s) until data.bytesize >= size
-				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

@@ -1,117 +0,0 @@
-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.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

@@ -1,33 +0,0 @@
-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
-				@instances = -1
-				@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
-		end
-	end
-end

data/lib/plezi/handlers/http_echo.rb

@@ -1,27 +0,0 @@
-module Plezi
-	#####
-	# this is a Handler stub class for an HTTP echo server.
-	module HTTPEcho
-		module_function
-
-		# handles requests by printing out the parsed data. gets the `request` parameter from the HTTP protocol.
-		def on_request request
-			response = HTTPResponse.new request, 200, {'content-type' => 'text/plain'}, ["parsed as:\r\n", request.to_s]
-			response.body.last << "\n\n params:"
-			request.params.each {|k,v| response.body.last << "\n#{k}: #{v}"}
-			response.send
-			response.finish
-		end
-
-		# does nothing - a simple stub as required from handlers
-		def add_route *args
-			self
-		end
-
-		# does nothing - a simple stub as required from handlers
-		def add_host *args
-			self
-		end
-	end
-
-end

data/lib/plezi/handlers/http_host.rb

@@ -1,214 +0,0 @@
-module Plezi
-	#####
-	# this is a Handler stub class for an HTTP echo server.
-	class HTTPHost
-
-		# the parameters / settings for the Host.
-		attr_reader :params
-		# the routing array
-		attr_reader :routes
-
-		# initializes an HTTP host with the parameters for the specific host.
-		#
-		# 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.dup
-			@routes = []
-			# params[:save_assets] = true unless params[:save_assets] == false
-			@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
-		end
-
-		# adds a route under the specific host
-		def add_route path, controller, &block
-			routes << Route.new(path, controller, params, &block)
-		end
-
-		# handles requests sent to the host. returns true if the host delt with the request.
-		#
-		# since hosts are required to handle the requests (send 404 errors if resources arrn't found),
-		# this method always returns true.
-		def on_request request
-			begin
-				# render any assets?
-				return true if render_assets request
-
-				# send static file, if exists and root is set.
-				return true if send_static_file request
-
-				# return if a route answered the request
-				routes.each {|r| return true if r.on_request(request) }
-
-				# send folder listing if root is set, directory listing is set and folder exists
-
-				#to-do
-
-				#return error code or 404 not found
-				send_by_code request, 404			
-			rescue Exception => e
-				# return 500 internal server error.
-				Plezi.error e
-				send_by_code request, 500
-			end
-			true
-		end
-
-		# Dresses up as a Rack app (If you don't like WebSockets, it's a reasonable aaproach).
-		def call request
-			request = Rack::Request.new request if defined? Rack
-			ret = nil
-			begin
-				# render any assets?
-				ret = render_assets request
-				return ret if ret
-
-				# send static file, if exists and root is set.
-				ret = send_static_file request
-				return ret if ret
-
-				# return if a route answered the request
-				routes.each {|r| ret = r.call(request); return ret if ret }
-
-				# send folder listing if root is set, directory listing is set and folder exists
-
-				#to-do
-
-				#return error code or 404 not found
-				return send_by_code request, 404			
-			rescue Exception => e
-				# return 500 internal server error.
-				Plezi.error e
-				return send_by_code request, 500
-			end
-			true
-		end
-
-		################
-		## basic responses
-		## (error codes and static files)
-
-		# sends a response for an error code, rendering the relevent file (if exists).
-		def send_by_code request, code, headers = {}
-			begin
-				@base_code_path ||= params[:templates] || File.expand_path('.')
-				if defined?(::Slim) && Plezi.file_exists?(fn = File.join(@base_code_path, "#{code}.html.slim"))
-					Plezi.cache_data fn, Slim::Template.new( fn ) unless Plezi.cached? fn
-					return send_raw_data request, Plezi.get_cached( fn ).render( self, request: request ), 'text/html', code, headers
-				elsif defined?(::Haml) && Plezi.file_exists?(fn = File.join(@base_code_path, "#{code}.html.haml"))
-					Plezi.cache_data fn, Haml::Engine.new( IO.read( fn ) ) unless Plezi.cached? fn
-					return send_raw_data request, Plezi.get_cached( File.join(@base_code_path, "#{code}.html.haml") ).render( self ), 'text/html', code, headers
-				elsif defined?(::ERB) && Plezi.file_exists?(fn = File.join(@base_code_path, "#{code}.html.erb"))
-					return send_raw_data request, ERB.new( Plezi.load_file( fn ) ).result(binding), 'text/html', code, headers
-				elsif Plezi.file_exists?(fn = File.join(@base_code_path, "#{code}.html"))
-					return send_file(request, fn, code, headers)
-				end
-				return true if send_raw_data(request, HTTPResponse::STATUS_CODES[code], 'text/plain', code, headers)
-			rescue Exception => e
-				Plezi.error e
-			end
-			false
-		end
-
-		# attempts to send a static file by the request path (using `send_file` and `send_raw_data`).
-		#
-		# returns true if data was sent.
-		def send_static_file request
-			return false unless params[:root]
-			file_requested = request[:path].to_s.split('/')
-			unless file_requested.include? '..'
-				file_requested.shift
-				file_requested = File.join(params[:root], *file_requested)
-				return true if send_file request, file_requested
-				return send_file request, File.join(file_requested, params[:index_file])
-			end
-			false
-		end
-
-		# sends a file/cacheed data if it exists. otherwise returns false.
-		def send_file request, filename, status_code = 200, headers = {}
-			if Plezi.file_exists?(filename) && !::File.directory?(filename)
-				return send_raw_data request, Plezi.load_file(filename), MimeTypeHelper::MIME_DICTIONARY[::File.extname(filename)], status_code, headers
-			end
-			return false
-		end
-		# sends raw data through the connection. always returns true (data send).
-		def send_raw_data request, data, mime, status_code = 200, headers = {}
-			response = HTTPResponse.new request, status_code, headers
-			response['cache-control'] = 'public, max-age=86400'					
-			response << data
-			response['content-length'] = data.bytesize
-			response.finish
-			true
-		end
-
-		###############
-		## asset rendering and responses
-
-		# renders assets, if necessary, and places the rendered result in the cache and in the public folder.
-		def render_assets request
-			# contine only if assets are defined and called for
-			return false unless @params[:assets] && request.path.match(/^#{params[:assets_public]}\/.+/)
-			# review callback, if defined
-			return true if params[:assets_callback] && params[:assets_callback].call(request)
-
-			# get file requested
-			source_file = File.join(params[:assets], *(request.path.match(/^#{params[:assets_public]}\/(.+)/)[1].split('/')))
-
-			# stop if file name is reserved / has security issues
-			return false if source_file.match(/(scss|sass|coffee|\.\.\/)$/)
-
-			# set where to store the rendered asset
-			target_file = false
-			target_file = File.join( params[:root], params[:assets_public], *request.path.match(/^#{params[:assets_public]}\/(.*)/)[1].split('/') ) if params[:root]
-
-			# send the file if it exists (no render needed)
-			if File.exists?(source_file)
-				data = Plezi.cache_needs_update?(source_file) ? Plezi.save_file(target_file, Plezi.reload_file(source_file), params[:save_assets]) : Plezi.load_file(source_file)
-				return (data ? send_raw_data(request, data, MimeTypeHelper::MIME_DICTIONARY[::File.extname(source_file)]) : false)
-			end
-
-			# render supported assets
-			case source_file
-			when /\.css$/
-				sass = source_file.gsub /css$/, 'sass'
-				sass.gsub! /sass$/, 'scss' unless Plezi.file_exists?(sass)
-				return false unless Plezi.file_exists?(sass)
-				# review mtime and render sass if necessary
-				if defined?(::Sass) && refresh_sass?(sass)
-					eng = Sass::Engine.for_file(sass, cache_store: @sass_cache)
-					Plezi.cache_data sass, eng.dependencies
-					css, map = eng.render_with_sourcemap(params[:assets_public])
-					Plezi.save_file target_file, css, params[:save_assets]
-					Plezi.save_file (target_file + ".map"), map, params[:save_assets]
-				end
-				# try to send the cached css file which started the request.
-				return send_file request, target_file
-			when /\.js$/
-				coffee = source_file.gsub /js$/i, 'coffee'
-				return false unless Plezi.file_exists?(coffee)
-				# review mtime and render coffee if necessary
-				if defined?(::CoffeeScript) && Plezi.cache_needs_update?(coffee)
-					# render coffee to cache
-					Plezi.cache_data coffee, nil
-					Plezi.save_file target_file, CoffeeScript.compile(IO.read coffee), params[:save_assets]
-				end
-				# try to send the cached js file which started the request.
-				return send_file request, target_file
-			end
-			false
-		end
-		def refresh_sass? sass
-			return false unless File.exists?(sass)
-			return true if Plezi.cache_needs_update?(sass)
-			mt = Plezi.file_mtime(sass)
-			Plezi.get_cached(sass).each {|e| return true if File.exists?(e.options[:filename]) && (File.mtime(e.options[:filename]) > mt)} # fn = File.join( e.options[:load_paths][0].root, e.options[:filename]) 
-			false
-		end
-	end
-
-end