xconn 0.1.0

data/lib/wamp/manager/event/authenticate.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Wamp
+  module Manager
+    module Event
+      # Authenticate
+      class Authenticate < Base
+        def emit_event_name
+          :authenticate
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/base.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module Wamp
+  module Manager
+    # no:doc
+    module Event
+      # Base Class for Listening and Emitting events
+      # Each event should base as parent class
+      class Base < SimpleDelegator
+        attr_reader :session
+
+        def initialize(message, session)
+          super(message)
+          @session = session
+        end
+
+        def emit_event(message)
+          session.emit(emit_event_name, message)
+        end
+
+        def transmit
+          session.transmit(payload)
+        end
+
+        def listen_event_name
+          "request_#{request_id}"
+        end
+
+        def emit_event_name
+          "request_#{request_id}"
+        end
+
+        def error?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/call.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wamp
+  module Manager
+    module Event
+      # Call Message Event
+      class Call < Base
+        def add_event_listener(&block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          on_progress = options.delete(:on_progress)
+          options.merge!(receive_progress: true) if on_progress
+
+          session.on(listen_event_name) do |result, error|
+            if error
+              block&.call(nil, error)
+            elsif result && result.details["progress"]
+              on_progress.call(result)
+            else
+              session.off(listen_event_name)
+              block&.call(result, nil)
+            end
+          end
+          session.transmit(payload)
+        end
+
+        def emit_event(message)
+          manager = Wamp::Router::Registrations.invoke(message, session)
+          return manager.transmit if manager.error?
+
+          # Invocation Manager Receives Yield Message
+          manager.add_event_listener do |yield_msg|
+            result = Message::Result.new(message.request_id, {}, *yield_msg.args, **yield_msg.kwargs)
+            session.transmit(result.payload)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/challenge.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "openssl"
+
+module Wamp
+  module Manager
+    module Event
+      # Welcome Message Event
+      class Challenge < Base
+        def emit_event_name
+          :challenge
+        end
+
+        def emit_event(challenge)
+          session.emit(emit_event_name, challenge)
+          send_authenticate(session.authenticate(challenge))
+        end
+
+        def send_authenticate(authenticate)
+          session.transmit(authenticate.payload)
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/error.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wamp
+  module Manager
+    module Event
+      # Welcome Message Event
+      class Error < Base
+        def emit_event_name
+          "request_#{request_id}"
+        end
+
+        def emit_event(message)
+          session.emit(emit_event_name, nil, message)
+
+          begin
+            raise message.error if message.error
+          rescue StandardError => e
+            puts "Error: #{e.message}"
+          end
+        end
+
+        def error?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/event.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wamp
+  module Manager
+    module Event
+      # Event Message Event
+      class Event < Base
+        def emit_event_name
+          "event_#{subscription_id}"
+        end
+
+        def emit_event(message)
+          session.emit(emit_event_name, message)
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/goodbye.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "abort"
+
+module Wamp
+  module Manager
+    module Event
+      # Abort Message Event
+      class Goodbye < Abort
+        def emit_event(_message)
+          reply = Message::Goodbye.new({}, "wamp.close.goodbye_and_out")
+          session.transmit(reply.payload)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/hello.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../../router"
+
+module Wamp
+  module Manager
+    module Event
+      # Hello Message Event
+      class Hello < Base
+        def add_event_listener
+          session.transmit(payload)
+        end
+
+        def emit_event(hello)
+          session.emit(:authenticate, hello) # handle second hello message
+          auth_session = Wamp::Router::Session::Base.new(hello)
+          message = update_session_id_and_return(auth_session.handle_auth)
+          session.transmit(message.payload)
+
+          session.on(:authenticate) do |authenticate|
+            welcome_or_error = update_session_id_and_return(auth_session.authenticate(authenticate))
+            session.transmit(welcome_or_error.payload)
+          end
+        end
+
+        def update_session_id_and_return(message)
+          session.session_id = message.session_id if message.respond_to?(:session_id) # welcome message
+          message
+        end
+
+        def listen_event_name
+          :join
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/invocation.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wamp
+  module Manager
+    module Event
+      # Unregistered Message Event
+      class Invocation < Base
+        def add_event_listener(&callback)
+          session.on(listen_event_name) do |yield_msg|
+            session.off(listen_event_name)
+            callback.call(yield_msg)
+          end
+          transmit
+        end
+
+        def emit_event_name
+          "registration_#{registration_id}"
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/publish.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wamp
+  module Manager
+    module Event
+      # Publish Message Event
+      class Publish < Base
+        def add_event_listener(&block)
+          session.transmit(payload)
+          return unless block_given?
+
+          session.on(listen_event_name) do |publication|
+            session.off(listen_event_name)
+            block.call(publication, nil)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/published.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wamp
+  module Manager
+    module Event
+      # Published Message Event
+      class Published < Base
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/register.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "registered"
+
+module Wamp
+  module Manager
+    module Event
+      # Register Message Event
+      class Register < Base
+        def add_event_listener(handler, &block)
+          session.transmit(payload)
+          session.on(listen_event_name) do |registered, error|
+            session.off(listen_event_name)
+            block&.call(registered, error)
+
+            unless error
+              manager = Registered.new(registered, session)
+              manager.add_event_listener(handler)
+            end
+          end
+        end
+
+        def emit_event(message)
+          msg = Wamp::Router::Registrations.register(message, session)
+          session.transmit(msg.payload)
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/registered.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wamp
+  module Manager
+    module Event
+      # Registered Message Event
+      class Registered < Base
+        # Adding listener for invocation message
+        def listen_event_name
+          "registration_#{registration_id}"
+        end
+
+        def add_event_listener(handler)
+          session.on(listen_event_name) do |invocation|
+            details = {}
+            details = { details: yield_method(invocation) } if invocation.details["receive_progress"]
+            result = handler.call(*invocation.args, **invocation.kwargs, **details)
+            message = Message::Yield.new(invocation.request_id, {}, result)
+            session.transmit(message.payload)
+          end
+        end
+
+        def yield_method(invocation)
+          klass = Struct.new(:invocation, :session) do
+            def progress(*args, **kwargs)
+              message = Message::Yield.new(invocation.request_id, { progress: true }, *args, **kwargs)
+              session.transmit(message.payload)
+            end
+          end
+          klass.new(invocation, session)
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/result.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wamp
+  module Manager
+    module Event
+      # Result Message Event
+      class Result < Base
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/subscribe.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "subscribed"
+
+module Wamp
+  module Manager
+    module Event
+      # Subscribe Message Event
+      class Subscribe < Base
+        def subscription
+          @subscription ||= Subscription.new(__getobj__, session)
+        end
+
+        def add_event_listener(listener, &block)
+          session.on(listen_event_name) do |subscribed, error|
+            subscription.subscription_id = subscribed.subscription_id if subscribed
+
+            session.off(listen_event_name)
+            block.call(subscribed, error) if block_given?
+            add_subscribed_event_listner(subscribed, listener)
+          end
+          session.transmit(payload)
+        end
+
+        def listen_event_name
+          "request_#{request_id}"
+        end
+
+        private
+
+        def add_subscribed_event_listner(message, listener)
+          manager = Subscribed.new(message, session)
+          manager.add_event_listener(listener)
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/subscribed.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wamp
+  module Manager
+    module Event
+      # Subscribed Message Event
+      class Subscribed < Base
+        def add_event_listener(listener)
+          session.on(listen_event_name) do |event|
+            listener.call(*event.args, **event.kwargs)
+          end
+        end
+
+        def emit_event_name
+          "request_#{request_id}"
+        end
+
+        def listen_event_name
+          "event_#{subscription_id}"
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/unregister.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wamp
+  module Manager
+    module Event
+      # Unregister Message Event
+      class Unregister < Base
+        def add_event_listener(&block)
+          session.transmit(payload)
+          session.on(listen_event_name) do |unregistered, error|
+            block&.call(unregistered, error)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/unregistered.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wamp
+  module Manager
+    module Event
+      # Unregistered Message Event
+      class Unregistered < Base
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/unsubscribe.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wamp
+  module Manager
+    module Event
+      # Unsubscribe Message Event
+      class Unsubscribe < Base
+        def add_event_listener(handler)
+          session.on(listen_event_name) do |unsubscribed, error|
+            session.off(listen_event_name)
+            handler&.call(unsubscribed, error)
+            remove_event_listening
+          end
+          session.transmit(payload)
+        end
+
+        def remove_event_listening
+          session.off(clear_event_name)
+        end
+
+        def clear_event_name
+          "event_#{subscription_id}"
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/unsubscribed.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wamp
+  module Manager
+    module Event
+      # Unsubscribed Message Event
+      class Unsubscribed < Base
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/welcome.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wamp
+  module Manager
+    module Event
+      # Welcome Message Event
+      class Welcome < Base
+        def emit_event_name
+          :join
+        end
+
+        def emit_event(welcome)
+          session.session_id = welcome.session_id
+          session.emit(emit_event_name, session)
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/event/yield.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wamp
+  module Manager
+    module Event
+      #  Yield Message Event
+      class Yield < Base
+      end
+    end
+  end
+end

data/lib/wamp/manager/event.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "event/hello"
+require_relative "event/welcome"
+require_relative "event/abort"
+require_relative "event/challenge"
+require_relative "event/authenticate"
+require_relative "event/goodbye"
+
+require_relative "event/error"
+
+require_relative "event/subscribe"
+require_relative "event/subscribed"
+require_relative "event/unsubscribe"
+require_relative "event/unsubscribed"
+require_relative "event/publish"
+require_relative "event/published"
+require_relative "event/event"
+
+require_relative "event/call"
+require_relative "event/result"
+
+require_relative "event/register"
+require_relative "event/registered"
+
+require_relative "event/unregister"
+require_relative "event/unregistered"
+
+require_relative "event/invocation"
+require_relative "event/yield"
+
+module Wamp
+  module Manager
+    # handles creating correct event managers
+    module Event
+      # methods responsbile for instantiating correct event
+      module ClassMethods
+        def resolve(message, session)
+          klass_name = demodulize(message.class.name)
+          klass = constantize("Wamp::Manager::Event::#{klass_name}")
+          klass.new(message, session)
+        end
+
+        def demodulize(path)
+          path = path.to_s
+          if i = path.rindex("::") # rubocop:disable Lint/AssignmentInCondition
+            path[(i + 2), path.length]
+          else
+            path
+          end
+        end
+
+        def constantize(camel_cased_word)
+          Object.const_get(camel_cased_word)
+        end
+      end
+      extend ClassMethods
+    end
+  end
+end