plezi 0.10.13 → 0.10.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7f37f01622fbcda6cf86ca9575aafb2145b5479f
-  data.tar.gz: cbdf67890ad9995b11d058cbe821c62fad863995
+  metadata.gz: 2487750b4f8cbcb1de42a7bc91e065da2f94c212
+  data.tar.gz: 7f39f9de1020bc8f3d80113b2dc01d7c59c9d706
 SHA512:
-  metadata.gz: f940d9e1731e9708228c8519a3be967762c427db4d3644aac6ceb439db8a9e44ac1de7bdfd4d3e998039f70452e1e2ffe02dc4ab444c4445793a017c1c02b432
-  data.tar.gz: 9a336108299a74946dd97b6718f2440f80df3d5ec6dc33a925c35e5f82eb0d15c21571bbdd6a79c7c1b3cbfafd7ee79a89b3b449773e467018667a21948be1c0
+  metadata.gz: c97f85a27d0cce6a6d1df74e31ed9c8fef44377cfb9f0646d097f8917d80137dcddbe951631b2ab2126827595ad9028b53c01ffa3e1d3e1662440c710754ceb3
+  data.tar.gz: 79c93625fcc681835f0db3c87919fa4e4a906a4f4747c42ef3093155ac02489e3d834b2307c1b621a9a5cff43ea0481ecdab6f26b18488ef3dd8068d86ee94a4

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 #Change Log
 
+Change log v.0.10.14
+
+**Deprecation notice**: Setting the public root folder is now done using the option `public` instead of the option `root`.
+
+**Fix**: Yard documentation failed due to duplicate entries. The issue was fixed.
+
+**Update**: removed duplicate code and updated the server for better Rack support.
+
+***
+
 Change log v.0.10.13
 
 **Fix**: The Placebo API was tested and an issue with the new Placebo class broadcast method was fixed.

data/README.md

@@ -12,7 +12,7 @@ With Plezi, you can easily:
 
 3. Create a full fledged Ruby web application, taking full advantage of RESTful routing, HTTP streaming and scalable Websocket features.
 
-Plezi leverages [GRHttp server](https://github.com/boazsegev/GRHttp)'s new architecture. GRHttp is a pure Ruby HTTP and Websocket Generic Server built using [GReactor](https://github.com/boazsegev/GReactor) - a multi-threaded pure ruby alternative to EventMachine with basic process forking support (enjoy forking, if your code is scaling ready).
+Plezi leverages [GRHttp server's](https://github.com/boazsegev/GRHttp) new architecture. GRHttp is a pure Ruby HTTP and Websocket Generic Server built using [GReactor](https://github.com/boazsegev/GReactor) - a multi-threaded pure ruby alternative to EventMachine with basic process forking support (enjoy forking, if your code is scaling ready).
 
 ## Installation
 
@@ -117,20 +117,27 @@ 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
+## Adding Websockets to your existing Rails/Sinatra/Rack application
 
-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.
+You already have an amazing WebApp, but now you want to add websocket broadcasting and unicasting support - Plezi makes connecting your existing WebApp with your Plezi Websocket backend as easy as it gets.
 
 
-There are two easy ways to augment your existing WebApp, depending on your needs and preferences:
+There are two easy ways to add Plezi websockets to your existing WebApp, depending on your needs and preferences:
 
-1. Let Plezi and GRHttp run your application as a fallback position, defering to your application for anything Plezi doesn't handle (Plezi Websockets and routes will recieve priority).
+1. **The super easy way - a Hybrid app**:
 
-2. Run Plezi on a seperate process/server and set up communication between the two apps.
+     Plezi plays well with others, so you can add Plezi to your existing framework and let it catch any incoming websocket connections. Your application will still handle anything you didn't ask Plezi to handle (Plezi Websockets and routes will recieve priority, so your app can keep handling the 404 response).
 
-### The super easy augmentation - run together
 
-The easiest way to augment your existing application is to use GRHttp's Rack adapter to run your Rack app, while Plezi will use GRHttp's native features (such as Websockets and HTTP streaming).
+2. **The Placebo API**:
+
+     Plezi has a Placebo API, allowing you to add Plezi features without running a Plezi app.
+
+     By adding the Plezi Placebo to your app, you can easily communicate between your existing app and a remote Plezi process/server. So, although websocket connections are made to a different server, your app can still send and recieve data through the websocket connection (using Redis).
+
+### The super easy way - a Hybrid app
+
+The easiest way to add Plezi websockets to your existing application is to use [GRHttp's](https://github.com/boazsegev/GRHttp) Rack adapter to run your Rack app, while Plezi will use GRHttp's native features (such as Websockets and HTTP streaming).
 
 You can eaither use your existing Plezi application or create a new mini plezi application inside your existing app folder using:
 
@@ -145,22 +152,21 @@ Plezi.start_rack
 
 That's it! Now you can use the Plezi API and your existing application's API at the same time and they are both running on the same server.
 
-Plezi's route have priority, so that your app can keep handling the 404 (not found) error page.
+Plezi's routes will be attempted first, so that your app can keep handling the 404 (not found) error page.
 
-In the next section we will explore how to set up the placebo API for cross process apps... since you are sharing the same space, you won't need it - but you can still use most of the Placebo API if you wish to do so (just **don't** call `Plezi.start_placebo`)
+### The Plezi Placebo API - talking from afar
 
-### The easy (but not super easy) augmentation - talking from afar
+To use Plezi and your App on different processes, without mixing them together, 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, but Plezi will not interfere with your WebApp in any way.
 
-To use Plezi and your App on different processes, without mixing them together, 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:
+For instance, add the following code to your environment setup 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"
+# # Make sure the following is already in your 'my_plezi_app/environment.rb' file:
+# ENV['PL_REDIS_URL'] = "redis://username:password@my.host:6379"
 
 Plezi.start_placebo
 ```
@@ -172,7 +178,7 @@ Plezi will automatically set up the Redis connections and pub/sub to connect you
 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
-
+# Demo a Rails Controller:
 class ClientsController < ApplicationController
   def update
      #... your original logic here
@@ -199,23 +205,20 @@ 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:
+In your Rails app, add the logic:
 
 ```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:
+On the Plezi side, use multicasting or unicasting (but not broadcasting), from ANY controller:
 
 ```ruby
 
@@ -227,39 +230,33 @@ class ClientPleziCtrl
 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...
+That's it! Now you have your listening object... but be aware - to safely scale up this communication you might consider using unicasting instead of broadcasting.
+
+We recommend saving the uuid of the Rails process to a Redis key and picking it up from there.
 
 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
+pl = Plezi::Placebo.new MyReciever
+
+Plezi.redis_connection.set 'MainUUIDs', pl.uuid
 
 ```
-On the Plezi, save the data and use unicasting when possible:
+In your Plezi app, 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\""
+        main_uuid = Plezi.redis_connection.get 'MainUUIDs'
+        unicast main_uuid, :my_reciever_method, arg1, arg2, arg3, arg4... if main_uuid
     end
 end
 

data/bin/plezi

@@ -49,6 +49,8 @@ class AppTemplate
 		app_tree["Gemfile"] ||= ''
 		app_tree["Gemfile"] << "source 'https://rubygems.org'\n\n####################\n# core gems\n\n# include the basic plezi framework and server\ngem 'plezi', '~> #{Plezi::VERSION}'\n"
 		app_tree["Gemfile"] << "\n\n\nruby '#{RUBY_VERSION}'\n"
+		app_tree["404.html.erb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"404.erb"),  __FILE__))
+		app_tree["500.html.erb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"500.erb"),  __FILE__))
 		finalize
 	end
 

data/lib/plezi/common/api.rb

@@ -31,7 +31,7 @@ module Plezi
 	#
 	# Plezi's controller.render ERB, Slim and Haml are natively supported.
 	#
-	# @returns [Plezi::Router]
+	# @return [Plezi::Router]
 	#
 	def listen parameters = {}
 		# update default values

data/lib/plezi/common/settings.rb

@@ -32,7 +32,8 @@ module Plezi
 			raise "Can't change channel name after Redis subscription had been initiated." if @redis
 			@redis_channel_name = val
 		end
-		# @return [String] Returns the Redis Channel Name.
+		# Returns the Redis Channel Name used by this app.
+		# @return [String]
 		def redis_channel_name
 			@redis_channel_name ||= 'Plezi_Redis_Channel'
 		end

data/lib/plezi/handlers/controller_core.rb

@@ -19,7 +19,7 @@ module Plezi
 					@host_params = request.io[:params]
 					@response = response
 					@cookies = request.cookies
-					# @response["content-type"] ||= ::Plezi.default_content_type
+					# # \@response["content-type"] ||= ::Plezi.default_content_type
 					super()
 				end
 
@@ -57,19 +57,6 @@ module Plezi
 				def on_close ws
 					super() if defined? super
 				end
-				# handles websocket multicasting/broadcasting/unicasting.
-				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] && data[:type] != :all && !self.is_a?(data[:type])
-					# return false if data[:target] && data[:target] != ws.uuid + Plezi::Settings.uuid # already reviewed by the GRHttp
-					return false unless self.class.has_method?(data[:method])
-					self.method(data[:method]).call *data[:data]
-				end
 
 				# Inner Routing
 				#

data/lib/plezi/handlers/controller_magic.rb

@@ -20,10 +20,10 @@ module Plezi
 		end
 
 		module InstanceMethods
-			module_function
+
 			public
 
-			# the request object, class: HTTPRequest.
+			# the request object, type HTTPRequest.
 			attr_reader :request
 
 			# the :params variable contains all the parameters set by the request (/path?locale=he  => params ["locale"] == "he").
@@ -97,7 +97,7 @@ module Plezi
 				request.base_url + url_for(dest)
 			end
 
-			# this method adds data to be sent.
+			# Send raw data to be saved as a file or viewed as an attachment. Browser should believe it had recieved a file.
 			#
 			# this is usful for sending 'attachments' (data to be downloaded) rather then
 			# a regular response.

data/lib/plezi/handlers/placebo.rb

@@ -27,10 +27,10 @@ module Plezi
 			#the methods here will be injected to the Placebo controller.
 			module Core
 				def self.included base
+					base.send :include, Plezi::Base::WSObject
 					base.send :include, InstanceMethods
 					base.extend ClassMethods
 					base.superclass.instance_eval {extend SuperClassMethods}
-					base.send :include, Plezi::Base::WSObject
 				end
 
 				#the methods here will be injected to the Placebo controller as Instance methods.

data/lib/plezi/handlers/ws_object.rb

@@ -35,6 +35,7 @@ module Plezi
 						return false
 					end
 					return false if data[:type] && data[:type] != :all && !self.is_a?(data[:type])
+					# return ( self.class.placebo? ? true : we.write(ws.data)) if :method == :to_client
 					return ((data[:type] == :all) ? false : (raise "Broadcasting recieved but no method can handle it - dump:\r\n #{data.to_s}") ) unless self.class.has_super_method?(data[:method])
 					self.method(data[:method]).call *data[:data]
 				end
@@ -130,6 +131,9 @@ module Plezi
 			module SuperClassMethods
 				public
 
+				# answers the question if this is a placebo object.
+				def placebo?; false end
+
 				# WebSockets: fires an event on all of this controller's active websocket connections.
 				#
 				# Class method.

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-    VERSION = "0.10.13"
+    VERSION = "0.10.14"
 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.16"
+  spec.add_dependency "grhttp", "~> 0.0.17"
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
 

data/resources/environment.rb

@@ -40,7 +40,7 @@ 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 	root: Root.join('public').to_s,
+listen 	public: Root.join('public').to_s,
 		assets: Root.join('assets').to_s,
 		assets_public: '/assets',
 		templates: Root.join('app','views').to_s,

data/resources/mini_app.rb

@@ -9,6 +9,8 @@
 	# Dir.chdir Root.to_s
 	## load code from a subfolder called 'code'
 	# Dir[File.join "{code}", "**" , "*.rb"].each {|file| load File.expand_path(file)}
+	## OR load code from all the ruby files in the main forlder (subfolder inclussion will fail on PaaS)
+	# Dir[File.join File.dirname(__FILE__), "*.rb"].each {|file| load File.expand_path(file) unless file == __FILE__}
 
 	## 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.
@@ -60,7 +62,7 @@ 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,
-		# root: Root.join('public').to_s,
+		# public: Root.join('public').to_s,
 		# assets: Root.join('assets').to_s,
 		# templates: Root.join('templates').to_s,
 		ssl: false

data/resources/mini_exec.rb

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
+# set the working directory
+Dir.chdir ::File.expand_path(File.join(__FILE__, ".."))
 # load the appname-app
 load ::File.expand_path(File.join("..", "appname.rb"),  __FILE__)

data/resources/websockets.js

@@ -3,7 +3,7 @@
 // Your websocket URI should be an absolute path. The following sets the base URI.
 // remember to update to the specific controller's path to your websocket URI.
 var ws_controller_path = window.location.pathname; // change to '/controller/path'
-var ws_uri = (window.location.protocol.match(/https/) ? 'wss' : 'ws') + '://' + window.location.hostname + (window.location.port == '' ? '' : (':' + window.location.port) ) + ws_controller_path
+var ws_uri = (window.location.protocol.match(/https/) ? 'wss' : 'ws') + '://' + window.document.location.host + ws_controller_path
 // websocket variable.
 var websocket = NaN
 // count failed attempts

data/resources/welcome_page.html

@@ -177,7 +177,7 @@ input[type=submit]:active
 // Your websocket URI should be an absolute path. The following sets the base URI.
 // remember to update to the specific controller's path to your websocket URI.
 var ws_controller_path = '/' // window.location.pathname; // change to '/controller/path'
-var ws_uri = (window.location.protocol.match(/https/) ? 'wss' : 'ws') + '://' + window.location.hostname + (window.location.port == '' ? '' : (':' + window.location.port) ) + ws_controller_path
+var ws_uri = (window.location.protocol.match(/https/) ? 'wss' : 'ws') + '://' + window.document.location.host + ws_controller_path
 // websocket variable.
 var websocket = NaN
 // count failed attempts

data/test/plezi_tests.rb

@@ -312,28 +312,28 @@ module PleziTestTasks
 		PL.on_shutdown {puts "    * Websocket unicast message test: #{RESULTS[unicast_test]}"}
 	end
 	def test_websocket_sizes
-			# should_disconnect = false
-			# ws = GRHttp::WSClient.connect_to("ws://localhost:3000/ws/size") do |ws|
-			# 	if should_disconnect
-			# 		puts "    * Websocket size disconnection test: #{RESULTS[false]}"
-			# 	else
-			# 		puts "    * Websocket message size test: got #{ws.data.bytesize} bytes"
-			# 	end
-
-			# end
-			# ws.on_close do
-			# 	puts "    * Websocket size disconnection test: #{RESULTS[should_disconnect]}"
-			# end
-			# str = 'a'
-			# time_now = Time.now
-			# 8.times {|i| str = str * 2**i;puts "    * Websocket message size test: sending #{str.bytesize} bytes"; ws << str; }
-			# str.clear
-			# 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
-			# ws << ('0123'*258)
+			should_disconnect = false
+			ws = GRHttp::WSClient.connect_to("ws://localhost:3000/ws/size") do |ws|
+				if should_disconnect
+					puts "    * Websocket size disconnection test: #{RESULTS[false]}"
+				else
+					puts "    * Websocket message size test: got #{ws.data.bytesize} bytes"
+				end
+
+			end
+			ws.on_close do
+				puts "    * Websocket size disconnection test: #{RESULTS[should_disconnect]}"
+			end
+			str = 'a'
+			time_now = Time.now
+			7.times {|i| str = str * 2**i;puts "    * Websocket message size test: sending #{str.bytesize} bytes"; ws << str; }
+			str.clear
+			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
+			ws << ('0123'*258)
 	end
 	def test_broadcast_stress
 		PlaceboStressTestCtrl.create_listeners
@@ -464,11 +464,15 @@ puts "    --- Plezi will ran async, performing some tests that than hang"
 
 puts "    --- Starting tests"
 puts "    --- Failed tests should read: #{PleziTestTasks::RESULTS[false]}"
-Plezi.start_async
-PleziTestTasks.run_tests
 
 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
 
 # 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::Settings.set_forking 4

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plezi
 version: !ruby/object:Gem::Version
-  version: 0.10.13
+  version: 0.10.14
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-25 00:00:00.000000000 Z
+date: 2015-07-27 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.16
+        version: 0.0.17
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.16
+        version: 0.0.17
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -78,7 +78,6 @@ files:
 - lib/plezi/handlers/controller_core.rb
 - lib/plezi/handlers/controller_magic.rb
 - lib/plezi/handlers/http_router.rb
-- lib/plezi/handlers/placebo old.rb
 - lib/plezi/handlers/placebo.rb
 - lib/plezi/handlers/route.rb
 - lib/plezi/handlers/stubs.rb

data/lib/plezi/handlers/placebo old.rb

@@ -1,161 +0,0 @@
-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
-					base.superclass.instance_eval {extend SuperClassMethods}
-				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
-					# notice of disconnect
-					def on_close
-						return super() if defined? super
-						GR.warn "Placebo #{self.class.superclass.name} disconnected. Ignore if this message appears during shutdown."
-					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] && data[:type] != :all && !self.is_a?(data[:type])
-						return ((data[:type] == :all) ? false : (raise "Placebo Broadcasting recieved but no method can handle it - dump:\r\n #{data.to_s}") ) 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
-						return (@uuid ||= @response.uuid + Plezi::Settings.uuid) if @response.is_a?(GRHttp::WSEvent)
-					end
-
-					# Performs a websocket unicast to the specified target.
-					def unicast target_uuid, method_name, *args
-						self.class.unicast target_uuid, method_name, *args
-					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)
-						self.class.__send_to_redis data: args, type: controller_class, method: method_name
-					end
-					# multicast to all handlers.
-					def multicast method_name, *args
-						self.class.multicast method_name, *args
-					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
-				module SuperClassMethods
-					# 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
-					# Broadcast to all instances (usually one instance) of THIS placebo controller.
-					#
-					# This should be used by the real websocket connections to forward messages to the placebo controller classes.
-					def broadcast method_name, *args
-						@methods_list ||= self.public_instance_methods.to_set
-						raise "No mothod defined to accept this broadcast." unless @methods_list.include? method_name
-						GRHttp::Base::WSHandler.broadcast data: args, type: self, method: method_name
-						__send_to_redis data: args, type: self, method: method_name
-					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
-					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
-			end
-			class PlaceboIO < GReactor::BasicIO
-				def clear?
-					io.closed?
-				end
-				def call
-					self.read
-					GR.warn "Placebo IO recieved IO signal - this is unexpected..."
-				end
-				def on_disconnect
-					@params[:out].close rescue nil
-					@cache[:websocket_handler].on_close if @cache[:websocket_handler]
-				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
-			io = Placebo::Base::PlaceboIO.new i, out: o
-			io = GReactor.add_raw_io i, io
-			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)