xconn 0.1.0

data/lib/wamp/manager/hello_event.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module Wamp
+  module Manager
+    # handles hello event
+    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 self.instance_from(message, session)
+        klass_name = demodulize(message.class.name)
+        klass = constantize("Wamp::Manager::#{klass_name}Event")
+        klass.new(message, session)
+      end
+
+      def self.demodulize(path)
+        path = path.to_s
+        if i = path.rindex("::") # rubocop:disable Lint/AssignmentInCondition
+          path[(i + 2), path.length]
+        else
+          path
+        end
+      end
+
+      def self.constantize(camel_cased_word)
+        Object.const_get(camel_cased_word)
+      end
+    end
+
+    # message
+    class HelloEvent < Base
+      def add_event_listener
+        session.transmit(payload)
+      end
+
+      def emit_event_name
+        raise RuntimeError
+      end
+
+      def listen_event_name
+        :join
+      end
+    end
+
+    # Welcome Event
+    class WelcomeEvent < Base
+      def emit_event_name
+        :join
+      end
+
+      def emit_event(_message)
+        session.emit(emit_event_name, @session)
+      end
+    end
+
+    # Abort Event
+    class AbortEvent < Base
+      def emit_event_name
+        :close
+      end
+
+      def emit_event(message)
+        session.emit(emit_event_name, message)
+        session.close(1000, message.reason)
+      end
+    end
+
+    class GoodbyeEvent < AbortEvent
+    end
+
+    # Error Event
+    class ErrorEvent < Base
+      def emit_event_name
+        "request_#{request_id}"
+      end
+
+      def emit_event(message)
+        session.emit(emit_event_name, nil, message)
+      end
+    end
+
+    # Subscribe Event
+    class SubscribeEvent < Base
+      def emit_event_name
+        raise RuntimeError
+      end
+
+      def add_event_listener(listener, &block)
+        session.on(listen_event_name) do |subscribed, error|
+          session.off(listen_event_name)
+          block.call(subscribed, error) if block_given?
+          manager = SubscribedEvent.new(subscribed, session)
+          manager.add_event_listener(listener)
+        end
+        session.transmit(payload)
+      end
+
+      def listen_event_name
+        "request_#{request_id}"
+      end
+    end
+
+    # Subscribe Event
+    class SubscribedEvent < Base
+      def emit_event_name
+        "request_#{request_id}"
+      end
+
+      def emit_event(message)
+        session.emit(emit_event_name, message)
+      end
+
+      def add_event_listener(listener)
+        session.on(listen_event_name, listener)
+      end
+
+      def listen_event_name
+        "event_#{subscription_id}"
+      end
+    end
+
+    # Event Event
+    class EventEvent < Base
+      def emit_event_name
+        "event_#{subscription_id}"
+      end
+
+      def emit_event(message)
+        session.emit(emit_event_name, message)
+      end
+
+      def listen_event_name
+        raise NotImplementedError
+      end
+    end
+
+    # Publish Event
+    class PublishEvent < Base
+      def emit_event_name
+        raise NotImplementedError
+      end
+
+      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
+
+      def listen_event_name
+        "request_#{request_id}"
+      end
+    end
+
+    # Published Event
+    class PublishedEvent < Base
+      def emit_event_name
+        "request_#{request_id}"
+      end
+
+      def emit_event(message)
+        session.emit(emit_event_name, message)
+      end
+
+      def listen_event_name
+        "request_#{request_id}"
+      end
+    end
+
+    # Call Message Decorator
+    class CallEvent < Base
+      def listen_event_name
+        "request_#{request_id}"
+      end
+
+      def add_event_listener(&block)
+        session.on(listen_event_name) do |result, error|
+          session.off(listen_event_name)
+          block.call(result, error)
+        end
+        session.transmit(payload)
+      end
+    end
+
+    # Call Result Message Decorator
+    class ResultEvent < Base
+      def emit_event_name
+        "request_#{request_id}"
+      end
+    end
+
+    # Unregister Messagae Decorator
+    class UnregisterEvent < Base
+      def listen_event_name
+        "request_#{request_id}"
+      end
+
+      def add_event_listener(&block)
+        session.transmit(payload)
+        session.on(listen_event_name) do |unregistered, error|
+          block&.call(unregistered, error)
+        end
+      end
+    end
+
+    # Register Message Decorator
+    class RegisterEvent < Base
+      def listen_event_name
+        "request_#{request_id}"
+      end
+
+      def add_event_listener(handler, &block)
+        session.transmit(payload)
+        session.on(listen_event_name) do |registered, error|
+          session.off(listen_event_name)
+          manager = RegisteredEvent.new(registered, session)
+          manager.add_event_listener(handler)
+          block.call(registered, error)
+        end
+      end
+    end
+
+    # Registered Message Decorator
+    class RegisteredEvent < Base
+      def emit_event_name
+        "request_#{request_id}"
+      end
+
+      # 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|
+          result = handler.call(invocation)
+          message = Message::Yield.new(invocation.request_id, {}, result)
+          session.transmit(message.payload)
+        end
+      end
+    end
+
+    # Invocation Message Decorator
+    class InvocationEvent < Base
+      def emit_event_name
+        "registration_#{registration_id}"
+      end
+    end
+  end
+end

data/lib/wamp/manager/session.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Wamp
+  module Manager
+    # handles session
+    class Session
+      extend Forwardable
+
+      attr_reader :connection, :session_id
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def session_id=(id)
+        if session_id
+          send_protocol_violation("Received WELCOME message after session was established")
+        else
+          @session_id = id
+        end
+      end
+
+      def send_protocol_violation(text, *args, **kwargs)
+        message = Message::Abort.new({ message: text }, "wamp.error.protocol_violation", *args, **kwargs)
+        manager = Manager::Event::Abort.new(message, self)
+        connection.transmit(message.payload)
+        manager.emit_event(message)
+      end
+
+      def subscribe(topic, handler, options = {}, &block)
+        message = Message::Subscribe.new(next_request_id, options, topic)
+        manager = Manager::Event::Subscribe.new(message, self)
+        manager.add_event_listener(handler, &block)
+        manager.subscription
+      end
+
+      def unsubscribe(subscription_id, &block)
+        message = Message::Unsubscribe.new(next_request_id, subscription_id)
+        Subscription.new(message, self, subscription_id).unsubscribe(&block)
+      end
+
+      def publish(topic, options = {}, *args, **kwargs, &block)
+        options = options.merge({ acknowledge: true }) if block_given?
+        message = Message::Publish.new(next_request_id, options, topic, *args, **kwargs)
+        Manager::Event::Publish.new(message, self).add_event_listener(&block)
+      end
+
+      def call(procedure, options = {}, *args, **kwargs, &block)
+        message = Message::Call.new(next_request_id, options, procedure, *args, **kwargs)
+        Manager::Event::Call.new(message, self).add_event_listener(&block)
+      end
+
+      def register(procedure, handler, options = {}, &block)
+        message = Message::Register.new(next_request_id, options, procedure)
+        Manager::Event::Register.new(message, self).add_event_listener(handler, &block)
+      end
+
+      def unregister(registration_id, &block)
+        message = Message::Unregister.new(next_request_id, registration_id)
+        Manager::Event::Unregister.new(message, self).add_event_listener(&block)
+      end
+
+      def on_message(message)
+        manager = Manager::Event.resolve(message, self)
+        manager.emit_event(message)
+      end
+
+      def create_request_id
+        next_request_id
+      end
+
+      private
+
+      def next_request_id
+        @next_request_id = create_request_id_generator unless defined?(@next_request_id)
+        @next_request_id.call
+      end
+
+      def create_request_id_generator
+        request_id = 0
+        -> { request_id += 1 }
+      end
+
+      def_delegators :@connection, :emit, :on, :close, :transmit, :my_listeners, :auth
+      def_delegator :auth, :authenticate
+      def_delegator :@connection, :remove_all_listeners, :off
+    end
+  end
+end

data/lib/wamp/manager/subscription.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Wamp
+  module Manager
+    # User facing subscripiton record
+    class Subscription
+      attr_accessor :subscription_id
+      attr_reader :message, :session
+
+      def initialize(message, session, subscription_id = nil)
+        @message = message
+        @session = session
+        @subscription_id = subscription_id
+      end
+
+      def subscribed?
+        !!subscription_id
+      end
+
+      def unsubscribe(&callback)
+        return false unless subscribed?
+
+        message = Wamp::Message::Unsubscribe.new(next_request_id, subscription_id)
+        manager = Wamp::Manager::Event::Unsubscribe.new(message, session)
+        manager.add_event_listener(callback)
+      end
+
+      def next_request_id
+        case message
+        when Wamp::Message::Subscribe
+          session.create_request_id
+        when Wamp::Message::Unsubscribe
+          message.request_id
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "manager/session"
+require_relative "manager/event"
+require_relative "manager/base"
+require_relative "manager/connection"
+
+module Wamp
+  # manager
+  module Manager
+  end
+end

data/lib/wamp/message_handler/api.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Wamp
+  module MessageHandler
+    # handles session
+    class Api
+      extend Forwardable
+
+      attr_reader :connection, :session_id, :id_gen
+
+      def initialize(connection)
+        @connection = connection
+        @id_gen = Wampproto::IdGenerator.new
+      end
+
+      def subscribe(topic, handler, options = {}, &block)
+        message = Wampproto::Message::Subscribe.new(next_request_id, options, topic)
+        action = MessageHandler::Subscribe.new(message, connection)
+        action.send_message(handler, &block)
+      end
+
+      def unsubscribe(subscription_id, &block)
+        subscription_id = connection.store[subscription_id] if connection.store.include?(subscription_id)
+
+        message = Wampproto::Message::Unsubscribe.new(next_request_id, subscription_id.to_i)
+        action = MessageHandler::Unsubscribe.new(message, connection)
+        action.send_message(&block)
+      end
+
+      def publish(topic, options = {}, *args, **kwargs, &block)
+        options = options.merge({ acknowledge: true }) if block_given?
+        message = Wampproto::Message::Publish.new(next_request_id, options, topic, *args, **kwargs)
+
+        action = MessageHandler::Publish.new(message, connection)
+        action.send_message(&block)
+      end
+
+      def call(procedure, options = {}, *args, **kwargs, &handler)
+        message = Wampproto::Message::Call.new(next_request_id, options, procedure, *args, **kwargs)
+
+        MessageHandler::Call.new(message, connection).send_message(handler)
+      end
+
+      def register(procedure, handler, options = {}, &block)
+        message = Wampproto::Message::Register.new(next_request_id, options, procedure)
+        action = MessageHandler::Register.new(message, connection)
+        action.send_message(handler, &block)
+      end
+
+      def unregister(registration_id, &block)
+        registration_id = connection.store[registration_id] if connection.store.include?(registration_id)
+
+        message = Wampproto::Message::Unregister.new(next_request_id, registration_id.to_i)
+        action = MessageHandler::Unregister.new(message, connection)
+        action.send_message(&block)
+      end
+
+      private
+
+      def next_request_id
+        id_gen.next
+      end
+    end
+  end
+end

data/lib/wamp/message_handler/base.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Wamp
+  module MessageHandler
+    # Result
+    class Base
+      extend Forwardable
+      attr_reader :message, :connection
+
+      def initialize(message, connection)
+        @message = message
+        @connection = connection
+      end
+
+      def handle
+        raise NotImplementedError
+      end
+
+      def send_message
+        raise NotImplementedError
+      end
+
+      private
+
+      def stored_data
+        @stored_data ||= store.delete(store_key) || {}
+      end
+
+      def store_key
+        "#{prefix}_#{identity}"
+      end
+
+      def prefix
+        "request"
+      end
+
+      def identity
+        message.request_id
+      end
+
+      def deliver_response(response)
+        callback = stored_data.fetch(:callback, proc {})
+        return unless callback
+
+        return callback.call(response) unless response.nil?
+
+        callback.call(message)
+      end
+
+      def validate_received_message
+        connection.session.receive_message(message)
+      end
+
+      def send_serialized(message)
+        connection.transmit session.send_message(message)
+      end
+
+      def_delegators :@connection, :store, :joiner, :session
+      # def_delegator :auth, :authenticate
+      # def_delegator :@connection, :remove_all_listeners, :off
+    end
+  end
+end

data/lib/wamp/message_handler/call.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Wamp
+  module MessageHandler
+    # Call
+    class Call < Base
+      def send_message(handler)
+        store[store_key] = { handler: handler, callback: handler }
+
+        send_serialized message
+      end
+    end
+  end
+end

data/lib/wamp/message_handler/challenge.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Wamp
+  module MessageHandler
+    # Challenge
+    class Challenge < Hello
+      def handle
+        connection.transmit connection.joiner.receive(connection.joiner.serializer.serialize(message))
+      end
+    end
+  end
+end

data/lib/wamp/message_handler/error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Wamp
+  module MessageHandler
+    # Call handler with error message
+    class Error < Base
+      def handle
+        validate_received_message
+
+        stored_data[:callback].call(response)
+      end
+
+      def response
+        Type::Error.new(uri: message.error, details: message.details)
+      end
+    end
+  end
+end

data/lib/wamp/message_handler/event.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Wamp
+  module MessageHandler
+    # publish event to subscriber
+    class Event < Base
+      def handle
+        validate_received_message
+
+        store[alt_store_key].fetch(:handler).call(message)
+      end
+
+      def alt_store_key
+        "subscription_#{message.subscription_id}"
+      end
+    end
+  end
+end

data/lib/wamp/message_handler/goodbye.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Wamp
+  module MessageHandler
+    # send unregister message
+    class Goodbye < Base
+      def send_message(&callback)
+        store[store_key] = { callback: callback }
+
+        send_serialized message
+      end
+
+      def handle
+        goodbye = Wampproto::Message::Goodbye.new({}, "wamp.close.goodbye_and_out")
+        send_serialized goodbye
+      end
+    end
+  end
+end

data/lib/wamp/message_handler/hello.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Wamp
+  module MessageHandler
+    # Hello
+    class Hello < Base
+      def handle
+        msg, is_welcome = connection.acceptor.receive(connection.serializer.serialize(message))
+        connection.transmit msg
+        connection.router.attach_client(connection) if is_welcome
+      end
+
+      def send_message
+        connection.transmit connection.joiner.send_hello
+      end
+    end
+  end
+end

data/lib/wamp/message_handler/invocation.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Wamp
+  module MessageHandler
+    # Call
+    class Invocation < Base
+      def handle
+        connection.session.receive_message(message)
+        data = store.fetch(alt_store_key)
+
+        send_yield_message data.fetch(:handler)
+      end
+
+      def alt_store_key
+        "registration_#{message.registration_id}"
+      end
+
+      def invocation_response
+        Type::Invocation.new(args: message.args, kwargs: message.kwargs, details: message.details)
+      end
+
+      private
+
+      def send_yield_message(handler)
+        result = handler.call(invocation_response)
+        yield_message = if result.instance_of?(Type::Result)
+          Wampproto::Message::Yield.new(message.request_id, result.details, *result.args, **result.kwargs)
+        else
+          Wampproto::Message::Yield.new(message.request_id, {}, result)
+        end
+        send_serialized yield_message
+      end
+    end
+  end
+end

data/lib/wamp/message_handler/publish.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Wamp
+  module MessageHandler
+    # Publish message
+    class Publish < Base
+      def send_message(&callback)
+        store[store_key] = { callback: callback } if message.options[:acknowledge]
+
+        send_serialized message
+      end
+    end
+  end
+end