mqtt-rails 1.0

data/lib/mqtt_rails/connection_helper.rb

@@ -0,0 +1,172 @@
+# 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 'socket'
+
+module MqttRails
+  class ConnectionHelper
+
+    attr_accessor :sender
+
+    def initialize(host, port, ssl, ssl_context, ack_timeout)
+      @cs          = MQTT_CS_DISCONNECT
+      @socket      = nil
+      @host        = host
+      @port        = port
+      @ssl         = ssl
+      @ssl_context = ssl_context
+      @ack_timeout = ack_timeout
+      @sender      = Sender.new(ack_timeout)
+    end
+
+    def handler=(handler)
+      @handler = handler
+    end
+
+    def do_connect(reconnection=false)
+      @cs = MQTT_CS_NEW
+      @handler.socket = @socket
+      # Waiting a Connack packet for "ack_timeout" second from the remote
+      connect_timeout = Time.now + @ack_timeout
+      while (Time.now <= connect_timeout) && !is_connected? do
+        @cs = @handler.receive_packet
+      end
+      unless is_connected?
+        Rails.logger.warn("Connection failed. Couldn't recieve a Connack packet from: #{@host}.")
+        raise Exception.new("Connection failed. Check log for more details.") unless reconnection
+      end
+      @cs
+    end
+
+    def is_connected?
+      @cs == MQTT_CS_CONNECTED
+    end
+
+    def do_disconnect(publisher, explicit, mqtt_thread)
+      Rails.logger.info("Disconnecting from #{@host}.")
+      if explicit
+        explicit_disconnect(publisher, mqtt_thread)
+      end
+      @socket.close unless @socket.nil? || @socket.closed?
+      @socket = nil
+    end
+
+    def explicit_disconnect(publisher, mqtt_thread)
+      @sender.flush_waiting_packet(false)
+      send_disconnect
+      mqtt_thread.kill if mqtt_thread && mqtt_thread.alive?
+      publisher.flush_publisher unless publisher.nil?
+    end
+
+    def setup_connection
+      clean_start(@host, @port)
+      config_socket
+      unless @socket.nil?
+        @sender.socket = @socket
+      end
+    end
+
+    def config_socket
+      Rails.logger.info("Attempt to connect to host: #{@host}...")
+      begin
+        tcp_socket = TCPSocket.new(@host, @port)
+        if @ssl
+          encrypted_socket(tcp_socket, @ssl_context)
+        else
+          @socket = tcp_socket
+        end
+      rescue StandardError
+        Rails.logger.warn("Could not open a socket with #{@host} on port #{@port}.")
+      end
+    end
+
+    def encrypted_socket(tcp_socket, ssl_context)
+      unless ssl_context.nil?
+        @socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context)
+        @socket.sync_close = true
+        @socket.connect
+      else
+        Rails.logger.error("The SSL context was found as nil while the socket's opening.")
+        raise Exception
+      end
+    end
+
+    def clean_start(host, port)
+      self.host = host
+      self.port = port
+      unless @socket.nil?
+        @socket.close unless @socket.closed?
+        @socket = nil
+      end
+    end
+
+    def host=(host)
+      if host.nil? || host == ""
+        Rails.logger.error("The host was found as nil while the connection setup.")
+        raise ArgumentError
+      else
+        @host = host
+      end
+    end
+
+    def port=(port)
+      if port.to_i <= 0
+        Rails.logger.error("The port value is invalid (<= 0). Could not setup the connection.")
+        raise ArgumentError
+      else
+        @port = port
+      end
+    end
+
+    def send_connect(session_params)
+      setup_connection
+      packet = MqttRails::Packet::Connect.new(session_params)
+      @handler.clean_session = session_params[:clean_session]
+      @sender.send_packet(packet)
+      MQTT_ERR_SUCCESS
+    end
+
+    def send_disconnect
+      packet = MqttRails::Packet::Disconnect.new
+      @sender.send_packet(packet)
+      MQTT_ERR_SUCCESS
+    end
+
+    # Would return 'true' if ping requset should be sent and  'nil' if not
+    def should_send_ping?(now, keep_alive, last_packet_received_at)
+      last_pingreq_sent_at = @sender.last_pingreq_sent_at
+      last_pingresp_received_at = @handler.last_pingresp_received_at
+      if !last_pingreq_sent_at || (last_pingresp_received_at && (last_pingreq_sent_at <= last_pingresp_received_at))
+        next_pingreq_at = [@sender.last_packet_sent_at, last_packet_received_at].min + (keep_alive * 0.7).ceil
+        return next_pingreq_at <= now
+      end
+    end
+
+    def check_keep_alive(persistent, keep_alive)
+      now = Time.now
+      last_packet_received_at = @handler.last_packet_received_at
+      # send a PINGREQ only if we don't already wait for a PINGRESP
+      if persistent && should_send_ping?(now, keep_alive, last_packet_received_at)
+        Rails.logger.info("Checking if server is still alive...")
+        @sender.send_pingreq
+      end
+      disconnect_timeout_at = last_packet_received_at + (keep_alive * 1.1).ceil
+      if disconnect_timeout_at <= now
+        Rails.logger.info("No activity is over timeout, disconnecting from #{@host}.")
+        @cs = MQTT_CS_DISCONNECT
+      end
+      @cs
+    end
+  end
+end

data/lib/mqtt_rails/exception.rb

@@ -0,0 +1,52 @@
+# Copyright (c) 2016-2018 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
+
+
+module MqttRails
+  class Exception < ::StandardError
+    def initialize(msg="")
+      super
+    end
+  end
+
+  class ProtocolViolation < Exception
+  end
+
+  class WritingException < Exception
+  end
+
+  class ReadingException < Exception
+  end
+
+  class PacketException < Exception
+  end
+
+  class PacketFormatException < Exception
+  end
+
+  class ProtocolVersionException < Exception
+  end
+
+  class LowVersionException < Exception
+  end
+
+  class FullWritingException < Exception
+  end
+
+  class FullQueueException < Exception
+  end
+
+  class NotSupportedEncryptionException < Exception
+  end
+end

data/lib/mqtt_rails/handler.rb

@@ -0,0 +1,274 @@
+# 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
+
+module MqttRails
+  class Handler
+
+    attr_reader   :registered_callback
+    attr_reader   :last_packet_received_at
+    attr_reader   :last_pingresp_received_at
+    attr_accessor :clean_session
+
+    def initialize
+      @registered_callback = []
+      @publisher           = nil
+      @subscriber          = nil
+    end
+
+    def config_pubsub(publisher, subscriber)
+      @publisher = publisher
+      @subscriber = subscriber
+    end
+
+    def socket=(socket)
+      @socket = socket
+    end
+
+    def receive_packet
+      result = IO.select([@socket], nil, nil, SELECT_TIMEOUT) unless @socket.nil? || @socket.closed?
+      unless result.nil?
+        packet = MqttRails::Packet::Base.read(@socket)
+        unless packet.nil?
+          @last_packet_received_at = Time.now
+          if packet.is_a?(MqttRails::Packet::Connack)
+            return handle_connack(packet)
+          else
+            handle_packet(packet)
+          end
+        end
+      end
+      result
+    end
+
+    def handle_packet(packet)
+      Rails.logger.info("New packet #{packet.class} received.")
+      type = packet_type(packet)
+      self.send("handle_#{type}", packet)
+    end
+
+    def register_topic_callback(topic, callback, &block)
+      if topic.nil?
+        Rails.logger.error("The topics where the callback is trying to be registered have been found nil.")
+        raise ArgumentError
+      end
+      clear_topic_callback(topic)
+      if block_given?
+        @registered_callback.push([topic, block])
+      elsif !(callback.nil?) && callback.is_a?(Proc)
+        @registered_callback.push([topic, callback])
+      end
+      MQTT_ERR_SUCCESS
+    end
+
+    def clear_topic_callback(topic)
+      if topic.nil?
+        Rails.logger.error("The topics where the callback is trying to be unregistered have been found nil.")
+        raise ArgumentError
+      end
+      @registered_callback.delete_if { |pair| pair.first == topic }
+      MQTT_ERR_SUCCESS
+    end
+
+    def handle_connack(packet)
+      if packet.return_code == 0x00
+        Rails.logger.info(packet.return_msg)
+        @last_pingresp_received_at = Time.now
+        handle_connack_accepted(packet.session_present)
+      else
+        Rails.logger.warn(packet.return_msg)
+        return MQTT_CS_DISCONNECT
+      end
+      @on_connack.call(packet) unless @on_connack.nil?
+      MQTT_CS_CONNECTED
+    end
+
+    def handle_connack_accepted(session_flag)
+      clean_session?(session_flag)
+      new_session?(session_flag)
+      old_session?(session_flag)
+    end
+
+    def new_session?(session_flag)
+      if !@clean_session && !session_flag
+        Rails.logger.info("New session created for the client.")
+      end
+    end
+
+    def clean_session?(session_flag)
+      if @clean_session && !session_flag
+        Rails.logger.info("No previous session found by server, starting a new one.")
+      end
+    end
+
+    def old_session?(session_flag)
+      if !@clean_session && session_flag
+        Rails.logger.info("Previous session restored by the server.")
+      end
+    end
+
+    def handle_pingresp(_packet)
+      @last_pingresp_received_at = Time.now
+    end
+
+    def handle_suback(packet)
+      max_qos = packet.return_codes
+      id      = packet.id
+      topics  = []
+      topics  = @subscriber.add_subscription(max_qos, id, topics)
+      unless topics.empty?
+        @on_suback.call(topics) unless @on_suback.nil?
+      end
+    end
+
+    def handle_unsuback(packet)
+      id = packet.id
+      topics = []
+      topics = @subscriber.remove_subscription(id, topics)
+      unless topics.empty?
+        @on_unsuback.call(topics) unless @on_unsuback.nil?
+      end
+    end
+
+    def handle_publish(packet)
+      id = packet.id
+      qos = packet.qos
+      if @publisher.do_publish(qos, id) == MQTT_ERR_SUCCESS
+        @on_message.call(packet) unless @on_message.nil?
+        check_callback(packet)
+      end
+    end
+
+    def handle_puback(packet)
+      id = packet.id
+      if @publisher.do_puback(id) == MQTT_ERR_SUCCESS
+        @on_puback.call(packet) unless @on_puback.nil?
+      end
+    end
+
+    def handle_pubrec(packet)
+      id = packet.id
+      if @publisher.do_pubrec(id) == MQTT_ERR_SUCCESS
+        @on_pubrec.call(packet) unless @on_pubrec.nil?
+      end
+    end
+
+    def handle_pubrel(packet)
+      id = packet.id
+      if @publisher.do_pubrel(id) == MQTT_ERR_SUCCESS
+        @on_pubrel.call(packet) unless @on_pubrel.nil?
+      end
+    end
+
+    def handle_pubcomp(packet)
+      id = packet.id
+      if @publisher.do_pubcomp(id) == MQTT_ERR_SUCCESS
+        @on_pubcomp.call(packet) unless @on_pubcomp.nil?
+      end
+    end
+
+    def on_connack(&block)
+      @on_connack = block if block_given?
+      @on_connack
+    end
+
+    def on_suback(&block)
+      @on_suback = block if block_given?
+      @on_suback
+    end
+
+    def on_unsuback(&block)
+      @on_unsuback = block if block_given?
+      @on_unsuback
+    end
+
+    def on_puback(&block)
+      @on_puback = block if block_given?
+      @on_puback
+    end
+
+    def on_pubrec(&block)
+      @on_pubrec = block if block_given?
+      @on_pubrec
+    end
+
+    def on_pubrel(&block)
+      @on_pubrel = block if block_given?
+      @on_pubrel
+    end
+
+    def on_pubcomp(&block)
+      @on_pubcomp = block if block_given?
+      @on_pubcomp
+    end
+
+    def on_message(&block)
+      @on_message = block if block_given?
+      @on_message
+    end
+
+    def on_connack=(callback)
+      @on_connack = callback if callback.is_a?(Proc)
+    end
+
+    def on_suback=(callback)
+      @on_suback = callback if callback.is_a?(Proc)
+    end
+
+    def on_unsuback=(callback)
+      @on_unsuback = callback if callback.is_a?(Proc)
+    end
+
+    def on_puback=(callback)
+      @on_puback = callback if callback.is_a?(Proc)
+    end
+
+    def on_pubrec=(callback)
+      @on_pubrec = callback if callback.is_a?(Proc)
+    end
+
+    def on_pubrel=(callback)
+      @on_pubrel = callback if callback.is_a?(Proc)
+    end
+
+    def on_pubcomp=(callback)
+      @on_pubcomp = callback if callback.is_a?(Proc)
+    end
+
+    def on_message=(callback)
+      @on_message = callback if callback.is_a?(Proc)
+    end
+
+    def packet_type(packet)
+      type = packet.class
+      if MqttRails::PACKET_TYPES[3..13].include?(type)
+        type.to_s.split('::').last.downcase
+      else
+        Rails.logger.error("Received an unexpeceted packet: #{packet}.")
+        raise PacketException.new('Invalid packet type id')
+      end
+    end
+
+    def check_callback(packet)
+      callbacks = []
+      @registered_callback.each do |reccord|
+        callbacks.push(reccord.last) if MqttRails.match_filter(packet.topic, reccord.first)
+      end
+      unless callbacks.empty?
+        callbacks.each do |callback|
+          callback.call(packet)
+        end
+      end
+    end
+  end
+end