plezi 0.10.6 → 0.10.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 86970dabaa35cafd7bdae2e7dc5233816f108247
-  data.tar.gz: 3e304fb54b25fa57cf03b56c0290a27baa0f76cc
+  metadata.gz: c504b33f40bbc1d8235c5d48101abab00a0facac
+  data.tar.gz: 5fad18c3d52af38f9ecc94cb899c337b54a3afdd
 SHA512:
-  metadata.gz: f66fbaefd4333b7400d25576b85a1f9444bcf1db176ae981ed4c6512130f8903999a863b8d72d7e608da8dcf3f01f4211a32327867130f7bc58b3e9df88727a3
-  data.tar.gz: 9f31d2ee28fcce84f1fbba07a6e559ac966743ffa03a0b98210a077a29aee81105ec49436b65f7754b679ef145a5512a09c0ff8e9c0d925549cc3f808af104ad
+  metadata.gz: c4f6a25bfa2846fd8ea384b741ee754673c3ecc6384402b9bd8c0766dea71ab0cc9711723ccaf38f20934fbf0b0f05c3c409850aa427a9d87f26775467b7382e
+  data.tar.gz: db2844de88d6dae7a1e019b4ec46fde5f33f4342484e38d5dc03f9aa9e5cc70c897ace96b4fed46f92bfd7e8c4d572f2e4bdc4952caa7dc0b283d93a01c1aaea

data/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ***
 
+Change log v.0.10.8
+
+**Fix**: Fixed an issue with the new websocket upgrade handler. It is unclear how come the issue did not show up during the testing.
+
+\* (All the changes in version 0.10.7 still apply)
+
+***
+
+Change log v.0.10.7 (yanked)
+
+**Fix**: Forces the use of a better version of the GRHttp server, now as fully tested as I could manage. This fixes an issue where the lasy byte on a Websocket message might have been corrupt.
+
+**Fix**: fixed an issue where websocket connections would be quietly established (messages would be ignored) even though they should have been declined.
+
+**Update**: Better support for intigration of Plezi with other frameworks, using `Plezi.start_async` and `Plezi.start_placebo` to get all the benifits of Plezi without distrupting the host framework.
+
+**Update**: added the multicasting feature - allows you to send a message to ALL the websocket connections that defined a method to handle the message - use `multicast :method_name, arg1, arg2, arg3...`.
+
+**Update**: Added the Placebo API to support websocket broadcasting on normal classes - allows for super-easy framework integration with other Ruby frameworks such as Rails and Sinatra.
+
+***
+
 Change log v.0.10.6
 
 **Performance Boost**: updated the GRHttp server version, to leverage the new Websocket engine, which offers a significant performance boost and allows for larger data to be transmitted over the websocket connection (tested with more than 250MB of data).

data/README.md

@@ -10,7 +10,7 @@ Find more info on [Plezi's framework documentation](http://www.rubydoc.info/gems
 
 Plezi is an easy to use Ruby Websocket Framework, with full RESTful routing support and HTTP streaming support. It's name comes from the word "fun" in Haitian, since Plezi is really fun to work with and it keeps our code clean and streamlined.
 
-Plezi works as an asynchronous multi-threaded Ruby alternative to a Rack/Rails/Sintra/Faye/EM-Websockets combo. It's also great as an alternative to socket.io, allowing for both websockets and long pulling.
+Plezi can both augment an existing Rails/Sinatra app, by providing it with easy Websocket and Asynchronous Events support, as well as offer an alternative to a Rack/Rails/Sintra/Faye/EM-Websockets combo. It's also great as an alternative to socket.io, allowing for both websockets and long pulling.
 
 Plezi runs over the [GRHttp server](https://github.com/boazsegev/GRHttp), which is a pure Ruby HTTP and Websocket Generic Server build using [GReactor](https://github.com/boazsegev/GReactor) - a multi-threaded pure ruby alternative to EventMachine with basic process forking support (enjoy it, if your code is scaling ready).
 
@@ -125,6 +125,124 @@ Remember to connect to the service from at least two browser windows - to truly
 
 method names starting with an underscore ('_') will NOT be made public by the router: so while both '/hello' and '/humans.txt' are public ( [try it](http://localhost:3000/humans.txt) ), '/_send_message' will return a 404 not found error ( [try it](http://localhost:3000/_send_message) ).
 
+## Augmenting a Rails/Sinatra with Websocket broadcasting
+
+You already have an amazing WebApp, but now you want to add websocket broadcasting and unicasting support - Plezi makes connection your existing WebApp with your Plezi Websocket backend as easy as it gets.
+
+Simply include the Plezi App in your existing app and call `Plezi.start_placebo` - now you can access all the websocket API that you want from your existing WebApp.
+
+For instance, add the following code to your environment on a Rails or Sinatra app:
+
+```ruby
+
+require './my_plezi_app/environment.rb'
+require './my_plezi_app/routes.rb'
+
+ENV['PL_REDIS_URL'] = "redis://username:password@my.host:6379"
+
+Plezi.start_placebo
+```
+
+That's it!
+
+Plezi will automatically set up the Redis connections and pub/sub to connect your existing WebApp with Plezi's Websocket backend - which you can safely scale over processes or machines.
+
+Now you can use Plezi from withing your existing App's code. For example, if your Plezi app has a controller named `ClientPleziCtrl`, you might use:
+
+```ruby
+
+class ClientsController < ApplicationController
+  def update
+     #... your original logic here
+     @client = Client.find(params[:id])
+
+     # now unicast data to your client on the websocket
+     # (assume his websocket uuid was saved in @client.ws_uuid)
+
+     ClientPleziCtrl.unicast @client.ws_uuid, :method_name, @client.attributes
+
+     # or broadcast data to your all your the clients currently connected
+
+     ClientPleziCtrl.broadcast :method_name, @client.attributes
+
+  end
+end
+```
+
+Easy.
+
+\- "But wait...", you might say to me, "How do we get information back FROM the back end?"
+
+Oh, that's easy too.
+
+With a few more lines of code, we can have the websocket connections _broadcast_ back to us using the `Plezi::Placebo` API.
+
+On your Rails app, add:
+
+```ruby
+
+class MyReciever
+    def my_reciever_method arg1, arg2, arg3, arg4...
+        # your app's logic
+    end
+end
+
+Plezi::Placebo.new MyReciever
+
+```
+
+Plezi will now take your class and add mimick an IO connection (the Placebo connection) on it's GRHttp serever. This Placebo connection will answer the Redis broadcasts just as if your class was a websocket controller...
+
+On the Plezi side, use multicasting, from ANY controller:
+
+```ruby
+
+class ClientPleziCtrl
+    def on_message data
+        # app logic here
+        multicast :my_reciever_method, arg1, arg2, arg3, arg4...
+    end
+end
+```
+
+That's it! Now you have your listening object... but careful - to saafely scale up this communication you might consider using unicasting instead of broadcasting...
+
+On your Rails app, add:
+
+```ruby
+#...
+class MyReciever
+    def get_controller sender
+        ClientPleziCtrl.unicast sender, :_set_controller_uuid, uuid
+    end
+    def my_reciever_method arg1, arg2, arg3, arg4...
+        # ...
+    end
+end
+
+Plezi::Placebo.new MyReciever
+
+```
+On the Plezi, save the data and use unicasting when possible:
+
+```ruby
+class ClientPleziCtrl
+    def on_open
+       multicast :get_controller, uuid
+    end
+    def on_message data
+        # app logic here
+        unicast @main_controller, :my_reciever_method, arg1, arg2, arg3, arg4... if @main_controller
+    end
+    def _controller_uuid controller_uuid
+        @main_controller = controller_uuid
+        # send ready flag to client using JSON?
+        response << "{\"state\":\"ready\""
+    end
+end
+
+```
+
 ## Native HTTP streaming with Asynchronous events
 
 Plezi comes with native HTTP streaming support, alowing you to use Plezi Events and Timers to send an Asynchronous response.

data/lib/plezi.rb

@@ -46,6 +46,7 @@ require 'plezi/handlers/http_router.rb'
 require 'plezi/handlers/route.rb'
 require 'plezi/handlers/controller_magic.rb'
 require 'plezi/handlers/controller_core.rb'
+require 'plezi/handlers/placebo.rb'
 require 'plezi/handlers/stubs.rb'
 
 

data/lib/plezi/common/dsl.rb

@@ -72,7 +72,8 @@ module Plezi
 				@listeners[parameters[:port]] = parameters
 
 				# make sure the protocol exists.
-				parameters[:upgrade_handler] = parameters[:http_handler] = HTTPRouter.new
+				parameters[:http_handler] = HTTPRouter.new
+				parameters[:upgrade_handler] = parameters[:http_handler].upgrade_proc
 
 				GRHttp.listen parameters
 				# set the active router to the handler or the protocol.
@@ -126,14 +127,30 @@ module Plezi
 		end
 	end
 
+	# starts the Plezi framework server and hangs until the exit signal is given.
 	def self.start
-		return GReactor.start if GReactor.running?
+		start_async
+		puts "\nPress ^C to exit.\n"
+		GReactor.join { puts "\r\nStarting shutdown sequesnce. Press ^C to force quit."}
+	end
+	# starts the Plezi framework and returns immidiately,
+	# allowing you to run the Plezi framework along side another framework. 
+	def self.start_async
 		Object.const_set("NO_PLEZI_AUTO_START", true) unless defined?(NO_PLEZI_AUTO_START)
+		return GReactor.start if GReactor.running?
 		puts "Starting Plezi #{Plezi::VERSION} Services using the GRHttp #{GRHttp::VERSION} server."
-		puts "Press ^C to exit."
 		GReactor.on_shutdown { puts "Plezi shutdown. It was fun to serve you."  }
 		GReactor.start Plezi::Settings.max_threads
-		GReactor.join { puts "\r\nStarting shutdown sequesnce. Press ^C to force quit."}
+	end
+	# This allows you to run the Plezi framework along side another framework - WITHOUT running the actual server.
+	#
+	# The server will not be initiatet and instead you will be able to use Plezi controllers and the Redis auto-config
+	# to broadcast Plezi messages to other Plezi processes - allowing for scalable intigration of Plezi into other frameworks.
+	def self.start_placebo
+		GReactor.clear_listeners
+		redis_connection # make sure the redis connection is activated
+		puts "* Plezi #{Plezi::VERSION} Services will start with no Server...\n"
+		start_async
 	end
 end
 

data/lib/plezi/common/redis.rb

@@ -13,29 +13,33 @@ module Plezi
 	def redis_connection
 		return @redis if (@redis_sub_thread && @redis_sub_thread.alive?) && @redis
 		return false unless defined?(Redis) && ENV['PL_REDIS_URL']
-		@redis_uri ||= URI.parse(ENV['PL_REDIS_URL'])
-		@redis ||= Redis.new(host: @redis_uri.host, port: @redis_uri.port, password: @redis_uri.password)
-		raise "Redis connction failed for: #{ENV['PL_REDIS_URL']}" unless @redis
-		@redis_sub_thread = Thread.new do
-			begin
-			Redis.new(host: @redis_uri.host, port: @redis_uri.port, password: @redis_uri.password).subscribe(Plezi::Settings.redis_channel_name) do |on|
-					on.message do |channel, msg|
-						begin
-							data = YAML.load(msg)
-							next if data[:server] == Plezi::Settings.uuid
-							if data[:target]
-								GRHttp::Base::WSHandler.unicast data[:target], data
-							else
-								GRHttp::Base::WSHandler.broadcast data
+		@redis_locker ||= Mutex.new
+		@redis_locker.synchronize do
+			return @redis if (@redis_sub_thread && @redis_sub_thread.alive?) && @redis # repeat the test once syncing is done.
+			@redis_uri ||= URI.parse(ENV['PL_REDIS_URL'])
+			@redis ||= Redis.new(host: @redis_uri.host, port: @redis_uri.port, password: @redis_uri.password)
+			raise "Redis connction failed for: #{ENV['PL_REDIS_URL']}" unless @redis
+			@redis_sub_thread = Thread.new do
+				begin
+				Redis.new(host: @redis_uri.host, port: @redis_uri.port, password: @redis_uri.password).subscribe(Plezi::Settings.redis_channel_name) do |on|
+						on.message do |channel, msg|
+							begin
+								data = YAML.load(msg)
+								next if data[:server] == Plezi::Settings.uuid
+								if data[:target]
+									GRHttp::Base::WSHandler.unicast data[:target], data
+								else
+									GRHttp::Base::WSHandler.broadcast data
+								end
+							rescue => e
+								Reactor.error e
 							end
-						rescue => e
-							Reactor.error e
 						end
 					end
+				rescue => e
+					Reactor.error e
+					retry
 				end
-			rescue => e
-				Reactor.error e
-				retry
 			end
 		end
 		@redis

data/lib/plezi/handlers/controller_core.rb

@@ -56,7 +56,7 @@ module Plezi
 				def on_close ws
 					super() if defined? super
 				end
-				# handles websocket being closed.
+				# handles websocket multicasting/broadcasting/unicasting.
 				def on_broadcast ws
 					data = ws.data
 					unless (data[:type] || data[:target]) && data[:method] && data[:data]
@@ -64,7 +64,8 @@ module Plezi
 						return super(data) if defined? super
 						return false
 					end
-					return false if data[:type] && !self.is_a?(data[:type])
+					return false if data[:type] && data[:type] != :all && !self.is_a?(data[:type])
+					return false if data[:target] && data[:target] != ws.uuid
 					return false unless self.class.has_method?(data[:method])
 					self.method(data[:method]).call *data[:data]
 				end

data/lib/plezi/handlers/controller_magic.rb

@@ -237,6 +237,18 @@ module Plezi
 				self.class._inner_broadcast method: method_name, data: args, target: target_uuid
 			end
 
+			# Use this to multicast an event to ALL websocket connections on EVERY controller, including Placebo controllers.
+			#
+			# Accepts:
+			# method_name:: a Symbol with the method's name that should respond to the broadcast.
+			# args*:: The method's argumenst - It MUST be possible to stringify the arguments into a YAML string, or broadcasting and unicasting will fail when scaling beyond one process / one machine.
+			#
+			# The method will be called asynchrnously for ALL websocket connections.
+			#
+			def multicast method_name, *args
+				self.class._inner_broadcast({ method: method_name, data: args, type: :all}, @response.io)
+			end
+
 
 			# # will (probably NOT), in the future, require authentication or, alternatively, return an Array [user_name, password]
 			# #
@@ -280,6 +292,18 @@ module Plezi
 				_inner_broadcast method: method_name, data: args, target: target_uuid
 			end
 
+			# Use this to multicast an event to ALL websocket connections on EVERY controller, including Placebo controllers.
+			#
+			# Accepts:
+			# method_name:: a Symbol with the method's name that should respond to the broadcast.
+			# args*:: The method's argumenst - It MUST be possible to stringify the arguments into a YAML string, or broadcasting and unicasting will fail when scaling beyond one process / one machine.
+			#
+			# The method will be called asynchrnously for ALL websocket connections.
+			#
+			def multicast method_name, *args
+				_inner_broadcast({ method: method_name, data: args, type: :all}, @response.io)
+			end
+
 			# This class method behaves the same way as the instance method #url_for. See the instance method's documentation for more details.
 			def url_for dest
 				get_pl_route.url_for dest				

data/lib/plezi/handlers/http_router.rb

@@ -15,6 +15,20 @@ module Plezi
 				end
 			end
 
+			# return the upgrade handler (the self.on_upgrade method)
+			def upgrade_proc
+				self.method :on_upgrade
+			end
+			#handles websocket connection requests.
+			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
+				# 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)
 			#
 			# the router holds the different hosts and sends them messages/requests.

data/lib/plezi/handlers/placebo.rb

@@ -0,0 +1,123 @@
+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` :
+	#
+	#       class MyListener
+	#          def _my_method_name *args
+	#             #logic
+	#          end
+	#       end
+	#
+	#       Plezi::Placebo.new MyListener
+	#
+	# 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.
+	#
+	# The new instance will also accept unicasts sent to it's unique UUID.
+	#
+	# Returns an instance that is a member of the class passed, after that class was inherited by Plezi and
+	# more methods were injected into it's subclass.
+	module Placebo
+
+		# the base module exposes some of the core functionality, but shouldn't be relied upon as far as it's API goes.
+		module Base
+			#the methods here will be injected to the Placebo controller.
+			module Core
+				def self.included base
+					base.send :include, InstanceMethods
+					base.extend ClassMethods
+				end
+
+				#the methods here will be injected to the Placebo controller as Instance methods.
+				module InstanceMethods
+					public
+					attr_accessor :io
+					def initialize io
+						@io = io
+						@io[:websocket_handler] = self
+						super()
+					end
+					# 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"
+							return super(data) if defined? super
+							return false
+						end
+						# return false if data[:type] && !self.is_a?(data[:type])
+						return false if data[:target] && data[:target] != ws.uuid
+						return false unless self.class.has_super_method?(data[:method])
+						self.method(data[:method]).call *data[:data]
+					end
+					# Returns the websocket connection's UUID, used for unicasting.
+					def uuid
+						io[:uuid] ||= SecureRandom.uuid
+					end
+
+					# Performs a websocket unicast to the specified target.
+					def unicast target_uuid, method_name, *args
+						GRHttp::Base::WSHandler.unicast target_uuid, data: args, target: target_uuid, method: method_name
+						__send_to_redis data: args, target: target_uuid, method: method_name
+					end
+					# broadcast to a specific controller
+					def broadcast controller_class, method_name, *args
+						GRHttp::Base::WSHandler.broadcast({data: args, type: controller_class, method: method_name}, self)
+						__send_to_redis data: args, type: controller_class, method: method_name
+					end
+					# multicast to all handlers.
+					def multicast method_name, *args
+						GRHttp::Base::WSHandler.broadcast({method: method_name, data: args, type: :all}, self)
+						__send_to_redis method: method_name, data: args, type: :all
+					end
+					protected
+					def __send_to_redis data
+						raise "Wrong method name for websocket broadcasting - expecting type Symbol" unless data[:method].is_a?(Symbol) || data[:method].is_a?(Symbol)
+						conn = Plezi.redis_connection
+						data[:server] = Plezi::Settings.uuid
+						return conn.publish( Plezi::Settings.redis_channel_name, data.to_yaml ) if conn
+						false
+					end
+				end
+				#the methods here will be injected to the Placebo controller as class methods.
+				module ClassMethods
+					public
+					def has_super_method? method_name
+						@super_methods_list ||= self.superclass.instance_methods.to_set
+						@super_methods_list.include? method_name
+					end
+				end
+			end
+		end
+		module_function
+		def new placebo_class
+			new_class_name = "PlaceboPlezi__#{placebo_class.name.gsub /[\:\-\#\<\>\{\}\(\)\s]/, '_'}"
+			new_class = nil
+			new_class =  Module.const_get new_class_name if Module.const_defined? new_class_name
+			unless new_class
+				new_class = Class.new(placebo_class) do
+					include Placebo::Base::Core
+				end
+				Object.const_set(new_class_name, new_class)
+			end
+			i, o = IO.pipe
+			o.close
+			io = GReactor.add_io i, handler: (Proc.new {|io| io.read })
+			new_class.new(io)
+		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)

data/lib/plezi/handlers/stubs.rb

@@ -141,4 +141,4 @@ module Plezi
 		end
 
 	end
-end
+end

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-    VERSION = "0.10.6"
+    VERSION = "0.10.8"
 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.0.9"
+  spec.add_dependency "grhttp", "~> 0.0.11"
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
 

data/test/plezi_tests.rb

@@ -17,6 +17,8 @@ def report_after_filter(result= true)
 	true
 end
 
+class Nothing
+end
 class TestCtrl
 
 
@@ -239,6 +241,15 @@ module PleziTestTasks
 		puts "    **** #url_for test FAILED TO RUN!!!"
 		puts e
 	end
+	def test_placebo
+		puts "    * Starting placebo tests..."
+		ws = GRHttp::WSClient.connect_to("ws://localhost:3000/ws/placebo") {|ws| 'ME?'}
+		ws << "    * Placebo WS connected."
+		sleep 2
+		rescue => e
+		puts "    **** Placebo test FAILED TO RUN!!!"
+		puts e
+	end
 	def test_websocket
 		connection_test = broadcast_test = echo_test = unicast_test = false
 		begin
@@ -343,7 +354,38 @@ module PleziTestTasks
 	end
 end
 
-NO_PLEZI_AUTO_START = true
+class PlaceboTestCtrl
+	# called when new Websocket data is recieved
+	#
+	# data is a string that contains binary or UTF8 (message dependent) data.
+	def index
+		false
+	end
+	def on_open
+		puts "    * Placebo multicasting to placebo test: #{PleziTestTasks::RESULTS[ multicast :send_back, uuid: uuid, test: true, type: 'multicast' ] }"
+	end
+	def on_message data
+		puts data
+	end
+	def _get_uuid data
+		puts "    * Placebo send #{data[:type]} test: #{PleziTestTasks::RESULTS[data[:test]]}"
+		unicast( data[:uuid], :send_back, {test: true, type: 'unicast'}) if data[:uuid]
+	end
+end
+
+class PlaceboCtrl
+	def send_back data
+		puts "    * Placebo recieve test for #{data[:type]}: #{PleziTestTasks::RESULTS[data[:test]]}"
+		if data[:uuid]
+			unicast( data[:uuid], :_get_uuid, {test: true, uuid: uuid, type: 'unicast'})
+		else
+			broadcast WSsizeTestCtrl, :_get_uuid, test: true, type: 'broadcast'
+			multicast :_get_uuid, test: true, type: 'multicast'
+		end
+	end
+end
+r = Plezi::Placebo.new PlaceboCtrl
+puts "    * Create Placebo test: #{PleziTestTasks::RESULTS[r && true]}"
 
 PL.create_logger '/dev/null'
 # PL::Settings.max_threads = 4
@@ -354,18 +396,21 @@ route("/ssl") {|req, res| res << "false" }
 listen port: 3030, ssl: true
 route("/ssl") {|req, res| res << "true" }
 
+shared_route 'ws/no', Nothing
+shared_route 'ws/placebo', PlaceboTestCtrl
 shared_route 'ws/size', WSsizeTestCtrl
 
 shared_route '/some/:multi{path|another_path}/(:option){route|test}/(:id)/(:optional)', TestCtrl
 shared_route '/', TestCtrl
 
 
-GReactor.run_async do
-	puts "    --- Starting tests"
-	puts "    --- Failed tests should read: #{PleziTestTasks::RESULTS[false]}"
-	PleziTestTasks.run_tests
-	puts "\n    --- Press ^C to complete tests."
-end
+Plezi.start_async
+puts "    --- Plezi will ran async, performing some tests that than hang"
+
+puts "    --- Starting tests"
+puts "    --- Failed tests should read: #{PleziTestTasks::RESULTS[false]}"
+PleziTestTasks.run_tests
+puts "\n    --- Press ^C to complete tests."
 
 # start_services
 
@@ -373,7 +418,6 @@ shoutdown_test = false
 # GReactor::Settings.set_forking 4
 Plezi.on_shutdown { shoutdown_test = true }
 
-
 Plezi.start
 # Plezi::EventMachine.clear_timers
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plezi
 version: !ruby/object:Gem::Version
-  version: 0.10.6
+  version: 0.10.8
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-20 00:00:00.000000000 Z
+date: 2015-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grhttp
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.9
+        version: 0.0.11
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.9
+        version: 0.0.11
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -77,6 +77,7 @@ files:
 - lib/plezi/handlers/controller_core.rb
 - lib/plezi/handlers/controller_magic.rb
 - lib/plezi/handlers/http_router.rb
+- lib/plezi/handlers/placebo.rb
 - lib/plezi/handlers/route.rb
 - lib/plezi/handlers/stubs.rb
 - lib/plezi/helpers/http_sender.rb