plezi 0.14.9 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75f5b97d8891d3fcdd74ee25d556883dbe50532a
-  data.tar.gz: dc0d53e3107a0333a78c70d34900b72b6427615f
+  metadata.gz: 45a3eb75b619cb1724e18f7ae3124558769d09d1
+  data.tar.gz: a201af9772fccbe0f07462c42500861fee8fcdb8
 SHA512:
-  metadata.gz: bc4f19777b080c9496d167b59aafd8e069e6efe8357980d8965382f7e2dba11760ef9a23d5a94fd8001929bff06297644b2d12e9291c4d740d0d805a542ac3ef
-  data.tar.gz: 1ec40cf39efcc59d72c053e11ecc89cdcf782cf6fdd0ade51f80f0f470a5f05d03ada4da7c6bce2e2c25b1d3b606299a0224162f2fbc9b2e707b8fca81700ce0
+  metadata.gz: 74e90ba29166b17ce68bcfdae5d00ace0c8030e674afa2a60a88d15dd29b4ff304b685529ea59a4aee7fde1f35656fc4b2d52c0de24c785db56eddab632483d4
+  data.tar.gz: b515a650921a1fd5f0d592c563340405b28c3925ce84824f5266c785060fd605c900498f31f1f3ad7c325770092f762baa9afd894cd6cf2a616d25697cc5d561

data/CHANGELOG.md

@@ -2,7 +2,15 @@
 
 ***
 
-Change log v.0.14.8 (next)
+Change log v.0.15.0
+
+**Deprecation**: no more `broadcast`, `unicast`, `multicast` or `write2everyone`... Plezi fully embraced the Pub/Sub design and the [Iodine Extensions to the Rack Websocket Specification Proposal](https://github.com/boazsegev/iodine/blob/master/SPEC-Websocket-Draft.md).
+
+**Feature**: Super powerful Pub/Sub support comes directly from the server layer (iodine), allowing for process cluster Pub/Sub without the need for any Pub/Sub service. Iodine also brings a native Redis connector to easily scale Pub/Sub to multiple machines using a Redis servers.
+
+***
+
+Change log v.0.14.9 - EOL (last 0.14.x release)
 
 **Fix**: Asset Sass rendering will now only save the output to a file in production mode, allowing development mode to hot-load the assets and re-render them when changes occur.
 

data/README.md

@@ -8,7 +8,32 @@ Are microservices on your mind? Do you dream of a an SPA that's easy to scale? D
 
 Welcome to your new home with [plezi.io](http://www.plezi.io), the Ruby real-time framework that assumes the business logic is *seperate* from the web service logic.
 
-**NOTICE**: Plezi 0.14.x (this branch) is NOT an update, it's a total rewrite. Features were _removed_ as well as altered. For example, Plezi is now a Rack framework, with the limitations of CGI design and the advantages of using existing middleware. API changes abound.
+## Short and Sweet
+
+What if your next Pub/Sub application could be as easy as:
+
+```ruby
+require 'plezi'
+class MyChatroom
+  # HTTP
+  def index
+    render :index
+  end
+  def on_open
+    subscribe channel: :chat
+    @name = ::ERB::Util.h(params[:nickname] || "anonymous")
+    publish channel: :chat, message: "#{@name} joined the chat."
+  end
+  def on_message data
+    publish channel: :chat, message: "#{@name}: #{::ERB::Util.h data}"
+  end
+  def on_shutdown
+    write "Server is going away. Come back again some other time, #{@name}."
+  end
+end
+
+Plezi.route '/(:nickname)', MyChatroom
+```
 
 ## What does Plezi have to offer?
 
@@ -28,6 +53,8 @@ Plezi will provide the following features over plain Rack:
 
 * Auto-Dispatch (optional) to automatically map JSON websocket "events" to Controller functions (handlers).
 
+* Native Pub/Sub provided by [Iodine](https://github.com/boazsegev/iodine).
+
 * Automatic (optional) scaling using Redis.
 
 * An extensible template rendering abstraction engine, supports Slim, Markdown (using RedCarpet) and ERB out of the box.

data/bin/ws_shootout

@@ -1,9 +1,11 @@
 #!/usr/bin/env ruby
 
-# # Uncomment and set Redis URL for automatic scalling across proccesses and machines:
-# require 'redis'
-# ENV['PL_REDIS_URL'] ||= "redis://localhost:7777/0"
-# ENV['PL_REDIS_URL'] ||= "redis://:password@my.host:6389/0"
+# Example benchmark scripts:
+#
+#    websocket-bench broadcast ws://127.0.0.1:3000/ --concurrent 10 --sample-size 100 --server-type binary --step-size 1000 --limit-percentile 95 --limit-rtt 250ms --initial-clients 1000
+#
+#    websocket-bench broadcast ws://127.0.0.1:3000/ --concurrent 10 --sample-size 100 --step-size 1000 --limit-percentile 95 --limit-rtt 250ms --initial-clients 1000 --server-type json
+#
 
 Dir.chdir(File.expand_path(File.join('..', '..', 'lib'), __FILE__))
 require 'bundler/setup'
@@ -14,25 +16,39 @@ class ShootoutApp
   def index
     "This application should be used with the websocket-shootout benchmark utility."
   end
+  def on_open
+    subscribe channel: "shootout"
+  end
   # we won't be using AutoDispatch, but directly using the `on_message` callback.
   def on_message data
+    if data[0] == 'b' # binary
+      publish(channel: "shootout", message: data)
+      data[0] = 'r'
+      write data
+      return
+    end
     cmd, payload = JSON(data).values_at('type', 'payload')
     if cmd == 'echo'
       write({type: 'echo', payload: payload}.to_json)
     else
       # data = {type: 'broadcast', payload: payload}.to_json
       # broadcast :push2client, data
-      ShootoutApp.write2everyone({type: 'broadcast', payload: payload}.to_json)
+      publish(channel: "shootout", message: ({type: 'broadcast', payload: payload}.to_json))
       write({type: "broadcastResult", payload: payload}.to_json)
     end
   rescue
     puts "Incoming message format error - not JSON?"
   end
 
-  def push2client data
-    write data
-  end
-
 end
 
 Plezi.route '*', ShootoutApp
+
+#
+# def cycle
+#   puts `websocket-bench broadcast ws://127.0.0.1:3000/ --concurrent 10 --sample-size 100 --server-type binary --step-size 1000 --limit-percentile 95 --limit-rtt 250ms --initial-clients 1000`
+#   sleep(2)
+#   puts `wrk -c4000 -d15 -t12 http://localhost:3000/`
+#   true
+# end
+# sleep(10) while cycle

data/examples/chat.rb

@@ -0,0 +1,38 @@
+# finish with `exit` if running within `irb`
+require 'plezi'
+class ChatServer
+  def index
+    "Use Websockets to connect."
+  end
+  def on_open
+    return close unless params['id']
+    @name = params['id']
+    subscribe channel: "chat"
+    publish channel: "chat", message: "#{@name} joind the chat."
+    write "Welcome, #{@name}!"
+    # if we have Redis
+    if(Iodine.default_pubsub.is_a? Iodine::PubSub::RedisEngine)
+      # We'll add the name to the list of people in the chat.
+      # Blocks are used as event callbacks and are executed asynchronously.
+      Iodine.default_pubsub.send("SADD", "chat_members", @name) do
+        # after the name was added, we'll get all the current people in the chat
+        Iodine.default_pubsub.send("SMEMBERS", "chat_members") do |members|
+          # By now, we're outside the Websocket connection's lock.
+          # To safely access the connection, we'll use `defer`
+          defer { write "Currently in the chatroom: #{members.join ', '}" }
+        end
+      end
+    end
+  end
+  def on_close
+    publish channel: "chat", message: "#{@name} joind the chat."
+    # if we have Redis
+    Iodine.default_pubsub.send("SREM", "chat_members", @name) if(Iodine.default_pubsub.is_a? Iodine::PubSub::RedisEngine)
+  end
+  def on_message data
+    publish channel: "chat", message: "#{@name}: #{data}"
+  end
+end
+path_to_client = File.expand_path( File.dirname(__FILE__) )
+Plezi.templates = path_to_client
+Plezi.route '/', ChatServer

data/exe/plezi

@@ -104,7 +104,7 @@ module Builder
       puts ''
       puts "please change directory into the app directory: cd #{app_name}"
       puts ''
-      puts "run the #{app_name} app using: ./#{app_name} or using the iodine / rackup commands."
+      puts "run the #{app_name} app using: ./#{app_name} or using the iodine or rackup commands."
       puts ''
    end
 end

data/lib/plezi/activation.rb

@@ -1,5 +1,4 @@
-require 'plezi/websockets/message_dispatch' unless defined?(::Plezi::Base::MessageDispatch)
-
+require 'uri' unless defined?(::URI)
 module Plezi
    protected
 
@@ -14,15 +13,13 @@ module Plezi
   def self.plezi_initialize
      if @plezi_initialize.nil?
         @plezi_initialize = true
-        self.hash_proc_4symstr # crerate the Proc object used for request params
+        self.hash_proc_4symstr # creates the Proc object used for request params
         @plezi_autostart = true if @plezi_autostart.nil?
-        if ENV['PL_REDIS_URL'.freeze] && !defined?(::Redis)
-          puts "WARNNING: auto-scaling with redis is set using ENV['PL_REDIS_URL'.freeze]\r\n           but the Redis gem isn't included! - SCALING IS IGNORED!"
-          ::Iodine.processes ||= 1
-        elsif !ENV['PL_REDIS_URL'.freeze]
-          ::Iodine.processes ||= 1
+        Iodine.patch_rack
+        if((ENV['PL_REDIS_URL'.freeze] ||= ENV["REDIS_URL"]))
+          uri = URI(ENV['PL_REDIS_URL'.freeze])
+          Iodine.default_pubsub = Iodine::PubSub::RedisEngine.new(uri.host, uri.port, 0, uri.password)
         end
-        ::Iodine.processes ||= 4
         at_exit do
            next if @plezi_autostart == false
            ::Iodine::Rack.app = ::Plezi.app
@@ -32,7 +29,3 @@ module Plezi
      true
   end
 end
-
-::Iodine.threads ||= 16
-# ::Iodine.processes ||= (ENV['PL_REDIS_URL'.freeze] ? 4 : 1)
-::Iodine.run { ::Plezi::Base::MessageDispatch._init }

data/lib/plezi/controller/controller.rb

@@ -1,7 +1,7 @@
 require 'plezi/render/render'
+require 'plezi/controller/identification'
 require 'plezi/controller/cookies'
 require 'plezi/controller/controller_class'
-require 'plezi/websockets/message_dispatch'
 
 module Plezi
    # This module contains the functionality provided to any Controller class.
@@ -119,13 +119,13 @@ module Plezi
          ::Plezi::Base::Router.url_for self.class, func, params
       end
 
-      # A connection's Plezi ID uniquely identifies the connection across application instances, allowing it to receive and send messages using {#unicast}.
+      # A connection's Plezi ID uniquely identifies the connection across application instances.
       def id
-         @_pl_id ||= (conn_id && "#{::Plezi::Base::MessageDispatch.pid}-#{conn_id.to_s(16)}")
+         @_pl_id ||= (conn_id && "#{::Plezi::Base::Identification.pid}-#{conn_id.to_s(16)}")
       end
 
       # @private
-      # This is the process specific Websocket's UUID. This function is here to protect you from yourself. Don't call it.
+      # This is the process specific Websocket's ID. This function is here to protect you from yourself. Don't call it.
       def conn_id
          defined?(super) && super
       end
@@ -143,71 +143,19 @@ module Plezi
       #
       # This allows a module "library" to be used similar to the way "rooms" are used in node.js, so that a number of different Controllers can listen to shared events.
       #
-      # By dynamically extending a Controller instance using a module, Websocket broadcasts will be allowed to invoke the module's functions.
+      # By dynamically extending a Controller instance using a module, Auto Dispatch events can be routed to the newly available methods.
       #
       # Notice: It is impossible to `unextend` an extended module at this time.
       def extend(mod)
          raise TypeError, '`mod` should be a module' unless mod.class == Module
-         raise "#{self} already extended by #{mod.name}" if is_a?(mod)
-         mod.extend ::Plezi::Controller::ClassMethods
-         super(mod)
+         unless is_a?(mod)
+           mod.extend ::Plezi::Controller::ClassMethods
+           super(mod)
+         end
          _pl_ws_map.update mod._pl_ws_map
          _pl_ad_map.update mod._pl_ad_map
       end
 
-      # Invokes a method on the `target` websocket connection. When using Iodine, the method is invoked asynchronously.
-      #
-      #       def perform_poke(target)
-      #         unicast target, :poke, self.id
-      #       end
-      #       def poke(from)
-      #         unicast from, :poke_back, self.id
-      #       end
-      #       def poke_back(from)
-      #         puts "#{from} is available"
-      #       end
-      #
-      # Methods invoked using {unicast}, {broadcast} or {multicast} will quietly fail if the connection was lost, the requested method is undefined or the 'target' was invalid.
-      def unicast(target, event_method, *args)
-         ::Plezi::Base::MessageDispatch.unicast(id ? self : self.class, target, event_method, args)
-      end
-
-      # Invokes a method on every websocket connection (except `self`) that belongs to this Controller / Type. When using Iodine, the method is invoked asynchronously.
-      #
-      #        self.broadcast :my_method, "argument 1", "argument 2", 3
-      #
-      # Methods invoked using {unicast}, {broadcast} or {multicast} will quietly fail if the connection was lost, the requested method is undefined or the 'target' was invalid.
-      def broadcast(event_method, *args)
-         ::Plezi::Base::MessageDispatch.broadcast(id ? self : self.class, event_method, args)
-      end
-
-      # Invokes a method on every websocket connection in the application (except `self`).
-      #
-      #        self.multicast :my_method, "argument 1", "argument 2", 3
-      #
-      # Methods invoked using {unicast}, {broadcast} or {multicast} will quietly fail if the connection was lost, the requested method is undefined or the 'target' was invalid.
-      def multicast(event_method, *args)
-         ::Plezi::Base::MessageDispatch.multicast(id ? self : self.class, event_method, args)
-      end
-
-      # Writes a message to every client websocket connection, for all controllers(!), EXCEPT self. Accepts an optional filter method using a location reference for a *static* (Class/Module/global) method. The filter method will be passerd the websocket object and it should return `true` / `false`.
-      #
-      #        self.write2everyone {event: "global", message: "This will be sent to everyone"}.to_json
-      #        # or, we can define a filter method somewhere in our code
-      #        module Filter
-      #            def self.should_send? ws
-      #               true
-      #            end
-      #        end
-      #        # and we can use this filter method.
-      #        data = {event: "global", message: "This will be sent to everyone"}.to_json
-      #        self.write2everyone data, ::Filter, :should_send?
-      #
-      # It's important that the filter method is defined statically in our code and isn't dynamically allocated. Otherwise, scaling the application would be impossible.
-      def write2everyone(data, filter_owner = nil, filter_name = nil)
-         ::Plezi::Base::MessageDispatch.write2everyone(id ? self : self.class, data, filter_owner, filter_name)
-      end
-
       # @private
       # This function is used internally by Plezi, do not call.
       def _pl_ws_map
@@ -226,6 +174,7 @@ module Plezi
          json = nil
          begin
             json = JSON.parse(data, symbolize_names: true)
+            # json.default_proc = Plezi.hash_proc_4symstr
          rescue
             puts 'AutoDispatch Warnnig: Received non-JSON message. Closing Connection.'
             close

data/lib/plezi/controller/controller_class.rb

@@ -7,55 +7,16 @@ module Plezi
             base._pl_init_class_data
          end
 
+         # Publishes a message to a channel.
+         def publish(args)
+            Iodine.publish args
+         end
+
          # Returns a relative URL for the controller, placing the requested parameters in the URL (inline, where possible and as query data when not possible).
          def url_for(func, params = {})
             ::Plezi::Base::Router.url_for self, func, params
          end
 
-         # Invokes a method on the `target` websocket connection. When using Iodine, the method is invoked asynchronously.
-         #
-         #        self.unicast target, :my_method, "argument 1"
-         #
-         # Methods invoked using {unicast}, {broadcast} or {multicast} will quitely fail if the connection was lost, the requested method is undefined or the 'target' was invalid.
-         def unicast(target, event_method, *args)
-            ::Plezi::Base::MessageDispatch.unicast(self, target, event_method, args)
-         end
-
-         # Invokes a method on every websocket connection that belongs to this Controller / Type. When using Iodine, the method is invoked asynchronously.
-         #
-         #        self.broadcast :my_method, "argument 1", "argument 2", 3
-         #
-         # Methods invoked using {unicast}, {broadcast} or {multicast} will quitely fail if the connection was lost, the requested method is undefined or the 'target' was invalid.
-         def broadcast(event_method, *args)
-            ::Plezi::Base::MessageDispatch.broadcast(self, event_method, args)
-         end
-
-         # Invokes a method on every websocket connection in the application.
-         #
-         #        self.multicast :my_method, "argument 1", "argument 2", 3
-         #
-         # Methods invoked using {unicast}, {broadcast} or {multicast} will quitely fail if the connection was lost, the requested method is undefined or the 'target' was invalid.
-         def multicast(event_method, *args)
-            ::Plezi::Base::MessageDispatch.multicast(self, event_method, args)
-         end
-         # Writes a message to every client websocket connection in all controllers(!). Accepts an optional filter method using a location reference for a *static* (Class/Module/global) method. The filter method will be passerd the websocket object and it should return `true` / `false`.
-         #
-         #        self.write2everyone {event: "global", message: "This will be sent to everyone"}.to_json
-         #        # or, we can define a filter method somewhere in our code
-         #        module Filter
-         #            def self.should_send? ws
-         #               true
-         #            end
-         #        end
-         #        # and we can use this filter method.
-         #        data = {event: "global", message: "This will be sent to everyone"}.to_json
-         #        self.write2everyone data, ::Filter, :should_send?
-         #
-         # It's important that the filter method is defined statically in our code and isn't dynamically allocated. Otherwise, scaling the application would be impossible.
-         def write2everyone(data, filter_owner = nil, filter_name = nil)
-            ::Plezi::Base::MessageDispatch.write2everyone(self, data, filter_owner, filter_name)
-         end
-
          # @private
          # This is used internally by Plezi, do not use.
          RESERVED_METHODS = [:delete, :create, :update, :new, :show, :pre_connect, :on_open, :on_close, :on_shutdown, :on_message].freeze

data/lib/plezi/controller/identification.rb

@@ -0,0 +1,29 @@
+module Plezi
+  module Base
+    module Identification
+
+      module_function
+
+      @ppid = ::Process.pid
+      # returns a Plezi flavored pid UUID, used to set the pub/sub channel when scaling
+      def pid
+         process_pid = ::Process.pid
+         if @ppid != process_pid
+            @pid = nil
+            @ppid = process_pid
+         end
+         @pid ||= SecureRandom.urlsafe_base64.tap { |str| @prefix_len = str.length }
+      end
+      # Converts a target Global UUID to a localized UUID
+      def target2uuid(target)
+         return nil unless target.start_with? pid
+         target[@prefix_len..-1].to_i
+      end
+
+      # Extracts the machine part from a target's Global UUID
+      def target2pid(target)
+         target ? target[0..(@prefix_len - 1)] : Plezi.app_name
+      end
+    end
+  end
+end

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-   VERSION = '0.14.9'.freeze
+   VERSION = '0.15.0'.freeze
 end

data/plezi.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'iodine', '~> 0.3', '< 0.4'
+  spec.add_dependency 'iodine', '~> 0.4'
   spec.add_dependency 'rack', '>= 2.0.0'
   spec.add_dependency 'bundler', '~> 1.14'
   # spec.add_dependency 'redcarpet', '> 3.3.0'

data/resources/ctrlr.rb

@@ -1,34 +1,25 @@
 # Replace this sample with real code.
 class ExampleCtrl
-   # HTTP
-   def index
-      # any String returned will be appended to the response. We return a String.
-      render 'welcome'
-   end
+  # HTTP
+  def index
+    # any String returned will be appended to the response. We return a String.
+    render 'welcome'
+  end
 
-   # Websockets
-   def on_message(data)
-      data = ERB::Util.html_escape data
-      print data
-      broadcast :print, data
-   end
+  # Websockets
+  def on_open
+    subscribe channel: "chat"
+    write 'Welcome to appname!'
+    @handle = params['id'.freeze] || 'Somebody'
+    publish channel: "chat", message: "#{ERB::Util.html_escape @handle} joind us :-)"
+  end
+  def on_message(data)
+    data = ERB::Util.html_escape data
+    publish channel: "chat", message: data
+  end
 
-   def on_open
-      print 'Welcome to appname!'
-      @handle = params['id'.freeze] || 'Somebody'
-      broadcast :print, "#{ERB::Util.html_escape @handle} joind us :-)"
-   end
+  def on_close
+    publish channel: "chat", message: "#{@handle} left us :-("
+  end
 
-   def on_close
-      broadcast :print, "#{@handle} left us :-("
-   end
-
-   protected
-
-   # write is inherites when a Websocket connection is opened.
-   #
-   # Inherited functions aren't exposed (for our security), so we need to wrap it.
-   def print(data)
-      write data
-   end
 end

data/resources/mini_exec

@@ -4,4 +4,4 @@
 # set the working directory
 cd "$(dirname "$0")"
 # load the website-app
-bundle exec iodine -t 16 -w 1 -www ./public
+bundle exec iodine -t 16 -w 4 -www ./public

data/resources/mini_welcome_page.html

@@ -187,7 +187,7 @@ var websocket_fail_count = 0
 function init_websocket()
 {
     if(websocket && websocket.readyState == 1) return true; // console.log('no need to renew socket connection');
-    websocket = new WebSocket(ws_uri);
+    websocket = new WebSocket(ws_uri + document.getElementById("input").value);
     websocket.onopen = function(e) {
         //restart fail count
         websocket_fail = 0
@@ -266,7 +266,7 @@ function send_text()
     </ol>
     <p class="bold">Good Luck!</p>
     <h3> Did you try our websocket broadcast? </h3>
-    <p>Your appname app can send <span class="bold">WebSocket</span> broadcasts (and unicasts). Why not try them out? You can even try them across multiple windows.</p>
+    <p>Your appname app can send <span class="bold">WebSocket</span> messages and subscribe / publish to channels of information. This chat works across browser windows.</p>
     <form onsubmit='send_text(); return false;' id='monitor'>
         <p><input type='text' id='input' placeholder='Your message' /> <input type='submit'  value='Broadcast'/> </p>
         <ul id='output'>

data/resources/procfile

@@ -1,3 +1,4 @@
-# Edit these parameters if you wish to leverage multi-process concurrency. i.e.:
-#    bundle exec iodine -p $PORT -t 16 -w 4 -www ./public -warmup # => 4 processes + fix lazy loading
-web: bundle exec iodine -p $PORT -t 16 -w 1 -www ./public
+# # Edit these parameters if you wish to manually manage concurrency. i.e.:
+# web:  bundle exec iodine -p $PORT -t 16 -w 4 -www ./public -warmup
+#
+web: bundle exec iodine -p $PORT -www ./public

metadata

@@ -1,23 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: plezi
 version: !ruby/object:Gem::Version
-  version: 0.14.9
+  version: 0.15.0
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-06-18 00:00:00.000000000 Z
+date: 2017-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: iodine
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
-    - - "<"
       - !ruby/object:Gem::Version
         version: '0.4'
   type: :runtime
@@ -25,9 +22,6 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
-    - - "<"
       - !ruby/object:Gem::Version
         version: '0.4'
 - !ruby/object:Gem::Dependency
@@ -106,6 +100,7 @@ files:
 - bin/hello_world
 - bin/setup
 - bin/ws_shootout
+- examples/chat.rb
 - exe/plezi
 - lib/plezi.rb
 - lib/plezi/activation.rb
@@ -113,6 +108,7 @@ files:
 - lib/plezi/controller/controller.rb
 - lib/plezi/controller/controller_class.rb
 - lib/plezi/controller/cookies.rb
+- lib/plezi/controller/identification.rb
 - lib/plezi/helpers.rb
 - lib/plezi/rake.rb
 - lib/plezi/render/erb.rb
@@ -127,8 +123,6 @@ files:
 - lib/plezi/router/route.rb
 - lib/plezi/router/router.rb
 - lib/plezi/version.rb
-- lib/plezi/websockets/message_dispatch.rb
-- lib/plezi/websockets/redis.rb
 - plezi.gemspec
 - resources/404.erb
 - resources/500.erb

data/lib/plezi/websockets/message_dispatch.rb

@@ -1,135 +0,0 @@
-module Plezi
-   module Base
-      # Websocket Message Dispatching Service, including the autoscaling driver control (at the moment Redis is the only builtin driver).
-      module MessageDispatch
-         # add class attribute accessors.
-         class << self
-           # Allows pub/sub drivers to attach to the message dispatch using `MessageDispatch.drivers << driver`
-           attr_reader :drivers
-         end
-         @drivers = [].to_set
-
-         module_function
-
-         # The YAML safe types used by Plezi
-         SAFE_TYPES = [Symbol, Date, Time, Encoding, Struct, Regexp, Range, Set].freeze
-         # a single use empty array (prevents the use of temporary objects where possible)
-         EMPTY_ARGS = [].freeze
-         # keeps track of the current process ID
-         @ppid = ::Process.pid
-         # returns a Plezi flavored pid UUID, used to set the pub/sub channel when scaling
-         def pid
-            process_pid = ::Process.pid
-            if @ppid != process_pid
-               @pid = nil
-               @ppid = process_pid
-            end
-            @pid ||= SecureRandom.urlsafe_base64.tap { |str| @prefix_len = str.length }
-         end
-
-         # initializes the drivers when possible.
-         def _init
-            @drivers.each(&:connect)
-         end
-
-         # Pushes a message to the Pub/Sub drivers
-         def push(message)
-            # message[:type] = message[:type].name if message[:type].is_a?(Class)
-            message[:origin] = pid
-            hst = message.delete(:host) || Plezi.app_name
-            yml = message.to_yaml
-            @drivers.each { |drv| drv.push(hst, yml) }
-         end
-
-         # Parses a text message received through a Pub/Sub service.
-         def <<(msg)
-            msg = YAML.safe_load(msg, SAFE_TYPES)
-            return if msg[:origin] == pid
-            target_type = msg[:type] || :all
-            event = msg[:event]
-            if (target = msg[:target])
-               Iodine::Websocket.defer(target2uuid(target)) { |ws| ws._pl_ad_review(ws.__send__(ws._pl_ws_map[event], *(msg[:args]))) if ws._pl_ws_map[event] }
-               return
-            end
-            if target_type == :all
-               Iodine::Websocket.each { |ws| ws._pl_ad_review(ws.__send__(ws._pl_ws_map[event], *(msg[:args]))) if ws._pl_ws_map[event] }
-               return
-            end
-            if event == :write2everyone
-               return unless msg[:data]
-               mth = msg[:method]
-               if(mth)
-                  target_type = Object.const_get target_type
-                  mth = target_type.method(mth)
-                  return unless mth
-                  Iodine::Websocket.each_write msg[:data], &mth
-               else
-                  Iodine::Websocket.each_write msg[:data]
-               end
-               return
-            end
-            target_type = Object.const_get target_type
-            if target_type._pl_ws_map[event]
-               Iodine::Websocket.each { |ws| ws._pl_ad_review(ws.__send__(ws._pl_ws_map[event], *(msg[:args]))) if ws.is_a?(target_type) }
-               return
-            end
-
-         rescue => e
-            puts '*** The following could be a security breach attempt:', e.message, e.backtrace
-            nil
-         end
-
-         # Sends a message to a specific target, if it's on this machine, otherwise forwards the message to the Pub/Sub.
-         def unicast(_sender, target, meth, args)
-            return false if target.nil?
-            if (tuuid = target2uuid(target))
-               Iodine::Websocket.defer(tuuid) { |ws| ws._pl_ad_review(ws.__send__(ws._pl_ws_map[meth], *args)) if ws._pl_ws_map[meth] }
-               return true
-            end
-            push target: target, args: args, host: target2pid(target)
-         end
-
-         # Sends a message to a all targets of a speific **type**, as well as pushing the message to the Pub/Sub drivers.
-         def broadcast(sender, meth, args)
-            target_type = nil
-            if sender.is_a?(Class)
-               target_type = sender
-               sender = Iodine::Websocket
-            else
-               target_type = sender.class
-            end
-            sender.each { |ws| ws._pl_ad_review(ws.__send__(ws._pl_ws_map[meth], *args)) if ws.is_a?(target_type) && ws._pl_ws_map[meth] }
-            push type: target_type.name, args: args, event: meth
-         end
-
-         # Sends a message to a all existing websocket connections, as well as pushing the message to the Pub/Sub drivers.
-         def multicast(sender, meth, args)
-            sender = Iodine::Websocket if sender.is_a?(Class)
-            sender.each { |ws| ws._pl_ad_review(ws.__send__(ws._pl_ws_map[meth], *args)) if ws._pl_ws_map[meth] }
-            push type: :all, args: args, event: meth
-         end
-
-         # Writes directly to all clients of all controllers.
-         def write2everyone(sender, data, filter_owner = nil, filter_name = nil)
-           sender = Iodine::Websocket if sender.is_a?(Class)
-           mth = nil
-           raise TypeError, "Plezi\#write_each filter error - method doesn't exist? #{filter_owner}.#{filter_name}" if(filter_owner && !(mth = filter_owner.method(filter_name)))
-           mth ? sender.each_write(data, &mth) : sender.each_write(data)
-           push event: :write2everyone, data: data, type: (filter_owner || Iodine::Websocket).name, method: (filter_owner && filter_name)
-         end
-
-         # Converts a target Global UUID to a localized UUID
-         def target2uuid(target)
-            return nil unless target.start_with? pid
-            target[@prefix_len..-1].to_i
-         end
-
-         # Extracts the machine part from a target's Global UUID
-         def target2pid(target)
-            target ? target[0..(@prefix_len - 1)] : Plezi.app_name
-         end
-      end
-   end
-end
-# connect default drivers
-require 'plezi/websockets/redis'

data/lib/plezi/websockets/redis.rb

@@ -1,54 +0,0 @@
-module Plezi
-   module Base
-      module MessageDispatch
-         module RedisDriver
-            @redis_locker ||= Mutex.new
-            @redis = @redis_sub_thread = nil
-
-            module_function
-
-            def connect
-               return false unless ENV['PL_REDIS_URL'] && defined?(::Redis)
-               return @redis if (@redis_sub_thread && @redis_sub_thread.alive?) && @redis
-               @redis_locker.synchronize do
-                  return @redis if (@redis_sub_thread && @redis_sub_thread.alive?) && @redis # repeat the test inside syncing, things change.
-                  @redis.quit if @redis
-                  @redis = ::Redis.new(url: ENV['PL_REDIS_URL'])
-                  raise "Redis connction failed for: #{ENV['PL_REDIS_URL']}" unless @redis
-                  @redis_sub_thread = Thread.new do
-                     begin
-                        ::Redis.new(url: ENV['PL_REDIS_URL']).subscribe(::Plezi.app_name, ::Plezi::Base::MessageDispatch.pid) do |on|
-                           on.message do |_channel, msg|
-                              ::Plezi::Base::MessageDispatch << msg
-                           end
-                        end
-                     rescue => e
-                        puts e.message, e.backtrace
-                        retry
-                     end
-                  end
-                  @redis
-               end
-            end
-
-            # Get the current redis connection.
-            def redis
-               @redis || connect
-            end
-
-            def push(channel, message)
-               return unless connect
-               return if away?(channel)
-               redis.publish(channel, message)
-            end
-
-            def away?(server)
-               return true unless connect
-               @redis.pubsub('CHANNELS', server).empty?
-            end
-         end
-      end
-   end
-end
-
-::Plezi::Base::MessageDispatch.drivers << ::Plezi::Base::MessageDispatch::RedisDriver