xconn 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f4a4f50da44bd4849d8e503de34fcdee9edf558c06244ec43746b81401c09e3a
+  data.tar.gz: 5624eedc589212e83ba1684ab67e06d27bbb14c35dc8cf91245aed67b92475ce
+SHA512:
+  metadata.gz: 2867240ea024fafcd2fbc93da161473a546989fe349bc9be61a3e12c209d2358187957f291b0ee9d58874e524139cbfbd567838a4305bde178bb5c7e2519f253
+  data.tar.gz: 477e4d9640d8da4e555ace59c5b29f76c7b2b799399c4ad76e17ef9402ca2284519299c4b1e931b18d8e788ba60af7c72300f87819969743e51819fcd9bfb403

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,29 @@
+AllCops:
+  TargetRubyVersion: 2.6
+  NewCops: enable
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/BlockLength:
+  Enabled: false
+
+Layout/BeginEndAlignment:
+  EnforcedStyleAlignWith: start_of_line
+
+Layout/EndAlignment:
+  EnforcedStyleAlignWith: start_of_line
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+Layout/CaseIndentation:
+  EnforcedStyle: end

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-02-15
+
+- Initial release

data/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Simple Things Inc.
+Copyright (c) 2024 XConnIO Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Makefile

@@ -0,0 +1,9 @@
+build-docs:
+	mkdir -p site/xconn/
+	mkdocs build -d site/xconn/ruby
+
+run-docs:
+	mkdocs serve
+
+clean-docs:
+	rm -rf site/

data/README.md

@@ -0,0 +1,2 @@
+# wamp.rb
+WAMP v2 Client for Ruby

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]
+
+Dir.glob("lib/tasks/**/*.rake").each { |r| load r }

data/bin/xconn

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "wamp"
+
+require "optparse"
+
+options = { host: "127.0.0.1", port: 8080, realm: "realm1", directory: ".", app: "App" }
+OptionParser.new do |opts|
+  opts.banner = "Usage: xconn [options]"
+
+  opts.on("-hHOST", "--host HOST", "WebSocket host (default: ws://127.0.0.1:8080/ws)") do |host|
+    options[:host] = host
+  end
+
+  opts.on("-rREALM", "--realm REALM", "Realm (default: reaml1)") do |realm|
+    options[:realm] = realm
+  end
+
+  opts.on("-pPORT", "--port PORT", "Port (default: 8080)") do |port|
+    options[:port] = port
+  end
+
+  opts.on("-dDIRECTORY", "--directory DIRECTORY", 'Directory (default: ".")') do |directory|
+    options[:directory] = directory
+  end
+
+  opts.on("-aAPP", "--app APP", 'App (default: "App")') do |app|
+    options[:app] = app
+  end
+
+  opts.on("-v", "--version", "Gem Version") do |version|
+    options[:version] = version
+  end
+end.parse!
+
+if options.include?(:version)
+  puts "Xconn v#{Wamp::VERSION}"
+  exit 0
+end
+
+def create_client_session(router)
+  session = Wamp::Connection::Session.new
+
+  server_session = Wamp::Router::Client.new
+  server_session.router = router
+  server_session.connection = session
+
+  session.stream = server_session
+  session
+end
+
+router = Wamp::Router::Base.new
+router.add_realm(options.fetch(:realm))
+
+client = create_client_session(router).tap(&:on_open)
+
+begin
+  Pathname.new(options[:directory]).glob("**/*.rb").each { |file| require file.to_s }
+rescue LoadError => e
+  puts e.message
+  exit 1
+end
+
+begin
+  app = Object.const_get(options[:app])
+  app.new.procedures.each do |procedure, func|
+    client.api.register(procedure, func) do
+      puts "Registered procedure: #{procedure}"
+    end
+  end
+rescue StandardError => e
+  puts e.message
+  exit 1
+end
+
+server = Wamp::Router::Server.new(router, options)
+server.run

data/docs/index.md

@@ -0,0 +1,7 @@
+# Overview
+WAMP v2 Client and Router for Ruby.
+
+For full documentation visit [XConnIO](https://xconn.io).
+
+# Installation
+For installation & usage [xconn-ruby](https://xconn.io/xconn/ruby/installation/).

data/docs/installation.md

@@ -0,0 +1,11 @@
+# Installation
+Run this command:
+
+```shell
+gem install xconn
+```
+
+Gemfile
+```ruby
+gem 'xconn', '~> 0.0.1'
+```

data/example/sample/example.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "wamp"
+require "date"
+require_relative "included_app"
+
+# SystemApp
+class Example < Wamp::App
+  register echo: "io.xconn.echo", current_date: "io.xconn.date.get"
+
+  def initialize
+    super
+    include_app(IncludedApp.new, "test.")
+  end
+
+  def echo(invocation)
+    Wamp::Type::Result.new(args: invocation.args, kwargs: invocation.kwargs, details: invocation.details)
+  end
+
+  def current_date(_invocation)
+    Wamp::Type::Result.new(args: Date.today.iso8601)
+  end
+end

data/example/sample/included_app.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "wamp"
+
+# Class that can be included
+class IncludedApp < Wamp::App
+  register echo: "foo.bar.echo"
+
+  def echo(invocation)
+    Wamp::Type::Result.new(args: invocation.args, kwargs: invocation.kwargs, details: invocation.details)
+  end
+end

data/lib/tasks/tasks.rake

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+namespace :xconn do
+  desc "Start SAMPLE app"
+  task :run, [:host, :port, :realm, :directory, :app] do |_t, args|
+    host      = args[:host]       || "127.0.0.1"
+    port      = args[:port]       || 8080
+    realm     = args[:realm]      || "realm1"
+    app       = args[:app]        || "Example"
+    directory = args[:directory]  || "./example/sample"
+
+    command = "bin/xconn -h #{host} -p #{port} -r #{realm} -d #{directory} -a #{app}"
+
+    puts "Running: #{command}"
+
+    trap("SIGINT") do
+      puts "\nReceived SIGINT. Gracefully exiting..."
+
+      exit 0
+    end
+
+    `#{command}`
+  end
+end

data/lib/wamp/app.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Wamp
+  # WAMPApp
+  class App
+    def initialize
+      @procedures = {}
+    end
+
+    def include_app(app, prefix = "")
+      if prefix&.length&.zero?
+        procedures.merge!(app.procedures)
+      else
+        app.procedures.each do |procedure, func|
+          procedures.merge!({ "#{prefix}#{procedure}" => func })
+        end
+      end
+    end
+
+    def procedures
+      return {} if self.class.procedures && self.class.procedures.empty?
+      return @procedures if @procedures.any?
+
+      self.class.procedures.map do |procedure, registration_name|
+        @procedures[registration_name.to_s] = method(procedure)
+      end
+      @procedures
+    end
+
+    class << self
+      attr_reader :procedures
+
+      def register(procedures = {})
+        @procedures ||= {}
+        @procedures.merge!(procedures)
+      end
+    end
+  end
+end

data/lib/wamp/connection/session.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Wamp
+  module Connection
+    # Client Session
+    class Session
+      attr_reader :joiner, :session, :store, :api
+      attr_accessor :executor, :stream
+
+      def initialize(joiner = Wampproto::Joiner.new("realm1"))
+        @joiner = joiner
+        @session = Wampproto::Session.new(joiner.serializer)
+        @api = MessageHandler::Api.new(self)
+        @store = {}
+      end
+
+      def on_join(&block)
+        self.executor = block
+      end
+
+      def on_open
+        stream.on_message joiner.send_hello
+      end
+
+      def on_message(data)
+        handler = MessageHandler.resolve(data, self)
+        handler.handle
+      end
+
+      def transmit(data)
+        stream.on_message data
+      end
+    end
+  end
+end

data/lib/wamp/connection/stream.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "nio4r"
+
+module Wamp
+  module Connection
+    # creates actual socket and provides a way to read and write to it
+    class Stream
+      def initialize(socket_object)
+        @socket_object = socket_object
+        uri = URI.parse(socket_object.url)
+
+        @selector = NIO::Selector.new
+        @socket = TCPSocket.new(uri.host, uri.port)
+        monitor = @selector.register(@socket, :r)
+        monitor.value = proc { read_nonblock(monitor.io) }
+      end
+
+      def write(data)
+        written = @socket.write_nonblock(data, exception: false)
+
+        case written
+        when :wait_writable
+          # procceed
+        when data.bytesize
+          data.bytesize
+        else
+          puts [:incomplete_write]
+        end
+      end
+
+      def receive(data)
+        @socket_object.parse(data)
+      end
+
+      def run
+        loop do
+          @selector.select { |monitor| monitor.value.call if monitor.readable? }
+          break if @closed
+        end
+      end
+
+      def read_nonblock(io)
+        incoming = io.read_nonblock(4096, exception: false)
+
+        case incoming
+        when :wait_readable
+          nil
+        when nil
+          close
+        else
+          receive incoming
+        end
+      end
+
+      def shutdown
+        @selector.deregister(@socket)
+        @socket.close
+      end
+
+      def close
+        shutdown
+        @socket_object.connection_gone
+        @closed = true
+      end
+    end
+  end
+end

data/lib/wamp/connection/websocket_client.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "websocket/driver"
+require_relative "stream"
+
+module Wamp
+  module Connection
+    # handles opening connection and providing callbacks when data is avaialble
+    class WebsocketClient
+      CONNECTING = 0
+      OPEN       = 1
+      CLOSING    = 2
+      CLOSED     = 3
+
+      attr_reader :url
+
+      def initialize(event_target, protocols) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        @event_target = event_target
+
+        @driver = @driver_started = nil
+        @close_params = ["", 1006]
+
+        @url = event_target.url
+        @ready_state = CONNECTING
+
+        @driver = WebSocket::Driver.client(self, protocols: protocols)
+
+        @driver.on(:open)     { |_e| open }
+        @driver.on(:message)  { |e| receive_message(e.data) }
+        @driver.on(:close)    { |e| begin_close(e.reason, e.code) }
+        @driver.on(:error)    { |e| emit_error(e.message) }
+
+        @stream = Wamp::Connection::Stream.new(self)
+      end
+
+      def run
+        start_driver
+        @stream.run
+      end
+
+      def start_driver
+        return if @driver_started
+
+        @driver_started = true
+        @driver.start
+      end
+
+      def write(data)
+        @stream.write(data)
+      rescue StandardError => e
+        emit_error(e.message)
+      end
+
+      def transmit(message)
+        return false if @ready_state > OPEN
+
+        case 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
+
+      def connection_gone
+        finalize_close
+      end
+
+      def close(code = nil, reason = nil)
+        code   ||= 1000
+        reason ||= ""
+
+        unless code == 1000 || (code >= 3000 && code <= 4999)
+          raise ArgumentError, "Failed to execute 'close' on WebSocket: " \
+                               "The code must be either 1000, or between 3000 and 4999. " \
+                               "#{code} is neither."
+        end
+
+        @ready_state = CLOSING unless @ready_state == CLOSED
+        @driver.close(reason, code)
+      end
+
+      def parse(data)
+        @driver.parse(data)
+      end
+
+      def alive?
+        @ready_state == OPEN
+      end
+
+      # This is populated after successful handeshake
+      def protocol
+        @driver.protocol
+      end
+
+      private
+
+      def open
+        return unless @ready_state == CONNECTING
+
+        @ready_state = OPEN
+
+        @event_target.on_open
+      end
+
+      def receive_message(data)
+        return unless @ready_state == OPEN
+
+        @event_target.on_message(data)
+      end
+
+      def emit_error(message)
+        return if @ready_state >= CLOSING
+
+        @event_target.on_error(message)
+      end
+
+      def begin_close(reason, code)
+        return if @ready_state == CLOSED
+
+        @ready_state = CLOSING
+        @close_params = [reason, code]
+
+        @stream.close
+        finalize_close
+      end
+
+      def finalize_close
+        return if @ready_state == CLOSED
+
+        @ready_state = CLOSED
+
+        @event_target.on_close(*@close_params)
+      end
+    end
+  end
+end

data/lib/wamp/connection/websocket_connection.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "wampproto"
+require_relative "websocket_client"
+
+module Wamp
+  module Connection
+    # Conn
+    class WebSocketConnection < Session
+      attr_reader :url, :websocket
+
+      def initialize(url = "ws://localhost:8080/ws", joiner = Wampproto::Joiner.new("realm1"))
+        super(joiner)
+        @url        = url
+        @websocket  = Wamp::Connection::WebsocketClient.new(self, protocols)
+      end
+
+      def run
+        websocket.run
+      ensure
+        p %i[run close]
+        websocket.close
+      end
+
+      def on_open
+        transmit joiner.send_hello
+      end
+
+      def transmit(data)
+        websocket.transmit data
+      end
+
+      def on_close(reason, code)
+        p [:on_close, reason, code]
+      end
+
+      def on_error; end
+
+      private
+
+      def protocols
+        case joiner.serializer.name
+        when Wampproto::Serializer::JSON.name then "wamp.2.json"
+        when Wampproto::Serializer::Msgpack.name then "wamp.2.msgpack"
+        when Wampproto::Serializer::Cbor.name then "wamp.2.cbor"
+        end.then do |protocol|
+          [protocol]
+        end
+      end
+    end
+  end
+end

data/lib/wamp/manager/base.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "event"
+require_relative "subscription"
+
+module Wamp
+  module Manager
+    # no:doc
+    class Base
+      include WebSocket::Driver::EventEmitter
+      attr_reader :session
+
+      def initialize(options = {})
+        super()
+        @options = options
+        @session = Session.new(self)
+      end
+
+      def transmit(data); end
+
+      def on_message(message)
+        manager = Manager::Event.resolve(message, session)
+        manager.emit_event(message)
+      end
+
+      def auth
+        @options.fetch(:auth, Auth::Anonymous.new)
+      end
+
+      def run
+        message = Message::Hello.new("realm1")
+        manager = Manager::Event::Hello.new(message, session)
+        manager.add_event_listener # adds on :join event listener
+      end
+
+      def authenticate(challenge)
+        auth.authenticate(challenge)
+      end
+    end
+  end
+end

data/lib/wamp/manager/connection.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Wamp
+  module Manager
+    # connection
+    class Connection < Connection::Base
+      attr_reader :session
+
+      def initialize(*args)
+        super
+        @session = Session.new(self)
+      end
+
+      def on_message(data)
+        message = Message.resolve(coder.decode(data))
+        session.on_message(message)
+      end
+
+      def on_open
+        send_hello_message
+      end
+
+      private
+
+      def send_hello_message
+        message = Message::Hello.new(@realm, auth.details)
+        manager = Manager::Event::Hello.new(message, self)
+        manager.add_event_listener # adds on :join event listener
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wamp
+  module Manager
+    module Event
+      # Abort Message Event
+      class Abort < Base
+        def emit_event_name
+          :close
+        end
+
+        def emit_event(message)
+          session.emit(emit_event_name, message)
+          session.close(1000, message.reason)
+        end
+      end
+    end
+  end
+end