paho-mqtt 1.0.0 → 1.0.1

data/lib/paho_mqtt/publisher.rb

@@ -0,0 +1,180 @@
+# 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 PahoMqtt
+  class Publisher
+
+    def initialize(sender)
+      @waiting_puback = []
+      @waiting_pubrec = []
+      @waiting_pubrel = []
+      @waiting_pubcomp = []
+      @puback_mutex = Mutex.new
+      @pubrec_mutex = Mutex.new
+      @pubrel_mutex = Mutex.new
+      @pubcomp_mutex = Mutex.new
+      @sender = sender
+    end
+
+    def sender=(sender)
+      @sender = sender
+    end
+
+    def send_publish(topic, payload, retain, qos, new_id)
+      packet = PahoMqtt::Packet::Publish.new(
+        :id => new_id,
+        :topic => topic,
+        :payload => payload,
+        :retain => retain,
+        :qos => qos
+      )
+      @sender.append_to_writing(packet)
+      case qos
+      when 1
+        @puback_mutex.synchronize{
+          @waiting_puback.push({:id => new_id, :packet => packet, :timestamp => Time.now})
+        }
+      when 2
+        @pubrec_mutex.synchronize{
+          @waiting_pubrec.push({:id => new_id, :packet => packet, :timestamp => Time.now})
+        }
+      end
+      MQTT_ERR_SUCCESS
+    end
+
+    def do_publish(qos, packet_id)
+      case qos
+      when 0
+      when 1
+        send_puback(packet_id)
+      when 2
+        send_pubrec(packet_id)
+      else
+        @logger.error("The packet qos value is invalid in publish.") if logger?
+        raise PacketException
+      end
+      MQTT_ERR_SUCCESS
+    end
+
+    def send_puback(packet_id)
+      packet = PahoMqtt::Packet::Puback.new(
+        :id => packet_id
+      )
+      @sender.append_to_writing(packet)
+      MQTT_ERR_SUCCESS
+    end
+
+    def do_puback(packet_id)
+      @puback_mutex.synchronize{
+        @waiting_puback.delete_if { |pck| pck[:id] == packet_id }
+      }
+      MQTT_ERR_SUCCESS      
+    end
+    
+    def send_pubrec(packet_id)
+      packet = PahoMqtt::Packet::Pubrec.new(
+        :id => packet_id
+      )
+      @sender.append_to_writing(packet)
+      @pubrel_mutex.synchronize{
+        @waiting_pubrel.push({:id => packet_id , :packet => packet, :timestamp => Time.now})
+      }
+      MQTT_ERR_SUCCESS
+    end
+
+    def do_pubrec(packet_id)
+      @pubrec_mutex.synchronize {
+        @waiting_pubrec.delete_if { |pck| pck[:id] == packet_id }
+      }
+      send_pubrel(packet_id)
+      MQTT_ERR_SUCCESS
+    end
+
+    def send_pubrel(packet_id)
+      packet = PahoMqtt::Packet::Pubrel.new(
+        :id => packet_id
+      )
+      @sender.append_to_writing(packet)
+      @pubcomp_mutex.synchronize{
+        @waiting_pubcomp.push({:id => packet_id, :packet => packet, :timestamp => Time.now})
+      }
+      MQTT_ERR_SUCCESS
+    end
+
+    def do_pubrel(packet_id)
+      @pubrel_mutex.synchronize {
+        @waiting_pubrel.delete_if { |pck| pck[:id] == packet_id }
+      }
+      send_pubcomp(packet_id)
+      MQTT_ERR_SUCCESS
+    end
+
+    def send_pubcomp(packet_id)
+      packet = PahoMqtt::Packet::Pubcomp.new(
+        :id => packet_id
+      )
+      @sender.append_to_writing(packet)
+      MQTT_ERR_SUCCESS
+    end
+
+    def do_pubcomp(packet_id)
+      @pubcomp_mutex.synchronize {
+        @waiting_pubcomp.delete_if { |pck| pck[:id] == packet_id }
+      }
+      MQTT_ERR_SUCCESS
+    end
+
+    def config_all_message_queue
+      config_message_queue(@waiting_puback, @puback_mutex, MAX_PUBACK)
+      config_message_queue(@waiting_pubrec, @pubrec_mutex, MAX_PUBREC)
+      config_message_queue(@waiting_pubrel, @pubrel_mutex, MAX_PUBREL)
+      config_message_queue(@waiting_pubcomp, @pubcomp_mutex, MAX_PUBCOMP)
+    end
+
+    def config_message_queue(queue, mutex, max_packet)
+      mutex.synchronize {
+        cnt = 0 
+        queue.each do |pck|
+          pck[:packet].dup ||= true
+          if cnt <= max_packet
+            @sender.append_to_writing(pck[:packet])
+            cnt += 1
+          end
+        end
+      }
+    end
+
+    def check_waiting_publisher
+      @sender.check_ack_alive(@waiting_puback, @puback_mutex, MAX_PUBACK)
+      @sender.check_ack_alive(@waiting_pubrec, @pubrec_mutex, MAX_PUBREC)
+      @sender.check_ack_alive(@waiting_pubrel, @pubrel_mutex, MAX_PUBREL)
+      @sender.check_ack_alive(@waiting_pubcomp, @pubcomp_mutex, MAX_PUBCOMP)
+    end
+
+    def flush_publisher
+      @puback_mutex.synchronize {
+        @waiting_puback = []
+      }
+      @pubrec_mutex.synchronize {
+        @waiting_pubrec = []
+      }
+      @pubrel_mutex.synchronize {
+        @waiting_pubrel = []
+      }
+      @pubcomp_mutex.synchronize {
+        @waiting_pubcomp = []
+      }
+    end
+  end
+end

data/lib/paho_mqtt/sender.rb

@@ -0,0 +1,90 @@
+# 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 PahoMqtt
+  class Sender
+
+    attr_accessor :last_ping_req
+
+    def initialize(ack_timeout)
+      @socket = nil
+      @writing_queue = []
+      @writing_mutex = Mutex.new
+      @last_ping_req = -1
+      @ack_timeout = ack_timeout
+    end
+
+    def socket=(socket)
+      @socket = socket
+    end
+
+    def send_packet(packet)
+      begin
+        @socket.write(packet.to_s) unless @socket.nil? || @socket.closed?
+        @last_ping_req = Time.now
+        MQTT_ERR_SUCCESS
+      rescue StandardError
+        raise WritingException
+      end
+    end
+
+    def append_to_writing(packet)      
+      @writing_mutex.synchronize {
+        @writing_queue.push(packet)
+      }
+      MQTT_ERR_SUCCESS
+    end
+
+      @writing_mutex.synchronize {
+    def writing_loop(max_packet)
+        cnt = 0
+        while !@writing_queue.empty? && cnt < max_packet do
+          packet = @writing_queue.shift
+          send_packet(packet)
+          cnt += 1
+        end
+      }
+      MQTT_ERR_SUCCESS
+    end
+
+    def flush_waiting_packet(sending=true)
+      if sending
+        @writing_mutex.synchronize {
+          @writing_queue.each do |m|
+            send_packet(m)
+          end
+        }
+      else
+        @writing_queue = []
+      end
+    end
+    
+    def check_ack_alive(queue, mutex, max_packet)
+      mutex.synchronize {
+        now = Time.now
+        cnt = 0
+        queue.each do |pck|
+          if now >= pck[:timestamp] + @ack_timeout
+            pck[:packet].dup ||= true unless pck[:packet].class == PahoMqtt::Packet::Subscribe || pck[:packet].class == PahoMqtt::Packet::Unsubscribe
+            unless cnt > max_packet
+              append_to_writing(pck[:packet]) 
+              pck[:timestamp] = now
+              cnt += 1
+            end
+          end
+        end
+      }
+    end
+  end
+end

data/lib/paho_mqtt/ssl_helper.rb

@@ -0,0 +1,42 @@
+# 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 PahoMqtt
+  module SSLHelper
+    extend self
+
+    def config_ssl_context(cert_path, key_path, 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, ssl_context)
+      ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(cert_path))
+    end
+
+    def set_key(key_path, ssl_context)
+      ssl_context.key = OpenSSL::PKey::RSA.new(File.read(key_path))
+    end
+
+    def set_root_ca(ca_path, ssl_context)
+      ssl_context.ca_file = ca_path
+    end
+  end
+end

data/lib/paho_mqtt/subscriber.rb

@@ -0,0 +1,195 @@
+# 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 PahoMqtt
+  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 = PahoMqtt::Packet::Subscribe.new(
+          :id => new_id,
+          :topics => @subscribed_topics
+        )
+        @subscribed_mutex.synchronize {
+          @subscribed_topics = []
+        }
+        @suback_mutex.synchronize {
+          @waiting_suback.push({ :id => new_id, :packet => packet, :timestamp => Time.now })
+        }
+        @sender.send_packet(packet)
+      end
+      MQTT_ERR_SUCCESS
+    end
+
+    def add_subscription(max_qos, packet_id, adjust_qos)
+      @suback_mutex.synchronize {
+        adjust_qos, @waiting_suback = @waiting_suback.partition { |pck| pck[:id] == packet_id }
+      }
+      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
+
+            @logger.error("The qos value is invalid in subscribe.") if logger?
+            raise PacketException
+          end
+        end
+      else
+        @logger.error("The packet id is invalid, already used.") if logger?
+        raise PacketException
+      end
+      @subscribed_mutex.synchronize {
+        @subscribed_topics.concat(adjust_qos)
+      }
+      MQTT_ERR_SUCCESS
+    end
+
+    def remove_subscription(packet_id, to_unsub)
+      @unsuback_mutex.synchronize {
+        to_unsub, @waiting_unsuback = @waiting_unsuback.partition { |pck| pck[:id] == packet_id }
+      }
+      
+      if to_unsub.length == 1
+        to_unsub = to_unsub.first[:packet].topics
+      else
+        @logger.error("The packet id is invalid, already used.") if logger?
+        raise PacketException
+      end
+
+      @subscribed_mutex.synchronize {
+        to_unsub.each do |filter|
+          @subscribed_topics.delete_if { |topic| match_filter(topic.first, filter.first) }
+        end
+      }
+      MQTT_ERR_SUCCESS
+    end
+    
+    def send_subscribe(topics, new_id)
+      unless valid_topics?(topics) == MQTT_ERR_FAIL
+        packet = PahoMqtt::Packet::Subscribe.new(
+          :id => new_id,
+          :topics => topics
+        )        
+        @sender.append_to_writing(packet)
+        @suback_mutex.synchronize {
+          @waiting_suback.push({ :id => new_id, :packet => packet, :timestamp => Time.now })
+        }
+        MQTT_ERR_SUCCESS
+      else
+        raise ProtocolViolation
+      end
+    end
+
+    def send_unsubscribe(topics, new_id)
+      unless valid_topics?(topics) == MQTT_ERR_FAIL
+        packet = PahoMqtt::Packet::Unsubscribe.new(
+          :id => new_id,
+          :topics => topics
+        )
+        
+        @sender.append_to_writing(packet)
+        @unsuback_mutex.synchronize {
+          @waiting_unsuback.push({:id => new_id, :packet => packet, :timestamp => Time.now})
+        }
+        MQTT_ERR_SUCCESS
+      else
+        raise ProtocolViolation
+      end
+    end
+
+    def check_waiting_subscriber
+      @sender.check_ack_alive(@waiting_suback, @suback_mutex, @waiting_suback.length)
+      @sender.check_ack_alive(@waiting_unsuback, @unsuback_mutex, @waiting_unsuback.length)
+    end
+
+    def valid_topics?(topics)
+      unless topics.length == 0
+        topics.map do |topic|
+          return MQTT_ERR_FAIL if topic.first == ""
+        end
+      else
+        MQTT_ERR_FAIL
+      end
+      MQTT_ERR_SUCCESS
+    end
+
+
+    private
+
+    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
+        @logger.error("Topics or Wildcards are not found as String.") if logger?
+        raise ArgumentError
+      end
+    end
+  end
+end