mqtt-rails 1.0

data/lib/mqtt_rails/sender.rb

@@ -0,0 +1,129 @@
+# 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 Sender
+
+    attr_reader :last_packet_sent_at
+    attr_reader :last_pingreq_sent_at
+
+    def initialize(ack_timeout)
+      @socket          = nil
+      @writing_queue   = []
+      @publish_queue   = []
+      @publish_mutex   = Mutex.new
+      @writing_mutex   = Mutex.new
+      @ack_timeout     = ack_timeout
+    end
+
+    def socket=(socket)
+      @socket = socket
+    end
+
+    def send_packet(packet)
+      begin
+        unless @socket.nil? || @socket.closed?
+          @socket.write(packet.to_s)
+          @last_packet_sent_at = Time.now
+          MQTT_ERR_SUCCESS
+        else
+          MQTT_ERR_FAIL
+        end
+      end
+    rescue StandardError
+      raise WritingException
+    rescue IO::WaitWritable
+      IO.select(nil, [@socket], nil, SELECT_TIMEOUT)
+      retry
+    end
+
+    def send_pingreq
+      @last_pingreq_sent_at = Time.now if send_packet(MqttRails::Packet::Pingreq.new) == MQTT_ERR_SUCCESS
+    end
+
+    def prepare_sending(queue, mutex, max_packet, packet)
+      if queue.length < max_packet
+        mutex.synchronize do
+          queue.push(packet)
+        end
+      else
+        Rails.logger.error('Writing queue is full, slowing down')
+        raise FullWritingException
+      end
+    end
+
+    def append_to_writing(packet)
+      begin
+        if packet.is_a?(MqttRails::Packet::Publish)
+          prepare_sending(@publish_queue, @publish_mutex, MAX_PUBLISH, packet)
+        else
+          prepare_sending(@writing_queue, @writing_mutex, MAX_QUEUE, packet)
+        end
+      rescue FullWritingException
+        sleep SELECT_TIMEOUT
+        retry
+      end
+      MQTT_ERR_SUCCESS
+    end
+
+    def writing_loop
+      @writing_mutex.synchronize do
+        MAX_QUEUE.times do
+          break if @writing_queue.empty?
+          packet = @writing_queue.shift
+          send_packet(packet)
+        end
+      end
+      @publish_mutex.synchronize do
+        MAX_PUBLISH.times do
+          break if @publish_queue.empty?
+          packet = @publish_queue.shift
+          send_packet(packet)
+        end
+      end
+      MQTT_ERR_SUCCESS
+    end
+
+    def flush_waiting_packet(sending=true)
+      if sending
+        @writing_mutex.synchronize do
+          @writing_queue.each do |packet|
+            send_packet(packet)
+          end
+        end
+        @publish_mutex.synchronize do
+          @publish_queue.each do |packet|
+            send_packet(packet)
+          end
+        end
+      end
+      @writing_queue = []
+      @publish_queue = []
+    end
+
+    def check_ack_alive(queue, mutex)
+      mutex.synchronize do
+        now = Time.now
+        queue.each do |pck|
+          if now >= pck[:timestamp] + @ack_timeout
+            pck[:packet].dup ||= true unless pck[:packet].class == MqttRails::Packet::Subscribe || pck[:packet].class == MqttRails::Packet::Unsubscribe
+            Rails.logger.info("Acknowledgement timeout is over, resending #{pck[:packet].inspect}")
+            send_packet(pck[:packet])
+            pck[:timestamp] = now
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mqtt_rails/ssl_helper.rb

@@ -0,0 +1,61 @@
+# 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 'openssl'
+
+module MqttRails
+  module SSLHelper
+    extend self
+
+    def config_ssl_context(cert_path=nil, key_path=nil, ca_path=nil)
+      ssl_context = OpenSSL::SSL::SSLContext.new
+      set_cert(cert_path, ssl_context)
+      set_key(key_path, ssl_context)
+      set_root_ca(ca_path, ssl_context)
+      # ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER unless ca_path.nil?
+      ssl_context
+    end
+
+    def set_cert(cert_path=nil, ssl_context)
+      unless cert_path.nil?
+        ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(cert_path))
+      end
+    end
+
+    def set_key(key_path=nil, ssl_context)
+      unless key_path.nil?
+        return MQTT_ERR_SUCCESS if try_rsa_key(key_path, ssl_context) == MQTT_ERR_SUCCESS
+        begin
+          ssl_context.key = OpenSSL::PKey::EC.new(File.read(key_path))
+          return MQTT_ERR_SUCCESS
+        rescue OpenSSL::PKey::ECError
+          raise NotSupportedEncryptionException.new("Could not support the type of the provided key (supported: RSA and EC)")
+        end
+      end
+    end
+
+    def try_rsa_key(key_path, ssl_context)
+      begin
+        ssl_context.key = OpenSSL::PKey::RSA.new(File.read(key_path))
+        return MQTT_ERR_SUCCESS
+      rescue OpenSSL::PKey::RSAError
+        return MQTT_ERR_FAIL
+      end
+    end
+
+    def set_root_ca(ca_path, ssl_context)
+      ssl_context.ca_file = ca_path
+    end
+  end
+end

data/lib/mqtt_rails/subscriber.rb

@@ -0,0 +1,166 @@
+# 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 Subscriber
+
+    attr_reader :subscribed_topics
+
+    def initialize(sender)
+      @waiting_suback    = []
+      @waiting_unsuback  = []
+      @subscribed_mutex  = Mutex.new
+      @subscribed_topics = []
+      @suback_mutex      = Mutex.new
+      @unsuback_mutex    = Mutex.new
+      @sender            = sender
+    end
+
+    def sender=(sender)
+      @sender = sender
+    end
+
+    def config_subscription(new_id)
+      unless @subscribed_topics == [] || @subscribed_topics.nil?
+        packet = MqttRails::Packet::Subscribe.new(
+          :id     => new_id,
+          :topics => @subscribed_topics
+        )
+        @subscribed_mutex.synchronize do
+          @subscribed_topics = []
+        end
+        @suback_mutex.synchronize do
+          if @waiting_suback.length >= MAX_SUBACK
+            Rails.logger.error('SUBACK queue is full, could not send subscribe')
+            return MQTT_ERR_FAILURE
+          end
+          @waiting_suback.push(:id => new_id, :packet => packet, :timestamp => Time.now)
+        end
+        @sender.append_to_writing(packet)
+      end
+      MQTT_ERR_SUCCESS
+    end
+
+    def add_subscription(max_qos, packet_id, adjust_qos)
+      @suback_mutex.synchronize do
+        adjust_qos, @waiting_suback = @waiting_suback.partition { |pck| pck[:id] == packet_id }
+      end
+      if adjust_qos.length == 1
+        adjust_qos = adjust_qos.first[:packet].topics
+        adjust_qos.each do |t|
+          if [0, 1, 2].include?(max_qos[0])
+            t[1] = max_qos.shift
+          elsif max_qos[0] == 128
+            adjust_qos.delete(t)
+          else
+            Rails.logger.error("The QoS value is invalid in subscribe.")
+            raise PacketException.new('Invalid suback QoS value')
+          end
+        end
+      else
+        Rails.logger.error("The packet id is invalid, already used.")
+        raise PacketException.new("Invalid suback packet id: #{packet_id}")
+      end
+      @subscribed_mutex.synchronize do
+        @subscribed_topics.concat(adjust_qos)
+      end
+      return adjust_qos
+    end
+
+    def remove_subscription(packet_id, to_unsub)
+      @unsuback_mutex.synchronize do
+        to_unsub, @waiting_unsuback = @waiting_unsuback.partition { |pck| pck[:id] == packet_id }
+      end
+
+      if to_unsub.length == 1
+        to_unsub = to_unsub.first[:packet].topics
+      else
+        Rails.logger.error("The packet id is invalid, already used.")
+        raise PacketException.new("Invalid unsuback packet id: #{packet_id}")
+      end
+
+      @subscribed_mutex.synchronize do
+        to_unsub.each do |filter|
+          @subscribed_topics.delete_if { |topic| MqttRails.match_filter(topic.first, filter) }
+        end
+      end
+      return to_unsub
+    end
+
+    def send_subscribe(topics, new_id)
+      unless valid_topics?(topics) == MQTT_ERR_FAIL
+        packet = MqttRails::Packet::Subscribe.new(
+          :id     => new_id,
+          :topics => topics
+        )
+        @sender.append_to_writing(packet)
+        @suback_mutex.synchronize do
+          if @waiting_suback.length >= MAX_SUBACK
+            Rails.logger.error('SUBACK queue is full, could not send subscribe')
+            return MQTT_ERR_FAILURE
+          end
+          @waiting_suback.push(:id => new_id, :packet => packet, :timestamp => Time.now)
+        end
+        MQTT_ERR_SUCCESS
+      else
+        raise ProtocolViolation
+      end
+    end
+
+    def send_unsubscribe(topics, new_id)
+      unless valid_topics?(topics) == MQTT_ERR_FAIL
+        packet = MqttRails::Packet::Unsubscribe.new(
+          :id     => new_id,
+          :topics => topics
+        )
+        @sender.append_to_writing(packet)
+        @unsuback_mutex.synchronize do
+          if @waiting_suback.length >= MAX_UNSUBACK
+            Rails.logger.error('UNSUBACK queue is full, could not send unbsubscribe')
+            return MQTT_ERR_FAIL
+          end
+          @waiting_unsuback.push(:id => new_id, :packet => packet, :timestamp => Time.now)
+        end
+        MQTT_ERR_SUCCESS
+      else
+        raise ProtocolViolation
+      end
+    end
+
+    def check_waiting_subscriber
+      @sender.check_ack_alive(@waiting_suback, @suback_mutex)
+      @sender.check_ack_alive(@waiting_unsuback, @unsuback_mutex)
+    end
+
+    def clear_queue
+      @waiting_suback = []
+    end
+
+    def valid_topics?(topics)
+      unless topics.length == 0
+        topics.map do |topic|
+          case topic
+          when Array
+            return MQTT_ERR_FAIL if topic.first == ""
+          when String
+            return MQTT_ERR_FAIL if topic == ""
+          end
+        end
+      else
+        MQTT_ERR_FAIL
+      end
+      MQTT_ERR_SUCCESS
+    end
+  end
+end

data/lib/mqtt_rails/version.rb

@@ -0,0 +1,3 @@
+module MqttRails
+  VERSION = "1.0"
+end

data/mqtt-rails.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mqtt_rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mqtt-rails"
+  spec.version       = MqttRails::VERSION
+  spec.authors       = ["Nicolas KOVACS"]
+  spec.email         = ["pro.nkovacs@gmail.com"]
+
+  spec.summary       = %q{A simple rails mqtt client gem}
+  spec.description   = %q{A simple rails mqtt client gem}
+  spec.homepage      = "https://github.com/nicovak/mqtt.rails.git"
+  spec.license       = "EPL-1.0"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+  #    spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/samples/client_blocking(reading).rb

@@ -0,0 +1,29 @@
+require 'mqtt-rails'
+
+client = MqttRails::Client.new()
+
+client.on_message do |pck|
+  puts "New Message: #{pck.topic}\n>>> #{pck.payload}"
+end
+
+wait_suback = true
+client.on_suback do |pck|
+  wait_suback = false
+end
+
+client.connect('localhost', 1883, client.keep_alive, true, true)
+
+Thread.new do
+  while wait_suback do
+    client.loop_read
+    sleep 0.001
+  end
+end
+
+client.subscribe(["topic_test", 2])
+client.loop_write
+
+loop do
+  client.loop_read
+  sleep 0.01
+end

data/samples/client_blocking(writing).rb

@@ -0,0 +1,18 @@
+require 'mqtt-rails'
+
+Rails.logger = ('mqtt_rails.log')
+
+client = MqttRails::Client.new()
+
+client.on_message = lambda { |p|  puts ">>>>> This is the callback for a message event <<<<<\nTopic: #{p.topic}\nPayload: #{p.payload}\nQoS: #{p.qos}" }
+
+
+client.connect('localhost', 1883, client.keep_alive, true, true)
+client.subscribe(["topic_test", 2])
+
+loop do
+  client.publish("topic_test", "Hello, Are you there?", false, 1)
+  client.loop_write
+  client.loop_read
+  sleep 1
+end