isomorfeus-transport 1.0.0.zeta24 → 2.0.0.rc3

data/lib/isomorfeus/transport/server_processor.rb

@@ -1,129 +1,129 @@
-# frozen_string_literal: true
-
-module Isomorfeus
-  module Transport
-    module ServerProcessor
-      def process_request(request, handler_instance_cache, response_agent_array)
-        if request.key?('request') && request['request'].key?('agent_ids')
-          request['request']['agent_ids'].each_key do |agent_id|
-            request['request']['agent_ids'][agent_id].each_key do |handler_class_name|
-              response_agent = Isomorfeus::Transport::ResponseAgent.new(agent_id, request['request']['agent_ids'][agent_id][handler_class_name])
-              response_agent_array << response_agent
-              begin
-                handler = if handler_instance_cache.key?(handler_class_name)
-                            handler_instance_cache[handler_class_name]
-                          else
-                            handler_class = Isomorfeus.cached_handler_class(handler_class_name) if Isomorfeus.valid_handler_class_name?(handler_class_name)
-                            handler_instance_cache[handler_class_name] = handler_class.new if handler_class
-                          end
-                if handler
-                  handler.process_request(response_agent)
-                else
-                  response_agent.error = { error: { handler_class_name => 'No such handler!'}}
-                end
-              rescue Exception => e
-                response_agent.error = { response: { error: "#{handler_class_name}: #{e.message}\n#{e.backtrace.join("\n")}" }}
-              end
-            end
-          end
-        elsif request.key?('notification')
-          begin
-            channel = request['notification']['channel']
-            channel_class_name = request['notification']['class']
-            if Isomorfeus.valid_channel_class_name?(channel_class_name) && channel
-              channel_class = Isomorfeus.cached_channel_class(channel_class_name)
-              if channel_class && channel_class.valid_channel?(channel)
-                if Isomorfeus.current_user.authorized?(channel_class_name, :send_message, channel)
-                  allow_publish = if channel_class.server_is_processing_messages?(channel)
-                                    channel_class.server_process_message(request['notification']['message'], channel)
-                                  else
-                                    true
-                                  end
-                  if allow_publish == true
-                    Isomorfeus.pub_sub_client.publish("#{channel_class_name}_#{channel}", Oj.dump({ 'notification' => request['notification'] }, mode: :strict))
-                  else
-                    response_agent = OpenStruct.new
-                    response_agent.result = { notification: request['notification'].merge(error: 'Message cancelled!') }
-                    response_agent_array << response_agent
-                  end
-                else
-                  response_agent = OpenStruct.new
-                  response_agent.result = { notification: request['notification'].merge(error: 'Not authorized!') }
-                  response_agent_array << response_agent
-                end
-              else
-                response_agent = OpenStruct.new
-                response_agent.result = { notification: request['notification'].merge(error: "Not a valid channel #{channel} for #{channel_class_name}!") }
-                response_agent_array << response_agent
-              end
-            else
-              response_agent = OpenStruct.new
-              response_agent.result = { notification: request['notification'].merge(error: "Not a valid Channel class #{channel_class_name}!") }
-              response_agent_array << response_agent
-            end
-          rescue Exception => e
-            response_agent = OpenStruct.new
-            response_agent.result = { notification: request['notification'].merge(error: "Isomorfeus::Transport::ServerProcessor: #{e.message}\n#{e.backtrace.join("\n")}") }
-            response_agent_array << response_agent
-          end
-        elsif request.key?('subscribe') && request['subscribe'].key?('agent_ids')
-          begin
-            agent_id = request['subscribe']['agent_ids'].keys.first
-            response_agent = Isomorfeus::Transport::ResponseAgent.new(agent_id, request['subscribe']['agent_ids'][agent_id])
-            response_agent_array << response_agent
-            channel = response_agent.request['channel']
-            channel_class_name = response_agent.request['class']
-            if Isomorfeus.valid_channel_class_name?(channel_class_name) && channel
-              channel_class = Isomorfeus.cached_channel_class(channel_class_name)
-              if channel_class && channel_class.valid_channel?(channel)
-                if Isomorfeus.current_user.authorized?(channel_class, :subscribe, channel)
-                  Isomorfeus.pub_sub_client.subscribe("#{channel_class_name}_#{channel}")
-                  response_agent.agent_result = { success: channel }
-                else
-                  response_agent.error = { error: "Not authorized!"}
-                end
-              else
-                response_agent = OpenStruct.new
-                response_agent.result = { response: { error: "Not a valid channel #{channel} for #{channel_class_name}!" }}
-                response_agent_array << response_agent
-              end
-            else
-              response_agent.error = { error: "Not a valid Channel class #{channel_class_name}!" }
-            end
-          rescue Exception => e
-            response_agent.error = { error: "Isomorfeus::Transport::ServerProcessor: #{e.message}\n#{e.backtrace.join("\n")}" }
-          end
-        elsif request.key?('unsubscribe') && request['unsubscribe'].key?('agent_ids')
-          begin
-            agent_id = request['unsubscribe']['agent_ids'].keys.first
-            response_agent = Isomorfeus::Transport::ResponseAgent.new(agent_id, request['unsubscribe']['agent_ids'][agent_id])
-            response_agent_array << response_agent
-            channel = response_agent.request['channel']
-            channel_class_name = response_agent.request['class']
-            if Isomorfeus.valid_channel_class_name?(channel_class_name) && channel
-              channel_class = Isomorfeus.cached_channel_class(channel_class_name)
-              if channel_class && channel_class.valid_channel?(channel)
-                if Isomorfeus.current_user.authorized?(channel_class, :unsubscribe, channel)
-                  Isomorfeus.pub_sub_client.unsubscribe("#{channel_class_name}_#{channel}")
-                  response_agent.agent_result = { success: channel }
-                else
-                  response_agent.error = { error: "Not authorized!"}
-                end
-              else
-                response_agent = OpenStruct.new
-                response_agent.result = { response: { error: "Not a valid channel #{channel} for #{channel_class_name}!" }}
-                response_agent_array << response_agent
-              end
-            else
-              response_agent.error = { error: "Not a valid Channel class #{channel_class_name}!" }
-            end
-          rescue Exception => e
-            response_agent.error = { error: "Isomorfeus::Transport::ServerProcessor: #{e.message}\n#{e.backtrace.join("\n")}" }
-          end
-        else
-          response_agent.error = { error: "No such thing!" }
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Isomorfeus
+  module Transport
+    module ServerProcessor
+      def process_request(request, handler_instance_cache, response_agent_array)
+        if request.key?('request') && request['request'].key?('agent_ids')
+          request['request']['agent_ids'].each_key do |agent_id|
+            request['request']['agent_ids'][agent_id].each_key do |handler_class_name|
+              response_agent = Isomorfeus::Transport::ResponseAgent.new(agent_id, request['request']['agent_ids'][agent_id][handler_class_name])
+              response_agent_array << response_agent
+              begin
+                handler = if handler_instance_cache.key?(handler_class_name)
+                            handler_instance_cache[handler_class_name]
+                          else
+                            handler_class = Isomorfeus.cached_handler_class(handler_class_name) if Isomorfeus.valid_handler_class_name?(handler_class_name)
+                            handler_instance_cache[handler_class_name] = handler_class.new if handler_class
+                          end
+                if handler
+                  handler.process_request(response_agent)
+                else
+                  response_agent.error = { error: { handler_class_name => 'No such handler!'}}
+                end
+              rescue Exception => e
+                response_agent.error = { response: { error: "#{handler_class_name}: #{e.message}\n#{e.backtrace.join("\n")}" }}
+              end
+            end
+          end
+        elsif request.key?('notification')
+          begin
+            channel = request['notification']['channel']
+            channel_class_name = request['notification']['class']
+            if Isomorfeus.valid_channel_class_name?(channel_class_name) && channel
+              channel_class = Isomorfeus.cached_channel_class(channel_class_name)
+              if channel_class && channel_class.valid_channel?(channel)
+                if Isomorfeus.current_user.authorized?(channel_class_name, :send_message, channel)
+                  allow_publish = if channel_class.server_is_processing_messages?(channel)
+                                    channel_class.server_process_message(request['notification']['message'], channel)
+                                  else
+                                    true
+                                  end
+                  if allow_publish == true
+                    Isomorfeus.pub_sub_client.publish("#{channel_class_name}_#{channel}", Oj.dump({ 'notification' => request['notification'] }, mode: :strict))
+                  else
+                    response_agent = OpenStruct.new
+                    response_agent.result = { notification: request['notification'].merge(error: 'Message cancelled!') }
+                    response_agent_array << response_agent
+                  end
+                else
+                  response_agent = OpenStruct.new
+                  response_agent.result = { notification: request['notification'].merge(error: 'Not authorized!') }
+                  response_agent_array << response_agent
+                end
+              else
+                response_agent = OpenStruct.new
+                response_agent.result = { notification: request['notification'].merge(error: "Not a valid channel #{channel} for #{channel_class_name}!") }
+                response_agent_array << response_agent
+              end
+            else
+              response_agent = OpenStruct.new
+              response_agent.result = { notification: request['notification'].merge(error: "Not a valid Channel class #{channel_class_name}!") }
+              response_agent_array << response_agent
+            end
+          rescue Exception => e
+            response_agent = OpenStruct.new
+            response_agent.result = { notification: request['notification'].merge(error: "Isomorfeus::Transport::ServerProcessor: #{e.message}\n#{e.backtrace.join("\n")}") }
+            response_agent_array << response_agent
+          end
+        elsif request.key?('subscribe') && request['subscribe'].key?('agent_ids')
+          begin
+            agent_id = request['subscribe']['agent_ids'].keys.first
+            response_agent = Isomorfeus::Transport::ResponseAgent.new(agent_id, request['subscribe']['agent_ids'][agent_id])
+            response_agent_array << response_agent
+            channel = response_agent.request['channel']
+            channel_class_name = response_agent.request['class']
+            if Isomorfeus.valid_channel_class_name?(channel_class_name) && channel
+              channel_class = Isomorfeus.cached_channel_class(channel_class_name)
+              if channel_class && channel_class.valid_channel?(channel)
+                if Isomorfeus.current_user.authorized?(channel_class, :subscribe, channel)
+                  Isomorfeus.pub_sub_client.subscribe("#{channel_class_name}_#{channel}")
+                  response_agent.agent_result = { success: channel }
+                else
+                  response_agent.error = { error: "Not authorized!"}
+                end
+              else
+                response_agent = OpenStruct.new
+                response_agent.result = { response: { error: "Not a valid channel #{channel} for #{channel_class_name}!" }}
+                response_agent_array << response_agent
+              end
+            else
+              response_agent.error = { error: "Not a valid Channel class #{channel_class_name}!" }
+            end
+          rescue Exception => e
+            response_agent.error = { error: "Isomorfeus::Transport::ServerProcessor: #{e.message}\n#{e.backtrace.join("\n")}" }
+          end
+        elsif request.key?('unsubscribe') && request['unsubscribe'].key?('agent_ids')
+          begin
+            agent_id = request['unsubscribe']['agent_ids'].keys.first
+            response_agent = Isomorfeus::Transport::ResponseAgent.new(agent_id, request['unsubscribe']['agent_ids'][agent_id])
+            response_agent_array << response_agent
+            channel = response_agent.request['channel']
+            channel_class_name = response_agent.request['class']
+            if Isomorfeus.valid_channel_class_name?(channel_class_name) && channel
+              channel_class = Isomorfeus.cached_channel_class(channel_class_name)
+              if channel_class && channel_class.valid_channel?(channel)
+                if Isomorfeus.current_user.authorized?(channel_class, :unsubscribe, channel)
+                  Isomorfeus.pub_sub_client.unsubscribe("#{channel_class_name}_#{channel}")
+                  response_agent.agent_result = { success: channel }
+                else
+                  response_agent.error = { error: "Not authorized!"}
+                end
+              else
+                response_agent = OpenStruct.new
+                response_agent.result = { response: { error: "Not a valid channel #{channel} for #{channel_class_name}!" }}
+                response_agent_array << response_agent
+              end
+            else
+              response_agent.error = { error: "Not a valid Channel class #{channel_class_name}!" }
+            end
+          rescue Exception => e
+            response_agent.error = { error: "Isomorfeus::Transport::ServerProcessor: #{e.message}\n#{e.backtrace.join("\n")}" }
+          end
+        else
+          response_agent.error = { error: "No such thing!" }
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/transport/server_socket_processor.rb

@@ -1,54 +1,54 @@
-module Isomorfeus
-  module Transport
-    class ServerSocketProcessor
-      include Isomorfeus::Transport::ServerProcessor
-
-      def on_message(client, data)
-        if Isomorfeus.development?
-          write_lock = Isomorfeus.zeitwerk_lock.try_write_lock
-          if write_lock
-            Isomorfeus.zeitwerk.reload
-            Isomorfeus.zeitwerk_lock.release_write_lock
-          end
-          Isomorfeus.zeitwerk_lock.acquire_read_lock
-        end
-        request_hash = Oj.load(data, mode: :strict)
-        handler_instance_cache = {}
-        response_agent_array = []
-        Thread.current[:isomorfeus_user] = user(client)
-        Thread.current[:isomorfeus_pub_sub_client] = client
-        process_request(request_hash, handler_instance_cache, response_agent_array)
-        handler_instance_cache.each_value do |handler|
-          handler.resolve if handler.resolving?
-        end
-        result = {}
-        response_agent_array.each do |response_agent|
-          result.deep_merge!(response_agent.result)
-        end
-        client.write Oj.dump(result, mode: :strict) unless result.empty?
-      ensure
-        Thread.current[:isomorfeus_user] = nil
-        Thread.current[:isomorfeus_pub_sub_client] = nil
-        Isomorfeus.zeitwerk_lock.release_read_lock if Isomorfeus.development?
-      end
-
-      def on_close(client)
-        # nothing for now
-      end
-
-      def on_open(client)
-        # nothing for now
-      end
-
-      def on_shutdown(client)
-        # nothing for now
-      end
-
-      def user(client)
-        current_user = client.instance_variable_get(:@isomorfeus_user)
-        return current_user if current_user
-        Anonymous.new
-      end
-    end
-  end
-end
+module Isomorfeus
+  module Transport
+    class ServerSocketProcessor
+      include Isomorfeus::Transport::ServerProcessor
+
+      def on_message(client, data)
+        if Isomorfeus.development?
+          write_lock = Isomorfeus.zeitwerk_lock.try_write_lock
+          if write_lock
+            Isomorfeus.zeitwerk.reload
+            Isomorfeus.zeitwerk_lock.release_write_lock
+          end
+          Isomorfeus.zeitwerk_lock.acquire_read_lock
+        end
+        request_hash = Oj.load(data, mode: :strict)
+        handler_instance_cache = {}
+        response_agent_array = []
+        Thread.current[:isomorfeus_user] = user(client)
+        Thread.current[:isomorfeus_pub_sub_client] = client
+        process_request(request_hash, handler_instance_cache, response_agent_array)
+        handler_instance_cache.each_value do |handler|
+          handler.resolve if handler.resolving?
+        end
+        result = {}
+        response_agent_array.each do |response_agent|
+          result.deep_merge!(response_agent.result)
+        end
+        client.write Oj.dump(result, mode: :strict) unless result.empty?
+      ensure
+        Thread.current[:isomorfeus_user] = nil
+        Thread.current[:isomorfeus_pub_sub_client] = nil
+        Isomorfeus.zeitwerk_lock.release_read_lock if Isomorfeus.development?
+      end
+
+      def on_close(client)
+        # nothing for now
+      end
+
+      def on_open(client)
+        # nothing for now
+      end
+
+      def on_shutdown(client)
+        # nothing for now
+      end
+
+      def user(client)
+        current_user = client.instance_variable_get(:@isomorfeus_user)
+        return current_user if current_user
+        Anonymous.new
+      end
+    end
+  end
+end

data/lib/isomorfeus/transport/ssr_login.rb

@@ -1,28 +1,28 @@
-module Isomorfeus
-  module Transport
-    class SsrLogin
-      def self.init
-        session_id = `global.IsomorfeusSessionId`
-        if session_id && session_id.size > 0
-          Isomorfeus::Transport.promise_send_path('Isomorfeus::Transport::Handler::AuthenticationHandler', 'ssr_login', session_id).then do |agent|
-            if agent.processed
-              agent.result
-            else
-              agent.processed = true
-              if agent.response.key?(:success)
-                Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.response[:data])
-                class_name = agent.response[:data].keys.first
-                key = agent.response[:data][class_name].keys.first
-                logged_in_user = Isomorfeus.cached_data_class(class_name).new(key: key)
-                Isomorfeus.set_current_user(logged_in_user)
-              else
-                error = agent.response[:error]
-                Isomorfeus.raise_error(message: "SSR Login failed, #{error}!") # triggers .fail
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
+module Isomorfeus
+  module Transport
+    class SsrLogin
+      def self.init
+        session_id = `global.IsomorfeusSessionId`
+        if session_id && session_id.size > 0
+          Isomorfeus::Transport.promise_send_path('Isomorfeus::Transport::Handler::AuthenticationHandler', 'ssr_login', session_id).then do |agent|
+            if agent.processed
+              agent.result
+            else
+              agent.processed = true
+              if agent.response.key?(:success)
+                Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.response[:data])
+                class_name = agent.response[:data].keys.first
+                key = agent.response[:data][class_name].keys.first
+                logged_in_user = Isomorfeus.cached_data_class(class_name).new(key: key)
+                Isomorfeus.set_current_user(logged_in_user)
+              else
+                error = agent.response[:error]
+                Isomorfeus.raise_error(message: "SSR Login failed, #{error}!") # triggers .fail
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/transport/version.rb

@@ -1,5 +1,5 @@
-module Isomorfeus
-  module Transport
-    VERSION = '1.0.0.zeta24'
-  end
-end
+module Isomorfeus
+  module Transport
+    VERSION = '2.0.0.rc3'
+  end
+end