plezi 0.11.2 → 0.12.0

data/lib/plezi/common/defer.rb

@@ -3,19 +3,19 @@ module Plezi
 
 	module_function
 
-	# Defers any missing methods to the GReactor Library.
+	# Defers any missing methods to the Iodine Library.
 	def method_missing name, *args, &block
 		return super unless REACTOR_METHODS.include? name
-		::GReactor.send name, *args, &block
+		::Iodine.__send__ name, *args, &block
 	end
-	# Defers any missing methods to the GReactor Library.
+	# Defers any missing methods to the Iodine Library.
 	def respond_to_missing?(name, include_private = false)
 		REACTOR_METHODS.include?(name) || super
 	end
 
 	protected
 
-	REACTOR_METHODS = ::GReactor.public_methods(false)
+	REACTOR_METHODS = ::Iodine.public_methods(false)
 
 end
 

data/lib/plezi/common/dsl.rb

@@ -3,22 +3,24 @@ PL = Plezi
 
 unless defined? PLEZI_NON_DSL
 
-	# shortcut for Plezi.listen.
+	# shortcut for Plezi.listen. Deprecated.
 	#
 	def listen(params = {})
 		Plezi.listen params
 	end
 
-	# adds a virtul host to the current service (the last `listen` call) or switches to an existing host within the active service.
+	# adds a virtul host or switches to an existing host, for routes setup or parameters update.
 	#
 	# accepts:
 	# host_name: a String with the full host name (i.e. "www.google.com" / "mail.google.com")
-	# params:: any of the parameters accepted by the `listen` command, except `protocol`, `handler`, and `ssl` parameters.
+	# params:: any of the parameters accepted by the {Plezi.host} command.
+	#
+	# If no host is specified or host name is `false`, the default host would be set as the active host and returned.
 	def host(host_name = false, params = {})
 		Plezi.host host_name, params
 	end
 
-	# adds a route to the last server object
+	# adds a route to the last (or default) host
 	#
 	# path:: the path for the route
 	# controller:: The controller class which will accept the route.
@@ -49,7 +51,7 @@ unless defined? PLEZI_NON_DSL
 	#
 	# magic routes make for difficult debugging - the smarter the routes, the more difficult the debugging.
 	# use with care and avoid complex routes when possible. RESTful routes are recommended when possible.
-	# json serving apps are advised to use required parameters, empty sections indicating missing required parameters (i.e. /path///foo/bar///).
+	# JSON serving apps are advised to use required parameters and empty sections indicating missing required parameters (i.e. /path///foo/bar///).
 	#
 	def route(path, controller = nil, &block)
 		Plezi.route(path, controller, &block)
@@ -74,28 +76,10 @@ unless defined? PLEZI_NON_DSL
 	end
 
 
-
-	# finishes setup of the servers and starts them up. This will hange the proceess.
-	#
-	# this method is called automatically by the Plezi framework.
-	#
-	# it is recommended that you DO NOT CALL this method.
-	# if any post shut-down actions need to be performed, use Plezi.on_shutdown instead.
-	def start_services
-		return 0 if defined?(NO_PLEZI_AUTO_START)
-		undef listen
-		undef host
-		undef route
-		undef shared_route
-		Plezi.start
-	end
-
 	# sets information to be used when restarting
 	$PL_SCRIPT = $0
 	$PL_ARGV = $*.dup
 
-	# sets up a generic session-token name based on the script name
-	GRHttp.session_token = "#{($0).split(/[\\\/]/).last.split(/[\s\.]+/).first}_uuid"
 	# restarts the Plezi app with the same arguments as when it was started.
 	#
 	# EXPERIMENTAL
@@ -104,5 +88,10 @@ unless defined? PLEZI_NON_DSL
 	end
 
 	# sets to start the services once dsl script is finished loading.
-	at_exit { start_services }
+	at_exit do
+		undef listen
+		undef host
+		undef route
+		undef shared_route
+	end
 end

data/lib/plezi/common/redis.rb

@@ -24,18 +24,18 @@ module Plezi
 										next if data[:server] == Plezi::Settings.uuid
 										data[:type] = Object.const_get(data[:type]) unless data[:type].nil? || data[:type] == :all
 										if data[:target]
-											GRHttp::Base::WSHandler.unicast data[:target], data
+											data[:type].___faild_unicast( data ) unless Iodine::Http::Websockets.unicast data[:target], data
 										else
-											GRHttp::Base::WSHandler.broadcast data
+											Iodine::Http::Websockets.broadcast data
 										end
 									rescue => e
-										GReactor.error "The following could be a security breach attempt:"
-										GReactor.error e
+										Iodine.error "The following could be a security breach attempt:"
+										Iodine.error e
 									end
 								end
 							end
 						rescue => e
-							GReactor.error e
+							Iodine.error e
 							retry
 						end
 					end
@@ -46,6 +46,10 @@ module Plezi
 				return @redis if (@redis_sub_thread && @redis_sub_thread.alive?) && @redis
 				inner_init_redis
 			end
+			def away? server
+				return true unless get_redis
+				@redis.pubsub('CHANNELS', server).empty?				
+			end
 		end
 	end
 

data/lib/plezi/common/settings.rb

@@ -6,26 +6,6 @@ module Plezi
 
 		module_function
 
-		# The maximum number of threads that are used for concurrency.
-		def max_threads
-			@max_threads ||= 30
-		end
-		# Sets the maximum number of threads that are used for concurrency.
-		def max_threads=val
-			@max_threads = val
-		end
-
-		# The number of second between pings automatically sent by an open websocket.
-		def autoping
-			@autoping ||= 45
-		end
-		# Sets the number of second between pings automatically sent by an open websocket.
-		#
-		# Set to nil or false to disable auto-pinging.
-		def autoping=val
-			@autoping = 45
-		end
-
 		# Sets the Redis Channel Name.
 		def redis_channel_name=val
 			return false unless defined? Redis
@@ -35,7 +15,7 @@ module Plezi
 		# Returns the Redis Channel Name used by this app.
 		# @return [String]
 		def redis_channel_name
-			@redis_channel_name ||= 'Plezi_Redis_Channel'
+			@redis_channel_name ||= "#{File.basename($0, '.*')}_Redis_Channel"
 		end
 
 		# Sets the message byte size limit for a Websocket message. Defaults to 0 (no limit)
@@ -45,11 +25,11 @@ module Plezi
 		#
 		# If the sessage size limit is exceeded, the disconnection will be immidiate as an attack will be assumed. The protocol's normal disconnect sequesnce will be discarded.
 		def ws_message_size_limit=val
-			GRHttp.ws_message_size_limit = val
+			Iodine::Http::Websockets.message_size_limit = val
 		end
 		# Gets the message byte size limit for a Websocket message. Defaults to 0 (no limit)
 		def ws_message_size_limit
-			GRHttp.ws_message_size_limit
+			Iodine::Http::Websockets.message_size_limit
 		end
 
 		# This Server's UUID, for Redis and unicasting identification.
@@ -58,4 +38,4 @@ module Plezi
 		end
 	end
 end
-
+Iodine.threads = 30

data/lib/plezi/handlers/controller_core.rb

@@ -16,7 +16,7 @@ module Plezi
 					@request = request
 					@params = request.params
 					@flash = response.flash
-					@host_params = request.io[:params]
+					@host_params = request[:host_settings]
 					@response = response
 					@cookies = request.cookies
 					# # \@response["content-type"] ||= ::Plezi.default_content_type
@@ -38,31 +38,24 @@ module Plezi
 					# finish if the response was sent
 					return false if response.headers_sent?
 					# make sure that the session object is available for websocket connections
-					response.session
+					session
 					# complete handshake
 					return self
 				end
 				# handles websocket opening.
-				def on_open ws
-					# set broadcasts and return true
-					@response = ws
-					ws.autoping Plezi::Settings.autoping if Plezi::Settings.autoping
-					# create the redis connection (in case this in the first instance of this class)
-					Plezi.redis
+				def on_open
 					super() if defined?(super)
 				end
 				# handles websocket messages.
-				def on_message ws
-					super(ws.data) if defined?(super)
+				def on_message data
+					super if defined?(super)
 				end
 				# handles websocket being closed.
-				def on_close ws
-					super() if defined? super
+				def on_close
+					super if defined? super
 				end
 
 				# Inner Routing
-				#
-				#
 				def _route_path_to_methods_and_set_the_response_
 					#run :before filter
 					return false if self.class.has_method?(:before) && self.before == false 

data/lib/plezi/handlers/controller_magic.rb

@@ -42,7 +42,7 @@ module Plezi
 
 			# Session data can be stored here (session data will be stored on the Redis server, if Redis is available).
 			#
-			# The first time this method is called, the session object will be created. The session object must be created BEFORE the headers are set , if it is to be used.
+			# The first time this method is called, the `n object will be created. The session object must be created BEFORE the headers are set , if it is to be used.
 			#
 			# Sessions are not automatically created, because they require more resources. The one exception is the Websocket connection that will force a session object into existence, as it's very common to use session data in Websocket connections and the extra connection time is less relevant for a long term connection.
 			def session
@@ -56,7 +56,7 @@ module Plezi
 			# these cookies will live for one successful request to a Controller and will then be removed.
 			attr_reader :flash
 
-			# the parameters used to create the host (the parameters passed to the `listen` / `add_service` call).
+			# the parameters used to create the host (the parameters passed to the `Plezi.host`).
 			attr_reader :host_params
 
 			# this method does two things.
@@ -79,7 +79,6 @@ module Plezi
 			#
 			def redirect_to url, options = {}
 				return super *[] if defined? super
-				raise 'Cannot redirect once a Websocket connection was established.' if response.is_a?(::GRHttp::WSEvent)
 				raise 'Cannot redirect after headers were sent.' if response.headers_sent?
 				url = "#{request.base_url}/#{url.to_s.gsub('_', '/')}" if url.is_a?(Symbol) || ( url.is_a?(String) && url.empty? ) || url.nil?
 				# redirect
@@ -129,8 +128,6 @@ module Plezi
 			# filename:: sets a filename for the browser to "save as". defaults to empty.
 			#
 			def send_data data, options = {}
-				raise 'Cannot use "send_data" once a Websocket connection was established.' if response.is_a?(::GRHttp::WSEvent)
-				# return response.write(data) if response.is_a?(::GRHttp::WSEvent)
 				raise 'Cannot use "send_data" after headers were sent' if response.headers_sent?
 				Plezi.warn 'HTTP response buffer is cleared by `#send_data`' if response.body && response.body.any? && response.body.clear
 				response << data
@@ -180,7 +177,12 @@ module Plezi
 				options[:type] ||= 'html'.freeze
 				options[:locale] ||= params[:locale].to_sym if params[:locale]
 				#update content-type header
-				response['content-type'] ||= "#{MimeTypeHelper::MIME_DICTIONARY[".#{options[:type]}".freeze]}; charset=utf-8".freeze
+				case options[:type]
+				when 'html', 'js', 'txt'
+					response['content-type'] ||= "#{MimeTypeHelper::MIME_DICTIONARY[".#{options[:type]}".freeze]}; charset=utf-8".freeze
+				else
+					response['content-type'] ||= "#{MimeTypeHelper::MIME_DICTIONARY[".#{options[:type]}".freeze]}".freeze
+				end
 				# Circumvents I18n persistance issues (live updating and thread data storage).
 				I18n.locale = options[:locale] || I18n.default_locale if defined?(I18n) # sets the locale to nil for default behavior even if the locale was set by a previous action - removed: # && options[:locale]
 				# find template and create template object
@@ -201,19 +203,19 @@ module Plezi
 				# respond to websocket special case
 				return :pre_connect if request.upgrade?
 				# respond to save 'new' special case
-				return (self.class.has_method?(:save) ? :save : false) if request.request_method.match(/POST|PUT|PATCH/) && (params[:id].nil? || params[:id] == 'new')
+				return (self.class.has_method?(:save) ? :save : false) if (request.request_method =~ /POST|PUT|PATCH/i.freeze) && (params[:id].nil? || params[:id] == 'new')
 				# set DELETE method if simulated
 				request.request_method = 'DELETE' if params[:_method].to_s.downcase == 'delete'
 				# respond to special :id routing
 				return params[:id].to_s.to_sym if params[:id] && self.class.has_exposed_method?(params[:id].to_s.to_sym)
 				#review general cases
 				case request.request_method
-				when 'GET', 'HEAD'
+				when 'GET'.freeze, 'HEAD'.freeze
 					return (self.class.has_method?(:index) ? :index : false) unless params[:id]
 					return (self.class.has_method?(:show) ? :show : false)
-				when 'POST', 'PUT', 'PATCH'
+				when 'POST'.freeze, 'PUT'.freeze, 'PATCH'.freeze
 					return (self.class.has_method?(:update) ? :update : false)
-				when 'DELETE'
+				when 'DELETE'.freeze
 					return (self.class.has_method?(:delete) ? :delete : false)
 				end
 				false

data/lib/plezi/handlers/http_router.rb

@@ -4,7 +4,7 @@ module Plezi
 
 		#####
 		# handles the HTTP Routing
-		class HTTPRouter
+		module HTTPRouter
 
 			class Host
 				attr_reader :params
@@ -12,8 +12,9 @@ module Plezi
 				def initialize params
 					@params = params
 					@routes = []
-					params[:assets_public_regex] = /^#{params[:assets_public].to_s.chomp('/')}\/(.+)/.freeze
-					params[:assets_refuse_templates] = /(#{AssetManager.all_extentions.join('|')}|\.\.\/)$/.freeze
+					@params[:assets_public_regex] = /^#{params[:assets_public].to_s.chomp('/')}\//i.freeze
+					@params[:assets_public_length] = @params[:assets_public].to_s.chomp('/').length + 1
+					@params[:assets_refuse_templates] = /(#{AssetManager.all_extentions.join('|')}|\.\.\/)$/i.freeze
 				end
 			end
 
@@ -25,23 +26,25 @@ module Plezi
 			def on_upgrade request, response
 				host = get_host(request[:host_name].to_s.downcase) || @hosts[:default]
 				return false unless host
-				request.io[:params] = host.params
+				request[:host_settings] = host.params
 				# return if a route answered the request
 				host.routes.each {|r| a = r.on_request(request, response); return a if a}
 				# websockets should cut out here
 				false
 			end
-			# initializes an HTTP router (the normal Handler for HTTP requests)
+			# initializes the HTTP router (the normal Handler for HTTP requests)
 			#
 			# the router holds the different hosts and sends them messages/requests.
-			def initialize
-				@hosts = {}
-				@active_host = nil
-			end
+			@hosts = {}
+			@active_host = nil
 
-			# adds a host to the router (or activates an existing host to add new routes). accepts a host name and any parameters not related to the actual connection (ssl etc') (see {Plezi.listen})
+			# adds a host to the router (or activates an existing host to add new routes). accepts a host name and any parameters not related to the actual connection (ssl etc') (see {Plezi.host})
 			def add_host host_name, params = {}
-				host_name = (host_name ? (host_name.is_a?(String) ? host_name.to_s.downcase : host_name) : :default)
+				params[:index_file] ||= 'index.html'
+				params[:assets_public] ||= '/assets'
+				params[:assets_public].chomp! '/'
+				params[:public] ||= params[:root] # backwards compatability
+				host_name = (host_name.is_a?(String) ? host_name.to_s.downcase : (host_name.is_a?(Regexp) ? host_name : :default))
 				@active_host = get_host(host_name) || ( @hosts[host_name] = Host.new(params) )
 				add_alias host_name, *params[:alias] if params[:alias]
 				@active_host
@@ -49,21 +52,21 @@ module Plezi
 			# adds an alias to an existing host name (normally through the :alias parameter in the `add_host` method).
 			def add_alias host_name, *aliases
 				host = get_host host_name
-				return false unless host
+				host ||= add_host :default
 				aliases.each {|a| @hosts[a.to_s.downcase] = host}
 				true
 			end
 
 			# adds a route to the active host. The active host is the last host referenced by the `add_host`.
 			def add_route path, controller, &block
-				raise 'No Host defined.' unless @active_host
-				@active_host.routes << Route.new(path, controller, &block)
+				@active_host ||= add_host :default
+				@active_host.routes << ::Plezi::Base::Route.new(path, controller, &block)
 			end
 
 			# adds a route to all existing hosts.
 			def add_shared_route path, controller, &block
-				raise 'No Host defined.' if @hosts.empty?
-				@hosts.each {|n, h| h.routes << Route.new(path, controller, &block) }
+				add_host :default if @hosts.empty?
+				@hosts.each {|n, h| h.routes << ::Plezi::Base::Route.new(path, controller, &block) }
 			end
 
 			# handles requests send by the HTTP Protocol (HTTPRequest objects)
@@ -71,7 +74,7 @@ module Plezi
 				begin
 					host = get_host(request[:host_name].to_s.downcase) || @hosts[:default]
 					return false unless host
-					request.io[:params] = host.params
+					request[:host_settings] = host.params
 					# render any assets?
 					return true if render_assets request, response, host.params
 					# send static file, if exists and root is set.
@@ -79,10 +82,10 @@ module Plezi
 					# return if a route answered the request
 					host.routes.each {|r| a = r.on_request(request, response); return a if a}
 					#return error code or 404 not found
-					return Base::HTTPSender.send_by_code request, response, 404 unless request[:io].params[:http_handler] == ::GRHttp::Base::Rack
+					return Base::HTTPSender.send_by_code request, response, 404 unless ( @avoid_404 ||= ( Iodine::Http.on_http == ::Iodine::Http::Rack ? 1 : 0 ) ) == 1
 				rescue => e				
 					# return 500 internal server error.
-					GReactor.error e
+					Iodine.error e
 					Base::HTTPSender.send_by_code request, response, 500
 				end
 			end
@@ -105,14 +108,14 @@ module Plezi
 				return true if params[:assets_callback] && params[:assets_callback].call(request, response)
 
 				# get file requested
-				source_file = File.join(params[:assets], *(request.path.match(params[:assets_public_regex])[1].split('/')))
+				source_file = File.join(params[:assets], *(request.path[params[:assets_public_length]..-1].split('/')))
 
 
 				# stop if file name is reserved / has security issues
 				return false if File.directory?(source_file) || source_file =~ params[:assets_refuse_templates]
 
 				# set where to store the rendered asset
-				target_file = File.join( params[:public].to_s, params[:assets_public].to_s, *request.path.match(params[:assets_public_regex])[1].split('/') )
+				target_file = File.join( params[:public].to_s, *request.path.split('/') )
 
 				# send the file if it exists (no render needed)
 				if File.exists?(source_file)
@@ -134,7 +137,9 @@ module Plezi
 				# return false if an asset couldn't be rendered and wasn't found.
 				return false
 			end
-
+			extend self
 		end
+		Iodine::Http.on_http ::Plezi::Base::HTTPRouter
+		Iodine::Http.on_websocket ::Plezi::Base::HTTPRouter.upgrade_proc
 	end
 end

data/lib/plezi/handlers/placebo.rb

@@ -3,15 +3,27 @@ module Plezi
 	# This API wil allows you to listen to Websocket Broadcasts sent to any object and to accept unicasts
 	# even when NOT connected to a websocket.
 	#
-	# Simpley create a class to handle any events and call `Plezi::Placebo.new ClassName` :
+	# Simpley create a class to handle any events and call `Plezi::Placebo.new ClassName` or use the {Plezi.start_placebo} shortcut:
 	#
-	#       class MyListener
-	#          def _my_method_name *args
-	#             #logic
-	#          end
-	#       end
+	#        # Important: set up a unique - but shared - main redis channel for BOTH Apps (The Plezi and the Placebo).
+	#        Plezi::Settings.redis_channel_name = 'unique_channel_name_for_app_b24270e2'
+	#        # Important: set Plezi's auo-Redis pub/sub server.
+	#        ENV['PL_REDIS_URL'] ||=  "redis://redis:password@redis.server.com:9999"
 	#
-	#       Plezi::Placebo.new MyListener
+	#        # create the Placebo bridge handler
+	#        class PleziBridge
+	#        	def on_open
+	#        		multicast :print, "Hello from Placebo!"
+	#        	end
+	#        	def print data
+	#        		Iodine.info "Placebo message: #{data}"
+	#        		puts "Placebo message: #{data}"
+	#        	end
+	#        end
+	#
+	#        # initiate Placebo mode using the bridge class. it's possible to create multiple
+	#        # it's possible to create multiple bridge classes this way.
+	#        Plezi.start_placebo(PleziBridge)
 	#
 	# A new instance will be created and that instance will answer any broadcasts, for ALL possible
 	# Plezi controllers, as long as it had a method defined that is capable to handle the broadcast.
@@ -37,15 +49,17 @@ module Plezi
 				module InstanceMethods
 					public
 					attr_accessor :io
-					def initialize io
-						@io = io
-						@io[:websocket_handler] = self
+					def initialize io_in, io_out, request
+						@io_in = io_in
+						@io_out = io_out
+						@request = request
 						super()
 					end
-					# notice of disconnect
+					# Cleanup on disconnection
 					def on_close
+						io_out.close unless io_out.closed?
 						return super() if defined? super
-						GR.warn "Placebo #{self.class.superclass.name} disconnected. Ignore if this message appears during shutdown."
+						Iodine.warn "Placebo #{self.class.superclass.name} disconnected. Ignore if this message appears during shutdown."
 					end
 					def placebo?
 						true
@@ -60,17 +74,19 @@ module Plezi
 					end
 				end
 			end
-			class PlaceboIO < GReactor::BasicIO
-				def clear?
-					io.closed?
+			class PlaceboIO < ::Iodine::Http::Websockets
+				# emulate Iodine::Protocol#timeout?
+				def timeout? time
+					false
 				end
+				# emulate Iodine::Protocol#call
 				def call
-					self.read
-					GR.warn "Placebo IO recieved IO signal - this is unexpected..."
+					read
+					Iodine.warn "Placebo IO recieved IO signal - this is unexpected..."
 				end
-				def on_close
-					@params[:out].close rescue nil
-					@cache[:websocket_handler].on_close if @cache[:websocket_handler]
+				# override "go_away"
+				def go_away
+					close
 				end
 			end
 		end
@@ -86,19 +102,10 @@ module Plezi
 				Object.const_set(new_class_name, new_class)
 			end
 			i, o = IO.pipe
-			io = Placebo::Base::PlaceboIO.new i, out: o, reactor: ::GReactor
-			new_class.new(io)
+			req = {}
+			handler = new_class.new(i, o, req)
+			io = Placebo::Base::PlaceboIO.new i, handler, req
+			handler
 		end
 	end
 end
-
-
-# class A
-# def _hi
-# 'hi'
-# end
-# end
-# Plezi::Placebo.new A
-# a = nil
-# GReactor.each {|h| a= h}
-# a[:websocket_handler].on_broadcast GRHttp::WSEvent.new(nil, type: true, data: [], method: :_hi)