plezi 0.7.7 → 0.8.1

data/lib/plezi/base/io_reactor.rb

@@ -1,62 +0,0 @@
-
-module Plezi
-
-	module_function
-
-	# set the default idle waiting time.
-	@idle_sleep = 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 idle_sleep
-		@idle_sleep
-	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
-		@idle_sleep = value
-	end
-
-	# DANGER ZONE - Plezi Engine. the io reactor mutex
-	IO_LOCKER = Mutex.new
-
-	# Plezi Engine, DO NOT CALL. waits on IO and pushes events. all threads hang while reactor is active (unless events are already 'in the pipe'.)
-	def io_reactor
-		IO_LOCKER.synchronize do
-			return false unless EVENTS.empty?
-			united = SERVICES.keys + IO_CONNECTION_DIC.keys
-			return false if united.empty?
-			io_r = (IO.select(united, nil, united, @idle_sleep) ) #rescue false)
-			if io_r
-				io_r[0].each do |io|
-					if SERVICES[io]
-						begin
-							connection = io.accept_nonblock
-							push_event method(:add_connection), connection, SERVICES[io]
-						rescue Errno::EWOULDBLOCK => e
-
-						rescue Exception => e
-							error e
-							# SERVICES.delete s if s.closed?
-						end
-					elsif IO_CONNECTION_DIC[io]
-						push_event IO_CONNECTION_DIC[io].method(:on_message)
-					else
-						IO_CONNECTION_DIC.delete(io)
-						SERVICES.delete(io)
-					end
-				end
-				io_r[2].each { |io| (IO_CONNECTION_DIC.delete(io) || SERVICES.delete(io)).close rescue true }
-			end
-		end
-		true
-	end
-end

data/lib/plezi/base/rack_app.rb

@@ -1,89 +0,0 @@
-
-module Plezi
-
-	# Rack application model support
-	module_function
-
-	# todo: move falsh into the special cookie class...?
-	
-
-	# Plezi dresses up for Rack - this is a watered down version missing some features (such as flash and WebSockets).
-	# a full featured Plezi app, with WebSockets, requires the use of the Plezi server
-	# (the built-in server)
-	def call env
-		raise "No Plezi Services" unless Plezi::SERVICES[0]
-		Object.const_set('PLEZI_ON_RACK', true) unless defined? PLEZI_ON_RACK
-
-		# re-encode to utf-8, as it's all BINARY encoding at first
-		env['rack.input'].rewind
-		env['rack.input'] = StringIO.new env['rack.input'].read.encode('utf-8', 'binary', invalid: :replace, undef: :replace, replace: '')		 	
-		env.each do |k, v|
-			if k.to_s.match /^[A-Z]/
-				if v.is_a?(String) && !v.frozen?
-					v.force_encoding('binary').encode!('utf-8', 'binary', invalid: :replace, undef: :replace, replace: '') unless v.force_encoding('utf-8').valid_encoding?
-				end
-			end
-		end
-		# re-key params
-		# new_params = {}
-		# env[:params].each {|k,v| HTTP.add_param_to_hash k, v, new_params}
-		# env[:params] = new_params
-
-		# make hashes magical
-		make_hash_accept_symbols(env)
-
-		# use Plezi Cookies
-		env['rack.request.cookie_string'] = env['HTTP_COOKIE']
-		env['rack.request.cookie_hash'] = Plezi::Cookies.new.update(env['rack.request.cookie_hash'] || {})
-
-		# chomp path
-		env['PATH_INFO'].chomp! '/'
-
-		# get response
-		response = Plezi::SERVICES[0][1][:handler].call env
-
-		return response if response.is_a?(Array)
-
-		response.finish
-		response.fix_headers
-		headers = response.headers
-		# set cookie headers
-		headers.delete 'transfer-encoding'
-		headers.delete 'connection'
-		unless response.cookies.empty?
-			headers['Set-Cookie'] = []
-			response.cookies.each {|k,v| headers['Set-Cookie'] << ("#{k.to_s}=#{v.to_s}")}
-		end
-		[response.status, headers, response.body]
-	end
-end
-
-# # rack code to set cookie headers
-# # File actionpack/lib/action_controller/vendor/rack-1.0/rack/response.rb, line 56
-#     def set_cookie(key, value)
-#       case value
-#       when Hash
-#         domain  = "; domain="  + value[:domain]    if value[:domain]
-#         path    = "; path="    + value[:path]      if value[:path]
-#         # According to RFC 2109, we need dashes here.
-#         # N.B.: cgi.rb uses spaces...
-#         expires = "; expires=" + value[:expires].clone.gmtime.
-#           strftime("%a, %d-%b-%Y %H:%M:%S GMT")    if value[:expires]
-#         secure = "; secure"  if value[:secure]
-#         httponly = "; HttpOnly" if value[:httponly]
-#         value = value[:value]
-#       end
-#       value = [value]  unless Array === value
-#       cookie = Utils.escape(key) + "=" +
-#         value.map { |v| Utils.escape v }.join("&") +
-#         "#{domain}#{path}#{expires}#{secure}#{httponly}"
-
-#       case self["Set-Cookie"]
-#       when Array
-#         self["Set-Cookie"] << cookie
-#       when String
-#         self["Set-Cookie"] = [self["Set-Cookie"], cookie]
-#       when nil
-#         self["Set-Cookie"] = cookie
-#       end
-#     end

data/lib/plezi/base/services.rb

@@ -1,57 +0,0 @@
-
-module Plezi
-
-	module_function
-
-	#######################
-	## Services pooling and calling
-
-	# DANGER ZONE - Plezi Engine. the services store
-	SERVICES = {}
-	# DANGER ZONE - Plezi Engine. the services mutex
-	S_LOCKER = Mutex.new
-
-	# public API to add a service to the framework.
-	# accepts:
-	# port:: port number
-	# parameters:: a hash of parameters that are passed on to the service for handling (and from there, service dependent, to the protocol and/or handler).
-	#
-	# parameters are any of the following:
-	# 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.
-	#
-	#
-	# 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. if it is impossible to write the files, they will be rendered dynamically for every request (it would be better to render them before-hand).
-	#
-	# templates:
-	#
-	# templates can be either an ERB file on a Haml file.
-	#
-	def add_service port, parameters = {}
-		parameters[:port] ||= port
-		parameters[:service_type] ||= ( parameters[:ssl] ? SSLService : BasicService)
-		service = nil
-		service = parameters[:service_type].create_service(port, parameters) unless ( defined?(BUILDING_PLEZI_TEMPLATE) || defined?(PLEZI_ON_RACK) )
-		S_LOCKER.synchronize {SERVICES[service] = parameters}
-		Plezi.callback Plezi, :info, "Started listening on port #{port}."
-		true
-	end
-
-	# Plezi Engine, DO NOT CALL. stops all services - active connection will remain open until completion.
-	def stop_services
-		info 'Stopping services'
-		S_LOCKER.synchronize {SERVICES.each {|s, p| s.close rescue true; info "Stoped listening on port #{p[:port]}"}; SERVICES.clear }
-	end
-
-end

data/lib/plezi/base/timers.rb

@@ -1,71 +0,0 @@
-
-module Plezi
-
-	module_function
-
-	#######################
-	## Timed Events / Multi-tasking
-
-	# DANGER ZONE - Plezi Engine. an Array containing all the current events.
-	TIMERS = []
-	# DANGER ZONE - Plezi Engine. the Mutex locker for the event machine.
-	T_LOCKER = Mutex.new
-
-	# This class is used by Plezi to hold events and push them into the events stack when the time comes.
-	class TimedEvent
-
-		def initialize seconds, repeat, handler, args, block
-			@time = Time.now + seconds
-			@seconds, @repeat, @handler, @args, @block  = seconds, repeat, handler, args, block
-		end
-
-		def done?
-			return false unless @time <= Time.now
-			Plezi.push_event @handler, *@args, &@block
-			return true unless @repeat
-			@time = Time.now + @seconds
-			false
-		end
-
-		def stop_repeat
-			@repeat = false
-		end
-
-		attr_reader :timed
-	end
-
-	# returns true if there are any unhandled events
-	def timers?
-		T_LOCKER.synchronize {!TIMERS.empty?}
-	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.
-	# handler:: an object that answers to `call`, usually a Proc or a method.
-	# *arg:: any arguments that will be passed to the handler's `call` method.
-	#
-	# if a block is passed along, it will be used as a callback: the block will be called with the values returned by the handler's `call` method.
-	def run_after seconds, handler, *args, &block
-		T_LOCKER.synchronize {TIMERS << TimedEvent.new(seconds, false, handler, args, block); TIMERS.last}
-	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.
-	# handler:: an object that answers to `call`, usually a Proc or a method.
-	# *arg:: any arguments that will be passed to the handler's `call` method.
-	#
-	# if a block is passed along, it will be used as a callback: the block will be called with the values returned by the handler's `call` method.
-	def run_every seconds, handler, *args, &block
-		T_LOCKER.synchronize {TIMERS << TimedEvent.new(seconds, true, handler, args, block); TIMERS.last}
-	end
-
-	# DANGER ZONE - Used by the Plezi engine to review timed events and push them to the event stack
-	def fire_timers
-		return false if T_LOCKER.locked?
-		T_LOCKER.synchronize { TIMERS.delete_if {|t| t.done? } }
-	end
-end

data/lib/plezi/server/README.md

@@ -1,33 +0,0 @@
-# server object\file structure
-
-- services
-
-this folder holds the modules and classes regarding the core-services classes (normal TCP/IP service and SSL service should be here).
-
-services have one protocol that parses incoming requests and one handler that takes the parsed request and responds to it.
-
-both protocols and handlers can be changed mid-stream, allowing a service to switch protocols (such as from HTTP to WebSockets, HTTP/1.1 to SPDY etc') or a handler.
-
-- protocols
-
-this folder holds the different protocols that could be run over the each socket-service (HTTP / WebSockets etc' should be here).
-
-the protocols are devided into two different classes/object types:
-
-1. parsing input.
-2. formatting output.
-
-- handlers
-
-this folder holds the classes and modules used to actually handle the requests parsed by the protocol layer.
-
-these are the classes and modules the Plezi framework users (developers) connect with when writing their web apps.
-
-## servers, services and protocols ... what?
-
-services are the part of the server that recieves and sends data - services run specific protocols that together make up the whole of a server.
-
-this division allows the user to change protocols mid-stream when allowed (such as switching from HTTP to WebSockets).
-
-this abstraction to the sockets layer allows support for future or custom protocols without any changes to the abstraction layer.
-

data/lib/plezi/server/services/basic_service.rb

@@ -1,224 +0,0 @@
-module Plezi
-
-	# this class is a basic TCP socket service.
-	#
-	# a protocol should be assigned, or the service will fall back to an echo service.
-	#
-	# a protocol should answer to: on_connect(service), on_message(service, data), on_disconnect(service) and on_exception(service, exception)
-	#
-	# the on_message method should return any data that wasn't used (to be sent again as part of the next `on_message` call, once more data is received).
-	#
-	# if the protocol is a class, these methods should be instance methods.
-	# a protocol class should support the initialize(service, parameters={}) method as well.
-	#
-	# to-do: fix logging
-	class BasicService
-
-		# create a listener (io) - will create a TCPServer socket
-		#
-		# listeners are 'server sockets' that answer to `accept` by creating a new connection socket (io).
-		def self.create_service port, parameters
-			TCPServer.new(port)
-		end
-
-		# instance methods
-
-		attr_reader :socket, :locker, :closed, :parameters, :out_que, :active_time
-		attr_accessor :protocol, :handler, :timeout
-
-		# creates a new connection wrapper object for the new socket that was recieved from the `accept_nonblock` method call.
-		def initialize socket, parameters = {}
-			@handler = parameters[:handler]
-			@socket = socket
-			# 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
-			@parameters = parameters
-			@protocol = parameters[:protocol]
-			@protocol = protocol.new self, parameters if protocol.is_a?(Class)
-			@protocol.on_connect self if @protocol && @protocol.methods.include?(:on_connect)
-			touch
-			@timeout ||= 5
-			# Plezi.callback self, :on_message
-		end
-
-		# # sets a connection timeout
-		# def set_timeout timeout = 8
-		# 	@timeout = timeout
-		# end
-
-		# checks if a connection timed out
-		def timedout?
-			Time.now - @active_time > @timeout
-		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
-			touch
-			@socket
-		end
-
-		# sends data immidiately - forcing the data to be sent, flushing any pending messages in the que
-		def send data = nil
-			return if @out_que.empty? && data.nil?
-			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
-				touch
-			end
-		end
-
-		# sends data immidiately, interrupting any pending que and ignoring thread safety.
-		def send_unsafe_interrupt data = nil
-			touch
-			_send data rescue disconnect
-		end
-
-		# sends data without waiting - data might be sent in a different order then intended.
-		def send_nonblock data
-			touch
-			locker.synchronize {@out_que << data}
-			Plezi.callback(self, :send)
-		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
-			begin
-				send
-				socket.flush				
-			rescue Exception => e
-				
-			end
-		end
-
-		# event based interface for messages.
-
-		# notice: since it is all async evet base - multipart messages might be garbled up...?
-		# todo: protect from garbeling.
-		def on_message
-			# return false if locker.locked?
-			return false if locker.locked?
-			begin
-				
-				locker.synchronize do
-					return disconnect if _disconnected?
-					protocol.on_message(self)
-				end
-
-			rescue Exception => e
-				return disconnect
-			end
-		end
-
-		# called once a socket is disconnected or needs to be disconnected.
-		def on_disconnect
-			Plezi.callback Plezi, :remove_connection, self
-			locker.synchronize do
-				@out_que.each { |d| _send d rescue true}
-				@out_que.clear
-			end
-			Plezi.callback protocol, :on_disconnect, self if protocol
-			close
-		end
-
-		# status markers
-
-		# closes the connection
-		def close
-			locker.synchronize do
-				_close rescue true
-			end
-		end
-		# returns true if the service is disconnected
-		def disconnected?
-			_disconnected?
-		end
-		# disconects the service.
-		def disconnect
-			Plezi.callback self, :on_disconnect
-		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
-			data = @socket.recv_nonblock( size )
-			touch unless data.nil? || data.empty?
-			return data
-			rescue Exception => e
-				return ''
-		end
-
-		protected
-
-		# this is a protected method, it should be used by child classes to implement each
-		# send action.
-		def _send data
-			# data.force_encoding "binary" rescue false
-			len = data.bytesize
-			act = @socket.send data, 0
-			while len > act
-				act += @socket.send data.byteslice(act..-1) , 0
-				touch
-			end
-		end
-		# this is a protected method, it should be used by child classes to implement each
-		# close action. doesn't accept any arguments.
-		def _close
-			socket.flush rescue true
-			socket.close
-		end
-		# this is a protected method, it should be used by child classes to tell if the socket
-		# was closed (returns true/false).
-		def _disconnected?
-			socket.closed? rescue true # || socket.stat.mode == 0140222 rescue true # if mode is read only, it's the same as closed.
-		end
-
-	end
-end
-
-
-######
-## example requests
-
-# GET /parsed_request HTTP/1.1
-# Host: localhost:2000
-# Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
-# Cookie: user_token=2INa32_vDgx8Aa1qe43oILELpSdIe9xwmT8GTWjkS-w
-# User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10) AppleWebKit/600.1.25 (KHTML, like Gecko) Version/8.0 Safari/600.1.25
-# Accept-Language: en-us
-# Accept-Encoding: gzip, deflate
-# Connection: keep-alive
-# X-Forwarded-For: 127.0.0.3