plezi 0.14.4 → 0.14.5

data/lib/plezi/router/router.rb

@@ -2,127 +2,134 @@ require 'plezi/router/route'
 require 'plezi/router/errors'
 require 'plezi/router/assets'
 require 'plezi/router/adclient'
-require 'rack'
 
 module Plezi
-  module Base
-    module Router
-      @routes = []
-      @app = nil
+   module Base
+      # this module is incharge of routing requests to the correct Controller.
+      module Router
+         @routes = []
+         @app = nil
 
-      module_function
+         module_function
 
-      def new(app)
-        if app && app != call_method
-          puts 'Plezi as Middleware'
-          @app = app
-        end
-        Plezi.app
-      end
+         # Creates a new router
+         def new(app)
+            if app && app != call_method
+               puts 'Plezi as Middleware'
+               @app = app
+            end
+            Plezi.app
+         end
 
-      def call(env)
-        request = Rack::Request.new(env)
-        response = Rack::Response.new
-        ret = nil
-        @routes.each { |route| ret = route.call(request, response); break if ret }
-        unless ret
-          return @app.call(env) if @app
-          ret = ::Plezi::Base::Err404Ctrl.new._pl_respond(request, response, request.params)
-        end
-        response.write(ret) if ret.is_a?(String)
-        return response.finish
-      rescue => e
-        puts e.message, e.backtrace
-        response = Rack::Response.new
-        response.write ::Plezi::Base::Err500Ctrl.new._pl_respond(request, response, request.params)
-        return response.finish
-      end
+         # called when an HTTP request had arrived
+         def call(env)
+            request = Rack::Request.new(env)
+            response = Rack::Response.new
+            ret = nil
+            @routes.each { |route| ret = route.call(request, response); break if ret }
+            unless ret
+               return @app.call(env) if @app
+               ret = ::Plezi::Base::Err404Ctrl.new._pl_respond(request, response, request.params)
+            end
+            response.write(ret) if ret.is_a?(String)
+            return response.finish
+         rescue => e
+            puts e.message, e.backtrace
+            response = Rack::Response.new
+            response.write ::Plezi::Base::Err500Ctrl.new._pl_respond(request, response, request.params)
+            return response.finish
+         end
 
-      # returns the `call` method. Used repeatedly in middleware mode and only once in application mode.
-      def call_method
-        @call_method ||= Plezi::Base::Router.method(:call)
-      end
+         # returns the `call` method. Used repeatedly in middleware mode and only once in application mode.
+         def call_method
+            @call_method ||= Plezi::Base::Router.method(:call)
+         end
 
-      def route(path, controller)
-        path = path.chomp('/'.freeze) unless path == '/'.freeze
-        case controller
-        when :client
-          controller = ::Plezi::Base::Router::ADClient
-        when :assets
-          controller = ::Plezi::Base::Assets
-          path << '/*'.freeze unless path[-1] == '*'.freeze
-        when Regexp
-          path << '/*'.freeze unless path[-1] == '*'.freeze
-          return @routes << RouteRewrite.new(path, controller)
-        end
-        @routes << Route.new(path, controller)
-      end
+         # Creates a new route.
+         #
+         # `path`:: should be a string describing the route. Named parameters are allowed.
+         # `controller`:: should be a Class object that will receive all the class properties of a Plezi Controller, or one of the allowed keywords.
+         def route(path, controller)
+            path = path.chomp('/'.freeze) unless path == '/'.freeze
+            case controller
+            when :client
+               controller = ::Plezi::Base::Router::ADClient
+            when :assets
+               controller = ::Plezi::Base::Assets
+               path << '/*'.freeze unless path[-1] == '*'.freeze
+            when Regexp
+               path << '/*'.freeze unless path[-1] == '*'.freeze
+               return @routes << RouteRewrite.new(path, controller)
+            end
+            @routes << Route.new(path, controller)
+         end
 
-      def list
-        @routes
-      end
+         def list
+            @routes
+         end
 
-      def url_for(controller, method_sym, params = {})
-        # GET,PUT,POST,DELETE
-        r = nil
-        url = '/'.dup
-        @routes.each do |tmp|
-          case tmp.controller
-          when Class
-            next if tmp.controller != controller
-            r = tmp
-            break
-          when Regexp
-            nm = nil
-            nm = tmp.param_names[0] if params[tmp.param_names[0]]
-            nm ||= tmp.param_names[0].to_sym
-            url << "#{params.delete nm}/" if params[nm] && params[nm].to_s =~ tmp.controller
-          else
-            next
-          end
-        end
-        return nil if r.nil?
-        case method_sym.to_sym
-        when :new
-          params.delete :id
-          params.delete :_method
-          params.delete '_method'.freeze
-          params['id'.freeze] = :new
-        when :create
-          params['id'.freeze] = :new
-          params.delete :id
-          params['_method'.freeze] = :post
-          params.delete :_method
-        when :update
-          params.delete :_method
-          params['_method'.freeze] = :put
-        when :delete
-          params.delete :_method
-          params['_method'.freeze] = :delete
-        when :index
-          params.delete 'id'.freeze
-          params.delete '_method'.freeze
-          params.delete :id
-          params.delete :_method
-        when :show
-          raise "The URL for ':show' MUST contain a valid 'id' parameter for the object's index to display." unless params['id'.freeze].nil? && params[:id].nil?
-          params.delete '_method'.freeze
-          params.delete :_method
-        else
-          params.delete :id
-          params['id'.freeze] = method_sym
-        end
-        names = r.param_names
-        url.chomp! '/'.freeze
-        url << r.prefix
-        url.clear if url == '/'.freeze
-        while names.any? && params[name[0]]
-          url << "/#{Rack::Utils.escape params[names.shift]}"
-        end
-        url << '/'.freeze if url.empty?
-        (url << '?') << Rack::Utils.build_nested_query(params) if params.any?
-        url
+         # Returns the URL for requested controller method and paramerets.
+         def url_for(controller, method_sym, params = {})
+            # GET,PUT,POST,DELETE
+            r = nil
+            url = '/'.dup
+            @routes.each do |tmp|
+               case tmp.controller
+               when Class
+                  next if tmp.controller != controller
+                  r = tmp
+                  break
+               when Regexp
+                  nm = nil
+                  nm = tmp.param_names[0] if params[tmp.param_names[0]]
+                  nm ||= tmp.param_names[0].to_sym
+                  url << "#{params.delete nm}/" if params[nm] && params[nm].to_s =~ tmp.controller
+               else
+                  next
+               end
+            end
+            return nil if r.nil?
+            case method_sym.to_sym
+            when :new
+               params.delete :id
+               params.delete :_method
+               params.delete '_method'.freeze
+               params['id'.freeze] = :new
+            when :create
+               params['id'.freeze] = :new
+               params.delete :id
+               params['_method'.freeze] = :post
+               params.delete :_method
+            when :update
+               params.delete :_method
+               params['_method'.freeze] = :put
+            when :delete
+               params.delete :_method
+               params['_method'.freeze] = :delete
+            when :index
+               params.delete 'id'.freeze
+               params.delete '_method'.freeze
+               params.delete :id
+               params.delete :_method
+            when :show
+               raise "The URL for ':show' MUST contain a valid 'id' parameter for the object's index to display." unless params['id'.freeze].nil? && params[:id].nil?
+               params.delete '_method'.freeze
+               params.delete :_method
+            else
+               params.delete :id
+               params['id'.freeze] = method_sym
+            end
+            names = r.param_names
+            url.chomp! '/'.freeze
+            url << r.prefix
+            url.clear if url == '/'.freeze
+            while names.any? && params[name[0]]
+               url << "/#{Rack::Utils.escape params[names.shift]}"
+            end
+            url << '/'.freeze if url.empty?
+            (url << '?') << Rack::Utils.build_nested_query(params) if params.any?
+            url
+         end
       end
-    end
-  end
+   end
 end

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-  VERSION = '0.14.4'.freeze
+   VERSION = '0.14.5'.freeze
 end

data/lib/plezi/websockets/message_dispatch.rb

@@ -1,97 +1,135 @@
-require 'set'
-require 'securerandom'
-require 'yaml'
 module Plezi
-  module Base
-    module MessageDispatch
-      class << self
-        # Allows pub/sub drivers to attach to the message dispatch using `MessageDispatch.drivers << driver`
-        attr_reader :drivers
-      end
-      @drivers = [].to_set
+   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
+         module_function
 
-      @ppid = ::Process.pid
+         # 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
 
-      def 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
 
-      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
 
-      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 { |d| d.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
 
-      def <<(msg)
-        @safe_types ||= [Symbol, Date, Time, Encoding, Struct, Regexp, Range, Set].freeze
-        msg = YAML.safe_load(msg, @safe_types)
-        return if msg[:origin] == pid
-        msg[:type] ||= msg['type'.freeze]
-        msg[:type] = Object.const_get msg[:type] if msg[:type] && msg[:type] != :all
-        if msg[:target] ||= msg['target'.freeze]
-          Iodine::Websocket.defer(target2uuid(msg[:target])) { |ws| ws._pl_ad_review(ws.__send__(ws._pl_ws_map[msg[:event]], *(msg[:args] ||= msg['args'.freeze] || []))) if ws._pl_ws_map[msg[:event] ||= msg['event'.freeze]] }
-        elsif (msg[:type]) == :all
-          Iodine::Websocket.each { |ws| ws._pl_ad_review(ws.__send__(ws._pl_ws_map[msg[:event]], *(msg[:args] ||= msg['args'.freeze] || []))) if ws._pl_ws_map[msg[:event] ||= msg['event'.freeze]] }
-        else
-          Iodine::Websocket.each { |ws| ws._pl_ad_review(ws.__send__(ws._pl_ws_map[msg[:event]], *(msg[:args] ||= msg['args'.freeze] || []))) if ws.is_a?(msg[:type]) && msg[:type]._pl_ws_map[msg[:event] ||= msg['event'.freeze]] }
-        end
+         rescue => e
+            puts '*** The following could be a security breach attempt:', e.message, e.backtrace
+            nil
+         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
 
-      def unicast(_sender, target, meth, args)
-        return false if target.nil?
-        if (tuuid = target2uuid)
-          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
 
-      def broadcast(sender, meth, args)
-        if sender.is_a?(Class)
-          Iodine::Websocket.each { |ws| ws._pl_ad_review(ws.__send__(ws._pl_ws_map[meth], *args)) if ws.is_a?(sender) && ws._pl_ws_map[meth] }
-          push type: sender.name, args: args, event: meth
-        else
-          sender.each { |ws| ws._pl_ad_review(ws.__send__(ws._pl_ws_map[meth], *args)) if ws.is_a?(sender.class) && ws._pl_ws_map[meth] }
-          push type: sender.class.name, args: args, event: meth
-        end
-      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
 
-      def multicast(sender, meth, args)
-        if sender.is_a?(Class)
-          Iodine::Websocket.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
-        else
-          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
-      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
 
-      def target2uuid(target)
-        return nil unless target.start_with? pid
-        target[@prefix_len..-1].to_i
-      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
 
-      def target2pid(target)
-        target ? target[0..(@prefix_len - 1)] : Plezi.app_name
+         # 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
+   end
 end
 # connect default drivers
 require 'plezi/websockets/redis'