plezi 0.9.2 → 0.10.1

data/lib/plezi/common/redis.rb

@@ -0,0 +1,44 @@
+
+module Plezi
+
+	module_function
+
+	# 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.
+	# for example:
+	#      ENV['PL_REDIS_URL'] = ENV['REDISCLOUD_URL']`
+	# or
+	#      ENV['PL_REDIS_URL'] = "redis://username:password@my.host:6379"
+	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
+							end
+						rescue => e
+							Plezi.error e
+						end
+					end
+				end
+			rescue => e
+				Plezi.error e
+				retry
+			end
+		end
+		@redis
+	end
+end
+

data/lib/plezi/common/settings.rb

@@ -0,0 +1,58 @@
+
+module Plezi
+
+	# This module allows you to set some of the Plezi framework's settings.
+	module Settings
+
+		module_function
+
+		# The maximum number of threads that are used for concurrency.
+		def max_threads
+			@max_threads ||= 8
+		end
+		# Sets the maximum number of threads that are used for concurrency.
+		def max_threads=val
+			@max_threads = val
+		end
+
+		# The number of second between pings automatically sent by an open websocket.
+		def autoping
+			@autoping ||= 45
+		end
+		# Sets the number of second between pings automatically sent by an open websocket.
+		#
+		# Set to nil or false to disable auto-pinging.
+		def autoping=val
+			@autoping = 45
+		end
+
+		# Sets the Redis Channel Name.
+		def redis_channel_name=val
+			return false unless defined? Redis
+			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.
+		def redis_channel_name
+			@redis_channel_name ||= 'Plezi_Redis_Channel'
+		end
+
+		# Sets the message byte size limit for a Websocket message. Defaults to 0 (no limit)
+		#
+		# Although memory will be allocated for the latest TCP/IP frame,
+		# this allows the websocket to disconnect if the incoming expected message size exceeds the allowed maximum size.
+		#
+		# If the sessage size limit is exceeded, the disconnection will be immidiate as an attack will be assumed. The protocol's normal disconnect sequesnce will be discarded.
+		def ws_message_size_limit=val
+			GRHttp.ws_message_size_limit = val
+		end
+		# Gets the message byte size limit for a Websocket message. Defaults to 0 (no limit)
+		def ws_message_size_limit
+			GRHttp.ws_message_size_limit
+		end
+
+		# This Server's UUID
+		UUID = SecureRandom.uuid
+	end
+end
+

data/lib/plezi/handlers/controller_core.rb

@@ -0,0 +1,132 @@
+module Plezi
+	module Base
+
+		# the methods defined in this module will be injected into the Controller's Core class (inherited from the controller).
+		module ControllerCore
+			def self.included base
+				base.send :include, InstanceMethods
+				base.extend ClassMethods
+			end
+
+			module InstanceMethods
+				public
+
+				def initialize request, response
+					@request = request
+					@params = request.params
+					@flash = response.flash
+					@host_params = request.io[:params]
+					@response = response
+					@cookies = request.cookies
+					# @response["content-type"] ||= ::Plezi.default_content_type
+					super()
+				end
+
+
+				# WebSockets.
+				#
+				# this method handles the protocol and handler transition between the HTTP connection
+				# (with a protocol instance of HTTPProtocol and a handler instance of HTTPRouter)
+				# and the WebSockets connection
+				# (with a protocol instance of WSProtocol and an instance of the Controller class set as a handler)
+				def pre_connect
+					# make sure this is a websocket controller
+					return false unless self.class.has_super_method?(:on_message)
+					# call the controller's original method, if exists, and check connection.
+					return false if (defined?(super) && !super)
+					# finish if the response was sent
+					return false if response.headers_sent?
+					# complete handshake
+					return self
+				end
+				# handles websocket opening.
+				def on_open ws
+					# set broadcasts and return true
+					@response = ws
+					ws.autopong Plezi::Settings.autoping unless Plezi::Settings.autoping
+					# create the redis connection (in case this in the first instance of this class)
+					Plezi.redis_connection
+					super() if defined?(super)
+				end
+				# handles websocket messages.
+				def on_message ws
+					super(ws.data) if defined?(super)
+				end
+				# handles websocket being closed.
+				def on_close ws
+					super() if defined? super
+				end
+				# handles websocket being closed.
+				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 unless self.class.has_method?(data[:method])
+					self.method(data[:method]).call *data[:data]
+				end
+
+				# Inner Routing
+				#
+				#
+				def _route_path_to_methods_and_set_the_response_
+					#run :before filter
+					return false if self.class.has_method?(:before) && self.before == false 
+					#check request is valid and call requested method
+					ret = requested_method
+					return false unless ret
+					ret = self.method(ret).call
+					return false unless ret
+					#run :after filter
+					return false if self.class.has_method?(:after) && self.after == false
+					# review returned type for adding String to response
+					return ret
+				end
+
+			end
+
+			module ClassMethods
+				public
+
+				def reset_routing_cache
+					@methods_list = nil
+					@exposed_methods_list = nil
+					@super_methods_list = nil
+					has_method? nil
+					has_exposed_method? nil
+					has_super_method? nil
+				end
+				def has_method? method_name
+					@methods_list ||= self.instance_methods.to_set
+					@methods_list.include? method_name
+				end
+				def has_exposed_method? method_name
+					@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
+				def has_super_method? method_name
+					@super_methods_list ||= self.superclass.instance_methods.to_set
+					@super_methods_list.include? method_name
+				end
+
+				protected
+
+				# a callback that resets the class router whenever a method (a potential route) is added
+				def method_added(id)
+					reset_routing_cache
+				end
+				# a callback that resets the class router whenever a method (a potential route) is removed
+				def method_removed(id)
+					reset_routing_cache
+				end
+				# a callback that resets the class router whenever a method (a potential route) is undefined (using #undef_method).
+				def method_undefined(id)
+					reset_routing_cache
+				end
+			end
+		end
+	end
+end

data/lib/plezi/handlers/controller_magic.rb

@@ -44,31 +44,6 @@ module Plezi
 			# the parameters used to create the host (the parameters passed to the `listen` / `add_service` call).
 			attr_reader :host_params
 
-			# 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.
-			def uuid
-				@uuid ||= SecureRandom.uuid
-			end
-			alias :unicast_id :uuid
-
-			# checks whether this instance accepts broadcasts (WebSocket instances).
-			def accepts_broadcast?
-				@_accepts_broadcast
-			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.
-			def refuse_broadcasts
-				@_accepts_broadcast = false
-				self
-			end
-
 			# this method does two things.
 			#
 			# 1. sets redirection headers for the response.
@@ -140,29 +115,14 @@ module Plezi
 			#
 			def send_data data, options = {}
 				raise 'Cannot use "send_data" after headers were sent' if response.headers_sent?
-				# write data to response object
+				Plezi.warn 'HTTP response buffer is cleared by `#send_data`' if response.body && response.body.any? && response.body.clear
 				response << data
 
 				# set headers
-				content_disposition = 'attachment'
+				content_disposition = options[:inline] ? 'inline' : 'attachment'
+				content_disposition << "; filename=#{options[:filename]}" if options[:filename]
 
-				options[:type] ||= MimeTypeHelper::MIME_DICTIONARY[::File.extname(options[:filename])] if options[:filename]
-
-				if options[:type]
-					response['content-type'] = options[:type]
-					options.delete :type
-				end
-				if options[:inline]
-					content_disposition = 'inline'
-					options.delete :inline
-				end
-				if options[:attachment]
-					options.delete :attachment
-				end
-				if options[:filename]
-					content_disposition << "; filename=#{options[:filename]}"
-					options.delete :filename
-				end
+				response['content-type'] = options[:type] ||= MimeTypeHelper::MIME_DICTIONARY[::File.extname(options[:filename])] if options[:filename]
 				response['content-length'] = data.bytesize rescue true
 				response['content-disposition'] = content_disposition
 				response.finish
@@ -216,7 +176,7 @@ module Plezi
 
 			# returns the initial method called (or about to be called) by the router for the HTTP request.
 			#
-			# this is can be very useful within the before / after filters:
+			# this can be very useful within the before / after filters:
 			#   def before
 			#     return false unless "check credentials" && [:save, :update, :delete].include?(requested_method)
 			#
@@ -225,75 +185,56 @@ module Plezi
 			# (which is the last method called before the protocol is switched from HTTP to WebSockets).
 			def requested_method
 				# respond to websocket special case
-				return :pre_connect if request['upgrade'] && request['upgrade'].to_s.downcase == 'websocket' &&  request['connection'].to_s.downcase == 'upgrade'
+				return :pre_connect if request.upgrade?
 				# respond to save 'new' special case
-				return :save if request.request_method.match(/POST|PUT|PATCH/) && (params[:id].nil? || params[:id] == 'new')
+				return (self.class.has_method?(:save) ? :save : false) if request.request_method.match(/POST|PUT|PATCH/) && (params[:id].nil? || params[:id] == 'new')
 				# set DELETE method if simulated
 				request.request_method = 'DELETE' if params[:_method].to_s.downcase == 'delete'
 				# respond to special :id routing
-				return params[:id].to_s.to_sym if params[:id] && self.class.available_public_methods.include?(params[:id].to_s.to_sym)
+				return params[:id].to_s.to_sym if params[:id] && self.class.has_exposed_method?(params[:id].to_s.to_sym)
 				#review general cases
 				case request.request_method
 				when 'GET', 'HEAD'
-					return :index unless params[:id]
-					return :show
+					return (self.class.has_method?(:index) ? :index : false) unless params[:id]
+					return (self.class.has_method?(:show) ? :show : false)
 				when 'POST', 'PUT', 'PATCH'
-					return :update
+					return (self.class.has_method?(:update) ? :update : false)
 				when 'DELETE'
-					return :delete
+					return (self.class.has_method?(:delete) ? :delete : false)
 				end
 				false
 			end
 
 			## WebSockets Magic
 
+			# 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.
+			def uuid
+				return @response.uuid if @response.is_a?(GRHttp::WSEvent)
+				nil
+			end
+			alias :unicast_id :uuid
+
 			# WebSockets.
 			#
 			# Use this to brodcast an event to all 'sibling' websockets (websockets that have been created using the same Controller class).
 			#
-			# accepts:
+			# Accepts:
 			# 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).
+			# 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 each sibling instance of this Controller class.
+			# The method will be called asynchrnously for each sibling instance of this Controller class.
 			#
-			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, nil, method_name, args, &block) || self.class.__inner_process_broadcast(uuid, nil, method_name.to_sym, args, &block)
+			def broadcast method_name, *args
+				return false unless self.class.has_method? method_name
+				self.class._inner_broadcast({ method: method_name, data: args, type: self.class}, @response.io)
 			end
 
 			# {include:ControllerMagic::ClassMethods#unicast}
 			def unicast target_uuid, method_name, *args
-				self.class.unicast target_uuid, method_name, *args
-			end
-
-			# WebSockets.
-			#
-			# Use this to collect data from all 'sibling' websockets (websockets that have been created using the same Controller class).
-			#
-			# This method will call the requested method on all instance siblings and return an Array of the returned values (including nil values).
-			#
-			# This method will block the excecution unless a block is passed to the method - in which case
-			#  the block will used as a callback and recieve the Array as a parameter.
-			#
-			# i.e.
-			#
-			# this will block: `collect :_get_id`
-			#
-			# this will not block: `collect(:_get_id) {|a| puts "got #{a.length} responses."; a.each { |id| puts "#{id}"} }
-			#
-			# accepts:
-			# 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.
-			# &block:: an optional block to be used as a callback.
-			#
-			# the method will be called asynchrnously for each sibling instance of this Controller class.
-			def collect method_name, *args, &block
-				return Plezi.callback(self, :collect, *args, &block) if block
-				r = []
-				ObjectSpace.each_object(self.class) { |controller|  r << controller.method(method_name).call(*args) if controller.accepts_broadcast?  && (controller.object_id != self.object_id) }
-				return r
+				self.class._inner_broadcast method: method_name, data: args, target: target_uuid
 			end
 
 
@@ -307,46 +248,62 @@ module Plezi
 		end
 
 		module ClassMethods
-			protected
+			public
 
-			# Sets the HTTP route that is the owner of this controller.
+			# WebSockets: fires an event on all of this controller's active websocket connections.
 			#
-			# This is used by the Plezi framework internally and is supplied only for advanced purposes. It is better to avoid using this method. 
-			def set_pl_route route
-				@pl_http_route = route
+			# Class method.
+			#
+			# Use this to brodcast an event to all connections.
+			#
+			# accepts:
+			# 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).
+			#
+			# this method accepts and optional block (NON-REDIS ONLY) to be used as a callback for each sibling's event.
+			#
+			# the method will be called asynchrnously for each sibling instance of this Controller class.
+			def broadcast method_name, *args
+				return false unless has_method? method_name
+				_inner_broadcast method: method_name, data: args, type: self
 			end
 
-			# Gets the HTTP route that is the owner of this controller.
+			# WebSockets: fires an event on a specific websocket connection using it's UUID.
 			#
-			# This is used to utilize the `url_for` method.
-			def get_pl_route
-				@pl_http_route
+			# 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
+				_inner_broadcast method: method_name, data: args, target: target_uuid
 			end
 
-			public
-
 			# 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				
 			end
 
-			# lists the available methods that will be exposed to HTTP requests
-			def available_public_methods
-				# set class global to improve performance while checking for supported methods
-				@available_public_methods ||= (available_routing_methods - [:before, :after, :save, :show, :update, :delete, :initialize, :on_message, :pre_connect, :on_connect, :on_disconnect]).to_set
+			# resets the routing cache
+			def reset_routing_cache
+				@inheritance.each {|sub| sub.reset_routing_cache}
 			end
 
-			# lists the available methods that will be exposed to the HTTP router
-			def available_routing_methods
-				@available_routing_methods ||= ( ( (public_instance_methods - Object.public_instance_methods) - Plezi::ControllerMagic::InstanceMethods.instance_methods).delete_if {|m| m.to_s[0] == '_'}).to_set
+			protected
+
+			# Sets the HTTP route that is the owner of this controller.
+			#
+			# This is used by the Plezi framework internally and is supplied only for advanced purposes. It is better to avoid using this method. 
+			def set_pl_route route
+				@pl_http_route = route
 			end
 
-			# resets this controller's router, to allow for dynamic changes
-			def reset_routing_cache
-				@available_routing_methods = false
-				@available_public_methods = false
-				available_routing_methods
-				available_public_methods
+			# Gets the HTTP route that is the owner of this controller.
+			#
+			# This is used to utilize the `url_for` method.
+			def get_pl_route
+				@pl_http_route
 			end
 
 			# a callback that resets the class router whenever a method (a potential route) is added
@@ -361,163 +318,32 @@ module Plezi
 			def method_undefined(id)
 				reset_routing_cache
 			end
-			# # lists the available methods that will be exposed to HTTP requests
-			# def available_public_methods
-			# 	# set class global to improve performance while checking for supported methods
-			# 	Plezi.cached?(self.superclass.name + '_p&rt') ? Plezi.get_cached(self.superclass.name + "_p&rt") : Plezi.cache_data(self.superclass.name + "_p&rt", (available_routing_methods - [:before, :after, :save, :show, :update, :delete, :initialize, :on_message, :pre_connect, :on_connect, :on_disconnect]).to_set )
-			# end
 
-			# # lists the available methods that will be exposed to the HTTP router
-			# def available_routing_methods
-			# 	# set class global to improve performance while checking for supported methods
-			# 	Plezi.cached?(self.superclass.name + '_r&rt') ? Plezi.get_cached(self.superclass.name + "_r&rt") : Plezi.cache_data(self.superclass.name + "_r&rt",  (((public_instance_methods - Object.public_instance_methods) - Plezi::ControllerMagic::InstanceMethods.instance_methods).delete_if {|m| m.to_s[0] == '_'}).to_set  )
-			# end
-
-			# # resets this controller's router, to allow for dynamic changes
-			# def reset_routing_cache
-			# 	Plezi.clear_cached(self.superclass.name + '_p&rt')
-			# 	Plezi.clear_cached(self.superclass.name + '_r&rt')
-			# 	available_routing_methods
-			# 	available_public_methods
-			# end
-
-			
-			# 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.
-			# for example:
-			#      ENV['PL_REDIS_URL'] = ENV['REDISCLOUD_URL']`
-			# or
-			#      ENV['PL_REDIS_URL'] = "redis://username:password@my.host:6379"
-			def redis_connection
-				# return false unless defined?(Redis) && ENV['PL_REDIS_URL']
-				# return @redis if defined?(@redis_sub_thread) && @redis
-				# @@redis_uri ||= URI.parse(ENV['PL_REDIS_URL'])
-				# @redis ||= Redis.new(host: @@redis_uri.host, port: @@redis_uri.port, password: @@redis_uri.password)
-				# @redis_sub_thread = Thread.new do
-				# 	begin
-				# 		Redis.new(host: @@redis_uri.host, port: @@redis_uri.port, password: @@redis_uri.password).subscribe(redis_channel_name) do |on|
-				# 			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
-				# 			end
-				# 		end						
-				# 	rescue Exception => e
-				# 		Plezi.error e
-				# 		retry
-				# 	end
-				# end
-				# raise "Redis connction failed for: #{ENV['PL_REDIS_URL']}" unless @redis
-				# @redis
-				return false unless defined?(Redis) && ENV['PL_REDIS_URL']
-				return Plezi.get_cached(self.superclass.name + '_b') if Plezi.cached?(self.superclass.name + '_b')
-				@@redis_uri ||= URI.parse(ENV['PL_REDIS_URL'])
-				Plezi.cache_data self.superclass.name + '_b', Redis.new(host: @@redis_uri.host, port: @@redis_uri.port, password: @@redis_uri.password)
-				raise "Redis connction failed for: #{ENV['PL_REDIS_URL']}" unless Plezi.cached?(self.superclass.name + '_b')
-				t = Thread.new do
-					begin
-						Redis.new(host: @@redis_uri.host, port: @@redis_uri.port, password: @@redis_uri.password).subscribe(redis_channel_name) do |on|
-							on.message do |channel, msg|
-								args = JSON.parse(msg)
-								params = args.shift
-								__inner_process_broadcast params['_pl_ignore_object'], params['_pl_target_object'], params['_pl_method_broadcasted'].to_sym, args
-							end
-						end						
-					rescue Exception => e
-						Plezi.error e
-						retry
-					end
-				end
-				Plezi.cache_data self.superclass.name + '_t', t
-				Plezi.get_cached(self.superclass.name + '_b')
+			def inherited sub
+				(@inheritance ||= [].to_set) << sub
 			end
 
-			# returns a Redis channel name for this controller.
-			def redis_channel_name
-				self.superclass.name.to_s
-			end
 
-			# broadcasts messages (methods) for this process
-			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
+			# WebSockets
 
-			# broadcasts messages (methods) between all processes (using Redis).
-			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, _pl_target_object: target})
-				redis_connection.publish(redis_channel_name, args.to_json )
+			# sends the broadcast
+			def _inner_broadcast data, ignore_io = nil
+				if data[:target]
+					__inner_redis_broadcast data unless GRHttp::Base::WSHandler.unicast data[:target], data
+				else
+					GRHttp::Base::WSHandler.broadcast data, ignore_io
+					__inner_redis_broadcast data				
+				end
 				true
 			end
 
-			# WebSockets: fires an event on all of this controller's active websocket connections.
-			#
-			# Class method.
-			#
-			# Use this to brodcast an event to all connections.
-			#
-			# accepts:
-			# 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).
-			#
-			# this method accepts and optional block (NON-REDIS ONLY) to be used as a callback for each sibling's event.
-			#
-			# 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, nil, method_name, args, &block) || __inner_process_broadcast(nil, nil, method_name.to_sym, args, &block)
-			end
-
-			# WebSockets: fires an event on a specific websocket connection using it's UUID.
-			#
-			# 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.
-			#
-			# Class method.
-			#
-			# Use this to collect data from all websockets for the calling class (websockets that have been created using the same Controller class).
-			#
-			# This method will call the requested method on all instance and return an Array of the returned values (including nil values).
-			#
-			# This method will block the excecution unless a block is passed to the method - in which case
-			#  the block will used as a callback and recieve the Array as a parameter.
-			#
-			# i.e.
-			#
-			# this will block: `collect :_get_id`
-			#
-			# this will not block: `collect(:_get_id) {|a| puts "got #{a.length} responses."; a.each { |id| puts "#{id}"} }
-			#
-			# accepts:
-			# 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.
-			# &block:: an optional block to be used as a callback.
-			#
-			# the method will be called asynchrnously for each instance of this Controller class.
-			def collect method_name, *args, &block				
-				return Plezi.push_event(self.method(:collect), *args, &block) if block
-
-				r = []
-				ObjectSpace.each_object(self) { |controller|  r << controller.method(method_name).call(*args) if controller.accepts_broadcast? }
-				return r
+			def __inner_redis_broadcast data
+				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
 
-		module_function
-
-
 	end
 end