celluloid-io or eventmachine with mosquitto loops

Question

I'm building a small ruby program to run a connection to a MQTT server and subscribe to a channel. I'm using the mosquitto gem which is just a bridge for libmosquitto C library.

I created a very simple implementation of a program that can run with ruby my_prog.rb:

# Dependencies

require File.expand_path(File.join('..', 'environment'), __FILE__)


# MQTT Application

module Pulsr
    class MQTT
        attr_reader :host, :port, :alive

        def initialize(host = 'iot.eclipse.org', port = 1883, alive = 60)
            @client ||=  Mosquitto::Client.new SecureRandom.hex(8)

            Signal.trap(Signal.list.has_key?('INT') ? 'SIGINT' : 'SIGTERM') do
            @client.log 'Shutdown'
            shutdown
            end

            @host = host
            @port = port
            @alive = alive

            start
        end


        private

        def on_connect
            Proc.new { |return_code|
                @client.log "Connected RC #{return_code}"

                @client.subscribe(nil, '/pulsr', Mosquitto::EXACTLY_ONCE)
            }
        end

        def on_disconnect
            Proc.new { |return_code| @client.log "Disconnected RC #{return_code}" }
        end

        def on_subscribe
            Proc.new { |message_id, granted_qos| @client.log "Subscribed MID #{message_id} QoS #{granted_qos}" }
        end

        def on_unsubscribe
            Proc.new { |message_id| @client.log "Unsubscribed MID #{message_id}" }
        end

        def on_message
            Proc.new { |message| Pulsr::Workers::TrackingEvent.perform_async message.to_s }
        end

        def configure
            @client.logger = Logger.new(STDOUT)

            @client.on_connect &on_connect
            @client.on_disconnect &on_disconnect
            @client.on_subscribe &on_subscribe
            @client.on_unsubscribe &on_unsubscribe
            @client.on_message &on_message
        end

        def connect
            @client.connect_async(@host, @port, @alive)
        end

        def start
            @client.loop_start

            configure
            connect

            sleep
        end

        def shutdown
            @client.loop_stop(true)
            Process.exit
        end
    end
end


# MQTT Start

Pulsr::MQTT.new :host => 'iot.eclipse.org', :port => 1883, :alive => 60

I was wondering, if I wanted to use Celluloid or EventMachine to run the loops that the mosquitto gem provides, how would I do it?

The mosquitto gem provides a good documentation and presents a few loop methods that can be used, but I have no clue where to start or how to do it, neither I have ever used EM or Celluloid.

Could anyone help get started with this, I think it could bring some value to the community and it can end up as a open source project, a small addition to the mosquitto gem?

Answer 1

I think it is not that hard. Mosquitto has a good library.

Yo need to connect these functions:

mosquitto_loop_misc() <-> EventMachine::PeriodicTimer.new
mosquitto_read() <-> EventMachine.watch
mosquitto_write() <-> EventMachine.watch