Getting started

[mhenrixon]

I came up with the following code based on the getting started documentation:

require 'async'
require 'async/http/endpoint'
require 'async/websocket/client'

class Fortnox
  TOPICS_URL = "wss://ws.fortnox.se/topics-v1"

  def self.start
    @thread ||= Thread.new do
      Async do |task|
        endpoint = Async::HTTP::Endpoint.parse(TOPICS_URL)

        Async::WebSocket::Client.connect(endpoint) do |connection|
          Rails.logger.info("Adding tenants")
          p("Adding tenants")

          p connection.write({
            command: "add-tenants-v1",
            clientSecret: "mysecret",
            accessTokens: [
              "Bearer tokenOne",
              "Bearer tokenTwo",
              "Bearer tokenThree",
            ]
          })

          Rails.logger.info("Adding topics")
          p("Adding topics")
          p connection.write({
            command: "add-topics-v1",
            topics: [
              {
                topic: "invoices"
              },
              {
                topic: "articles"
              }
            ]
          })

          Rails.logger.info("Subscribing")
          p("Subscribing")
          p connection.write({ command: "subscribe-v1" })
          connection.flush

          while message = connection.read
            puts message.inspect
            Rails.logger.debug(message)
          end
        end
      end
    end
  end
end

I need to have this running in the background of a rails project. The reason is that I have to store some credentials somewhere and deploy a rails app somewhere. I need to create some check-in for the client as I can only have one open connection for all tokens.

If I try to use Async directly without the background thread, I lock the entire rails app from starting.

Where I am at the moment is that nothing works, and I can't tell why 🤣

Going to need some hand-holding through this. Can I get some feedback from async websockets or dump debug information somewhere?

[ioquatix]

What server are you using?

[mhenrixon]

Falcon

[ioquatix]

Apologies but some of the methods changed their behaviour, and you might be depending on the old behaviour.

I will double check this all tomorrow, but:

https://github.com/socketry/protocol-websocket/blob/58f0d15c6c5b44d224fd7a6eb237ce331bd8a587/lib/protocol/websocket/json_message.rb is the JSONMessage wrapper you should be using JSONMessage.generate({command: ...})

You can use that with the write method, e.g.

async-websocket/test/async/websocket/adapters/rack.rb

Lines 29 to 41 in f85eb48

	let(:message) do
	Protocol::WebSocket::JSONMessage.generate({text: "Hello World"})
	end
	it "can make websocket connection to server" do
	Async::WebSocket::Client.connect(client_endpoint) do |connection|
	connection.write(message)
	expect(connection.read).to be == message
	connection.close
	end
	end

is an example.

Hopefully that's enough to get you on track, but do let me know.

[mhenrixon]

Same thing, it just doesn't give any feedback at all. I am on ruby 3.2.1 and rails 7.0.4 or whatever with Falcon web server of course.

I got something running using Iodine but I really want to use async-websocket. Feels more natural somehow.

[mhenrixon]

I mean, I can run it separately with the rails runner and not deploy this as part of the rails server but I'm not sure how I would handle signals etc.

I could figure that out but I would have to know how at least get some feedback:

This is the Async client:

# frozen_string_literal: true

require "async"
require "async/http/endpoint"
require "async/websocket/client"

module Fortnox
  class AsyncClient
    LOCK_KEY = "fortnox"
    TOPICS_URL = "wss://ws.fortnox.se/topics-v1"
    TOPICS = [
      { topic: "articles" },
      { topic: "warehouse-stockbalance" },
    ].freeze

    def self.start
      lock = Lock.create(key: LOCK_KEY)
      if lock.persisted?
        Async do |task|
          new(task, lock).start
        ensure
          task&.stop
        end
      end
    ensure
      lock&.unlock!
    end

    def initialize(task, lock, logger: Rails.logger)
      @task = task
      @lock = lock
      @logger = logger
    end

    def start
      endpoint = Async::HTTP::Endpoint.parse(TOPICS_URL)

      Async::WebSocket::Client.connect(endpoint) do |connection|
        add_tenants(connection)
        add_topics(connection)
        subscribe(connection)

        while (message = connection.read)
          Event.record(message)
        end
      end
    end

    private

    attr_reader :task, :logger

    def add_tenants(connection) # rubocop:disable Metrics/MethodLength
      logger.info("Adding tenants")

      logger.debug connection.write(
        Protocol::WebSocket::JSONMessage.generate({
          command: "add-tenants-v1",
          clientSecret: "mysecret",
          accessTokens: Tenant.pluck(:token),
        })
      )
    end

    def add_topics(connection)
      logger.info("Adding topics")

      connection.write(
        Protocol::WebSocket::JSONMessage.generate({
          command: "add-topics-v1",
          topics: TOPICS,
        })
      )
    end

    def subscribe(connection)
      logger.info("Subscribing")

      connection.write(
        Protocol::WebSocket::JSONMessage.generate({ command: "subscribe-v1" })
      )
      connection.flush
    end
  end
end

This is the iodine client:

# frozen_string_literal: true

require "iodine"

module Fortnox
  class IodineClient
    LOCK_KEY = "fortnox"

    def on_open(connection)
      @lock = Lock.create(key: LOCK_KEY)
      if lock.persisted?
        add_tenants(connection)
        add_topics(connection)
        subscribe(connection)
      end
    end

    def on_message(connection, message)
      Rails.logger.info "Received: #{message}"
      Event.record(message)
    end

    def on_close(_connection)
      # in this example, we stop iodine once the client is closed
      Rails.logger.info "* Client closed."
      @lock&.destroy!
      Iodine.stop
    end

    def add_tenants(connection)
      Rails.logger.info("Adding tenants")

      connection.write({
        command: "add-tenants-v1",
        clientSecret: "mysecret",
        accessTokens: Tenant.pluck(:token)
      }.to_json)
    end

    def add_topics(connection)
      Rails.logger.info("Adding topics subscriptions")

      connection.write({ command: "add-topics-v1", topics: TOPICS }.to_json)
    end

    def subscribe(connection)
      Rails.logger.info("Subscribing to websocket")

      connection.write({ command: "subscribe-v1" }.to_json)
    end
  end
end

# Iodine.threads = 1
# Iodine.workers = 1
# Iodine.connect url: Fortnox::TOPICS_URL, handler: Fortnox::IodineClient.new, ping: 40
# Iodine.start

So here on the last one I get feedback that I failed to add tokens because I didn't have any valid ones.