plezi 0.12.20 → 0.12.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 67b08fc4fb11066038232a931493efec82a441a9
-  data.tar.gz: 2027a428e55e2d2ae9dbb071f10cdc0db5f5ee07
+  metadata.gz: 393d101919837f0ce957673f30cf4afa858977bb
+  data.tar.gz: 5e23ca2e9ddd479fefd37c0747c246a924f6c755
 SHA512:
-  metadata.gz: 3b886af9e5a9a93fe98e4f80d336bb6fd472f28dcb208ec3182a9c96f7d364c6c0adfc974cbc505e92f3a3832dd3bd51ac1dc54f642cb10fcb8210b076e6830c
-  data.tar.gz: 48598ce1bc2dc17f13bc4d8917cfa07dc38420c43bfb50407b36d8190c4de362d49a7ec8c42a160ff9123fb72e67790f21a2281597211757f9e4ff69fe1e68ea
+  metadata.gz: 855bc07cedb86d69f9787f6740a8f3397140487d9f00d5eb7fbfbafbc7bf912e8a9719b44ed0d683ea1370a115984f83c6097abda71b3fc6a10a83d68226498d
+  data.tar.gz: 1ca4b13dd3ca651514b5822c1265bff122d1b0d791cab76a841926139b8b93c655b2107611781408399c9b224ce0fdc892f392da1bb0db2f1f96a44a5de40963

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ***
 
+Change log v.0.12.21
+
+**Update**: Auto-Dispatch:
+
+* method whitlisting process was updates. Method arity is now reviewed, so that only methods that accept one or more parameters are recognized as websocket auto-dispatch methods (allowing for Http only methods without throwing exceptions).
+
+* client now adds helper methods for AJAJ (like AJAX, but JSON instead of XML). The javascript client supports the `client.ajaj.emit` to send AJAJ requests and the `client.ajaj.auto=true` to automatically fallback on AJAJ after timeout (unless a custom callback is defined for the specific `emit`).
+
+***
+
 Change log v.0.12.20
 
 **Fix (Client)**: The onopen callback is now called (the issue was related to a typo in the name of the onopen callback).

data/README.md

@@ -666,17 +666,23 @@ Plezi and Iodine are written for Ruby versions 2.1.0 or greater (or API compatib
 
 ## Who's afraid of multi-threading?
 
+Let's start with the obvious, **if** your code is short and efficient (no blocking tasks), it is best to run Plezi (Iodine) in a single threaded mode - you get better performance AND safer code, **as long as there are no blocking tasks**:
+
+      Plezi.threads = 1
+
+But... most applications will naturally have blocking tasks, such as database queries etc'. This is why...:
+
 Plezi builds on Iodine's concept of "connection locking", meaning that your controllers shouldn't be acessed by more than one thread at the same time.
 
 This allows you to run Plezi as a multi-threaded (and even multi-process) application as long as your controllers don't change or set any global data... Readeing global data after it was set during initialization is totally fine, just not changing or setting it...
 
 But wait, global data is super important, right?
 
-Well, sometimes it is. And although it's a better practice to avoide storing any global data in global variables, sometimes storing stuff in the global space is exactly what we need.
+Well, sometimes it is. And although it's a better practice to avoide storing any global data in global variables (databases are usually thread safe storage places), sometimes storing stuff in the global space is exactly what we need.
 
 The solution is simple - if you can't use persistent databases with thread-safe libraries (i.e. Sequel / ActiveRecord / Redis, etc'), use Plezi's global cache storage (see Plezi::Cache).
 
-Plezi's global cache storage is a memory based storage protected by a mutex for any reading or writing from the cache.
+Plezi's global cache storage is a local memory based storage protected by a mutex whenever reading or writing from the cache.
 
 So... these are protected:
 
@@ -713,7 +719,7 @@ However, the following is unsafe:
     global_hash[:change] = "NOT safe"
  
 
-\* be aware, if using Plezi in as a multi-process application, that each process has it's own cache and that processes can't share the cache. The different threads in each of the processes will be able to acess their process's cache, but each process runs in a different memory space, so they can't share.
+\* be aware, if using Plezi in as a multi-process application, that each process has it's own cache and that processes can't share the cache. The different threads in each of the processes will be able to access their process's cache, but each process runs in a different memory space, so they can't share.
 
 ## Contributing
 

data/lib/plezi/handlers/controller_core.rb

@@ -60,19 +60,13 @@ module Plezi
 					rescue
 						return close
 					end
-					self.class.instance_variable_set :@allow_dispatch, (( self.class.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] == '_'}).to_set unless self.class.instance_variable_get(:@allow_dispatch)
 					Plezi::Base::Helpers.make_hash_accept_symbols data
 					ret = nil
 					begin
 						if data['_EID_'.freeze]
 							write "{\"event\":\"_ack_\",\"_EID_\":#{data['_EID_'.freeze]}}"
 						end
-						if self.class.has_super_method?(data['event'.freeze] = data['event'.freeze].to_s.to_sym) && self.class.instance_variable_get(:@allow_dispatch).include?(data['event'.freeze])
+						if self.class.has_auto_dispatch_method?(data['event'.freeze] = data['event'.freeze].to_s.to_sym)
 							ret = self.__send__(data['event'.freeze], data)
 						else
 							ret = (self.class.has_super_method?(:unknown) && ( unknown(data) || true)) || (self.class.has_super_method?(:unknown_event) && Iodine.warn('Auto-Dispatch API updated: use `unknown` instead of `unknown_event`') && ( unknown_event(data) || true)) || ({ event: :err, status: 404, result: "not found", request: data }.to_json)

data/lib/plezi/handlers/stubs.rb

@@ -46,7 +46,7 @@ module Plezi
 			"update called - updating #{params[:id]}"
 		end
 
-		# called when request is DELETE (or params["_method"] == 'delete') and request.params\[:id] exists
+		# called when request is DELETE (or params[:_method] == 'delete') and request.params\[:id] exists
 		def delete
 			"delete called - deleting object #{params[:id]}"
 		end

data/lib/plezi/handlers/ws_object.rb

@@ -77,7 +77,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[: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
@@ -103,6 +103,14 @@ module Plezi
 					(@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
@@ -153,9 +161,11 @@ module Plezi
 					@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
@@ -175,6 +185,15 @@ module Plezi
 					@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
 
@@ -229,8 +248,8 @@ module Plezi
 				# *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
+					@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.

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-    VERSION = "0.12.20"
+    VERSION = "0.12.21"
 end

data/resources/plezi_client.js

@@ -33,6 +33,13 @@ function PleziClient(url, autoreconnect) {
     }
     // Connect Websocket
     this.reconnect();
+    // Setup AJAJ
+    this.ajaj = {};
+    this.ajaj.client = this
+    this.ajaj.url = this.url.replace(/^ws:\/\//i, "http://").replace(/^wss:\/\//i, "https://");
+    this.ajaj.add = {};
+    this.ajaj.emit = this.___ajaj__emit;
+    this.ajaj.auto = false
     // auto-reconnection
     this.autoreconnect = false;
     this.reconnect_interval = 200
@@ -66,23 +73,32 @@ PleziClient.prototype.___on_error = function(e) {
 PleziClient.prototype.___on_message = function(e) {
     try {
         var msg = JSON.parse(e.data);
-        if (this.owner.log_events) {console.log(msg)}
+        this.owner.___dispatch(msg);
+    } catch(err) {
+        console.error("PleziClient experienced an error parsing the following data (not JSON):",
+            err, e.data)
+    }
+}
+PleziClient.prototype.___dispatch = function(msg) {
+    try {
+        if (this.log_events) {console.log(msg)}
         if ( msg.event == '_ack_') { clearTimeout(msg._EID_) }
-        if ( (msg.event) && (this.owner[msg.event])) {
-            this.owner[msg.event](msg);
-        } else if ( (msg.event) && (this.owner['on' + msg.event])) {
+        if ( (msg.event) && (this[msg.event])) {
+            this[msg.event](msg);
+        } else if ( (msg.event) && (this['on' + msg.event])) {
             console.warn('PleziClient: use a callback called "' + msg.event +
                 '" instead of of "on' + msg.event + '"');
-            this.owner['on' + msg.event](msg);
+            this['on' + msg.event](msg);
         } else
         {
-            if (this.owner['unknown'] && (msg.event != '_ack_') ) {this.owner['unknown'](msg)};
+            if (this['unknown'] && (msg.event != '_ack_') ) {this['unknown'](msg)};
         }
     } catch(err) {
         console.error("PleziClient experienced an error while responding to the following onmessage event",
             err, e)
     }
 }
+
 // Sets a timeout for the websocket message
 PleziClient.prototype.___set_failed_timeout = function(event, callback, timeout) {
     if(event._EID_) {return event;};
@@ -95,7 +111,12 @@ PleziClient.prototype.___set_failed_timeout = function(event, callback, timeout)
 // Removes the _client_ property from the event and calls
 // the ontimeout callback within the correct scope
 PleziClient.prototype.___on_timeout = function(event, client) {
-    client.ontimeout(event)
+    if (client.ajaj.auto) {
+        if (client.log_events) {console.log("falling back on AJAJ for the event:", event)}
+        client.ajaj.emit(event, client.ontimeout);
+    } else {
+        client.ontimeout(event);
+    }
 }
 // The timeout callback
 PleziClient.prototype.ontimeout = function(event) {
@@ -139,3 +160,39 @@ PleziClient.prototype.emit = function(event, callback, timeout) {
 }
 
 PleziClient.prototype.readyState = function() { return this.ws.readyState; }
+
+PleziClient.prototype.___ajaj__emit = function(event, callback) {
+    var combined = {}
+    for (var k in this.add) {combined[k] = this.add[k];};
+    for (var k in event) {combined[k] = event[k];};
+    if(!combined.id) {combined.id = event.event;};
+    var req = new XMLHttpRequest();
+    req.client = this.client;
+    req.json = combined;
+    req.callback = callback
+    // if(!req.callback) req.callback = this.failed
+    req.onreadystatechange = function() {
+        if (this.readyState != 4) { return }
+        if (this.status == 200) {
+            try {
+                var res = JSON.parse(this.responseText);
+                this.client.___dispatch(res);
+            } catch(err) {
+                console.error("PleziClient experienced an error parsing the following data (not JSON):",
+            err, this.responseText)
+            }
+            
+        } else {
+            if(this.callback) {
+                this.callback(this.json);
+            }
+        }
+    }
+    req.open("POST", this.url ,true);
+    req.setRequestHeader("Content-type", "application/json");
+    try {
+        req.send(JSON.stringify(combined));
+    } catch(err) {
+        callback(event)
+    }
+}

data/test/dispatch

@@ -21,6 +21,9 @@ class DispatchTest
 	def _hidden
 		{event: :failed, data: :forbidden}.to_json
 	end
+	def html
+		{event: 'html', data: 'only'}.to_json
+	end
 	def test data = {}
 		data[:data] ||= "test"
 		{event: 'alert', data: data[:data]}.to_json

data/test/plezi_tests.rb

@@ -376,7 +376,7 @@ module PleziTestTasks
 			end
 			ws3 = Iodine::Http::WebsocketClient.connect("ws://localhost:3000/", on_open: -> { write 'get uuid' } ) do |data|
 				if data.match /uuid: ([^s]*)/
-					ws2 << "to: #{data.match(/^uuid: ([^s]*)/)[1]}"
+					ws3 << "to: #{data.match(/^uuid: ([^s]*)/)[1]}"
 					puts "    * Websocket UUID for unicast testing: #{data.match(/^uuid: ([^s]*)/)[1]}"
 				elsif data == "unicast"
 					puts "    * Websocket unicast testing: #{RESULTS[:waiting]} (target received data)"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plezi
 version: !ruby/object:Gem::Version
-  version: 0.12.20
+  version: 0.12.21
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-04 00:00:00.000000000 Z
+date: 2015-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: iodine