plezi 0.11.2 → 0.12.0

data/lib/plezi/handlers/session.rb

@@ -5,7 +5,7 @@ module Plezi
 			# returns a session object
 			def fetch id
 				return Plezi::Session.new(id) if Plezi.redis # avoid a local cache if Redis is used.
-				GRHttp::Base::FileSessionStorage.fetch id # use the tmp-file-session logic if Redis isn't present
+				Iodine::Http::SessionManager::FileSessionStorage.fetch id # use the tmp-file-session logic if Redis isn't present
 			end
 		end
 	end
@@ -90,5 +90,5 @@ module Plezi
 			
 		end
 	end
-	GRHttp::SessionManager.storage = Plezi::Base::SessionStorage
+	Iodine::Http::SessionManager.storage = Plezi::Base::SessionStorage
 end

data/lib/plezi/handlers/stubs.rb

@@ -120,6 +120,13 @@ module Plezi
 			response << data.to_s
 		end
 
+		# a CLASS level callback that will be called when a unicast doesn't find it's target.
+		#
+		# the lack of this callback being called does NOT imply that the unicast was processed without errors,
+		# it's only called if the target itself wasn't found.
+		def self.failed_unicast target, method, arguments_array
+		end
+
 		#####
 		## It is possible to use RESTful methods to help emulate long XHR pulling.
 		## a RESTful controller can also be a WebSockets controller (these are not exclusive qualities).

data/lib/plezi/handlers/ws_object.rb

@@ -27,10 +27,9 @@ module Plezi
 			module InstanceMethods
 				public
 				# handles broadcasts / unicasts
-				def on_broadcast ws
-					data = ws.data
-					unless (data[:type] || data[:target]) && data[:method] && data[:data]
-						GReactor.warn "Broadcast message unknown... falling back on base broadcasting"
+				def on_broadcast data
+					unless data.is_a?(Hash) && (data[:type] || data[:target]) && data[:method] && data[:data]
+						Iodine.warn "Broadcast message unknown... falling back on base broadcasting"
 						return super(data) if defined? super
 						return false
 					end
@@ -73,12 +72,10 @@ module Plezi
 				#
 				# This UUID is also used to make sure Radis broadcasts don't triger the
 				# boadcasting object's event.
-				def uuid					
+				def uuid
 					return @uuid if @uuid
-					if @response && @response.is_a?(GRHttp::WSEvent)
-						return (@uuid ||= @response.uuid + Plezi::Settings.uuid)
-					elsif @io
-						return (@uuid ||=  (@io[:uuid] ||= SecureRandom.uuid) + Plezi::Settings.uuid)
+					if __get_io
+						return (@uuid ||=  Plezi::Settings.uuid + @io.id)
 					end
 					nil
 				end
@@ -86,7 +83,7 @@ module Plezi
 
 				protected
 				def __get_io
-					@io ||= (@request ? @request.io : nil)
+					@io ||= (@request ? @request[:io] : nil)
 				end
 			end
 			module ClassMethods
@@ -111,6 +108,7 @@ module Plezi
 					@exposed_methods_list ||= ( (self.public_instance_methods - Class.new.instance_methods - Plezi::ControllerMagic::InstanceMethods.instance_methods - [:before, :after, :save, :show, :update, :delete, :initialize, :on_message, :on_broadcast, :pre_connect, :on_open, :on_close]).delete_if {|m| m.to_s[0] == '_'} ).to_set
 					@exposed_methods_list.include? method_name
 				end
+
 				protected
 
 				# a callback that resets the class router whenever a method (a potential route) is added
@@ -163,7 +161,7 @@ module Plezi
 				def unicast target_uuid, method_name, *args
 					raise 'No target specified for unicasting!' unless target_uuid
 					@@uuid_cutoff ||= Plezi::Settings.uuid.length
-					_inner_broadcast method: method_name, data: args, target: target_uuid[0...@@uuid_cutoff], to_server: target_uuid[@@uuid_cutoff..-1]
+					_inner_broadcast method: method_name, data: args, target: target_uuid[@@uuid_cutoff..-1], to_server: target_uuid[0...@@uuid_cutoff], type: self
 				end
 
 				# Use this to multicast an event to ALL websocket connections on EVERY controller, including Placebo controllers.
@@ -183,9 +181,12 @@ module Plezi
 				# sends the broadcast
 				def _inner_broadcast data, ignore_io = nil
 					if data[:target]
-						return ( (data[:to_server].nil? || data[:to_server] == Plezi::Settings.uuid) ? GRHttp::Base::WSHandler.unicast(data[:target], data) : false ) || __inner_redis_broadcast(data)
+						if data[:target] && (data[:to_server] == Plezi::Settings.uuid )
+							return ( ::Iodine::Http::Websockets.unicast( data[:target], data ) || ___faild_unicast( data ) )
+						end
+						return ( data[:to_server].nil? && ::Iodine::Http::Websockets.unicast(data[:target], data) ) || ( Plezi::Base::AutoRedis.away?(data[:to_server]) && ___faild_unicast( data ) ) || __inner_redis_broadcast(data)
 					else
-						GRHttp::Base::WSHandler.broadcast data, ignore_io
+						::Iodine::Http::Websockets.broadcast data, ignore_io
 						__inner_redis_broadcast data				
 					end
 					true
@@ -194,16 +195,25 @@ module Plezi
 				def __inner_redis_broadcast data
 					return unless conn = Plezi.redis
 					data = data.dup
-					data[:type] = data[:type].name if data[:type]
+					data[:type] = data[:type].name if data[:type].is_a?(Class)
 					data[:server] = Plezi::Settings.uuid
-					return conn.publish( ( data[:to_server] ? data[:to_server] : Plezi::Settings.redis_channel_name ), data.to_yaml ) if conn
+					return conn.publish( ( data[:to_server] || Plezi::Settings.redis_channel_name ), data.to_yaml ) if conn
 					false
 				end
 
+				def ___faild_unicast data
+					has_class_method?(:failed_unicast) && failed_unicast( data[:to_server].to_s + data[:target], data[:method], data[:data] )
+					true
+				end
+
 				def has_method? method_name
 					@methods_list ||= self.instance_methods.to_set
 					@methods_list.include? method_name
 				end
+				def has_class_method? method_name
+					@class_methods_list ||= self.methods.to_set - Object.methods
+					@class_methods_list.include? method_name
+				end
 			end
 		end
 	end

data/lib/plezi/helpers/http_sender.rb

@@ -18,7 +18,7 @@ module Plezi
 			# sends a response for an error code, rendering the relevent file (if exists).
 			def send_by_code request, response, code, headers = {}
 				begin
-					base_code_path = request.io.params[:templates] || File.expand_path('.')
+					base_code_path = request[:host_settings][:templates] || File.expand_path('.')
 					fn = File.join(base_code_path, "#{code}.html")
 					rendered = ::Plezi::Renderer.render fn, binding #CodeContext.new(request)
 					return send_raw_data request, response, rendered, 'text/html', code, headers if rendered
@@ -34,14 +34,14 @@ module Plezi
 			#
 			# returns true if data was sent.
 			def send_static_file request, response
-				root = request.io[:params][:public]
+				root = request[:host_settings][:public]
 				return false unless root
 				file_requested = request[:path].to_s.split('/')
 				unless file_requested.include? '..'
 					file_requested.shift
 					file_requested = File.join(root, *file_requested)
 					return true if send_file request, response, file_requested
-					return send_file request, response, File.join(file_requested, request.io[:params][:index_file])
+					return send_file request, response, File.join(file_requested, request[:host_settings][:index_file])
 				end
 				false
 			end

data/lib/plezi/helpers/magic_helpers.rb

@@ -32,7 +32,7 @@ module Plezi
 				(str.to_s.gsub(/[^a-z0-9\*\.\_\-]/i) {|m| '%%%02x'.freeze % m.ord }).force_encoding(::Encoding::ASCII_8BIT)
 			end
 
-			# Adds paramaters to a Hash object, according to the GRHttp's server conventions.
+			# Adds paramaters to a Hash object, according to the Iodine's server conventions.
 			def self.add_param_to_hash name, value, target
 				begin
 					c = target
@@ -64,8 +64,8 @@ module Plezi
 					end
 					val
 				rescue => e
-					GReactor.error e
-					GReactor.error "(Silent): parameters parse error for #{name} ... maybe conflicts with a different set?"
+					Iodine.error e
+					Iodine.error "(Silent): parameters parse error for #{name} ... maybe conflicts with a different set?"
 					target[name] = val
 				end
 			end

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-    VERSION = "0.11.2"
+    VERSION = "0.12.0"
 end

data/plezi.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "grhttp", "~> 0.1.1"
+  spec.add_dependency "iodine", "~> 0.1.0"
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
 

data/resources/config.ru

@@ -3,14 +3,11 @@
 #
 # using Rack with Plezi poses some limitations...:
 #
-# 1. only the first service (and all it's virtual hosts) will be running.
-#    (only the first `listen` call and all it's related `host` calls)
+# 1. there is NO WebSockets support for Rack apps.
 #
-# 2. there is NO WebSockets support for Rack apps.
+# 2. this might break any streaming / asynchronous methods calls, such as Iodine's Http streaming.
 #
-# 3. this WILL BREAKE any streaming / asynchronous methods calls that use the Plezi events engine.
-#
-# 4. Plezi parameters and file uploads are different then Rack - HTML Form code might be incompatible!
+# 3. Plezi parameters and file uploads are different then Rack - HTML Form code might be incompatible!
 #    This MIGHT BREAKE YOUR CODE! (changing this requires Plezi to re-parse the HTML, and costs in performance).
 #
 # also, all Plezi server specific configuration will be ignored.
@@ -21,8 +18,12 @@
 #
 # 2. you have better control over Middleware then you could have with Plezi.
 # ("wait", you might say, "there is no Middleware in Plezi!"... "Ahhh", I will answer, "so much to discover...")
-
-Object.const_set("NO_PLEZI_AUTO_START", true) unless defined?(NO_PLEZI_AUTO_START)
+#
+#
+##############
+#
+# For now, Rack mode is NOT supported unless using the Iodine Http server,
+# even than you're 404 not found pages will break unless using a catch-all route.
 
 # load all framework and gems
 load ::File.expand_path(File.join("..", "environment.rb"),  __FILE__)
@@ -31,15 +32,8 @@ load ::File.expand_path(File.join("..", "environment.rb"),  __FILE__)
 load ::File.expand_path(File.join("..", "routes.rb"),  __FILE__)
 
 # start the plezi EM, to make sure that the plezi async code doesn't break.
-if Rack::Handler.default == GRHttp::Base::Rack
-	run(Proc.new { [404, {}, []] })
+if Rack::Handler.default == Iodine::Http::Rack
+	run(Proc.new { [404, {}, ["not found"]] })
 else
-	GReactor.clear_listeners
-	GReactor.start Plezi::Settings.max_threads
-
-	# run the Rack app - not yet supported
-	# run Plezi::Base::Rack
-
-	# # exit rack to start the plezi server
-	# Process.kill 'TERM'
+	raise "Unsupported Server - Plezi only runs using Iodine."
 end

data/resources/environment.rb

@@ -24,13 +24,13 @@ Bundler.require(:default, ENV['ENV'].to_s.to_sym)
 require 'tilt/sass' if defined?(::Slim) && defined?(::Sass)
 
 # set up Plezi's logs - Heroku logs to STDOUT, this machine logs to log file
-GReactor.create_logger File.expand_path(File.join 'logs','server.log'), ENV["RACK_ENV"]=="development" unless ENV['DYNO']
+Iodine.logger = Logger.new(File.expand_path(File.join 'logs','server.log'))
 
 # set the session token name
-GRHttp.session_token = 'appname_uui'
+Iodine::Http.session_token = 'appname_uui'
 
 ## Allow forking? ONLY if your code is fully scalable across processes.
-# GReactor::Settings.set_forking 4
+# Iodine.processes = 4
 
 # load all config files
 Dir[File.join "{config}", "**" , "*.rb"].each {|file| load File.expand_path(file)}
@@ -41,10 +41,9 @@ Dir[File.join "{lib}", "**" , "*.rb"].each {|file| load File.expand_path(file)}
 # load all application files
 Dir[File.join "{app}", "**" , "*.rb"].each {|file| load File.expand_path(file)}
 
-# start a web service to listen on the first default port (3000 or the port set by the command-line).
-# you can change some of the default settings here.
-listen 	public: Root.join('public').to_s,
+# change some of the default settings here.
+host :default,
+		public: Root.join('public').to_s,
 		assets: Root.join('assets').to_s,
 		assets_public: '/assets',
 		templates: Root.join('app','views').to_s,
-		ssl: false

data/resources/mini_app.rb

@@ -5,14 +5,12 @@
 	require 'pathname'
 	## Set up root object, it might be used by the environment and\or the plezi extension gems.
 	Root ||= Pathname.new(File.dirname(__FILE__)).expand_path
-	## Set a persistent session token id name
+
 	## If this app is independant, use bundler to load gems (including the plezi gem).
-	## Else, use the original app's Gemfile and start Plezi's Rack mode.
-		require 'bundler'
-		Bundler.require(:default, ENV['ENV'].to_s.to_sym)
-		## OR:
-		# Plesi.start_rack # remember 
-	GRHttp.session_token = 'appname_uui'
+	## otherwise, use the original app's Gemfile and start Plezi's Rack mode.
+	require 'bundler'
+	Bundler.require(:default, ENV['ENV'].to_s.to_sym)
+
 	## make sure all file access and file loading is relative to the application's root folder
 	# Dir.chdir Root.to_s
 	## load code from a subfolder called 'app'
@@ -21,14 +19,18 @@
 	# Dir[File.join File.dirname(__FILE__), "*.rb"].each {|file| load File.expand_path(file) unless file == __FILE__}
 
 	## Uncomment to create a log file
-	# GReactor.create_logger File.expand_path(Root.join('server.log').to_s)
+	# Iodine.logger = Logger.new File.expand_path(Root.join('server.log').to_s)
 
-## Options for Scaling the app (across processes or machines):
-	## uncomment to set up forking for 3 more processes (total of 4).
-	# GReactor.forking 3
-	## Redis scaling
+# # Options for Scaling the app (across processes or machines):
+	# # uncomment to set up forking for 3 more processes (total of 4).
+	# Iodine.processes = 4
+	#
+	# # Redis scaling
 	# Plezi::Settings.redis_channel_name = 'appsecret'
 	# ENV['PL_REDIS_URL'] ||= ENV['REDIS_URL'] || ENV['REDISCLOUD_URL'] || ENV['REDISTOGO_URL'] || "redis://username:password@my.host:6389"
+	#
+	# # Consider setting a common session token for Redis supported sessions.
+	# Iodine::Http.session_token = 'appname_uui'
 
 
 # The basic appname controller, to get you started
@@ -60,19 +62,17 @@ class MyController
 end
 
 
-# start a web service to listen on the first default port (3000 or the port set by the command-line).
-# you can change some of the default settings here.
-listen 	host: :default,
-		assets: Root.join('assets').to_s,
-		templates: Root.join('templates').to_s,
-		# public: Root.join('public').to_s,
-		ssl: false
+# change some of the default settings here.
+host :default,
+	# public: Root.join('public').to_s,
+	assets: Root.join('assets').to_s,
+	templates: Root.join('templates').to_s
 
-## Optional stuff:
-	## I18n re-write, i.e.: `/en/home` will be rewriten as `/home`, while setting params[:locale] to "en"
+# # Optional stuff:
+	# # I18n re-write, i.e.: `/en/home` will be rewriten as `/home`, while setting params[:locale] to "en"
 	# route "/:locale{#{I18n.available_locales.join "|"}}/*" , false if defined? I18n
 	#
-	## OAuth2 - Facebook / Google authentication
+	# # OAuth2 - Facebook / Google authentication
 	# require 'plezi/oauth'
 	# ENV["FB_APP_ID"] ||= "app id"; ENV["FB_APP_SECRET"] ||= "secret"; ENV['GOOGLE_APP_ID'] = "app id"; ENV['GOOGLE_APP_SECRET'] = "secret"
 	# create_auth_shared_route do |service_name, auth_token, remote_user_id, remote_user_email, remote_response|

data/resources/redis_config.rb

@@ -10,9 +10,11 @@ if defined? Redis
 	# ## Sets up Plezi to use Radis broadcast.
 	# ##
 	# ## If Plezi Redis Automation is enabled:
-	# ## Plezi creates is own listening thread for each Controller class that broadcasts using Redis.
+	# ## Plezi creates is own listening thread that listens for each Controller class that broadcasts using Redis.
 	# ## (using the Controller.redis_connection and Controller.redis_channel_name class methods)
 	# ##
+	# ## Only one thread will be created and initiated during startup (dynamically created controller routes might be ignored).
+	# ##
 	# ## this overrides the default Controller#broadcast method which is very powerful but
 	# ## is limited to one process.
 	# ##
@@ -33,7 +35,7 @@ if defined? Redis
 	# 		on.message do |channel, msg|
 	# 			msg = JSON.parse(msg)
 	# 			# do stuff, i.e.:
-	# 			# Plezi.run_async(msg) { |m| Plezi.info m.to_s }
+	# 			# Plezi.run(msg) { |m| Plezi.info m.to_s }
 	# 		end
 	# 	end
 	# end

data/test/plezi_tests.rb

@@ -103,6 +103,11 @@ class TestCtrl
 	############
 	## WebSockets
 
+	def fail_unicast
+		unicast (params[:uuid] || (Plezi::Settings.uuid + SecureRandom.hex(12))), :psedo, "agrument1"
+		"Sent a psedo unicast... It should fail."
+	end
+
 	# called once the websocket was connected
 	def on_open
 		response << "connected"
@@ -116,7 +121,7 @@ class TestCtrl
 		when 'get uuid'
 			response << "uuid: #{uuid}"
 		when /to: ([^\s]*)/
-			# puts "cating target: #{data.match(/to: ([^\s]*)/)[1]}"
+			# puts "unicasting to target: #{data.match(/to: ([^\s]*)/)[1]}"
 			unicast data.match(/to: ([^\s]*)/)[1], :_push, "unicast"
 			# broadcast :_push, "unicast"
 		else
@@ -131,6 +136,10 @@ class TestCtrl
 	def on_close
 	end
 
+	def self.failed_unicast target, method, args
+		puts "#{Process.pid}: Failed Unicast, on purpose, for target: #{target}, method: #{method} with: #{args}"
+	end
+
 	# a demo event method that recieves a broadcast from instance siblings.
 	def _push data
 		response << data.to_s
@@ -160,7 +169,7 @@ module PleziTestTasks
 		true
 	end
 	def test_sleep
-		Plezi.run_async do
+		Plezi.run do
 			begin
 				puts "    * Sleeper test: #{RESULTS[URI.parse("http://localhost:3000/sleeper").read == 'slept']}"
 				puts "    * ASync tasks test: #{RESULTS[true]}"
@@ -179,16 +188,18 @@ module PleziTestTasks
 			puts e
 		end
 	end
-	def test_ssl
-		puts "    * Connection to non-ssl and unique route test: #{RESULTS[URI.parse("http://localhost:3000/ssl").read == 'false']}"
-		uri = URI.parse("https://localhost:3030/ssl")
-		Net::HTTP.start(uri.host, uri.port, use_ssl: (uri.scheme == "https"), verify_mode: OpenSSL::SSL::VERIFY_NONE) do |http|
-			puts "    * Connection to ssl and unique ssl route test: #{RESULTS[ http.request(Net::HTTP::Get.new(uri)).body == 'true' ]}"
-		end
-		rescue => e
-		puts "    **** SSL Tests FAILED to complete!!!"
-		puts e
-	end
+	# # Starting with Iodine, Plezi can listen only to one port at a time, either SSL or NOT.
+	# def test_ssl
+	# 	puts "    * Connection to non-ssl and unique route test: #{RESULTS[URI.parse("http://localhost:3000/ssl").read == 'false']}"
+	# 	uri = URI.parse("https://localhost:3030/ssl")
+	# 	Net::HTTP.start(uri.host, uri.port, use_ssl: (uri.scheme == "https"), verify_mode: OpenSSL::SSL::VERIFY_NONE) do |http|
+	# 		puts "    * Connection to ssl and unique ssl route test: #{RESULTS[ http.request(Net::HTTP::Get.new(uri)).body == 'true' ]}"
+	# 	end
+	# 	rescue => e
+	# 	puts "    **** SSL Tests FAILED to complete!!!"
+	# 	puts e
+	# end
+
 	def test_new
 		puts "    * New RESTful path test: #{RESULTS[URI.parse("http://localhost:3000/new").read == 'new']}"
 
@@ -244,7 +255,7 @@ module PleziTestTasks
 	end
 	def test_placebo
 		puts "    * Starting placebo tests..."
-		ws = GRHttp::WSClient.connect_to("ws://localhost:3000/ws/placebo") {|ws| 'ME?'}
+		ws = Iodine::Http::WebsocketClient.connect("ws://localhost:3000/ws/placebo") {|ws| 'ME?'}
 		ws << "    * Placebo WS connected."
 		sleep 2
 		ws.close
@@ -255,54 +266,53 @@ module PleziTestTasks
 	def test_websocket
 		connection_test = broadcast_test = echo_test = unicast_test = false
 		begin
-			ws4 = GRHttp::WSClient.connect_to("wss://localhost:3030") do |ws|
-				if ws.data == "unicast"
+			ws4 = Iodine::Http::WebsocketClient.connect("ws://localhost:3000") do |data|
+				if data == "unicast"
 					puts "    * Websocket unicast testing: #{RESULTS[false]}"
 					unicast_test = :failed
 				end
 			end
-			ws2 = GRHttp::WSClient.connect_to("wss://localhost:3030") do |ws|
-				next unless @is_connected || !(@is_connected = true)
-				if ws.data == "unicast"
+			ws2 = Iodine::Http::WebsocketClient.connect("ws://localhost:3000") do |data|
+				next unless @is_connected || !( (@is_connected = true) )
+				if data == "unicast"
 					puts "    * Websocket unicast message test: #{RESULTS[false]}"
 					unicast_test = :failed
 					next
 				else
-					puts "    * Websocket broadcast message test: #{RESULTS[broadcast_test = (ws.data == 'echo test')]}"
+					puts "    * Websocket broadcast message test: #{RESULTS[broadcast_test = (data == 'echo test')]}"
 					go_test = false
 				end
 			end
-			ws3 = GRHttp::WSClient.connect_to("ws://localhost:3000") do |ws|
-				if ws.data.match /uuid: ([^s]*)/
-					ws2 << "to: #{ws.data.match(/^uuid: ([^s]*)/)[1]}"
-					puts "    * Websocket UUID for unicast testing: #{ws.data.match(/^uuid: ([^s]*)/)[1]}"
-				elsif ws.data == "unicast"
+			ws3 = Iodine::Http::WebsocketClient.connect("ws://localhost:3000", on_open: -> { write 'get uuid' } ) do |data|
+				if data.match /uuid: ([^s]*)/
+					ws2 << "to: #{data.match(/^uuid: ([^s]*)/)[1]}"
+					puts "    * Websocket UUID for unicast testing: #{data.match(/^uuid: ([^s]*)/)[1]}"
+				elsif data == "unicast"
 					puts "    * Websocket unicast testing: #{RESULTS[:waiting]}"
 					unicast_test ||= true
 				end
 			end
-			ws3 << 'get uuid'
-			puts "    * Websocket SSL client test: #{RESULTS[ws2 && true]}"
-			ws1 = GRHttp::WSClient.connect_to("ws://localhost:3000") do |ws|
+			puts "    * Websocket client test: #{RESULTS[ws2 && true]}"
+			ws1 = Iodine::Http::WebsocketClient.connect("ws://localhost:3000") do |data|
 				unless @connected
-					puts "    * Websocket connection message test: #{RESULTS[connection_test = (ws.data == 'connected')]}"
+					puts "    * Websocket connection message test: #{RESULTS[connection_test = (data == 'connected')]}"
 					@connected = true
-					response << "echo test"
+					write "echo test"
 					next
 				end
-				if ws.data == "unicast"
+				if data == "unicast"
 					puts "    * Websocket unicast testing: #{RESULTS[false]}"
 					unicast_test = :failed
 					next
 				end
-				puts "    * Websocket echo message test: #{RESULTS[echo_test = (ws.data == 'echo test')]}"
+				puts "    * Websocket echo message test: #{RESULTS[echo_test = (data == 'echo test')]}"
 			end
 			
 		rescue => e
 			puts "    **** Websocket tests FAILED TO RUN!!!"
 			puts e.message
 		end
-		remote = GRHttp::WSClient.connect_to("wss://echo.websocket.org/") {|ws| puts "    * Extra Websocket Remote test (SSL: echo.websocket.org): #{RESULTS[ws.data == 'Hello websockets!']}"; response.close}
+		remote = Iodine::Http::WebsocketClient.connect("wss://echo.websocket.org/") {|data| puts "    * Extra Websocket Remote test (SSL: echo.websocket.org): #{RESULTS[data == 'Hello websockets!']}"; close}
 		if remote.closed?
 			puts "    * Extra Websocket Remote test (SSL: echo.websocket.org): #{RESULTS[false]}"
 		else
@@ -317,13 +327,12 @@ module PleziTestTasks
 	end
 	def test_websocket_sizes
 			should_disconnect = false
-			ws = GRHttp::WSClient.connect_to("ws://localhost:3000/ws/size") do |ws|
+			ws = Iodine::Http::WebsocketClient.connect("ws://localhost:3000/ws/size") do |data|
 				if should_disconnect
 					puts "    * Websocket size disconnection test: #{RESULTS[false]}"
 				else
-					puts "    * Websocket message size test: got #{ws.data.bytesize} bytes"
+					puts "    * Websocket message size test: got #{data.bytesize} bytes"
 				end
-
 			end
 			ws.on_close do
 				puts "    * Websocket size disconnection test: #{RESULTS[should_disconnect]}"
@@ -335,13 +344,16 @@ module PleziTestTasks
 			to_sleep = (Time.now - time_now)*2 + 1
 			puts "will now sleep for #{to_sleep} seconds, waiting allowing the server to respond"
 			sleep to_sleep rescue true
-			should_disconnect = true
 			Plezi::Settings.ws_message_size_limit = 1024
+			should_disconnect = true
 			ws << ('0123'*258)
+			sleep 0.3
+			should_disconnect = false
 	end
 	def test_broadcast_stress
 		PlaceboStressTestCtrl.create_listeners
 		PlaceboStressTestCtrl.run_test
+		PlaceboStressTestCtrl.unicast ($failed_uuid = Plezi::Settings.uuid + PlaceboStressTestCtrl.object_id.to_s(16) ), :review
 	end
 	def test_404
 		puts "    * 404 not found and router continuity tests: #{RESULTS[ Net::HTTP.get_response(URI.parse "http://localhost:3000/get404" ).code == '404' ]}"
@@ -351,14 +363,7 @@ module PleziTestTasks
 		puts e
 	end
 	def test_500
-		workers = GReactor.instance_exec {@threads.select {|t| t.alive?} .count}
-		print "    * 500 internal error test: #{RESULTS[ Net::HTTP.get_response(URI.parse "http://localhost:3000/fail" ).code == '500' ]}"
-		# cause 10 more exceptions to be raised... testing thread survival.
-		10.times { putc "."; Net::HTTP.get_response(URI.parse "http://localhost:3000/fail" ).code }
-		putc "\n"
-		workers_after_test = GReactor.instance_exec {@threads.select {|t| t.alive?} .count}
-		puts "    * Worker survival test: #{RESULTS[workers_after_test == workers]} (#{workers_after_test} out of #{workers})"
-
+		puts "    * 500 internal error test: #{RESULTS[ Net::HTTP.get_response(URI.parse "http://localhost:3000/fail" ).code == '500' ]}"
 		rescue => e
 		puts "    **** 500 internal error test FAILED TO RUN!!!"
 		puts e
@@ -408,6 +413,9 @@ class PlaceboStressTestCtrl
 			PlaceboStressTestCtrl.run_unicast_test unless uni
 		end
 	end
+	def self.failed_unicast target, method, data
+		puts "    * Unicasting failure callback testing: #{PleziTestTasks::RESULTS[$failed_uuid == target]}"
+	end
 	def self.run_test
 		puts "\n    * Placebo Broadcast stress test starting - (#{LISTENERS} listening objects with #{REPEATS} messages."
 		start_time = Time.now
@@ -424,28 +432,19 @@ class PlaceboStressTestCtrl
 	end
 	def self.create_listeners
 		@uuid = nil
-		LISTENERS.times {@uuid = Plezi::Placebo.new(PlaceboStressTestCtrl).uuid}
+		LISTENERS.times { @uuid = Plezi::Placebo.new(PlaceboStressTestCtrl).uuid }
+		sleep 0.5
+		puts "    * Placebo creation test: #{PleziTestTasks::RESULTS[ Iodine.to_a.length >= LISTENERS ] }"
 	end
 	REPEATS = 1000
-	LISTENERS = 600
+	LISTENERS = 100
 end
 
-PL.create_logger nil
-# PL::Settings.max_threads = 4
-
-listen port: 3000
-
-route("/ssl") {|req, res| res << "false" }
-listen port: 3030, ssl: true
-route("/ssl") {|req, res| res << "true" }
+host
 
 shared_route 'ws/no', Nothing
 shared_route 'ws/placebo', PlaceboTestCtrl
 shared_route 'ws/size', WSsizeTestCtrl
-
-
-# puts Nothing.ancestors.join "\n"
-
 shared_route '/some/:multi{path|another_path}/(:option){route|test}/(:id)/(:optional)', TestCtrl
 shared_route '/', TestCtrl
 
@@ -459,40 +458,30 @@ mem_print_proc = Proc.new do
 end
 # puts ("\n\n*** GC.stat:\n" + ((GC.stat.merge ObjectSpace.count_objects_size).to_a.map {|i| i.join ': '} .join "\n"))
 # mem_print_proc.call
-# GR.run_every 30, &mem_print_proc
-
-
-
-
-puts "    --- Plezi will ran async, performing some tests that than hang"
-
-puts "    --- Starting tests"
-puts "    --- Failed tests should read: #{PleziTestTasks::RESULTS[false]}"
-
-r = Plezi::Placebo.new PlaceboCtrl
-puts "    * Create Placebo test: #{PleziTestTasks::RESULTS[r && true]}"
-puts "    * Placebo admists to being placebo: #{PleziTestTasks::RESULTS[PlaceboCtrl.placebo?]}"
-puts "    * Regular controller answers placebo: #{PleziTestTasks::RESULTS[!PlaceboTestCtrl.placebo?]}"
-
-
-Plezi.start_async
-PleziTestTasks.run_tests
+# Plezi.run_every 30, &mem_print_proc
 
+# require 'redis'
 # ENV['PL_REDIS_URL'] ||= ENV['REDIS_URL'] || ENV['REDISCLOUD_URL'] || ENV['REDISTOGO_URL'] || "redis://test:1234@pub-redis-11008.us-east-1-4.5.ec2.garantiadata.com:11008"
-# GReactor.forking 4
-# GR.run_async { PleziTestTasks.run_tests }
-# start_services
-
-shoutdown_test = false
-Plezi.on_shutdown { shoutdown_test = true }
+# Plezi.processes = 3
 
-puts "\n    --- Press ^C to complete tests."
-Plezi.start
-# Plezi::EventMachine.clear_timers
+Plezi.threads = 9
+PL.logger = nil
 
-# sleep PLEZI_TEST_TIME if defined? PLEZI_TEST_TIME
+Plezi.run do
 
+	puts "    --- Plezi #{Plezi::VERSION} will start a server, performing some tests."
+	puts "    --- Starting tests"
+	puts "    --- Failed tests should read: #{PleziTestTasks::RESULTS[false]}"
 
-puts "    * Shutdown test: #{ PleziTestTasks::RESULTS[shoutdown_test] }"
+	r = Plezi::Placebo.new PlaceboCtrl
+	puts "    * Create Placebo test: #{PleziTestTasks::RESULTS[r && true]}"
+	puts "    * Placebo admists to being placebo: #{PleziTestTasks::RESULTS[PlaceboCtrl.placebo?]}"
+	puts "    * Regular controller answers placebo: #{PleziTestTasks::RESULTS[!PlaceboTestCtrl.placebo?]}"
 
+	PleziTestTasks.run_tests
 
+	shoutdown_test = false
+	Plezi.on_shutdown { puts "    * Shutdown test: #{ PleziTestTasks::RESULTS[shoutdown_test] }" }
+	Plezi.on_shutdown { shoutdown_test = true }
+	
+end