mqtt-sub_handler 0.1.6 → 0.1.6.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 22d57768280da99134fc12c1ab6d07b441df823f59992d88411a1bc8b88cfe16
-  data.tar.gz: 34ead01f1186b52591969071404c2812badd339e17a404178b44295d6d6ed8e8
+SHA1:
+  metadata.gz: 9be8cc94d063f20f4e602ca44c33e1f063fcd8db
+  data.tar.gz: b115b3aa01cdb8aceab2ba442d1e8748c25ce3e1
 SHA512:
-  metadata.gz: 11569eef332d8d8c186b6c246bfd32bea0643270152e27c06b1e92e560c93a091809a2994c3424fd36ed9e0d2898defcc8f45e7e57da3879a276e837d6e2b663
-  data.tar.gz: a1d962a3af87a942f45af28540b5902903cf0e37a569d7b174793dd471183c8337fc95f1bd4f0a06a9b9997cb04da78e60ed663be399968bddced5e641ad0aad
+  metadata.gz: 18305fa0dbabdaea4762c0b53adec091bd0db67f06ef23aca414ab136ccc35e50c26641f5d21cd6d70554a6b213f87295b23ceaab1f07d9ff04f0e17fef53770
+  data.tar.gz: 8b1aa38aad47777c42538ef19d17db3cf9cd49259d177863664d8ae561406d0691a7e80b774e1f6dd5f6d09d8ce6c8bda7a23a933a2f68b593e29daf857aa7fe

data/lib/mqtt/base_handler.rb

@@ -0,0 +1,355 @@
+
+require 'timeout'
+require 'mqtt'
+require 'colorize'
+
+require 'xasin_logger'
+
+module MQTT
+	class BaseHandler
+		include XasLogger::Mix
+
+		# Split a Topic into a Topic-Array
+		# @param topicName [String] The string topic which to split
+		# @return [Array<String>] A list of individual topic-branches
+		# @note This function is mainly used for background processing.
+		def self.get_topic_split(topicName)
+			return topicName.scan(/[^\/]+/);
+		end
+
+		# Match a topic string to a topic pattern
+		# @param receivedTopicString [String] The string (as
+		#  returned by MQTT.get) to compare
+		# @param topicPattern [Array<String>] The Topic-Array (as
+		#  returned by .get_topic_split) to compare against
+		# @return [nil, Array<String>] Nil if no match was found.
+		#  An Array of matched wildcard topic branches (can be empty) when
+		#  successfully matched
+		# @note (see .get_topic_split)
+		def self.getTopicMatch(receivedTopicString, topicPattern)
+			receivedTopicList = get_topic_split receivedTopicString;
+
+			outputTopicList = Array.new();
+
+			return nil unless receivedTopicList.length >= topicPattern.length;
+
+			topicPattern.each_index do |i|
+				if(topicPattern[i] == "+")
+					outputTopicList << receivedTopicList[i];
+
+				elsif(topicPattern[i] == "#")
+					outputTopicList.concat receivedTopicList[i..-1];
+					return outputTopicList;
+
+				elsif topicPattern[i] != receivedTopicList[i];
+					return nil;
+
+				end
+			end
+
+			return outputTopicList if topicPattern.length == receivedTopicList.length;
+			return nil;
+		end
+
+		# Call all existing callbacks whose topic-list matches `topic`
+		def call_interested(topic, data)
+			topicHasReceivers = false;
+			@callbackList.each do |h|
+				tMatch = BaseHandler.getTopicMatch(topic, h.topic_split);
+				if tMatch
+					begin
+						Timeout.timeout(10) {
+							h.offer(tMatch, data)
+						}
+					rescue Timeout::Error
+						x_loge("Timeout on callback #{h}");
+					rescue => e
+						x_logf("Uncaught error on #{h}");
+						x_logf(e.inspect);
+					end
+					topicHasReceivers = true;
+				end
+			end
+
+			@mqtt.unsubscribe(topic) unless topicHasReceivers;
+		end
+		private :call_interested
+
+		def queue_packet(data)
+			return if @destroying
+
+			@packetQueueMutex.synchronize {
+				@packetQueue << data;
+				if(@packetQueue.size == 999)
+					x_logf("Packet queue congested, dropping packets!");
+				end
+				if(@packetQueue.size > 1000)
+					@packetQueue.shift
+				end
+
+				@publisherThread.run() if @publisherThreadWaiting;
+			}
+		end
+		private :queue_packet
+
+		# @!group Custom subscription handling
+
+		# Unregister a subscription. Removes it from the callback list and
+		# unsubscribes from the topic if no other subscriptions for it are present.
+		# @param subObject [MQTT::Subscriptions::Subscription]
+		#  The subscription-object to remove
+		# @return void
+		def unregister_subscription(subObject)
+			raise ArgumentError, "Object is not a subscription!" unless subObject.is_a? MQTT::Subscriptions::Subscription
+			return unless @callbackList.include? subObject;
+
+			queue_packet({type: :unsub, topic: subObject.topic});
+			@callbackList.delete(subObject);
+		end
+		# Register a custom subscription, and send a subscription message to the server.
+		# @param subObject [MQTT::Subscriptions::Subscription]
+		#  An instance of a MQTT Subscription object
+		# @return void
+		def register_subscription(subObject)
+			raise ArgumentError, "Object is not a subscription!" unless subObject.is_a? MQTT::Subscriptions::Subscription
+			return if @callbackList.include? subObject;
+
+			@callbackList << subObject;
+			queue_packet({type: :sub, topic: subObject.topic, qos: subObject.qos});
+		end
+
+		# @!endgroup
+
+		def ensure_clean_start()
+			@mqttWasStartedClean = @mqtt.clean_session
+			if @mqttWasStartedClean
+				begin
+					@mqtt.connect();
+					@mqtt.disconnect();
+				rescue MQTT::Exception
+					sleep 1;
+					retry
+				rescue SocketError, SystemCallError
+					sleep 5
+					retry
+				end
+				@mqtt.clean_session=false;
+			end
+		end
+		private :ensure_clean_start
+
+		def ensure_clean_exit()
+			if(@mqttWasStartedClean)
+				x_logi("Logging out.")
+				begin
+				Timeout.timeout(3) {
+					begin
+						@mqtt.clean_session = true;
+						@mqtt.disconnect();
+						@mqtt.connect();
+					rescue MQTT::Exception, SocketError, SystemCallError
+						sleep 0.3
+						retry;
+					end
+				}
+				rescue  Timeout::Error
+					x_loge("Timed out, aborting!");
+				else
+					x_logi("Done");
+				end
+			end
+		end
+		private :ensure_clean_exit
+
+		def attempt_packet_publish()
+			until @packetQueue.empty? do
+				h = nil;
+				@packetQueueMutex.synchronize {
+					h = @packetQueue[0];
+				}
+				Timeout.timeout(3) {
+					if(h[:type] == :sub)
+						@mqtt.subscribe(h[:topic] => h[:qos]);
+					elsif(h[:type] == :pub)
+						@mqtt.publish(h[:topic], h[:data], h[:retain], h[:qos]);
+					end
+				}
+				@packetQueueMutex.synchronize {
+					@packetQueue.shift();
+				}
+			end
+		end
+
+		def mqtt_push_thread
+			@push_error_count = 0;
+
+			loop do
+				@packetQueueMutex.synchronize {
+					@publisherThreadWaiting = true;
+				}
+				x_logd("Push thread stopping")
+				sleep 1
+				x_logd("Push thread active")
+				@packetQueueMutex.synchronize {
+					@publisherThreadWaiting = false;
+				}
+				break if @destroying
+
+				next unless @connected
+
+				begin
+					attempt_packet_publish();
+				rescue MQTT::Exception, SocketError, SystemCallError, Timeout::Error => e
+					x_loge("Push error!");
+					x_loge(e.inspect);
+
+					@push_error_count += 1;
+					if(@push_error_count >= 10)
+						@mqtt.disconnect();
+					end
+
+					sleep 0.5
+				else
+					@push_error_count = 0;
+				end
+			end
+
+			x_logd("Push thread exited!");
+		end
+		private :mqtt_push_thread
+
+		def mqtt_resub_thread
+			loop do
+				begin
+					return if @destroying
+
+					x_logw("Trying to reconnect...");
+					Timeout.timeout(4) {
+						@mqtt.connect()
+					}
+					x_logi("Connected!");
+					@conChangeMutex.synchronize {
+						@connected = true;
+						@reconnectCount = 0;
+					}
+
+					@packetQueueMutex.synchronize {
+						@publisherThread.run() if (@publisherThread && @publisherThreadWaiting)
+					}
+
+					x_logd("Sub thread reading...");
+					@mqtt.get do |topic, message|
+						call_interested(topic, message);
+					end
+				rescue MQTT::Exception, Timeout::Error, SocketError, SystemCallError
+					x_loge("Disconnected!") if @connected
+					@connected = false;
+					@reconnectCount += 1;
+
+					@conChangeMutex.unlock if @conChangeMutex.owned?
+					@mqtt.clean_session = false;
+					sleep [0.1, 0.5, 1, 1, 5, 5, 5, 10, 10, 10, 10][@reconnectCount] || 30;
+				end
+			end
+
+			x_logd("Sub thread exited");
+		end
+		private :mqtt_resub_thread
+
+		def destroy!()
+			return if @destroying
+			@destroying = true;
+
+			unless @packetQueue.empty?
+				x_logd "Finishing sending of MQTT messages ... "
+				@publisherThread.run() if @publisherThreadWaiting
+				begin
+					Timeout.timeout(4) {
+						until @packetQueue.empty? do
+							sleep 0.05;
+						end
+					}
+				rescue Timeout::Error
+					x_logw "Not all messages were published";
+				else
+					x_logd "Publish clean finished"
+				end
+			end
+
+			@publisherThread.run();
+			@publisherThread.join();
+			@listenerThread.kill();
+
+			@mqtt.disconnect() if @connected
+
+			ensure_clean_exit();
+
+			x_logi("Fully disconnected!");
+		end
+
+		# Initialize a new MQTT::SubHandler
+		# The handler immediately connects to the server, and begins receciving and sending.
+		# @param mqttClient [String, MQTT::Client] Either a URI to connect to, or a MQTT::Client
+		#  The URI can be of the form "mqtts://Password@User:URL:port".
+		#  The MQTT client instance can be fully configured, as specified by the MQTT Gem. It must *not* already be connected!
+		# @param jsonify [Boolean] Should Hashes and Arrays input into publish_to be converted to JSON?
+		#  This can be useful to have one less .to_json call. Default is true.
+		# @example Starting the handler
+		#  mqtt = MQTT::SubHandler.new('mqtt.eclipse.org');
+		#  mqtt = MQTT::SubHandler.new(MQTT::Client.new("Your.Client.Opts"))
+		def initialize(mqttClient, logger: nil, **extra_opts)
+			@callbackList = Array.new();
+			if mqttClient.is_a? String
+				@mqtt = MQTT::Client.new(mqttClient);
+				@mqtt.clean_session = false;
+
+				@mqttWasStartedClean = true if extra_opts[:client_id].nil?
+			else
+				@mqtt = mqttClient;
+			end
+
+			init_x_log("MQTT #{@mqtt.host}", logger);
+			self.log_level = Logger::INFO;
+
+			@conChangeMutex = Mutex.new();
+			@connected 		 = false;
+			@reconnectCount = 0;
+
+			@mqtt.client_id ||= extra_opts[:client_id] || MQTT::Client.generate_client_id("MQTT_Sub_", 8);
+
+			@packetQueue = Array.new();
+			@packetQueueMutex = Mutex.new();
+
+			@publisherThreadWaiting = false;
+
+			@subscribedTopics 	= Hash.new();
+
+			@trackerHash = Hash.new();
+
+			@listenerThread = Thread.new do
+				ensure_clean_start();
+				mqtt_resub_thread();
+			end
+			@listenerThread.abort_on_exception = true;
+
+			begin
+				Timeout.timeout(5) {
+					until(@connected)
+						sleep 0.1;
+					end
+				}
+			rescue Timeout::Error
+				x_loge("Broker did not connect!");
+			end
+
+			@publisherThread = Thread.new do
+				mqtt_push_thread();
+			end
+			@publisherThread.abort_on_exception = true;
+
+			at_exit {
+				destroy!()
+			}
+		end
+	end
+end

data/lib/mqtt/sub_handler.rb

@@ -1,121 +1,24 @@
 
-require 'timeout'
-require 'mqtt'
-require 'json'
 
-require 'colorize'
+require 'json'
 
 require_relative 'subscription_classes.rb'
+require_relative 'base_handler.rb'
 
 # @author Xasin
 module MQTT
 # A shortcut-function to quickly connect to the public Eclipse MQTT Broker.
-# @return [MQTT::SubHandler] Sub-Handler connected to `iot.eclipse.org`
+# @return [MQTT::SubHandler] Sub-Handler connected to `mqtt.eclipse.org`
 def self.Eclipse()
-	@EclipseMQTT ||= SubHandler.new('iot.eclipse.org');
+	@EclipseMQTT ||= SubHandler.new('mqtt.eclipse.org');
 	return @EclipseMQTT;
 end
 
 
-class SubHandler
+class SubHandler < BaseHandler
 	# Whether or not hashes and arrays should be converted to JSON when sending
 	attr_accessor :jsonifyHashes
 
-	# Split a Topic into a Topic-Array
-	# @param topicName [String] The string topic which to split
-	# @return [Array<String>] A list of individual topic-branches
-	# @note This function is mainly used for background processing.
-	def self.get_topic_split(topicName)
-		return topicName.scan(/[^\/]+/);
-	end
-
-	# Match a topic string to a topic pattern
-	# @param receivedTopicString [String] The string (as
-	#  returned by MQTT.get) to compare
-	# @param topicPattern [Array<String>] The Topic-Array (as
-	#  returned by .get_topic_split) to compare against
-	# @return [nil, Array<String>] Nil if no match was found.
-	#  An Array of matched wildcard topic branches (can be empty) when
-	#  successfully matched
-	# @note (see .get_topic_split)
-	def self.getTopicMatch(receivedTopicString, topicPattern)
-		receivedTopicList = get_topic_split receivedTopicString;
-
-		outputTopicList = Array.new();
-
-		return nil unless receivedTopicList.length >= topicPattern.length;
-
-		topicPattern.each_index do |i|
-			if(topicPattern[i] == "+")
-				outputTopicList << receivedTopicList[i];
-
-			elsif(topicPattern[i] == "#")
-				outputTopicList.concat receivedTopicList[i..-1];
-				return outputTopicList;
-
-			elsif topicPattern[i] != receivedTopicList[i];
-				return nil;
-
-			end
-		end
-
-		return outputTopicList if topicPattern.length == receivedTopicList.length;
-		return nil;
-	end
-
-	# Call all existing callbacks whose topic-list matches `topic`
-	def call_interested(topic, data)
-		topicHasReceivers = false;
-		@callbackList.each do |h|
-			tMatch = SubHandler.getTopicMatch(topic, h.topic_split);
-			if tMatch
-				begin
-					Timeout.timeout(5) {
-						h.offer(tMatch, data)
-					}
-				rescue Timeout::Error
-					STDERR.puts "MQTT Callback Timeout #{h}"
-				end
-				topicHasReceivers = true;
-			end
-		end
-
-		@mqtt.unsubscribe(topic) unless topicHasReceivers;
-	end
-	private :call_interested
-
-	# Handle sending a subscription-message to the server
-	def raw_subscribe_to(topic, qos: 1)
-		@subscribeQueue << [topic, qos];
-		@publisherThread.run();
-	end
-	private :raw_subscribe_to
-
-	# @!group Custom subscription handling
-
-	# Unregister a subscription. Removes it from the callback list and
-	# unsubscribes from the topic if no other subscriptions for it are present.
-	# @param subObject [MQTT::Subscriptions::Subscription]
-	#  The subscription-object to remove
-	# @return void
-	def unregister_subscription(subObject)
-		raise ArgumentError, "Object is not a subscription!" unless subObject.is_a? MQTT::Subscriptions::Subscription
-		return unless @callbackList.include? subObject;
-
-		@callbackList.delete(subObject);
-	end
-	# Register a custom subscription, and send a subscription message to the server.
-	# @param subObject [MQTT::Subscriptions::Subscription]
-	#  An instance of a MQTT Subscription object
-	# @return void
-	def register_subscription(subObject)
-		raise ArgumentError, "Object is not a subscription!" unless subObject.is_a? MQTT::Subscriptions::Subscription
-		return if @callbackList.include? subObject;
-
-		@callbackList << subObject;
-		raw_subscribe_to(subObject.topic, qos: subObject.qos);
-	end
-
 	# @!group Subscribing
 
 	# Synchronously wait for data.
@@ -211,110 +114,15 @@ class SubHandler
 			data = data.to_json
 		end
 
-		@publishQueue << {topic: topic, data: data, qos: qos, retain: retain}
-		@publisherThread.run();
-	end
-	alias publishTo publish_to
-
-	def ensure_clean_start()
-		@mqttWasStartedClean = @mqtt.clean_session
-		if @mqttWasStartedClean
-			begin
-				@mqtt.connect();
-				@mqtt.disconnect();
-			rescue MQTT::Exception
-				sleep 1;
-				retry
-			rescue SocketError, SystemCallError
-				sleep 5
-				retry
-			end
-			@mqtt.clean_session=false;
+		if(qos > 1)
+			qos = 1
+			x_logw("push with QOS > 1 was attempted, this is not supported yet!") unless $MQTTPubQOSWarned
+			$MQTTPubQOSWarned = true;
 		end
-	end
-	private :ensure_clean_start
 
-	def ensure_clean_exit()
-		if(@mqttWasStartedClean)
-			print "Logging out of mqtt server... "
-			begin
-			Timeout.timeout(3) {
-				begin
-					@mqtt.clean_session = true;
-					@mqtt.disconnect();
-					@mqtt.connect();
-				rescue MQTT::Exception, SocketError, SystemCallError
-					sleep 0.3
-					retry;
-				end
-			}
-			rescue  Timeout::Error
-				puts "Timed out, aborting!";
-			else
-				puts "Done."
-			end
-		end
-	end
-	private :ensure_clean_exit
-
-	def mqtt_push_thread
-		loop do
-			Thread.stop();
-
-			next unless @connected
-
-			begin
-				until @subscribeQueue.empty? do
-					h = @subscribeQueue[-1];
-					Timeout.timeout(3) {
-						@mqtt.subscribe(h[0] => h[1]);
-					}
-					@subscribeQueue.pop;
-					sleep 0.01
-				end
-				until @publishQueue.empty? do
-					h = @publishQueue[-1];
-					Timeout.timeout(3) {
-						@mqtt.publish(h[:topic], h[:data], h[:retain], h[:qos]);
-					}
-					@publishQueue.pop;
-					sleep 0.01
-				end
-			rescue MQTT::Exception, SocketError, SystemCallError, Timeout::Error
-					@conChangeMutex.synchronize {
-						@connected = false;
-					}
-					@mqtt.disconnect();
-			end
-		end
+		queue_packet({type: :pub, topic: topic, data: data, qos: qos, retain: retain});
 	end
-	private :mqtt_push_thread
-
-	def mqtt_resub_thread
-		while(true)
-			begin
-				Timeout.timeout(4) {
-					@mqtt.connect()
-				}
-				STDERR.puts("MQTT: #{@mqtt.host} connected!".green)
-				@conChangeMutex.synchronize {
-					@connected = true;
-				}
-				@publisherThread.run();
-				@mqtt.get do |topic, message|
-					call_interested(topic, message);
-				end
-			rescue MQTT::Exception, Timeout::Error, SocketError, SystemCallError
-				STDERR.puts("MQTT #{@mqtt.host} disconnected!".red);
-				@connected = false;
-
-				@conChangeMutex.unlock if @conChangeMutex.owned?
-				@mqtt.clean_session = false;
-				sleep 2
-			end
-		end
-	end
-	private :mqtt_resub_thread
+	alias publishTo publish_to
 
 	# Pause the main thread and wait for messages.
 	# This is mainly useful when the code has set everything up, but doesn't just want to end.
@@ -324,85 +132,15 @@ class SubHandler
 			exit 0
 		}
 
-		puts "Main thread paused."
+		x_logi("Main thread paused.")
 		Thread.stop();
 	end
-	def flush_pubqueue()
-		unless @publishQueue.empty?
-			print "Finishing sending of MQTT messages ... "
-			begin
-				Timeout.timeout(4) {
-					until @publishQueue.empty? do
-						sleep 0.05;
-					end
-				}
-			rescue Timeout::Error
-				puts "Timed out, aborting."
-			else
-				puts "Done."
-			end
-		end
-	end
-	private :flush_pubqueue
+	alias lock_and_listen lockAndListen
 
-	# Initialize a new MQTT::SubHandler
-	# The handler immediately connects to the server, and begins receciving and sending.
-	# @param mqttClient [String, MQTT::Client] Either a URI to connect to, or a MQTT::Client
-	#  The URI can be of the form "mqtts://Password@User:URL:port".
-	#  The MQTT client instance can be fully configured, as specified by the MQTT Gem. It must *not* already be connected!
-	# @param jsonify [Boolean] Should Hashes and Arrays input into publish_to be converted to JSON?
-	#  This can be useful to have one less .to_json call. Default is true.
-	# @example Starting the handler
-	#  mqtt = MQTT::SubHandler.new('iot.eclipse.org');
-	#  mqtt = MQTT::SubHandler.new(MQTT::Client.new("Your.Client.Opts"))
 	def initialize(mqttClient, jsonify: true)
-		@callbackList = Array.new();
-		if mqttClient.is_a? String
-			@mqtt = MQTT::Client.new(mqttClient);
-		else
-			@mqtt = mqttClient;
-		end
+		super(mqttClient);
 
 		@jsonifyHashes = jsonify;
-
-		@conChangeMutex = Mutex.new();
-		@connected 		= false;
-
-		@mqtt.client_id ||= MQTT::Client.generate_client_id("MQTT_Sub_", 8);
-
-		@publishQueue 		= Array.new();
-		@subscribeQueue 	= Array.new();
-		@subscribedTopics 	= Hash.new();
-
-		@trackerHash = Hash.new();
-
-		@listenerThread = Thread.new do
-			ensure_clean_start();
-			mqtt_resub_thread();
-		end
-		@listenerThread.abort_on_exception = true;
-
-		@publisherThread = Thread.new do
-			mqtt_push_thread();
-		end
-		@publisherThread.abort_on_exception = true;
-
-		begin
-			Timeout.timeout(3) {
-				until(@connected)
-					sleep 0.1;
-				end
-			}
-		rescue Timeout::Error
-			STDERR.puts "MQTT: #{@mqtt.host} did not connect!".red
-		end
-
-		at_exit {
-			flush_pubqueue();
-			@listenerThread.kill();
-			@publisherThread.kill();
-			ensure_clean_exit();
-		}
 	end
 end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mqtt-sub_handler
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.6.8
 platform: ruby
 authors:
 - Xasin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-06 00:00:00.000000000 Z
+date: 2021-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mqtt
@@ -28,30 +28,30 @@ dependencies:
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
-  name: colorize
+  name: xasin-logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -103,6 +103,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/mqtt/Waitpoint.rb
+- lib/mqtt/base_handler.rb
 - lib/mqtt/mqtt_hash.rb
 - lib/mqtt/persistence.rb
 - lib/mqtt/persistence_extensions.rb
@@ -128,7 +129,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubyforge_project: 
+rubygems_version: 2.5.2.1
 signing_key: 
 specification_version: 4
 summary: Asynchronous, topic-based MQTT gem