plezi 0.8.5 → 0.8.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7f6b05d42e0915681853564afa40dde6362c11a5
-  data.tar.gz: 4acd945c253d4eb550f4c3d102494703c5aac507
+  metadata.gz: c7c44156e8d07feee948374172192f5bbaafa806
+  data.tar.gz: a8a7badafd82d78e01a20d3ccf55e8bcc1dbd20a
 SHA512:
-  metadata.gz: c8e251f2f1e9b358612406cc13df2d59a3f601703000999a3424072c712ff2e6ebd0a3a2555dadaf5d8a11b26cc06ca75fea117b046b1b11967be99d27cd3e75
-  data.tar.gz: 5637b576b93d7672f83b3f5e7943e993aeeee2f6fdceb3125fe4e28df67c2830ca12959158c6043e0a5be5a608f0c26a341285fcaa7d53914dac5746acaf0095
+  metadata.gz: 54db5b96460193896c8feacf4db749ea68132b0659007b93b54633bc4e99e45689906bc666df1517aa644e2f5f573d63d4b0364a4723ddc621c13ec7eae6dd53
+  data.tar.gz: 1e2426a2844334deb000f49381f6dad3ee1c89feaff3feb32944ba5ec7ad03a37c44985de8a4d50bf7ab7c88479893d180ca871ee782c2e22a425359876cac3f

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ***
 
+Change log v.0.8.6
+
+**fix**: fixed an issue with the plezi helper script that prevented the script from starting the Plezi app or Plezi console.
+
+**feature**: Unicasting allows you to target a specific Websocket connection using a unique identifier (UUID). Use the controllers `#unicast(target_uuid, mathod_name, *args) to target a specific client. Automatically uses Radis, if Radis is set up, to unicast across processes.
+
+***
+
 Change log v.0.8.5
 
 **feature**: Plezi now includes a very simple Websocket Client (no support for cookies). It's used for testing the integrity of the Plezi Framework and could be used to test the Plezi apps.

data/README.md

@@ -36,13 +36,13 @@ to create a new barebones app using the Plezi framework, run from terminal:
 That's it, now you have a ready to use basic web server (with some demo code), just run it:
 
     $ cd appname
-    $ ./appname.rb # ( or: plezi s )
+    $ ./appname # ( or: plezi s )
 
 now go, in your browser, to: [http://localhost:3000/](http://localhost:3000/)
 
 the default first port for the app is 3000. you can set the first port to listen to by using the `-p ` option (make sure you have permissions for the requested port):
 
-    $ ./appname.rb -p 80
+    $ ./appname -p 80
 
 you now have a smart framework app that will happily eat any gem you feed it. it responds extra well to Haml, Sass and Coffee-Script, which you can enable in it's Gemfile.
 

data/bin/plezi

@@ -264,10 +264,10 @@ if ARGV[0] == 'new' || ARGV[0] == 'n' || ARGV[0] == "force"
 	template.build
 elsif ARGV[0] == 'server' || ARGV[0] == 'start' || ARGV[0] == 's'
 	ARGV.shift
-	load File.expand_path(Dir["."][0], (File.expand_path(Dir["."][0]).split(/[\\\/]/).last) ) rescue load( File.expand_path(Dir["."][0], (File.expand_path(Dir["."][0]).split(/[\\\/]/).last + '.rb') ) )
+	load File.expand_path(Dir["."][0], (File.expand_path(Dir["."][0]).split(/[\\\/]/).last) ) rescue load( File.expand_path(Dir["."][0], (File.expand_path(Dir["."][0]).split(/[\\\/]/).last ) ) )
 elsif ARGV[0] == 'console' || ARGV[0] == 'c'
 	NO_PLEZI_AUTO_START ||= true
-	load File.expand_path(Dir["."][0], (File.expand_path(Dir["."][0]).split(/[\\\/]/).last) ) rescue load( File.expand_path(Dir["."][0], (File.expand_path(Dir["."][0]).split(/[\\\/]/).last + '.rb') ) )
+	load File.expand_path(Dir["."][0], (File.expand_path(Dir["."][0]).split(/[\\\/]/).last) ) rescue load( File.expand_path(Dir["."][0], (File.expand_path(Dir["."][0]).split(/[\\\/]/).last) ) )
 	ARGV.clear
 	IRB.setup nil
 	IRB.conf[:MAIN_CONTEXT] = IRB::Irb.new.context

data/lib/plezi/eventmachine/em.rb

@@ -28,11 +28,14 @@ module Plezi
 		end
 
 		def stop_and_wait
-			@workers_lock.synchronize { @workers.each {|w| w.stop }; @workers.each {|w| w.join }; @workers.clear; Worker.reset_wait}
+			@workers.each {|w| w.stop }
+			@workers.each {|w| w.join }
+			@workers_lock.synchronize { @workers.clear }
 		end
 
 		def stop
-			@workers_lock.synchronize { @workers.each {|w| w.stop } ; @workers.clear; Worker.reset_wait}
+			@workers.each {|w| w.stop }
+			@workers_lock.synchronize { @workers.clear;}
 		end
 
 		def running?
@@ -48,9 +51,9 @@ module Plezi
 		SHUTDOWN_CALLBACKS = []
 		# runs the shutdown queue
 		def shutdown
-			stop_and_wait rescue false
 			old_timeout = io_timeout
 			io_timeout = 0.001
+			stop_and_wait rescue false
 			run
 			io_timeout = old_timeout
 			do_job while do_job

data/lib/plezi/eventmachine/timers.rb

@@ -60,7 +60,7 @@ module Plezi
 		end
 		# clears all timers
 		def clear_timers
-			TIMERS_LOCK.synchronize { TIMERS.clear }
+			TIMERS.clear
 		end
 
 	end

data/lib/plezi/eventmachine/workers.rb

@@ -9,6 +9,7 @@ module Plezi
 				@thread = Thread.new { EventMachine.run wait until @stop }
 			end
 			def stop
+				@instances = -1
 				@stop = true
 			end
 			def join
@@ -27,9 +28,6 @@ module Plezi
 				@instances += 1 if @instances < 7
 				@primes[@instances] / 10.0
 			end
-			def self.reset_wait
-				@instances = -1
-			end
 		end
 	end
 end

data/lib/plezi/handlers/controller_magic.rb

@@ -44,9 +44,14 @@ module Plezi
 			# the parameters used to create the host (the parameters passed to the `listen` / `add_service` call).
 			attr_reader :host_params
 
-			# a unique UUID to identify the object - used to make sure Radis broadcasts don't triger the
+			# Get's the websocket's unique identifier for unicast transmissions.
+			#
+			# This UUID is also used to make sure Radis broadcasts don't triger the
 			# boadcasting object's event.
-			attr_reader :uuid
+			def uuid
+				@uuid ||= SecureRandom.uuid
+			end
+			alias :unicast_id :uuid
 
 			# checks whether this instance accepts broadcasts (WebSocket instances).
 			def accepts_broadcast?
@@ -54,6 +59,8 @@ module Plezi
 			end
 			# sets the controller to refuse "broadcasts".
 			#
+			# The controller will also refuse any messages directed at it using the `unicast` method.
+			#
 			# This allows some websocket connections to isolate themselves even before they are fully disconnected.
 			#
 			# call this method once it is clear the websocket connection should be terminated.
@@ -253,7 +260,12 @@ module Plezi
 			def broadcast method_name, *args, &block
 				return false unless self.class.public_instance_methods.include?(method_name)
 				@uuid ||= SecureRandom.uuid
-				self.class.__inner_redis_broadcast(uuid, method_name, args, &block) || self.class.__inner_process_broadcast(uuid, method_name.to_sym, args, &block)
+				self.class.__inner_redis_broadcast(uuid, nil, method_name, args, &block) || self.class.__inner_process_broadcast(uuid, nil, method_name.to_sym, args, &block)
+			end
+
+			# {include:ControllerMagic::ClassMethods#unicast}
+			def unicast target_uuid, method_name, *args
+				self.class.unicast target_uuid, method_name, *args
 			end
 
 			# WebSockets.
@@ -370,9 +382,9 @@ module Plezi
 			# end
 
 			
-			# reviews the Redis connection, sets it up if it's missing and returns the Redis connection.
+			# Reviews the Redis connection, sets it up if it's missing and returns the Redis connection.
 			#
-			# a Redis connection will be automatically created if the `ENV['PL_REDIS_URL']` is set.
+			# A Redis connection will be automatically created if the `ENV['PL_REDIS_URL']` is set.
 			# for example:
 			#      ENV['PL_REDIS_URL'] = ENV['REDISCLOUD_URL']`
 			# or
@@ -409,7 +421,7 @@ module Plezi
 							on.message do |channel, msg|
 								args = JSON.parse(msg)
 								params = args.shift
-								__inner_process_broadcast params['_pl_ignore_object'], params['_pl_method_broadcasted'].to_sym, args
+								__inner_process_broadcast params['_pl_ignore_object'], params['_pl_target_object'], params['_pl_method_broadcasted'].to_sym, args
 							end
 						end						
 					rescue Exception => e
@@ -427,16 +439,16 @@ module Plezi
 			end
 
 			# broadcasts messages (methods) for this process
-			def __inner_process_broadcast ignore, method_name, args, &block
-				ObjectSpace.each_object(self) { |controller| Plezi.callback controller, method_name, *args, &block if controller.accepts_broadcast? && (!ignore || controller.uuid != ignore) }
+			def __inner_process_broadcast ignore, target, method_name, args, &block
+				ObjectSpace.each_object(self) { |controller| Plezi.callback controller, method_name, *args, &block if controller.accepts_broadcast? && (!ignore || (controller.uuid != ignore)) && (!target || (controller.uuid == target)) }
 			end
 
 			# broadcasts messages (methods) between all processes (using Redis).
-			def __inner_redis_broadcast ignore, method_name, args, &block
+			def __inner_redis_broadcast ignore, target, method_name, args, &block
 				return false unless redis_connection
 				raise "Radis broadcasts cannot accept blocks (no inter-process callbacks of memory sharing)!" if block
 				# raise "Radis broadcasts accept only one paramater, which is an optional Hash (no inter-process memory sharing)" if args.length > 1 || (args[0] && !args[0].is_a?(Hash))
-				args.unshift ({_pl_method_broadcasted: method_name, _pl_ignore_object: ignore})
+				args.unshift ({_pl_method_broadcasted: method_name, _pl_ignore_object: ignore, _pl_target_object: target})
 				redis_connection.publish(redis_channel_name, args.to_json )
 				true
 			end
@@ -456,7 +468,22 @@ module Plezi
 			# the method will be called asynchrnously for each sibling instance of this Controller class.
 			def broadcast method_name, *args, &block
 				return false unless public_instance_methods.include?(method_name)
-				__inner_redis_broadcast(nil, method_name, args, &block) || __inner_process_broadcast(nil, method_name.to_sym, args, &block)
+				__inner_redis_broadcast(nil, nil, method_name, args, &block) || __inner_process_broadcast(nil, nil, method_name.to_sym, args, &block)
+			end
+
+			# WebSockets.
+			#
+			# Class method.
+			#
+			# Use this to unidcast an event to specific websocket connection using it's UUID.
+			#
+			# accepts:
+			# target_uuid:: the target's unique UUID.
+			# method_name:: a Symbol with the method's name that should respond to the broadcast.
+			# *args:: any arguments that should be passed to the method (IF REDIS IS USED, LIMITATIONS APPLY).
+			def unicast target_uuid, method_name, *args
+				return false unless public_instance_methods.include?(method_name.to_sym)
+				__inner_redis_broadcast(nil, target_uuid, method_name, args) || __inner_process_broadcast(nil, target_uuid, method_name.to_sym, args)
 			end
 
 			# WebSockets.

data/lib/plezi/server/websocket_client.rb

@@ -50,6 +50,7 @@ module Plezi
 		def disconnect
 			@response.close if @response
 		end
+		alias :close :disconnect
 
 		# sends data through the socket. a shortcut for ws_client.response <<
 		def << data

data/lib/plezi/server/ws_response.rb

@@ -73,10 +73,12 @@ module Plezi
 			self
 		end
 
+		# a closeing Proc
+		CLOSE_PROC = Proc.new {|c| c.send "\x88\x00"; c.close}
+
 		# sends any pending data and closes the connection.
 		def close
-			service.send self.class.frame_data('', 8)
-			service.close
+			service.locker.locked? ? (EventMachine.queue [service], CLOSE_PROC) : (CLOSE_PROC.call(service)) 
 		end
 
 		FRAME_SIZE_LIMIT = 131_072

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-    VERSION = "0.8.5"
+    VERSION = "0.8.6"
 end

data/resources/Gemfile

@@ -21,7 +21,7 @@ gem 'plezi'
 # 
 # gem 'activesupport', :require => ['active_support', 'active_support/core_ext'] 
 ## or:
-# gem 'activesupport', :require => ['active_support', active_support/all'] 
+# gem 'activesupport', :require => ['active_support', 'active_support/all'] 
 
 
 ####################

data/test/plezi_tests.rb

@@ -110,8 +110,18 @@ class TestCtrl
 	#
 	# data is a string that contains binary or UTF8 (message dependent) data.
 	def on_message data
-		broadcast :_push, data
-		_push data
+		case data
+		when 'get uuid'
+			response << "uuid: #{uuid}"
+		when /to: ([^\s]*)/
+			# puts "cating target: #{data.match(/to: ([^\s]*)/)[1]}"
+			unicast data.match(/to: ([^\s]*)/)[1], :_push, "unicast"
+			# broadcast :_push, "unicast"
+		else
+			broadcast :_push, data
+			_push data
+		end
+			return true
 	end
 
 	# called when a disconnect packet has been recieved or the connection has been cut
@@ -129,8 +139,8 @@ module PleziTestTasks
 	module_function
 
 
-	RESULTS = {true => "\e[32mpassed\e[0m"}
-	RESULTS.default =  "\e[31mFAILED!\e[0m"
+	RESULTS = {true => "\e[32mpassed\e[0m", :waiting => "\e[32mwaiting validation\e[0m", :failed => "\e[31mFAILED!\e[0m"}
+	RESULTS.default = RESULTS[:failed]
 
 	def run_tests
 		(public_methods(false)).each {|m| method(m).call if m.to_s.match /^test_/}
@@ -221,44 +231,50 @@ module PleziTestTasks
 		puts "    **** #url_for test FAILED TO RUN!!!"
 		puts e
 	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' ]}"
-
-		rescue => e
-		puts "    **** 404 not found test FAILED TO RUN!!!"
-		puts e
-	end
-	def test_500
-		workers = Plezi::EventMachine.count_living_workers
-		puts "    * 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 { Net::HTTP.get_response(URI.parse "http://localhost:3000/fail" ).code }
-		workers_after_test = Plezi::EventMachine.count_living_workers
-		puts "    * Worker survival test: #{RESULTS[workers_after_test == workers]} (#{workers_after_test} out of #{workers})"
-
-		rescue => e
-		puts "    **** 500 internal error test FAILED TO RUN!!!"
-		puts e		
-	end
 	def test_websocket
-		connection_test = broadcast_test = echo_test = false
+		connection_test = broadcast_test = echo_test = unicast_test = false
 		begin
+			ws4 = Plezi::WebsocketClient.connect_to("wss://localhost:3030") do |msg|
+				if msg == "unicast"
+					puts "    * Websocket unicast testing: #{RESULTS[false]}"
+					unicast_test = :failed
+				end
+			end
 			ws2 = Plezi::WebsocketClient.connect_to("wss://localhost:3030") do |msg|
-				break unless @is_connected || !(@is_connected = true)
-				puts "    * Websocket broadcast message test: #{RESULTS[broadcast_test = (msg == 'echo test')]}"
-				response.close
-				go_test = false
+				next unless @is_connected || !(@is_connected = true)
+				if msg == "unicast"
+					puts "    * Websocket unicast message test: #{RESULTS[false]}"
+					unicast_test = :failed
+					next
+				else
+					puts "    * Websocket broadcast message test: #{RESULTS[broadcast_test = (msg == 'echo test')]}"
+					go_test = false
+				end
 			end
+			ws3 = Plezi::WebsocketClient.connect_to("wss://localhost:3030") do |msg|
+				if msg.match /uuid: ([^s]*)/
+					ws2 << "to: #{msg.match(/^uuid: ([^s]*)/)[1]}"
+					puts "    * Websocket UUID for unicast testing: #{msg.match(/^uuid: ([^s]*)/)[1]}"
+				elsif msg == "unicast"
+					puts "    * Websocket unicast testing: #{RESULTS[:waiting]}"
+					unicast_test ||= true
+				end
+			end
+			ws3 << 'get uuid'
 			puts "    * Websocket SSL client test: #{RESULTS[ws2 && true]}"
 			ws1 = Plezi::WebsocketClient.connect_to("ws://localhost:3000") do |msg|
 				unless @connected
 					puts "    * Websocket connection message test: #{RESULTS[connection_test = (msg == 'connected')]}"
 					@connected = true
 					response << "echo test"
-					break
+					next
+				end
+				if msg == "unicast"
+					puts "    * Websocket unicast testing: #{RESULTS[false]}"
+					unicast_test = :failed
+					next
 				end
 				puts "    * Websocket echo message test: #{RESULTS[echo_test = (msg == 'echo test')]}"
-				response.close
 			end
 			
 		rescue => e
@@ -267,16 +283,39 @@ module PleziTestTasks
 		end
 		remote = Plezi::WebsocketClient.connect_to("wss://echo.websocket.org/") {|msg| puts "    * Extra Websocket Remote test (SSL: echo.websocket.org): #{RESULTS[msg == 'Hello websockets!']}"; response.close}
 		remote << "Hello websockets!"
-		sleep 0.3
+		sleep 0.5
+		[ws1, ws2, ws3, ws4, remote].each {|ws| ws.close}
 		PL.on_shutdown {puts "    * Websocket connection message test: #{RESULTS[connection_test]}" unless connection_test}
 		PL.on_shutdown {puts "    * Websocket echo message test: #{RESULTS[echo_test]}" unless echo_test}
 		PL.on_shutdown {puts "    * Websocket broadcast message test: #{RESULTS[broadcast_test]}" unless broadcast_test}
+		PL.on_shutdown {puts "    * Websocket unicast message test: #{RESULTS[unicast_test]}"}
+	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' ]}"
+
+		rescue => e
+		puts "    **** 404 not found test FAILED TO RUN!!!"
+		puts e
+	end
+	def test_500
+		workers = Plezi::EventMachine.count_living_workers
+		putc "    * 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 = Plezi::EventMachine.count_living_workers
+		puts "    * Worker survival test: #{RESULTS[workers_after_test == workers]} (#{workers_after_test} out of #{workers})"
+
+		rescue => e
+		puts "    **** 500 internal error test FAILED TO RUN!!!"
+		puts e
 	end
 end
 
 NO_PLEZI_AUTO_START = true
 
 PL.create_logger '/dev/null'
+# PL.max_threads = 4
 
 listen port: 3000
 
@@ -298,12 +337,18 @@ puts "    --- Failed tests should read: #{PleziTestTasks::RESULTS[false]}"
 PleziTestTasks.run_tests
 
 
-Plezi::EventMachine.clear_timers
+# Plezi::EventMachine.clear_timers
 
 sleep PLEZI_TEST_TIME if defined? PLEZI_TEST_TIME
 
 Plezi::DSL.stop_services
-
+puts "#{Plezi::EventMachine::EM_IO.count} connections awaiting shutdown."
+Plezi::EventMachine.stop_connections
+puts "#{Plezi::EventMachine::EM_IO.count} connections awaiting shutdown after connection close attempt."
+if Plezi::EventMachine::EM_IO.count > 0
+	Plezi::EventMachine.forget_connections
+	puts "#{Plezi::EventMachine::EM_IO.count} connections awaiting shutdown after connections were forgotten."
+end
 Plezi::EventMachine.shutdown
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plezi
 version: !ruby/object:Gem::Version
-  version: 0.8.5
+  version: 0.8.6
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-15 00:00:00.000000000 Z
+date: 2015-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler