xconn 0.1.0

data/lib/wamp/message_handler/published.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Wamp
+  module MessageHandler
+    # Published confirmation message
+    class Published < Base
+      def handle
+        validate_received_message
+
+        deliver_response(response)
+      end
+
+      def response
+        Type::Publication.new(publication_id: message.publication_id)
+      end
+    end
+  end
+end

data/lib/wamp/message_handler/register.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Wamp
+  module MessageHandler
+    # publish event to subscriber
+    class Register < Base
+      def send_message(handler, &callback)
+        store[store_key] = { handler: handler, callback: callback, procedure: message.procedure }
+
+        send_serialized message
+      end
+    end
+  end
+end

data/lib/wamp/message_handler/registered.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Wamp
+  module MessageHandler
+    # Registered callback
+    class Registered < Base
+      def handle
+        validate_received_message
+
+        store[alt_store_key] = { handler: stored_data.fetch(:handler), procedure: stored_data.fetch(:procedure) }
+        store_procedure
+
+        deliver_response(response)
+      end
+
+      def response
+        Type::Registration.new(registration_id: message.registration_id)
+      end
+
+      def alt_store_key
+        "registration_#{message.registration_id}"
+      end
+
+      def store_procedure
+        procedure = stored_data.fetch(:procedure)
+        store[procedure] = message.registration_id
+      end
+    end
+  end
+end

data/lib/wamp/message_handler/result.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Wamp
+  module MessageHandler
+    # Result
+    class Result < Base
+      def handle
+        validate_received_message
+        stored_data.fetch(:handler).call(response)
+      end
+
+      def response
+        Type::Result.new(args: message.args, kwargs: message.kwargs, details: message.details)
+      end
+    end
+  end
+end

data/lib/wamp/message_handler/subscribe.rb

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

data/lib/wamp/message_handler/subscribed.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Wamp
+  module MessageHandler
+    # Receive subscribed
+    class Subscribed < Base
+      def handle
+        validate_received_message
+
+        store[alt_store_key] = { handler: stored_data.fetch(:handler), topic: stored_data.fetch(:topic) }
+        store_topic
+
+        deliver_response(response)
+      end
+
+      def response
+        Type::Subscription.new(subscription_id: message.subscription_id)
+      end
+
+      def alt_store_key
+        "subscription_#{message.subscription_id}"
+      end
+
+      def store_topic
+        topic = stored_data.fetch(:topic)
+        store[topic] = message.subscription_id
+      end
+    end
+  end
+end

data/lib/wamp/message_handler/unregister.rb

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

data/lib/wamp/message_handler/unregistered.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Wamp
+  module MessageHandler
+    # callback for unregister message
+    class Unregistered < Base
+      def handle
+        validate_received_message
+
+        delete_procedure store.delete(alt_store_key)
+
+        deliver_response(response)
+      end
+
+      def response
+        Type::Success.new
+      end
+
+      def alt_store_key
+        "registration_#{registration_id}"
+      end
+
+      def delete_procedure(data)
+        store.delete data.fetch(:procedure)
+      end
+
+      def registration_id
+        stored_data.fetch(:registration_id)
+      end
+    end
+  end
+end

data/lib/wamp/message_handler/unsubscribe.rb

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

data/lib/wamp/message_handler/unsubscribed.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Wamp
+  module MessageHandler
+    # Receive unsubscribed
+    class Unsubscribed < Base
+      def handle
+        validate_received_message
+        delete_topic store.delete(alt_store_key)
+
+        deliver_response(response)
+      end
+
+      def response
+        Type::Success.new
+      end
+
+      private
+
+      def alt_store_key
+        "subscription_#{subscription_id}"
+      end
+
+      def delete_topic(data)
+        store.delete data.fetch(:topic)
+      end
+
+      def subscription_id
+        stored_data.fetch(:subscription_id)
+      end
+    end
+  end
+end

data/lib/wamp/message_handler/welcome.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Wamp
+  module MessageHandler
+    # Welcome
+    class Welcome < Base
+      def handle
+        connection.executor&.call(connection.api)
+      end
+    end
+  end
+end

data/lib/wamp/message_handler.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "message_handler/base"
+
+require_relative "message_handler/hello"
+require_relative "message_handler/welcome"
+require_relative "message_handler/challenge"
+require_relative "message_handler/goodbye"
+
+require_relative "message_handler/subscribe"
+require_relative "message_handler/subscribed"
+require_relative "message_handler/unsubscribe"
+require_relative "message_handler/unsubscribed"
+
+require_relative "message_handler/publish"
+require_relative "message_handler/published"
+require_relative "message_handler/event"
+
+require_relative "message_handler/call"
+require_relative "message_handler/result"
+
+require_relative "message_handler/register"
+require_relative "message_handler/registered"
+require_relative "message_handler/unregister"
+require_relative "message_handler/unregistered"
+
+require_relative "message_handler/invocation"
+
+require_relative "message_handler/error"
+
+require_relative "message_handler/api"
+
+module Wamp
+  # routes messages
+  module MessageHandler
+    # instantiate correct handler
+    module ClassMethods
+      def resolve(data, connection)
+        # return handle_when_not_joined(data, connection) unless connection.joiner.joined?
+
+        message = connection.joiner.serializer.deserialize(data)
+        klass_name = demodulize(message.class.name)
+        klass = constantize("Wamp::MessageHandler::#{klass_name}")
+        klass.new(message, connection)
+      end
+
+      def handle_when_not_joined(data, connection)
+        authenticate = connection.joiner.receive(data) # maybe welcome message then state should be joined
+        connection.transmit authenticate unless connection.joiner.joined?
+        connection.executor.call(connection.api) if connection.joiner.joined?
+        Struct.new(:handle).new
+      end
+
+      def from(message, connection)
+        klass_name = demodulize(message.class.name)
+        klass = constantize("Wamp::MessageHandler::#{klass_name}")
+        klass.new(message, connection)
+      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

data/lib/wamp/router/base.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "realm"
+
+module Wamp
+  module Router
+    # Router
+    class Base
+      attr_reader :realms
+
+      def initialize
+        @realms = {}
+      end
+
+      def add_realm(name)
+        realms[name] = Realm.new(name)
+      end
+
+      def remove_realm(name)
+        realms.delete(name)
+      end
+
+      def attach_client(client)
+        error_message = "cannot attach client to non-existent realm #{client.realm}"
+        raise Wampproto::ValueError, error_message unless realms.include?(client.realm)
+
+        realms[client.realm].attach_client(client)
+      end
+
+      def detach_client(client)
+        error_message = "cannot attach client to non-existent realm #{client.realm}"
+        raise Wampproto::ValueError, error_message unless realms.include?(client.realm)
+
+        realms[client.realm].detach_client(client)
+      end
+
+      def receive_message(client, message)
+        error_message = "cannot attach client to non-existent realm #{client.realm}"
+        raise Wampproto::ValueError, error_message unless realms.include?(client.realm)
+
+        realms[client.realm].receive_message(client.session_id, message)
+      end
+    end
+  end
+end

data/lib/wamp/router/client.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "realm"
+
+module Wamp
+  module Router
+    # Auth
+    class Authenticator
+      def self.authenticate(request)
+        Wampproto::Acceptor::Response.new(request.authid, "role", "secret")
+      end
+    end
+
+    # Server Session
+    class Client
+      attr_accessor :router, :connection
+      attr_reader   :acceptor, :serializer
+
+      def initialize(serializer = Wampproto::Serializer::JSON, authenticator = Authenticator)
+        @serializer = serializer
+        @acceptor = Wampproto::Acceptor.new(serializer, authenticator)
+      end
+
+      def realm
+        acceptor.session_details&.realm
+      end
+
+      def send_message(message)
+        transmit(message)
+      end
+
+      def session_id
+        acceptor.session_details&.session_id
+      end
+
+      def transmit(data)
+        case data
+        when Wampproto::Message::Base
+          connection.on_message serializer.serialize(data)
+        else
+          connection.on_message data
+        end
+      end
+
+      def on_message(data)
+        unless acceptor.accepted?
+          msg, is_welcome = acceptor.receive(data)
+          transmit msg
+          router.attach_client(self) if is_welcome
+        end
+        router.receive_message(self, serializer.deserialize(data))
+      end
+    end
+  end
+end

data/lib/wamp/router/connection.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "websocket/driver"
+
+# Testing
+class Authenticator
+  def self.authenticate(request)
+    Wampproto::Acceptor::Response.new(request.authid, "role")
+  end
+end
+
+module Wamp
+  module Router
+    # TOP Level Doc
+    class Connection < Client # rubocop:disable Metrics/ClassLength
+      include WebSocket::Driver::EventEmitter
+      CONNECTING = 0
+      OPEN       = 1
+      CLOSING    = 2
+      CLOSED     = 3
+
+      attr_reader :socket, :session, :acceptor
+
+      def initialize(socket, &cleanup)
+        super()
+        @cleanup = cleanup
+        @socket = socket
+        @driver = WebSocket::Driver.server(self)
+        @driver.on(:open) { on_open(_1) }
+        @driver.on(:message) { on_message(_1.data) }
+        @driver.on(:close) { |evt| begin_close(evt.reason, evt.code) }
+        @driver.on(:connect) { on_connect }
+        @ready_state = CONNECTING
+      end
+
+      def on_connect
+        @driver.start if WebSocket::Driver.websocket?(@driver.env)
+        choose_serializer_from @driver.env["HTTP_SEC_WEBSOCKET_PROTOCOL"]
+        @acceptor = Wampproto::Acceptor.new(serializer, Authenticator)
+      end
+
+      def connection
+        self
+      end
+
+      def begin_close(reason, code)
+        return if @ready_state == CLOSED
+
+        @ready_state = CLOSING
+        @close_params = [reason, code]
+
+        @cleanup&.call(self)
+        finalize_close
+      end
+
+      def finalize_close
+        return if @ready_state == CLOSED
+
+        @ready_state = CLOSED
+        @driver.close
+        socket.close
+      end
+
+      def listen(&block) # rubocop:disable Metrics/MethodLength
+        return unless [CONNECTING, OPEN].include?(@ready_state)
+
+        begin
+          data = socket.read_nonblock(4096, exception: false)
+          case data
+          when :wait_readable
+            # do nothing
+          when nil
+            block&.call
+            @driver.close
+          else
+            receive_data(data)
+          end
+        rescue StandardError => e
+          puts e.message
+          puts e.backtrace
+          begin
+            block&.call
+            @driver.close
+          rescue StandardError
+            # Errno::ECONNRESET
+            puts "Failed to handle: Errno::ECONNRESET"
+          end
+        end
+      end
+
+      # triggers on_message
+      def receive_data(data)
+        return unless [OPEN, CONNECTING].include?(@ready_state)
+
+        @driver.parse(data)
+      end
+
+      # called when @driver.text is invoked
+      def write(data)
+        socket.write(data)
+      end
+
+      def transmit(message)
+        # return false if @ready_state > OPEN
+
+        case message
+        when Wampproto::Message::Base then transmit(serializer.serialize(message))
+        when Numeric then @driver.text(message.to_s)
+        when String  then @driver.text(message)
+        when Array   then @driver.binary(message)
+        else false
+        end
+      end
+
+      private
+
+      def on_open(_evt)
+        return unless @ready_state == CONNECTING
+
+        @ready_state = OPEN
+      end
+
+      def on_close(message)
+        return if @ready_state == CLOSED
+
+        @ready_state = CLOSED
+        socket.close
+        @driver.close(message.code, message.reason)
+      end
+
+      def close(_code, _reason)
+        @driver.close
+      end
+
+      attr_reader :serializer
+
+      def choose_serializer_from(protocols)
+        @serializer = if protocols.include?("wamp.2.msgpack")
+          Wampproto::Serializer::Msgpack
+        elsif protocols.include?("wamp.2.cbor")
+          Wampproto::Serializer::Cbor
+        elsif protocols.include?("wamp.2.json")
+          Wampproto::Serializer::JSON
+        else
+          close
+        end
+      end
+    end
+  end
+end

data/lib/wamp/router/realm.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Wamp
+  module Router
+    # Realm
+    class Realm
+      attr_reader :broker, :dealer, :name, :clients
+
+      DEALER_MESSAGES = [
+        Wampproto::Message::Call,
+        Wampproto::Message::Yield,
+        Wampproto::Message::Register,
+        Wampproto::Message::Unregister
+      ].freeze
+
+      BROKER_MESSAGES = [
+        Wampproto::Message::Publish,
+        Wampproto::Message::Subscribe,
+        Wampproto::Message::Unsubscribe
+      ].freeze
+
+      GOODBYE_MESSAGE = Wampproto::Message::Goodbye
+
+      def initialize(name)
+        @name   = name
+        @broker = Wampproto::Broker.new(id_gen)
+        @dealer = Wampproto::Dealer.new(id_gen)
+        @clients = {}
+      end
+
+      def attach_client(client)
+        session_id = client.session_id
+        session_details = client.acceptor.session_details
+
+        clients[session_id] = client
+        broker.add_session(session_details)
+        dealer.add_session(session_details)
+      end
+
+      def detach_client(client)
+        remove_client(client.session_id)
+      end
+
+      def clear
+        clients.each { |client| remove_client(client.session_id) }
+      end
+
+      def receive_message(session_id, message)
+        case message
+        when *DEALER_MESSAGES then handle_dealer(session_id, message)
+        when *BROKER_MESSAGES then handle_broker(session_id, message)
+        when GOODBYE_MESSAGE then handle_goodbye(session_id, message)
+        end
+      end
+
+      private
+
+      def handle_dealer(session_id, message)
+        send_message dealer.receive_message(session_id, message)
+      end
+
+      def handle_broker(session_id, message)
+        send_message broker.receive_message(session_id, message)
+      end
+
+      def handle_goodbye(session_id, _message)
+        goodbye = Wampproto::Message::Goodbye.new({}, "wamp.close.goodbye_and_out")
+        send_message Wampproto::MessageWithRecipient.new(goodbye, session_id)
+      end
+
+      def send_message(message_with_receipient)
+        Array(message_with_receipient).each do |object|
+          client = clients[object.recipient]
+
+          next unless client
+
+          client.send_message object.message
+        end
+      end
+
+      def id_gen
+        @id_gen ||= Wampproto::IdGenerator.new
+      end
+
+      def remove_client(session_id)
+        broker.remove_session(session_id)
+        dealer.remove_session(session_id)
+        clients.delete(session_id)
+      end
+    end
+  end
+end