plezi 0.12.22 → 0.14.0

data/lib/plezi/router/errors.rb

@@ -0,0 +1,29 @@
+module Plezi
+  module Base
+    class Err404Ctrl
+      def index
+        response.status = 404
+        render('404') || 'Error 404, not found.'
+      end
+
+      def requested_method
+        :index
+      end
+
+      include Plezi::Controller
+    end
+    class Err500Ctrl
+      def index
+        response.status = 500
+        render('500') || 'Internal Error 500.'
+      rescue
+        'Internal Error 500.'
+      end
+
+      def requested_method
+        :index
+      end
+      include Plezi::Controller
+    end
+  end
+end

data/lib/plezi/router/route.rb

@@ -0,0 +1,112 @@
+require 'plezi/controller/controller'
+require 'thread'
+require 'rack'
+require 'rack/query_parser.rb'
+
+module Plezi
+  module Base
+    class Route
+      attr_reader :prefix, :controller, :param_names
+
+      def initialize(path, controller)
+        @route_id = "Route#{object_id.to_s(16)}".to_sym
+        m = path.match(/([^\:\(\*]*)(.*)/)
+        @prefix = m[1].chomp('/'.freeze)
+        if @prefix.nil? || @prefix == ''.freeze
+          @prefix = '/'.freeze
+          @prefix_length = 1
+        else
+          @prefix = "/#{@prefix}" if @prefix[0] != '/'.freeze
+          @prefix_length = @prefix.length + 1
+        end
+        @controller = controller
+        @param_names = []
+        @origial = path.dup.freeze
+        path2regex(m[2])
+        self.class.qp
+        case @controller
+        when Class
+          prep_controller
+        when Regexp
+          raise "Rewrite Routes can't contain more then one parameter to collect" if @param_names.length > 1
+        else
+          raise 'Controller should be a class object' unless controller.is_a?(Class)
+        end
+      end
+
+      def call(request, response)
+        return nil unless match(request.path_info, request)
+        case @controller
+        when Class
+          c = @controller.new
+          return c._pl_respond(request, response, Thread.current[@route_id])
+        when Regexp
+          params = Thread.current[@route_id]
+          return nil unless controller =~ params[@param_names[0]]
+          request.path_info = "/#{params.delete('*'.freeze).to_a.join '/'}"
+          request.params.update params
+        end
+        nil
+      end
+
+      def fits_params(path, request)
+        params = (Thread.current[@route_id] ||= {}).clear
+        params.update request.params.to_h if request && request.params
+        # puts "cutting: #{path[(@prefix_length)..-1] ? path[(@prefix_length + 1)..-1] : 'nil'}"
+        pa = (path[@prefix_length..-1] || ''.freeze).split('/'.freeze)
+        # puts "check param count: #{pa}"
+        return false unless @params_range.include?(pa.length)
+        @param_names.each do |key|
+          next if pa[0].nil?
+          self.class.qp.normalize_params(params, Plezi.try_utf8!(Rack::Utils.unescape(key)),
+                                         Plezi.try_utf8!(Rack::Utils.unescape(pa.shift)), 100)
+        end
+        params['*'.freeze] = pa unless pa.empty?
+        true
+      end
+
+      def match(req_path, request = nil)
+        # puts "#{req_path} starts with #{@prefix}? #{req_path.start_with?(@prefix)}"
+        req_path.start_with?(@prefix) && fits_params(req_path, request)
+      end
+
+      def path2regex(postfix)
+        pfa = postfix.split '/'.freeze
+        start = 0; stop = 0
+        optional = false
+        while pfa.any?
+          name = pfa.shift
+          raise "#{name} is not a valid path section in #{@origial}" if /^((\:[\w\.\[\]]+)|(\(\:[\w\.\[\]]+\))|(\*))$/.match(name).nil?
+          if name[0] == ':'
+            raise "Cannot have a required parameter after an optional parameter in #{@origial}" if optional
+            @param_names << name[1..-1].freeze
+          elsif name[0] == '('
+            optional = true
+            @param_names << name[2..-2].freeze
+          elsif name[0] == '*'
+            stop += 999_999
+            break
+          else
+            raise "invalid path section #{name} in #{@origial}"
+          end
+          optional ? (stop += 1) : (start += 1)
+        end
+        unless (@param_names.include? 'id'.freeze) || stop >= 999_999
+          @param_names << 'id'.freeze
+          stop += 1
+        end
+        @params_range = (start..(start + stop))
+        @param_names.freeze
+        @params_range.freeze
+      end
+
+      def prep_controller
+        @controller.include Plezi::Controller
+      end
+
+      def self.qp
+        @qp ||= ::Rack::QueryParser.new(Hash, 65_536, 100)
+      end
+    end
+  end
+end

data/lib/plezi/router/router.rb

@@ -0,0 +1,120 @@
+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_function
+
+      def new(app)
+        puts 'Plezi as Middleware'
+        @app = ((app == Plezi.app) ? nil : app)
+        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
+
+      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
+        end
+        @routes << Route.new(path, controller)
+      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 = '/'.dup if url.empty?
+        (url << '?') << Rack::Utils.build_nested_query(params) if params.any?
+        url
+      end
+    end
+  end
+end

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-    VERSION = "0.12.22"
+  VERSION = '0.14.0'.freeze
 end

data/lib/plezi/websockets/message_dispatch.rb

@@ -0,0 +1,91 @@
+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_function
+
+      def pid
+        @uuid ||= SecureRandom.urlsafe_base64.tap { |str| @prefix_len = str.length }
+      end
+
+      def _init
+        @drivers.each(&:connect)
+      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
+
+      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
+
+      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
+
+      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
+
+      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
+
+      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
+      end
+    end
+  end
+end
+# connect default drivers
+require 'plezi/websockets/redis'

data/lib/plezi/websockets/redis.rb

@@ -0,0 +1,55 @@
+require 'securerandom'
+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

data/plezi.gemspec

@@ -4,25 +4,34 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'plezi/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "plezi"
+  spec.name          = 'plezi'
   spec.version       = Plezi::VERSION
-  spec.authors       = ["Boaz Segev"]
-  spec.email         = ['boaz@2be.co.il']
-  spec.summary       = %q{Plezi - the easy way to add Websockets, RESTful routing and HTTP streaming services to Ruby Web-Apps.}
-  spec.description   = %q{Plezi - the easy way to add Websockets, RESTful routing and HTTP streaming services to Ruby Web-Apps.}
-  spec.homepage      = "http://www.plezi.io/"
-  spec.license       = "MIT"
+  spec.authors       = ['Boaz Segev']
+  spec.email         = ['bo@plezi.io']
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.summary       = 'The Plezi.io Ruby Framework for real time web applications.'
+  spec.description   = 'The Plezi.io Ruby Framework for real time web applications.'
+  spec.homepage      = 'http://plezi.io'
+  spec.license       = 'MIT'
 
-  spec.add_dependency "iodine", "~> 0.1.20"
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
+  end
 
-  spec.post_install_message = "Thank you for installing Plezi, the native Ruby Framework for real time web-apps."
-  # spec.post_install_message = "** Deprecation Warning:\n\nThank you for installing Plezi, the native Ruby Framework for real time web-apps."
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
 
+  spec.add_dependency 'iodine', '~> 0.2.0'
+  # spec.add_dependency 'redcarpet', '> 3.3.0'
+  # spec.add_dependency 'slim', '> 3.0.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
 end