wampproto 0.1.0

data/lib/wampproto/message.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative "message/base"
+require_relative "message/hello"
+require_relative "message/welcome"
+require_relative "message/abort"
+require_relative "message/challenge"
+require_relative "message/authenticate"
+require_relative "message/goodbye"
+
+require_relative "message/error"
+
+require_relative "message/publish"
+require_relative "message/published"
+
+require_relative "message/subscribe"
+require_relative "message/subscribed"
+require_relative "message/unsubscribe"
+require_relative "message/unsubscribed"
+require_relative "message/event"
+
+require_relative "message/call"
+require_relative "message/result"
+
+require_relative "message/register"
+require_relative "message/registered"
+require_relative "message/unregister"
+require_relative "message/unregistered"
+
+require_relative "message/invocation"
+require_relative "message/yield"
+
+module Wampproto
+  # message root
+  module Message
+    module Type
+      HELLO         = 1
+      WELCOME       = 2
+      ABORT         = 3
+      CHALLENGE     = 4
+      AUTHENTICATE  = 5
+      GOODBYE       = 6
+
+      ERROR = 8
+
+      PUBLISH   = 16
+      PUBLISHED = 17
+
+      SUBSCRIBE     = 32
+      SUBSCRIBED    = 33
+      UNSUBSCRIBE   = 34
+      UNSUBSCRIBED  = 35
+      EVENT         = 36
+
+      CALL    = 48
+      CANCEL  = 49
+      RESULT  = 50
+
+      REGISTER      = 64
+      REGISTERED    = 65
+      UNREGISTER    = 66
+      UNREGISTERED  = 67
+      INVOCATION    = 68
+      INTERRUPT     = 69
+      YIELD         = 70
+    end
+
+    HANDLER = {
+      Type::HELLO => Hello,
+      Type::WELCOME => Welcome,
+      Type::ABORT => Abort,
+      Type::CHALLENGE => Challenge,
+      Type::AUTHENTICATE => Authenticate,
+      Type::GOODBYE => Goodbye,
+
+      Type::ERROR => Error,
+
+      Type::PUBLISH => Publish,
+      Type::PUBLISHED => Published,
+
+      Type::SUBSCRIBE => Subscribe,
+      Type::SUBSCRIBED => Subscribed,
+      Type::UNSUBSCRIBE => Unsubscribe,
+      Type::UNSUBSCRIBED => Unsubscribed,
+      Type::EVENT => Event,
+
+      Type::CALL => Call,
+      Type::RESULT => Result,
+
+      Type::REGISTER => Register,
+      Type::REGISTERED => Registered,
+      Type::UNREGISTER => Unregister,
+      Type::UNREGISTERED => Unregistered,
+      Type::INVOCATION => Invocation,
+      Type::YIELD => Yield
+    }.freeze
+
+    def self.resolve(wamp_message)
+      type, = Validate.array!("Wamp Message", wamp_message)
+      begin
+        HANDLER[type].parse(wamp_message)
+      rescue StandardError => e
+        p wamp_message
+        raise e
+      end
+    end
+  end
+end

data/lib/wampproto/message_with_recipient.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Wampproto
+  # handler class for dealer and broker responses
+  class MessageWithRecipient
+    attr_reader :message, :recipient
+
+    def initialize(message, recipient)
+      @message = message
+      @recipient = recipient
+    end
+  end
+end

data/lib/wampproto/serializer/cbor.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "cbor"
+
+module Wampproto
+  module Serializer
+    # Add common API for serializer
+    class Cbor
+      def self.serialize(message)
+        CBOR.encode(message.marshal).unpack("c*")
+      end
+
+      def self.deserialize(message)
+        CBOR.decode(message.pack("c*")).then { Message.resolve(_1) }
+      end
+    end
+  end
+end

data/lib/wampproto/serializer/json.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Wampproto
+  module Serializer
+    # Add common API for serializer
+    class JSON
+      def self.serialize(message)
+        ::JSON.dump(message.marshal)
+      end
+
+      def self.deserialize(message)
+        ::JSON.parse(message).then { Message.resolve(_1) }
+      end
+    end
+  end
+end

data/lib/wampproto/serializer/msgpack.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "msgpack"
+
+module Wampproto
+  module Serializer
+    # Add common API for serializer
+    class Msgpack
+      def self.serialize(message)
+        ::MessagePack.pack(message.marshal).unpack("c*")
+      end
+
+      def self.deserialize(message)
+        ::MessagePack.unpack(message.pack("c*")).then { Message.resolve(_1) }
+      end
+    end
+  end
+end

data/lib/wampproto/serializer.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "serializer/json"
+require_relative "serializer/msgpack"
+require_relative "serializer/cbor"

data/lib/wampproto/session.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Wampproto
+  # Session
+  class Session # rubocop:disable Metrics/ClassLength
+    attr_reader :serializer
+
+    def initialize(serializer = Serializer::JSON)
+      @serializer = serializer
+      init_state
+    end
+
+    ACCESSORS = %i[
+      call_requests
+      register_requests
+      registrations
+      invocation_requests
+      unregister_requests
+
+      publish_requests
+      subscribe_requests
+      subscriptions
+      unsubscribe_requests
+    ].freeze
+
+    def send_message(msg) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+      case msg
+      when Message::Call
+        call_requests[msg.request_id] = msg.request_id
+      when Message::Register
+        register_requests[msg.request_id] = msg.request_id
+      when Message::Unregister
+        unregister_requests[msg.request_id] = msg.registration_id
+      when Message::Yield
+        unless invocation_requests.include?(msg.request_id)
+          raise ValueError, "cannot yield for unknown invocation request"
+        end
+
+        invocation_requests.delete(msg.request_id)
+      when Message::Publish
+        publish_requests[msg.request_id] = msg.request_id if msg.options.fetch(:acknowledge, false)
+      when Message::Subscribe
+        subscribe_requests[msg.request_id] = msg.request_id
+      when Message::Unsubscribe
+        unsubscribe_requests[msg.request_id] = msg.subscription_id
+      when Message::Error
+        error_message = "send only supported for invocation error"
+        raise ValueError, error_message if msg.message_type != Message::Invocation.type
+
+        invocation_requests.delete(msg.request_id)
+      end
+
+      serializer.serialize(msg)
+    end
+
+    def receive(data)
+      msg = serializer.deserialize(data)
+      receive_message(msg)
+    end
+
+    def receive_message(msg) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      case msg
+      when Message::Result
+        error_message = "received RESULT for invalid request_id"
+        raise ValueError, error_message unless call_requests.delete(msg.request_id)
+      when Message::Registered
+        error_message = "received REGISTERED for invalid request_id"
+        raise ValueError, error_message unless register_requests.delete(msg.request_id)
+
+        registrations[msg.registration_id] = msg.registration_id
+      when Message::Unregistered
+        error_message = "received UNREGISTERED for invalid request_id"
+        registration_id = unregister_requests.delete(msg.request_id)
+        raise ValueError, error_message unless registration_id
+
+        error_message = "received UNREGISTERED for invalid registration_id"
+        raise ValueError, error_message unless registrations.delete(registration_id)
+      when Message::Invocation
+        error_message = "received INVOCATION for invalid registration_id"
+        raise ValueError, error_message unless registrations.delete(msg.registration_id)
+
+        invocation_requests[msg.request_id] = msg.request_id
+      when Message::Published
+        error_message = "received PUBLISHED for invalid topic"
+        raise ValueError, error_message unless publish_requests.delete(msg.request_id)
+      when Message::Subscribed
+        error_message = "received SUBSCRIBED for invalid request_id"
+        raise ValueError, error_message unless subscribe_requests.delete(msg.request_id)
+
+        subscriptions[msg.subscription_id] = msg.subscription_id
+      when Message::Unsubscribed
+        error_message = "received UNSUBSCRIBED for invalid request_id"
+        subscription_id = unsubscribe_requests.delete(msg.request_id)
+        raise ValueError, error_message unless subscription_id
+
+        error_message = "received UNSUBSCRIBED for invalid subscription_id"
+        raise ValueError, error_message unless subscriptions.delete(subscription_id)
+      when Message::Event
+        error_message = "received EVENT for invalid subscription_id"
+        raise ValueError, error_message unless subscriptions.include?(msg.subscription_id)
+      when Message::Error
+        case msg.message_type
+        when Message::Call.type
+          error_message = "received ERROR for invalid call request"
+          raise ValueError, error_message unless call_requests.delete(msg.request_id)
+        when Message::Register.type
+          error_message = "received ERROR for invalid register request"
+          raise ValueError, error_message unless register_requests.delete(msg.request_id)
+        when Message::Unregister.type
+          error_message = "received ERROR for invalid unregister request"
+          raise ValueError, error_message unless unregister_requests.delete(msg.request_id)
+        when Message::Subscribe.type
+          error_message = "received ERROR for invalid subscribe request"
+          raise ValueError, error_message unless subscribe_requests.delete(msg.request_id)
+        when Message::Unsubscribe.type
+          error_message = "received ERROR for invalid unsubscribe request"
+          raise ValueError, error_message unless unsubscribe_requests.delete(msg.request_id)
+        when Message::Publish.type
+          error_message = "received ERROR for invalid publish request"
+          raise ValueError, error_message unless publish_requests.delete(msg.request_id)
+        else
+          error_message = "unknown error message type #{msg.class}"
+          raise ValueError, error_message
+        end
+      when Message::Abort
+        p [:session, :abort, msg]
+      else
+        raise ValueError, "unknown message #{msg.class}"
+      end
+
+      msg
+    end
+
+    private
+
+    attr_reader(*ACCESSORS)
+
+    def init_state
+      ACCESSORS.each do |attr|
+        instance_variable_set("@#{attr}", {})
+      end
+    end
+  end
+end

data/lib/wampproto/session_details.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Wampproto
+  # Session Details
+  class SessionDetails
+    attr_reader :session_id, :realm, :authid, :authrole
+
+    def initialize(session_id, realm, authid, authrole)
+      @session_id = session_id
+      @realm = realm
+      @authid = authid
+      @authrole = authrole
+    end
+
+    def ==(other)
+      return false unless other.instance_of?(SessionDetails)
+
+      session_id == other.session_id &&
+        realm == other.realm &&
+        authid == other.authid &&
+        authrole == other.authrole
+    end
+  end
+end

data/lib/wampproto/validate.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Wampproto
+  # validation
+  class Validate
+    class << self
+      def int!(name, value)
+        return value if value.is_a?(Integer)
+
+        raise ArgumentError, "The #{name} argument should be an integer."
+      end
+
+      def string!(name, value)
+        return value if value.is_a?(String)
+
+        raise ArgumentError, "The #{name} argument should be a string."
+      end
+
+      def hash!(name, value)
+        return value.transform_keys(&:to_sym) if value.is_a?(Hash)
+
+        raise ArgumentError, "The #{name} argument should be a dictionary."
+      end
+
+      def array!(name, value)
+        return value if value.is_a?(Array)
+
+        raise ArgumentError, "The #{name} argument should be a list."
+      end
+
+      def length!(array, expected_length)
+        return array if array.length == expected_length
+
+        raise ArgumentError, "The response message length should be #{expected_length} but got #{array.length} "
+      end
+
+      def greater_than_equal!(array, expected_length)
+        return array if array.length >= expected_length
+
+        raise ArgumentError, "The response message length is #{array.length} but it should be #{expected_length} "
+      end
+
+      def options!(options, valid_keys)
+        options.each_key do |key|
+          raise ArgumentError, "Unrecognized option: #{key.inspect}" unless valid_keys.include?(key)
+        end
+
+        options
+      end
+    end
+  end
+end

data/lib/wampproto/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Wampproto
+  VERSION = "0.1.0"
+end

data/lib/wampproto.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "wampproto/version"
+require_relative "wampproto/validate"
+require_relative "wampproto/message"
+require_relative "wampproto/serializer"
+require_relative "wampproto/auth"
+require_relative "wampproto/id_generator"
+require_relative "wampproto/session_details"
+require_relative "wampproto/joiner"
+require_relative "wampproto/acceptor"
+require_relative "wampproto/session"
+require_relative "wampproto/message_with_recipient"
+require_relative "wampproto/dealer"
+require_relative "wampproto/broker"
+
+module Wampproto
+  class Error < StandardError; end
+
+  # ProtocolViolation Exception
+  class ProtocolViolation < StandardError
+    attr_reader :uri
+
+    def initialize(msg = "Protocol Violation", uri = "wamp.error.protocol_violation")
+      @uri = uri
+      super(msg)
+    end
+  end
+
+  class ValueError < StandardError
+  end
+end

data/sig/cbor.rbs

@@ -0,0 +1,5 @@
+module CBOR 
+  def self.encode: (untyped message) -> String
+
+  def self.decode: (String message) -> untyped
+end

data/sig/ed25519/signing_key.rbs

@@ -0,0 +1,7 @@
+module  Ed25519
+  class SigningKey
+    def initialize: (String private_key) -> void
+
+    def sign: (String challenge) -> untyped
+  end
+end

data/sig/ed25519/verify_key.rbs

@@ -0,0 +1,7 @@
+module  Ed25519
+  class VerifyKey
+    def initialize: (String private_key) -> void
+
+    def verify: (String signature, String message) -> bool
+  end
+end

data/sig/message_pack.rbs

@@ -0,0 +1,5 @@
+module MessagePack 
+  def self.pack: (untyped message) -> String
+
+  def self.unpack: (String message) -> untyped
+end

data/sig/wampproto/acceptor/authenticator.rbs

@@ -0,0 +1,9 @@
+module Wampproto
+  class Acceptor
+    # Interface to handle Authentications
+    class Authenticator
+      def self.authenticate: (Request request) -> Response
+    end
+  end
+end
+

data/sig/wampproto/acceptor/request.rbs

@@ -0,0 +1,46 @@
+module Wampproto
+  class Acceptor
+    # Request object sent for authentication
+    class Request
+      @hello: Message::Hello
+
+      extend Forwardable
+
+      attr_reader realm: String
+
+      attr_reader authid: String
+
+      attr_reader authextra: Hash[Symbol, untyped]
+
+      attr_reader hello: Message::Hello
+
+      def initialize: (Message::Hello hello) -> void
+
+      def authmethod: () -> Symbol
+
+      def public_key: () -> String
+
+      def secret: () -> nil
+
+      def ticket: () -> nil
+    end
+
+    # AuthenticateRequest
+    class AuthenticateRequest < Request
+      @authenticate: Message::Authenticate
+
+      @hello_request: Request
+
+      extend Forwardable
+
+      attr_reader authenticate: Message::Authenticate
+
+      def initialize: (Message::Authenticate authenticate, Request hello_request) -> void
+
+      def ticket: () -> (String | nil)
+
+      def secret: () -> (String | nil)
+    end
+  end
+end
+

data/sig/wampproto/acceptor/response.rbs

@@ -0,0 +1,25 @@
+module Wampproto
+  class Acceptor
+    # Request object sent for authentication
+    class Response
+      @authid: String
+
+      @authrole: String
+
+      @secret: String
+
+      attr_reader authid: String
+
+      attr_reader authrole: String
+
+      attr_reader secret: String
+
+      def initialize: (String authid, String authrole, ?String? secret) -> void
+
+      alias ticket secret
+
+      alias public_key secret
+    end
+  end
+end
+

data/sig/wampproto/acceptor.rbs

@@ -0,0 +1,86 @@
+module Wampproto
+  # Accepts Request
+  class Acceptor
+    type serializerTypes = (singleton(Serializer::JSON) | singleton(Serializer::Msgpack) | singleton(Serializer::Cbor))
+    # type authenticatorsType = Auth::Anonymous | Auth::Ticket | Auth::Cra | Auth::Cryptosign
+
+    @serializer: serializerTypes
+
+    @authenticator: singleton(Authenticator)
+
+    @state: Integer
+
+    @session_id: Integer
+
+    @hello: Message::Hello
+
+    @authid: String
+
+    @authmethod: String
+
+    @request: Request
+
+    @response: Response
+
+    @challenge: String
+
+    @public_key: String
+
+    @auth_request: AuthenticateRequest
+
+    STATE_NONE: 0
+
+    STATE_HELLO_RECEIVED: 1
+
+    STATE_CHALLENGE_SENT: 2
+
+    STATE_WELCOME_SENT: 3
+
+    STATE_ERROR: 4
+
+    ROUTER_ROLES: { dealer: ::Hash[untyped, untyped], broker: ::Hash[untyped, untyped] }
+
+    attr_reader serializer: serializerTypes
+
+    attr_reader session_id: Integer
+
+    attr_reader authmethod: String
+
+    attr_reader authenticator: singleton(Authenticator)
+
+    attr_accessor state: Integer
+
+    attr_accessor session_details: SessionDetails
+
+    def initialize: (?serializerTypes serializer, ?singleton(Authenticator) authenticator) -> void
+
+    def receive: (untyped data) -> untyped
+
+    def receive_message: (Message::Base msg) -> Message::Base
+
+    private
+
+    def handle_hello_message: (Message::Hello msg) -> (Message::Challenge | Message::Welcome | Message::Abort)
+
+    def handle_wampcra_hello: (Message::Hello msg) -> Message::Challenge
+
+    def handle_ticket_hello: (Message::Hello _msg) -> Message::Challenge
+
+    def handle_cryptosign_hello: (Message::Hello msg) -> Message::Challenge
+
+    def handle_anonymous_hello: (Message::Hello msg) -> Message::Welcome
+
+    def handle_authenticate_message: (Message::Authenticate msg) -> (Message::Welcome | Message::Abort)
+
+    def handle_wampcra_authenticate: (Message::Authenticate msg) -> (Message::Welcome | Message::Abort)
+
+    def abort_message: () -> Message::Abort
+
+    def handle_ticket_authenticate: (Message::Authenticate msg) -> (Message::Welcome | Message::Abort)
+
+    def handle_cryptosign_authenticate: (Message::Authenticate msg) -> (Message::Welcome | Message::Abort)
+
+    def create_session_id: () -> Integer
+  end
+end
+

data/sig/wampproto/auth/anonymous.rbs

@@ -0,0 +1,13 @@
+module Wampproto
+  module Auth
+    # anonymous authentication
+    class Anonymous < Base
+      @authid: String
+
+      AUTH_METHOD: "anonymous"
+
+      def initialize: (?String authid, ?::Hash[Symbol, untyped] authextra) -> void
+    end
+  end
+end
+

data/sig/wampproto/auth/base.rbs

@@ -0,0 +1,25 @@
+module Wampproto
+  module Auth
+    # Auth Base
+    class Base
+      @authmethod: String
+
+      @authid: String
+
+      @authextra: Hash[Symbol, untyped]
+
+      attr_reader authmethod: String
+
+      attr_reader authid: String
+
+      attr_reader authextra: Hash[Symbol, untyped]
+
+      attr_reader details: Hash[Symbol, untyped]
+
+      def initialize: (String method, String authid, Hash[Symbol, untyped] authextra) -> void
+
+      def authenticate: (Message::Challenge _challenge) -> String
+    end
+  end
+end
+