isomorfeus-transport 1.0.0.zeta23 → 2.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f880aa11773aa387acfd1e8bcee0b3dc1678c6657341a4dff9612b4e0cbd73d6
-  data.tar.gz: a17830e51f92e94ea20b1e059dcb6832578a6688583e1579edc1ccbc32d51729
+  metadata.gz: 51966e33a5412f5d3e38054cc87b91ee92d8ed273fecc4a2e8714cc7ef0e765d
+  data.tar.gz: 17fd590a9850f434d6a7a6d59d45e60af8d2efd1b37d2fd0bddff0ca1f9c6040
 SHA512:
-  metadata.gz: 8cc684ec49a19d7aedb5f1f59c284e78ae426bd9ff03f33874f07a37bf5085f902b803049efebb24ceea982e71ae97c23b59ae323fe510d8d97e09aeb6fab74a
-  data.tar.gz: 102b5ff34f5127d81ed4cd026b02b7beb87f9c595b2d5cfe49a4a42a675a8147cc9faff7ae5797293d3bf5982e86c5b1321e06a092acf7c195cf5374c4facb52
+  metadata.gz: 0cdd94a7cb3adcb4d6230abcf83d77c282d1cffb838dc4e024cd56215c3c2ca13657bdcb328e6bb3c463e7e3dad3029d5b44ea697fbccaf1a095a960b81c3dae
+  data.tar.gz: ce3e0da3e1caea29de684f7fb1e6b91713509e99e355f124f5e0f89134dd6eb817ab3af56623d668e6a3adfded0fa69bf1f39c4c3a8ad036b3c2d1345435cfbe

data/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2018, 2019 Jan Biedermann
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2018, 2019 Jan Biedermann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,36 +1,27 @@
-# isomorfeus-transport
-
-Transport and PubSub for Isomorfeus.
-
-### Community and Support
-At the [Isomorfeus Framework Project](http://isomorfeus.com) 
-
-## Installation
-isomorfeus-transport is usually installed with the installer.
-Otherwise add to your Gemfile:
-```ruby
-gem 'isomorfeus-transport'
-```
-and bundle install/update
-
-## Server Side Rendering
-`yarn add ws`
-
-The 'ws' module then needs to be imported in application_ssr.js:
-```
-import WebSocket from 'ws';
-global.WebSocket = WebSocket;
-```
-
-## Configuration options
-
-Client and Server:
-- Isomorfeus.api_websocket_path - path for server side endpoint, default: `/isomorfeus/api/websocket`
-
-Server only:
-- Isomorfeus.middlewares - all the rack middlewares to load
-
-## Usage
-
-- [Authentication and Current User](https://github.com/isomorfeus/isomorfeus-project/blob/master/ruby/isomorfeus-policy/docs/authentication.md)
-- [Channels (PubSub)](https://github.com/isomorfeus/isomorfeus-project/blob/master/ruby/isomorfeus-policy/docs/channels.md)
+# isomorfeus-transport
+
+Transport and PubSub for Isomorfeus.
+
+### Community and Support
+At the [Isomorfeus Framework Project](http://isomorfeus.com) 
+
+## Installation
+isomorfeus-transport is usually installed with the installer.
+Otherwise add to your Gemfile:
+```ruby
+gem 'isomorfeus-transport'
+```
+and bundle install/update
+
+## Configuration options
+
+Client and Server:
+- Isomorfeus.api_websocket_path - path for server side endpoint, default: `/isomorfeus/api/websocket`
+
+Server only:
+- Isomorfeus.middlewares - all the rack middlewares to load
+
+## Usage
+
+- [Authentication and Current User](https://github.com/isomorfeus/isomorfeus-project/blob/master/ruby/isomorfeus-transport/docs/authentication.md)
+- [Channels (PubSub)](https://github.com/isomorfeus/isomorfeus-project/blob/master/ruby/isomorfeus-transport/docs/channels.md)

data/lib/isomorfeus/transport/client_processor.rb

@@ -1,30 +1,35 @@
-module Isomorfeus
-  module Transport
-    class ClientProcessor
-      def self.process(json_hash)
-        if json_hash.key?(:response)
-          process_response(json_hash)
-        elsif json_hash.key?(:notification)
-          process_notification(json_hash)
-        end
-      end
-
-      def self.process_notification(notification_hash)
-        processor_class = "::#{notification_hash[:notification][:class]}".constantize
-        processor_class.process_message(notification_hash[:notification][:channel], notification_hash[:notification][:message])
-      end
-
-      def self.process_response(response_hash)
-        response_hash[:response][:agent_ids].keys.each do |agent_id|
-          agent = Isomorfeus::Transport::RequestAgent.get!(agent_id)
-          Isomorfeus::Transport.unregister_request_in_progress(agent_id)
-          unless agent.promise.realized?
-            agent.full_response = response_hash
-            agent.response = response_hash[:response][:agent_ids][agent_id]
-            agent.promise.resolve(agent)
-          end
-        end
-      end
-    end
-  end
-end
+module Isomorfeus
+  module Transport
+    class ClientProcessor
+      def self.process(json_hash)
+        if json_hash.key?(:response)
+          process_response(json_hash)
+        elsif json_hash.key?(:notification)
+          process_message(json_hash)
+        end
+      end
+
+      def self.process_message(message_hash)
+        processor_class_name = message_hash[:notification][:class]
+        Isomorfeus.raise_error(message: "Not a valid channel class #{processor_class_name}!") unless Isomorfeus.valid_channel_class_name?(processor_class_name)
+        processor_class = Isomorfeus.cached_channel_class(processor_class_name)
+        unless processor_class.respond_to?(:process_message)
+          Isomorfeus.raise_error(message: "Cannot process message, #{processor_class} must be a Channel and must have the on_message block defined!")
+        end
+        processor_class.process_message(message_hash[:notification][:message], message_hash[:notification][:error], message_hash[:notification][:channel])
+      end
+
+      def self.process_response(response_hash)
+        response_hash[:response][:agent_ids].keys.each do |agent_id|
+          agent = Isomorfeus::Transport::RequestAgent.get!(agent_id)
+          Isomorfeus::Transport.unregister_request_in_progress(agent_id)
+          unless agent.promise.realized?
+            agent.full_response = response_hash
+            agent.response = response_hash[:response][:agent_ids][agent_id]
+            agent.promise.resolve(agent)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/transport/config.rb

@@ -1,158 +1,182 @@
-module Isomorfeus
-  # available settings
-
-  if RUBY_ENGINE == 'opal'
-    add_client_option(:api_websocket_path)
-    add_client_option(:cookie_eater_path)
-    add_client_option(:transport_init_class_names, [])
-
-    def self.add_transport_init_class_name(init_class_name)
-      transport_init_class_names << init_class_name
-    end
-
-    def self.current_user
-      @current_user ||= init_current_user
-    end
-
-    def self.init_current_user
-      if Isomorfeus.current_user_sid
-        Isomorfeus.instance_from_sid(Isomorfeus.current_user_sid)
-      else
-        Anonymous.new
-      end
-    end
-
-    def self.set_current_user(user)
-      if user
-        @current_user = user
-        Isomorfeus.current_user_sid = user.to_sid
-      else
-        @current_user = Anonymous.new
-      end
-    end
-  else
-    class << self
-      attr_accessor :api_websocket_path
-      attr_accessor :cookie_eater_path
-      attr_accessor :session_store
-      attr_accessor :cookie_dbm_path
-
-      def add_middleware(middleware)
-        Isomorfeus.middlewares << middleware
-      end
-
-      def insert_middleware_after(existing_middleware, new_middleware)
-        index_of_existing = Isomorfeus.middlewares.index(existing_middleware)
-        unless Isomorfeus.middlewares.include?(new_middleware)
-          if index_of_existing
-            Isomorfeus.middlewares.insert(index_of_existing + 1, new_middleware)
-          else
-            Isomorfeus.middlewares << new_middleware
-          end
-        end
-      end
-
-      def insert_middleware_before(existing_middleware, new_middleware)
-        index_of_existing = Isomorfeus.middlewares.index(existing_middleware)
-        unless Isomorfeus.middlewares.include?(new_middleware)
-          if index_of_existing
-            Isomorfeus.middlewares.insert(index_of_existing, new_middleware)
-          else
-            Isomorfeus.middlewares << new_middleware
-          end
-        end
-      end
-
-      def middlewares
-        @middlewares ||= Set.new
-      end
-
-      def cached_channel_classes
-        @cached_channel_classes ||= {}
-      end
-
-      def cached_channel_class(class_name)
-        return "::#{class_name}".constantize if Isomorfeus.development?
-        return cached_channel_classes[class_name] if cached_channel_classes.key?(class_name)
-        cached_channel_classes[class_name] = "::#{class_name}".constantize
-      end
-
-      def valid_channel_class_names
-        @valid_channel_class_names ||= Set.new
-      end
-
-      def valid_channel_class_name?(class_name)
-        valid_channel_class_names.include?(class_name)
-      end
-
-      def add_valid_channel_class(klass)
-        valid_channel_class_names << raw_class_name(klass)
-      end
-
-      def valid_handler_class_names
-        @valid_handler_class_names ||= Set.new
-      end
-
-      def valid_handler_class_name?(class_name)
-        valid_handler_class_names.include?(class_name)
-      end
-
-      def add_valid_handler_class(klass)
-        valid_handler_class_names << raw_class_name(klass)
-      end
-
-      def cached_handler_classes
-        @cached_handler_classes ||= {}
-      end
-
-      def cached_handler_class(class_name)
-        return "::#{class_name}".constantize if Isomorfeus.development?
-        return cached_handler_classes[class_name] if cached_handler_classes.key?(class_name)
-        cached_handler_classes[class_name] = "::#{class_name}".constantize
-      end
-
-      def valid_user_class_names
-        @valid_user_class_names ||= Set.new
-      end
-
-      def valid_user_class_name?(class_name)
-        valid_user_class_names.include?(class_name)
-      end
-
-      def add_valid_user_class(klass)
-        valid_user_class_names << raw_class_name(klass)
-      end
-
-      def cached_user_classes
-        @cached_user_classes ||= {}
-      end
-
-      def cached_user_class(class_name)
-        return "::#{class_name}".constantize if Isomorfeus.development?
-        return cached_user_classes[class_name] if cached_user_classes.key?(class_name)
-        cached_user_classes[class_name] = "::#{class_name}".constantize
-      end
-
-      def raw_class_name(klass)
-        class_name = klass.name
-        class_name = class_name.split('>::').last if class_name.start_with?('#<')
-        class_name
-      end
-
-      def current_user
-        Thread.current[:isomorfeus_user]
-      end
-
-      def pub_sub_client
-        Thread.current[:isomorfeus_pub_sub_client]
-      end
-    end
-
-    self.cookie_dbm_path = 'cookie'
-    self.session_store = Isomorfeus::Transport::DbmSessionStore.new # dont use this one, but we keep it here to have at least something
-  end
-
-  # defaults
-  self.api_websocket_path = '/isomorfeus/api/websocket'
-  self.cookie_eater_path = '/isomorfeus/cookie/eat'
-end
+module Isomorfeus
+  # available settings
+  class << self
+    def cached_channel_classes
+      @cached_channel_classes ||= {}
+    end
+
+    def cached_channel_class(class_name)
+      return "::#{class_name}".constantize if Isomorfeus.development?
+      return cached_channel_classes[class_name] if cached_channel_classes.key?(class_name)
+      cached_channel_classes[class_name] = "::#{class_name}".constantize
+    end
+
+    def valid_channel_class_names
+      @valid_channel_class_names ||= Set.new
+    end
+
+    def add_valid_channel_class(klass)
+      valid_channel_class_names << raw_class_name(klass)
+    end
+
+    def raw_class_name(klass)
+      class_name = klass.name
+      class_name = class_name.split('>::').last if class_name.start_with?('#<')
+      class_name
+    end
+  end
+
+  if RUBY_ENGINE == 'opal'
+    add_client_option(:api_websocket_host)
+    add_client_option(:api_websocket_port)
+    add_client_option(:api_websocket_path)
+    add_client_option(:cookie_eater_path)
+    add_client_option(:transport_init_class_names, [])
+
+    class << self
+      def valid_channel_class_name?(class_name)
+        cached_channel_class(class_name) # because of autoloader
+        valid_channel_class_names.include?(class_name)
+      end
+
+      def add_transport_init_class_name(init_class_name)
+        transport_init_class_names << init_class_name
+      end
+
+      def current_user
+        @current_user ||= init_current_user
+      end
+
+      def init_current_user
+        if Isomorfeus.current_user_sid
+          Isomorfeus.instance_from_sid(Isomorfeus.current_user_sid)
+        else
+          Anonymous.new
+        end
+      end
+
+      def set_current_user(user)
+        if user
+          @current_user = user
+          Isomorfeus.current_user_sid = user.sid
+        else
+          @current_user = Anonymous.new
+        end
+      end
+    end
+  else
+    class << self
+      attr_accessor :api_websocket_host
+      attr_accessor :api_websocket_port
+      attr_accessor :api_websocket_path
+      attr_accessor :cookie_eater_path
+      attr_reader :session_store
+
+      def valid_channel_class_name?(class_name)
+        valid_channel_class_names.include?(class_name)
+      end
+
+      def add_middleware(middleware)
+        Isomorfeus.middlewares << middleware
+      end
+
+      def insert_middleware_after(existing_middleware, new_middleware)
+        index_of_existing = Isomorfeus.middlewares.index(existing_middleware)
+        unless Isomorfeus.middlewares.include?(new_middleware)
+          if index_of_existing
+            Isomorfeus.middlewares.insert(index_of_existing + 1, new_middleware)
+          else
+            Isomorfeus.middlewares << new_middleware
+          end
+        end
+      end
+
+      def insert_middleware_before(existing_middleware, new_middleware)
+        index_of_existing = Isomorfeus.middlewares.index(existing_middleware)
+        unless Isomorfeus.middlewares.include?(new_middleware)
+          if index_of_existing
+            Isomorfeus.middlewares.insert(index_of_existing, new_middleware)
+          else
+            Isomorfeus.middlewares << new_middleware
+          end
+        end
+      end
+
+      def middlewares
+        @middlewares ||= Set.new
+      end
+
+      def valid_handler_class_names
+        @valid_handler_class_names ||= Set.new
+      end
+
+      def valid_handler_class_name?(class_name)
+        valid_handler_class_names.include?(class_name)
+      end
+
+      def add_valid_handler_class(klass)
+        valid_handler_class_names << raw_class_name(klass)
+      end
+
+      def cached_handler_classes
+        @cached_handler_classes ||= {}
+      end
+
+      def cached_handler_class(class_name)
+        return "::#{class_name}".constantize if Isomorfeus.development?
+        return cached_handler_classes[class_name] if cached_handler_classes.key?(class_name)
+        cached_handler_classes[class_name] = "::#{class_name}".constantize
+      end
+
+      def valid_user_class_names
+        @valid_user_class_names ||= Set.new
+      end
+
+      def valid_user_class_name?(class_name)
+        valid_user_class_names.include?(class_name)
+      end
+
+      def add_valid_user_class(klass)
+        valid_user_class_names << raw_class_name(klass)
+      end
+
+      def cached_user_classes
+        @cached_user_classes ||= {}
+      end
+
+      def cached_user_class(class_name)
+        return "::#{class_name}".constantize if Isomorfeus.development?
+        return cached_user_classes[class_name] if cached_user_classes.key?(class_name)
+        cached_user_classes[class_name] = "::#{class_name}".constantize
+      end
+
+      def current_user
+        Thread.current[:isomorfeus_user]
+      end
+
+      def pub_sub_client
+        Thread.current[:isomorfeus_pub_sub_client]
+      end
+
+      def session_store
+        @session_store ||= @session_store_init.call
+      end
+
+      def session_store_init(&block)
+        @session_store_init = block
+      end
+    end
+
+    self.session_store_init do
+      store_path = File.expand_path(File.join(Isomorfeus.root, 'data', Isomorfeus.env), 'session_store')
+      Isomorfeus::Transport::HamsterSessionStore.new(store_path) # dont use this one, but we keep it here to have at least something
+    end
+  end
+
+  # defaults
+  self.api_websocket_host = 'localhost'
+  self.api_websocket_port = '3000'
+  self.api_websocket_path = '/isomorfeus/api/websocket'
+
+  self.cookie_eater_path = '/isomorfeus/cookie/eat'
+end

data/lib/isomorfeus/transport/hamster_session_store.rb

@@ -0,0 +1,96 @@
+module Isomorfeus
+  module Transport
+    class HamsterSessionStore
+      class << self
+        def environment
+          @environment
+        end
+
+        def environment=(env)
+          @environment = env
+        end
+
+        def ref
+          @ref ||= 0
+        end
+
+        def ref=(val)
+          @ref = val
+        end
+
+        def refa
+          self.ref += 1
+        end
+
+        def refs
+          self.ref -= 1 if self.ref > 0
+        end
+
+        def finalize(cls)
+          proc do
+            cls.refs
+            if cls.ref == 0
+              cls.environment.close rescue nil
+            end
+          end
+        end
+      end
+
+      def initialize(cookie_hamster_path)
+        @cookie_hamster_path = cookie_hamster_path
+        open_environment
+        @db = self.class.environment.database('cookies', create: true)
+        ObjectSpace.define_finalizer(self, self.class.finalize(self.class))
+      end
+
+      def add(session_id:, cookie:, user:, accessor:)
+        @db.env.transaction do
+          @db.put(session_id, Oj.dump([user.class.to_s, user.key], mode: :strict))
+          @db.put(accessor, cookie)
+        end
+      end
+
+      def take_cookie(accessor:)
+        @db.env.transaction do
+          cookie = @db.get(accessor)
+          if cookie
+            session_info = cookie.split('; ').first
+            session_id = session_info.split('=').last.strip
+            @db.put("eaten_#{accessor}", session_id)
+            @db.delete(accessor)
+          else
+            # asked for the same cookie a second time
+            # can probably only be due to session hijacking
+            # so delete all sessions associated with that accessor
+            session_id = @db.get("eaten_#{accessor}")
+            @db.delete(session_id) if session_id
+          end
+          cookie
+        end
+      end
+
+      def get_user(session_id:)
+        json = @db.get(session_id)
+        if json
+          user_info = Oj.load(json, mode: :strict)
+          user_info[0].constantize.load(key: user_info[1]) if user_info
+        end
+      end
+
+      def remove(session_id:)
+        @db.env.transaction do
+          @db.delete(session_id)
+        end
+      end
+
+      private
+
+      def open_environment
+        return self.class.refa if self.class.environment
+        FileUtils.mkdir_p(@cookie_hamster_path) unless Dir.exist?(@cookie_hamster_path)
+        self.class.environment = Isomorfeus::Hamster.new(@cookie_hamster_path)
+        self.class.refa
+      end
+    end
+  end
+end