mqtt-rails 1.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mqtt-rails"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mqtt-rails.rb

@@ -0,0 +1,144 @@
+# Copyright (c) 2016-2017 Pierre Goudet <p-goudet@ruby-dev.jp>
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# and Eclipse Distribution License v1.0 which accompany this distribution.
+#
+# The Eclipse Public License is available at
+#    https://eclipse.org/org/documents/epl-v10.php.
+# and the Eclipse Distribution License is available at
+#   https://eclipse.org/org/documents/edl-v10.php.
+#
+# Contributors:
+#    Pierre Goudet - initial committer
+
+require "mqtt_rails/version"
+require "mqtt_rails/client"
+require "mqtt_rails/exception"
+require "mqtt_rails/packet"
+
+module MqttRails
+  extend self
+
+  MAX_PACKET_ID = 65535
+
+  # Default connection setup
+  DEFAULT_SSL_PORT      = 8883
+  DEFAULT_PORT          = 1883
+  SELECT_TIMEOUT        = 0.002
+
+  # MAX size of queue
+  MAX_SUBACK   = 10
+  MAX_UNSUBACK = 10
+  MAX_PUBLISH  = 1000
+  MAX_QUEUE    = 1000
+
+  # Connection states values
+  MQTT_CS_NEW        = 0
+  MQTT_CS_CONNECTED  = 1
+  MQTT_CS_DISCONNECT = 2
+
+  # Error values
+  MQTT_ERR_SUCCESS = 0
+  MQTT_ERR_FAIL    = 1
+
+  PACKET_TYPES = [
+    nil,
+    MqttRails::Packet::Connect,
+    MqttRails::Packet::Connack,
+    MqttRails::Packet::Publish,
+    MqttRails::Packet::Puback,
+    MqttRails::Packet::Pubrec,
+    MqttRails::Packet::Pubrel,
+    MqttRails::Packet::Pubcomp,
+    MqttRails::Packet::Subscribe,
+    MqttRails::Packet::Suback,
+    MqttRails::Packet::Unsubscribe,
+    MqttRails::Packet::Unsuback,
+    MqttRails::Packet::Pingreq,
+    MqttRails::Packet::Pingresp,
+    MqttRails::Packet::Disconnect,
+    nil
+  ]
+
+  CONNACK_ERROR_MESSAGE = {
+    0x02 => "Client Identifier is correct but not allowed by remote server.",
+    0x03 => "Connection established but MQTT service unvailable on remote server.",
+    0x04 => "User name or user password is malformed.",
+    0x05 => "Client is not authorized to connect to the server."
+  }
+
+  CLIENT_ATTR_DEFAULTS = {
+      :host          => "",
+      :port          => nil,
+      :mqtt_version  => '3.1.1',
+      :clean_session => true,
+      :persistent    => false,
+      :blocking      => false,
+      :client_id     => nil,
+      :username      => nil,
+      :password      => nil,
+      :ssl           => false,
+      :will_topic    => nil,
+      :will_payload  => nil,
+      :will_qos      => 0,
+      :will_retain   => false,
+      :keep_alive    => 60,
+      :ack_timeout   => 5,
+      :on_connack    => nil,
+      :on_suback     => nil,
+      :on_unsuback   => nil,
+      :on_puback     => nil,
+      :on_pubrel     => nil,
+      :on_pubrec     => nil,
+      :on_pubcomp    => nil,
+      :on_message    => nil,
+  }
+
+  Thread.abort_on_exception = true
+
+  def match_filter(topics, filters)
+    check_topics(topics, filters)
+    index = 0
+    rc = false
+    topic = topics.split('/')
+    filter = filters.split('/')
+    while index < [topic.length, filter.length].max do
+      if is_end?(topic[index], filter[index])
+        break
+      elsif is_wildcard?(filter[index])
+        rc = index == (filter.length - 1)
+        break
+      elsif keep_running?(filter[index], topic[index])
+        index = index + 1
+      else
+        break
+      end
+    end
+    is_matching?(rc, topic.length, filter.length, index)
+  end
+
+  def keep_running?(filter_part, topic_part)
+    filter_part == topic_part || filter_part == '+'
+  end
+
+  def is_wildcard?(filter_part)
+    filter_part == '#'
+  end
+
+  def is_end?(topic_part, filter_part)
+    topic_part.nil? || filter_part.nil?
+  end
+
+  def is_matching?(rc, topic_length, filter_length, index)
+    rc || index == [topic_length, filter_length].max
+  end
+
+  def check_topics(topics, filters)
+    if topics.is_a?(String) && filters.is_a?(String)
+    else
+      Rails.logger.error("Topics or Wildcards are not found as String.")
+      raise ArgumentError
+    end
+  end
+end

data/lib/mqtt_rails/client.rb

@@ -0,0 +1,414 @@
+# Copyright (c) 2016-2017 Pierre Goudet <p-goudet@ruby-dev.jp>
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# and Eclipse Distribution License v1.0 which accompany this distribution.
+#
+# The Eclipse Public License is available at
+#    https://eclipse.org/org/documents/epl-v10.php.
+# and the Eclipse Distribution License is available at
+#   https://eclipse.org/org/documents/edl-v10.php.
+#
+# Contributors:
+#    Pierre Goudet - initial committer
+
+require 'mqtt_rails/handler'
+require 'mqtt_rails/connection_helper'
+require 'mqtt_rails/sender'
+require 'mqtt_rails/publisher'
+require 'mqtt_rails/subscriber'
+require 'mqtt_rails/ssl_helper'
+
+module MqttRails
+  class Client
+    # Connection related attributes:
+    attr_accessor :host
+    attr_accessor :port
+    attr_accessor :mqtt_version
+    attr_accessor :clean_session
+    attr_accessor :persistent
+    attr_accessor :reconnect_limit
+    attr_accessor :reconnect_delay
+    attr_accessor :blocking
+    attr_accessor :client_id
+    attr_accessor :username
+    attr_accessor :password
+    attr_accessor :ssl
+
+    # Last will attributes:
+    attr_accessor :will_topic
+    attr_accessor :will_payload
+    attr_accessor :will_qos
+    attr_accessor :will_retain
+
+    # Timeout attributes:
+    attr_accessor :keep_alive
+    attr_accessor :ack_timeout
+
+    #Read Only attribute
+    attr_reader :connection_state
+    attr_reader :ssl_context
+
+    def initialize(*args)
+      @last_packet_id         = 0
+      @ssl_context            = nil
+      @sender                 = nil
+      @handler                = Handler.new
+      @connection_helper      = nil
+      @connection_state       = MQTT_CS_DISCONNECT
+      @connection_state_mutex = Mutex.new
+      @mqtt_thread            = nil
+      @reconnect_thread       = nil
+      @id_mutex               = Mutex.new
+      @reconnect_limit        = 3
+      @reconnect_delay        = 5
+
+      if args.last.is_a?(Hash)
+        attr = args.pop
+      else
+        attr = {}
+      end
+
+      CLIENT_ATTR_DEFAULTS.merge(attr).each_pair do |k,v|
+        self.send("#{k}=", v)
+      end
+
+      if @ssl
+        @ssl_context = OpenSSL::SSL::SSLContext.new
+      end
+
+      if @port.nil?
+        if @ssl
+          @port = DEFAULT_SSL_PORT
+        else
+          @port = DEFAULT_PORT
+        end
+      end
+
+      if  @client_id.nil? || @client_id == ""
+        @client_id = generate_client_id
+      end
+    end
+
+    def generate_client_id(prefix='paho_ruby', lenght=16)
+      charset = Array('A'..'Z') + Array('a'..'z') + Array('0'..'9')
+      @client_id = prefix << Array.new(lenght) { charset.sample }.join
+    end
+
+    def config_ssl_context(cert_path, key_path, ca_path=nil)
+      @ssl ||= true
+      @ssl_context = SSLHelper.config_ssl_context(cert_path, key_path, ca_path)
+    end
+
+    def connect(host=@host, port=@port, keep_alive=@keep_alive, persistent=@persistent, blocking=@blocking)
+      @persistent = persistent
+      @blocking   = blocking
+      @host       = host
+      @port       = port.to_i
+      @keep_alive = keep_alive
+      @connection_state_mutex.synchronize do
+        @connection_state = MQTT_CS_NEW
+      end
+      @mqtt_thread.kill unless @mqtt_thread.nil?
+
+      init_connection unless reconnect?
+      @connection_helper.send_connect(session_params)
+      begin
+        init_pubsub
+        @connection_state = @connection_helper.do_connect(reconnect?)
+        if connected?
+          build_pubsub
+          daemon_mode unless @blocking
+        end
+      rescue LowVersionException
+        downgrade_version
+      end
+    end
+
+    def daemon_mode
+      @mqtt_thread = Thread.new do
+        @reconnect_thread.kill unless @reconnect_thread.nil? || !@reconnect_thread.alive?
+        begin
+          while connected? do
+            mqtt_loop
+          end
+        rescue SystemCallError => e
+          if @persistent
+            reconnect
+          else
+            raise e
+          end
+        end
+      end
+    end
+
+    def connected?
+      @connection_state == MQTT_CS_CONNECTED
+    end
+
+    def reconnect?
+      Thread.current == @reconnect_thread
+    end
+
+    def loop_write
+      begin
+        @sender.writing_loop
+      rescue WritingException
+        if check_persistence
+          reconnect
+        else
+          raise WritingException
+        end
+      end
+    end
+
+    def loop_read
+      begin
+        MAX_QUEUE.times do
+          result = @handler.receive_packet
+          break if result.nil?
+        end
+      rescue FullQueueException
+        Rails.logger.warn("Early exit in reading loop. The maximum packets have been reach for #{packet.type_name}")
+      rescue ReadingException
+        if check_persistence
+          reconnect
+        else
+          raise ReadingException
+        end
+      end
+    end
+
+    def mqtt_loop
+      loop_read
+      loop_write
+      loop_misc
+    end
+
+    def loop_misc
+      if @connection_helper.check_keep_alive(@persistent, @keep_alive) == MQTT_CS_DISCONNECT
+        reconnect if check_persistence
+      end
+      @publisher.check_waiting_publisher
+      @subscriber.check_waiting_subscriber
+      sleep SELECT_TIMEOUT
+    end
+
+    def reconnect
+      @reconnect_thread = Thread.new do
+        counter = 0
+        while (@reconnect_limit >= counter || @reconnect_limit == -1) do
+          counter += 1
+          Rails.logger.info("New reconnect attempt...")
+          connect
+          if connected?
+            break
+          else
+            sleep @reconnect_delay
+          end
+        end
+        unless connected?
+          Rails.logger.error("Reconnection attempt counter is over. (#{@reconnect_limit} times)")
+          disconnect(false)
+        end
+      end
+    end
+
+    def disconnect(explicit=true)
+      @connection_helper.do_disconnect(@publisher, explicit, @mqtt_thread)
+      @connection_state_mutex.synchronize do
+        @connection_state = MQTT_CS_DISCONNECT
+      end
+      if explicit && @clean_session
+        @last_packet_id = 0
+        @subscriber.clear_queue
+      end
+      MQTT_ERR_SUCCESS
+    end
+
+    def publish(topic, payload="", retain=false, qos=0)
+      if topic == "" || !topic.is_a?(String)
+        Rails.logger.error("Publish topics is invalid, not a string or empty.")
+        raise ArgumentError
+      end
+      id = next_packet_id
+      @publisher.send_publish(topic, payload, retain, qos, id)
+    end
+
+    def subscribe(*topics)
+      begin
+        id = next_packet_id
+        unless @subscriber.send_subscribe(topics, id) == MqttRails::MQTT_ERR_SUCCESS
+          reconnect if check_persistence
+        end
+        MQTT_ERR_SUCCESS
+      rescue ProtocolViolation
+        Rails.logger.error("Subscribe topics need one topic or a list of topics.")
+        raise ProtocolViolation
+      end
+    end
+
+    def unsubscribe(*topics)
+      begin
+        id = next_packet_id
+        unless @subscriber.send_unsubscribe(topics, id) == MQTT_ERR_SUCCESS
+          reconnect if check_persistence
+        end
+        MQTT_ERR_SUCCESS
+      rescue ProtocolViolation
+        Rails.logger.error("Unsubscribe need at least one topic.")
+        raise ProtocolViolation
+      end
+    end
+
+    def ping_host
+      @sender.send_pingreq
+    end
+
+    def add_topic_callback(topic, callback=nil, &block)
+      @handler.register_topic_callback(topic, callback, &block)
+    end
+
+    def remove_topic_callback(topic)
+      @handler.clear_topic_callback(topic)
+    end
+
+    def on_connack(&block)
+      @handler.on_connack = block if block_given?
+      @handler.on_connack
+    end
+
+    def on_suback(&block)
+      @handler.on_suback = block if block_given?
+      @handler.on_suback
+    end
+
+    def on_unsuback(&block)
+      @handler.on_unsuback = block if block_given?
+      @handler.on_unsuback
+    end
+
+    def on_puback(&block)
+      @handler.on_puback = block if block_given?
+      @handler.on_puback
+    end
+
+    def on_pubrec(&block)
+      @handler.on_pubrec = block if block_given?
+      @handler.on_pubrec
+    end
+
+    def on_pubrel(&block)
+      @handler.on_pubrel = block if block_given?
+      @handler.on_pubrel
+    end
+
+    def on_pubcomp(&block)
+      @handler.on_pubcomp = block if block_given?
+      @handler.on_pubcomp
+    end
+
+    def on_message(&block)
+      @handler.on_message = block if block_given?
+      @handler.on_message
+    end
+
+    def on_connack=(callback)
+      @handler.on_connack = callback if callback.is_a?(Proc)
+    end
+
+    def on_suback=(callback)
+      @handler.on_suback = callback if callback.is_a?(Proc)
+    end
+
+    def on_unsuback=(callback)
+      @handler.on_unsuback = callback if callback.is_a?(Proc)
+    end
+
+    def on_puback=(callback)
+      @handler.on_puback = callback if callback.is_a?(Proc)
+    end
+
+    def on_pubrec=(callback)
+      @handler.on_pubrec = callback if callback.is_a?(Proc)
+    end
+
+    def on_pubrel=(callback)
+      @handler.on_pubrel = callback if callback.is_a?(Proc)
+    end
+
+    def on_pubcomp=(callback)
+      @handler.on_pubcomp = callback if callback.is_a?(Proc)
+    end
+
+    def on_message=(callback)
+      @handler.on_message = callback if callback.is_a?(Proc)
+    end
+
+    def registered_callback
+      @handler.registered_callback
+    end
+
+    def subscribed_topics
+      @subscriber.subscribed_topics
+    end
+
+
+    private
+
+    def next_packet_id
+      @id_mutex.synchronize do
+        @last_packet_id = 0 if @last_packet_id >= MAX_PACKET_ID
+        @last_packet_id = @last_packet_id.next
+      end
+    end
+
+    def downgrade_version
+      Rails.logger.info("Connection refused: unacceptable protocol version #{@mqtt_version}, trying 3.1")
+      if @mqtt_version != "3.1"
+        @mqtt_version = "3.1"
+        connect(@host, @port, @keep_alive)
+      else
+        raise ProtocolVersionException.new("Unsupported MQTT version")
+      end
+    end
+
+    def init_pubsub
+      @subscriber.nil? ? @subscriber = Subscriber.new(@sender) : @subscriber.sender = @sender
+      @publisher.nil? ? @publisher = Publisher.new(@sender) : @publisher.sender = @sender
+      @handler.config_pubsub(@publisher, @subscriber)
+    end
+
+    def build_pubsub
+      @subscriber.config_subscription(next_packet_id)
+      @sender.flush_waiting_packet
+      @publisher.config_all_message_queue
+    end
+
+    def init_connection
+      @connection_helper         = ConnectionHelper.new(@host, @port, @ssl, @ssl_context, @ack_timeout)
+      @connection_helper.handler = @handler
+      @sender                    = @connection_helper.sender
+    end
+
+    def session_params
+      {
+        :version       => @mqtt_version,
+        :clean_session => @clean_session,
+        :keep_alive    => @keep_alive,
+        :client_id     => @client_id,
+        :username      => @username,
+        :password      => @password,
+        :will_topic    => @will_topic,
+        :will_payload  => @will_payload,
+        :will_qos      => @will_qos,
+        :will_retain   => @will_retain
+      }
+    end
+
+    def check_persistence
+      disconnect(false)
+      @persistent
+    end
+  end
+end