plezi 0.12.22 → 0.14.0

data/lib/plezi/handlers/ws_identity.rb

@@ -1,253 +0,0 @@
-module Plezi
-
-	module Base
-
-		module WSObject
-
-			# Used to emulate the Redis connection when the Identoty API
-			# is used on a single process with no Redis support.
-			module RedisEmultaion
-				public
-				def lrange key, first, last = -1
-					sync do
-						return [] unless @cache[key]
-						@cache[key][first..last] || []
-					end
-				end
-				def llen key
-					sync do
-						return 0 unless @cache[key]
-						@cache[key].count
-					end
-				end
-				def ltrim key, first, last = -1
-					sync do
-						return "OK".freeze unless @cache[key]
-						@cache[key] = @cache[key][first..last]
-						"OK".freeze
-					end
-				end
-				def del *keys
-					sync do
-						ret = 0
-						keys.each {|k| ret += 1 if @cache.delete k }
-						ret
-					end
-				end
-				def lpush key, value
-					sync do
-						@cache[key] ||= []
-						@cache[key].unshift value
-						@cache[key].count
-					end
-				end
-				def lpop key
-					sync do
-						@cache[key] ||= []
-						@cache[key].shift
-					end
-				end
-				def lrem key, count, value
-					sync do
-						@cache[key] ||= []
-						@cache[key].delete(value)
-					end
-				end
-				def rpush key, value
-					sync do
-						@cache[key] ||= []
-						@cache[key].push value
-						@cache[key].count
-					end
-				end
-				def expire key, seconds
-					@warning_sent ||= Iodine.warn "Identity API requires Redis - no persistent storage!".freeze
-					sync do
-						return 0 unless @cache[key]
-						if @timers[key]
-							@timers[key].stop!
-						end
-						@timers[key] = (Iodine.run_after(seconds) { self.del key })
-					end
-				end
-				def multi
-					sync do
-						@results = []
-						yield(self)
-						ret = @results
-						@results = nil
-						ret
-					end
-				end
-				alias :pipelined :multi
-				protected
-				@locker = Mutex.new
-				@cache = Hash.new
-				@timers = Hash.new
-
-				def sync &block
-					if @locker.locked? && @locker.owned?
-						ret = yield
-						@results << ret if @results
-						ret
-					else
-						@locker.synchronize { sync(&block) }
-					end
-				end
-
-				public
-				extend self
-			end
-
-			# the following are additions to the WebSocket Object module,
-			# to establish identity to websocket realtionships, allowing for a
-			# websocket message bank.
-
-			module InstanceMethods
-				protected
-
-				# @!visibility public
-				# The following method registers the connections as a unique global identity.
-				#
-				# The Identity API works best when a Redis server is used. See {Plezi#redis} for more information.
-				#
-				# By default, only one connection at a time can respond to identity events. If the same identity
-				# connects more than once, only the last connection will receive the notifications.
-				# This default may be controlled by setting the `:max_connections` option to a number greater than 1.
-				#
-				# The method accepts:
-				# identity:: a global application wide unique identifier that will persist throughout all of the identity's connections.
-				# options:: an option's hash that sets the properties of the identity.
-				#
-				# The option's Hash, at the moment, accepts only the following (optional) options:
-				# lifetime:: sets how long the identity can survive. defaults to `604_800` seconds (7 days).
-				# max_connections:: sets the amount of concurrent connections an identity can have (akin to open browser tabs receiving notifications). defaults to 1 (a single connection).
-				#
-				# Lifetimes are renewed with each registration and when a connected Identoty receives a notification.
-				# Identities should have a reasonable lifetime. For example, a 10 minutes long lifetime (60*10)
-				# may prove ineffective. When using such short lifetimes, consider the possibility that `unicast` might provide be a better alternative.
-				#
-				# A lifetime cannot (by design) be shorter than 10 minutes.
-				#
-				# Calling this method will also initiate any events waiting in the identity's queue.
-				# make sure that the method is only called once all other initialization is complete.
-				#
-				# i.e.
-				#
-				#       register_as session.id, lifetime: 60*60*24, max_connections: 4
-				#
-				# Do NOT call this method asynchronously unless Plezi is set to run as in a single threaded mode - doing so
-				# will execute any pending events outside the scope of the IO's mutex lock, thus introducing race conditions.
-				def register_as identity, options = {}
-					redis = Plezi.redis || ::Plezi::Base::WSObject::RedisEmultaion
-					options[:max_connections] ||= 1
-					options[:max_connections] = 1 if options[:max_connections].to_i < 1
-					options[:lifetime] ||= 604_800
-					options[:lifetime] = 600 if options[:lifetime].to_i < 600
-					identity = identity.to_s.freeze
-					@___identity ||= {}
-					@___identity[identity] = options
-					redis.multi do
-						redis.lpop(identity)
-						redis.lpush(identity, ''.freeze)
-						redis.lrem "#{identity}_uuid".freeze, 0, uuid
-						redis.lpush "#{identity}_uuid".freeze, uuid
-						redis.ltrim "#{identity}_uuid".freeze, 0, (options[:max_connections]-1)
-						redis.expire identity, options[:lifetime]
-						redis.expire "#{identity}_uuid".freeze, options[:lifetime]
-					end
-					___review_identity identity
-					identity
-				end
-
-				# @!visibility public
-				# sends a notification to an Identity. Returns false if the Identity never registered or it's registration expired.
-				def notify identity, event_name, *args
-					self.class.notify identity, event_name, *args
-				end
-				# @!visibility public
-				# returns true if the Identity in question is registered to receive notifications.
-				def registered? identity
-					self.class.registered? identity
-				end
-				# # handles websocket being closed.
-				# def on_close
-				# 	super if defined? super
-				# 	redis = Plezi.redis || ::Plezi::Base::WSObject::RedisEmultaion
-				# 	@___identity.each { |identity| redis.lrem "#{identity}_uuid".freeze, 0, uuid }
-				# end
-			end
-			module ClassMethods
-			end
-			module SuperInstanceMethods
-				protected
-
-				# this is the identity event and ittells the connection to "read" the messages in the "mailbox",
-				# and forward the messages to the rest of the connections.
-				def ___review_identity identity
-					redis = Plezi.redis || ::Plezi::Base::WSObject::RedisEmultaion
-					identity = identity.to_s.freeze
-					return Iodine.warn("Identity message reached wrong target (ignored).").clear unless @___identity[identity]
-					messages = redis.multi do
-						redis.lrange identity, 1, -1
-						redis.ltrim identity, 0, 0
-						redis.expire identity,  @___identity[identity][:lifetime]
-						redis.expire "#{identity}_uuid".freeze,  @___identity[identity][:lifetime]
-					end[0]
-					targets = redis.lrange "#{identity}_uuid", 0, -1
-					targets.delete(uuid)
-					while msg = messages.shift
-						msg = ::Plezi::Base::WSObject.translate_message(msg)
-						next unless msg
-						Iodine.error("Notification recieved but no method can handle it - dump:\r\n #{msg.to_s}") && next unless self.class.has_super_method?(msg[:method])
-						Iodine.run do
-							targets.each {|target| unicast(target, msg[:method], *msg[:data]) }
-						end
-						self.__send__(msg[:method], *msg[:data])
-					end
-					# ___extend_lifetime identity
-				end
-
-				# # re-registers the Identity, extending it's lifetime
-				# # and making sure it's still valid.
-				# def ___extend_lifetime identity
-				# 	return unless @___identity
-				# 	redis = Plezi.redis || ::Plezi::Base::WSObject::RedisEmultaion
-				# 	options = @___identity[identity]
-				# 	return unless options
-				# 	redis.multi do
-				# 		# redis.lpop(identity)
-				# 		# redis.lpush(identity, ''.freeze)
-				# 		# redis.lrem "#{identity}_uuid".freeze, 0, uuid
-				# 		# redis.lpush "#{identity}_uuid".freeze, uuid
-				# 		# redis.ltrim "#{identity}_uuid".freeze, 0, (options[:max_connections]-1)
-				# 		redis.expire identity, options[:lifetime]
-				# 		redis.expire "#{identity}_uuid".freeze, options[:lifetime]
-				# 	end
-				# end
-			end
-
-			module SuperClassMethods
-				public
-
-				# sends a notification to an Identity. Returns false if the Identity never registered or it's registration expired.
-				def notify identity, event_name, *args
-					redis = Plezi.redis || ::Plezi::Base::WSObject::RedisEmultaion
-					identity = identity.to_s.freeze
-					return false unless redis.llen(identity).to_i > 0
-					redis.rpush identity, ({method: event_name, data: args}).to_yaml
-					redis.lrange("#{identity}_uuid".freeze, 0, -1).each {|target| unicast target, :___review_identity, identity }
-					# puts "pushed notification #{event_name}"
-					true
-				end
-
-				# returns true if the Identity in question is registered to receive notifications.
-				def registered? identity
-					redis = Plezi.redis || ::Plezi::Base::WSObject::RedisEmultaion
-					identity = identity.to_s.freeze
-					redis.llen(identity).to_i > 0
-				end
-			end
-		end
-	end
-end

data/lib/plezi/handlers/ws_object.rb

@@ -1,308 +0,0 @@
-module Plezi
-
-	module Base
-
-		# This module includes all the methods that will be injected into Websocket objects,
-		# specifically into Plezi Controllers and Placebo objects.
-		#
-		# the methods defined in this module will be injected into the Controller class passed to
-		# Plezi (using the `route` or `shared_route` commands), and will be available
-		# for the controller to use within it's methods.
-		#
-		# for some reason, the documentation ignores the following additional attributes, which are listed here:
-		#
-		# request:: the HTTPRequest object containing all the data from the HTTP request. If a WebSocket connection was established, the `request` object will continue to contain the HTTP request establishing the connection (cookies, parameters sent and other information).
-		# params:: any parameters sent with the request (short-cut for `request.params`), will contain any GET or POST form data sent (including file upload and JSON format support).
-		# cookies:: a cookie-jar to get and set cookies (set: `cookie\[:name] = data` or get: `cookie\[:name]`). Cookies and some other data must be set BEFORE the response's headers are sent.
-		# flash:: a temporary cookie-jar, good for one request. this is a short-cut for the `response.flash` which handles this magical cookie style.
-		# response:: the HTTPResponse **OR** the WSResponse object that formats the response and sends it. use `response << data`. This object can be used to send partial data (such as headers, or partial html content) in blocking mode as well as sending data in the default non-blocking mode.
-		# host_params:: a copy of the parameters used to create the host and service which accepted the request and created this instance of the controller class.
-		#
-		module WSObject
-			def self.included base
-				base.send :include, InstanceMethods
-				base.extend ClassMethods
-				base.superclass.instance_eval {extend SuperClassMethods}
-				base.superclass.instance_eval {include SuperInstanceMethods}
-			end
-
-			def self.translate_message msg
-				begin
-					@safe_types ||= [Symbol, Date, Time, Encoding, Struct, Regexp, Range, Set]
-					YAML.safe_load(msg, @safe_types)
-				rescue => e
-					Iodine.error "The following could be a security breach attempt:"
-					Iodine.error e
-					nil
-				end
-			end
-			def self.forward_message data
-				begin
-					return false if data[:server] == Plezi::Settings.uuid
-					data[:type] = Object.const_get(data[:type]) unless data[:type].nil? || data[:type] == :all
-					if data[:target]
-						data[:type].___faild_unicast( data ) unless Iodine::Http::Websockets.unicast data[:target], data
-					else
-						Iodine::Http::Websockets.broadcast data
-					end
-				rescue => e
-					Iodine.error "The following could be a security breach attempt:"
-					Iodine.error e
-					nil
-				end
-			end
-
-			module InstanceMethods
-				public
-
-				# handles websocket opening.
-				def on_open
-					@ws_io = @request[:io]
-					super() if defined?(super)
-				end
-				# handles websocket messages.
-				def on_message data
-					super if defined?(super)
-				end
-				# handles websocket being closed.
-				def on_close
-					super if defined? super
-				end
-
-				# handles broadcasts / unicasts
-				def on_broadcast data
-					unless data.is_a?(Hash) && (data[:type] || data[:target]) && data[:method] && data[:data]
-						Iodine.warn "Broadcast message unknown... falling back on base broadcasting"
-						return super(data) if defined? super
-						return false
-					end
-					return false if data[:type] && data[:type] != :all && !self.is_a?(data[:type])
-					# return (data[:data].each {|e| emit(e)}) if data[:method] == :emit
-					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.__send__(data[:method], *data[:data])
-				end
-
-				# 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 @uuid if @uuid
-					if __get_io
-						return (@uuid ||=  Plezi::Settings.uuid + @io.id)
-					end
-					nil
-				end
-				alias :unicast_id :uuid
-
-				protected
-
-				# @!visibility public
-				# allows writing of data to the websocket (if opened). Otherwise appends the message to the Http response.
-				def write data
-					(@ws_io || @response) << data
-				end
-
-				# # @!visibility public
-				# # A helper method for easily sending JSON data. Accepts a Hash that will be translated to JSON and sent to the client as a JSON string.
-				# #
-				# # This method is available as a broadcast event.
-				# def emit event
-				# 	write event.to_json
-				# end
-
-				# @!visibility public
-				# Closes the connection
-				def close
-					# @request[:io] contains the Websockets Protocol instance
-					(@ws_io || @request[:io]).go_away
-				end
-
-				# @!visibility public
-				# Performs a websocket unicast to the specified target.
-				def unicast target_uuid, method_name, *args
-					self.class.unicast target_uuid, method_name, *args
-				end
-
-				# @!visibility public
-				# Use this to brodcast an event to all 'sibling' objects (websockets that have been created using the same Controller class).
-				#
-				# 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 each sibling instance of this Controller class.
-				#
-				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}, __get_io )
-				end
-
-				# @!visibility public
-				# 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}, __get_io )
-				end
-
-				def __get_io
-					@io ||= (@request ? @request[:io] : nil)
-				end
-			end
-			module ClassMethods
-
-				def reset_routing_cache
-					@methods_list = nil
-					@exposed_methods_list = nil
-					@super_methods_list = nil
-					@auto_dispatch_list = nil
-					has_method? nil
-					has_exposed_method? nil
-					has_super_method? nil
-					has_auto_dispatch_method? nil
-				end
-				def has_method? method_name
-					@methods_list ||= self.instance_methods.to_set
-					@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
-				def has_exposed_method? method_name
-					@reserved_methods_list ||= Class.new.public_instance_methods +
-						Plezi::Base::WSObject::InstanceMethods.public_instance_methods +
-						Plezi::Base::WSObject::SuperInstanceMethods.public_instance_methods +
-						Plezi::ControllerMagic::InstanceMethods.public_instance_methods +
-						Plezi::Base::ControllerCore::InstanceMethods.public_instance_methods +
-						[:before, :after, :save, :show, :update, :delete, :initialize]
-					@exposed_methods_list ||= ( (self.public_instance_methods - @reserved_methods_list ).delete_if {|m| m.to_s[0] == '_'} ).to_set
-					@exposed_methods_list.include? method_name
-				end
-				def has_auto_dispatch_method? method_name
-					@auto_dispatch_list ||= (( self.instance_methods - (Class.new.instance_methods +
-							Plezi::Base::WSObject::InstanceMethods.instance_methods +
-							Plezi::Base::WSObject::SuperInstanceMethods.instance_methods +
-							Plezi::ControllerMagic::InstanceMethods.instance_methods +
-							Plezi::Base::ControllerCore::InstanceMethods.instance_methods +
-							[:before, :after, :initialize, :unknown , :unknown_event]) ).delete_if {|m| m.to_s[0] == '_' || instance_method(m).arity == 0 }).to_set
-					@auto_dispatch_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
-			module SuperInstanceMethods
-			end
-
-			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.
-				#
-				# 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
-
-				# 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
-					raise 'No target specified for unicasting!' unless target_uuid
-					@uuid_cutoff ||= Plezi::Settings.uuid.length
-					_inner_broadcast method: method_name, data: args, target: target_uuid[@uuid_cutoff..-1], to_server: target_uuid[0...@uuid_cutoff], type: :all
-				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
-				end
-
-				# WebSockets
-
-				# sends the broadcast
-				def _inner_broadcast data, ignore_io = nil
-					if data[:target]
-						if data[:to_server] == Plezi::Settings.uuid
-							return ( ::Iodine::Http::Websockets.unicast( data[:target], data ) || ___faild_unicast( data ) )
-						end
-						return ( data[:to_server].nil? && ::Iodine::Http::Websockets.unicast(data[:target], data) ) || ( Plezi::Base::AutoRedis.away?(data[:to_server]) && ___faild_unicast( data ) ) || __inner_redis_broadcast(data)
-					else
-						::Iodine::Http::Websockets.broadcast data, ignore_io
-						__inner_redis_broadcast data				
-					end
-					true
-				end
-
-				def __inner_redis_broadcast data
-					return unless conn = Plezi.redis
-					data = data.dup
-					data[:type] = data[:type].name if data[:type].is_a?(Class)
-					data[:server] = Plezi::Settings.uuid
-					return conn.publish( ( data[:to_server] || Plezi::Settings.redis_channel_name ), data.to_yaml ) if conn
-					false
-				end
-
-				def ___faild_unicast data
-					has_class_method?(:failed_unicast) && failed_unicast( data[:to_server].to_s + data[:target], data[:method], data[:data] )
-					true
-				end
-
-				def has_method? method_name
-					@methods_list ||= self.instance_methods.to_set
-					@methods_list.include? method_name
-				end
-				def has_class_method? method_name
-					@class_methods_list ||= self.methods.to_set - Object.methods
-					@class_methods_list.include? method_name
-				end
-			end
-		end
-	end
-end