mqtt-sub_handler 0.1.6.2 → 0.1.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfe901d34d1a891840006f77467ef0929bfb9ff1363ccc3ece47cf35454178b0
-  data.tar.gz: 1e601e44349b5e360068d3e07a4a59caa0254cfc2aaee1e1f870fe1069041e96
+  metadata.gz: d3eef659ff2c5da99d386d05fc145c328d7eea5b2057d30fa7f1ec43bda7748c
+  data.tar.gz: 69559fc70301f60f25ea322731b936738eb7d55609a8c817fcedf161e3640590
 SHA512:
-  metadata.gz: 589b2c0307aa5ec6aa0e253805d8b095ce73997bd9461bc7abc060d306ac6f1b5c8ff18ddee861a1c2d43d6b7e3685bacb9b4994360b106c1ad19791c91bd511
-  data.tar.gz: 4d5d90483bfa7ce80c4c6359d5fb38faad29a08f447d987cebf1779597190c4e7d692950a0bafa1d63b98d5d76d5fcdedd696b6385ab170a5c917da0c4ef0ac0
+  metadata.gz: 1693df3d20154bb9a283cd75f0f3f82411173c7716daa89f84c89a0497ef36fa92965827927baa32ec1ead5c6697e87f3270c10099b7fd3815695be06af730f0
+  data.tar.gz: cc4fab89804258ffdbec5d89a11a94426c264b2866f10780cfff4aab3422cb78ca031b784e0e0200b20815f3ffc27934740b9250c8a0ef1283779bcbc05a0206

data/lib/mqtt/base_handler.rb

@@ -0,0 +1,350 @@
+
+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_logf("Timeout on callback #{h}");
+					rescue => e
+						x_logf("Uncaught error on #{h}");
+						x_logf(e);
+					end
+					topicHasReceivers = true;
+				end
+			end
+
+			@mqtt.unsubscribe(topic) unless topicHasReceivers;
+		end
+		private :call_interested
+
+		def queue_packet(data)
+			return if @destroying
+
+			x_logd("Queueing packet #{data.to_json}");
+			@packetQueueMutex.synchronize {
+				@packetQueue << data;
+				if(@packetQueue.size == 999)
+					x_loge("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 mqtt_push_thread
+			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
+					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
+				rescue MQTT::Exception, SocketError, SystemCallError, Timeout::Error => e
+						x_loge("Push error!");
+						x_loge(e.inspet);
+
+						sleep 0.5
+				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;
+					}
+
+					@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;
+
+					@conChangeMutex.unlock if @conChangeMutex.owned?
+					@mqtt.clean_session = false;
+					sleep 2
+				end
+			end
+
+			x_logd("Sub thread exited");
+		end
+		private :mqtt_resub_thread
+
+		# 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.
+		# "INT" is trapped, ensuring a smooth exit on Ctrl-C
+		def lockAndListen()
+			Signal.trap("INT") {
+				exit 0
+			}
+
+			puts "Main thread paused."
+			Thread.stop();
+		end
+
+		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 "Publishes did not complete";
+				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)
+			@callbackList = Array.new();
+			if mqttClient.is_a? String
+				@mqtt = MQTT::Client.new(mqttClient);
+				@mqtt.clean_session = false;
+			else
+				@mqtt = mqttClient;
+			end
+
+			init_x_log("MQTT #{@mqtt.host}", logger);
+			self.log_level = Logger::INFO;
+
+			@conChangeMutex = Mutex.new();
+			@connected 		= false;
+
+			@mqtt.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,129 +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}".red
-				end
-				topicHasReceivers = true;
-			end
-		end
-
-		@mqtt.unsubscribe(topic) unless topicHasReceivers;
-	end
-	private :call_interested
-
-	def queue_packet(data)
-		@packetQueueMutex.synchronize {
-			@packetQueue << data;
-			@packetQueue.shift if @packetQueue.size > 100
-
-			@publisherThread.run() if @publisherThreadWaiting;
-		}
-	end
-
-	# Handle sending a subscription-message to the server
-	def raw_subscribe_to(topic, qos: 1)
-		queue_packet({topic: topic, qos: qos, type: :sub});
-	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.
@@ -221,8 +116,7 @@ class SubHandler
 
 		if(qos > 1)
 			qos = 1
-			STDERR.puts("MQTT push with QOS > 1 was attempted, this is not supported yet!".yellow) unless $MQTTPubQOSWarned
-
+			x_logw("push with QOS > 1 was attempted, this is not supported yet!") unless $MQTTPubQOSWarned
 			$MQTTPubQOSWarned = true;
 		end
 
@@ -230,206 +124,10 @@ class SubHandler
 	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;
-		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
-			@packetQueueMutex.synchronize {
-				@publisherThreadWaiting = true;
-			}
-			Thread.stop();
-			@packetQueueMutex.synchronize {
-				@publisherThreadWaiting = false;
-			}
-
-			next unless @connected
-
-			begin
-				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
-			rescue MQTT::Exception, SocketError, SystemCallError, Timeout::Error => e
-					STDERR.puts("MQTT: #{@mqtt.host} push error, disconnecting!".red) if @connected
-					STDERR.puts(e.inspect);
-
-					sleep 1
-			end
-		end
-	end
-	private :mqtt_push_thread
-
-	def mqtt_resub_thread
-		loop do
-			begin
-				STDERR.puts("MQTT: #{@mqtt.host} trying reconnect...".yellow)
-				Timeout.timeout(4) {
-					@mqtt.connect()
-				}
-				STDERR.puts("MQTT: #{@mqtt.host} connected!".green)
-				@conChangeMutex.synchronize {
-					@connected = true;
-				}
-
-				@packetQueueMutex.synchronize {
-					@publisherThread.run() if (@publisherThread && @publisherThreadWaiting)
-				}
-
-				@mqtt.get do |topic, message|
-					call_interested(topic, message);
-				end
-			rescue MQTT::Exception, Timeout::Error, SocketError, SystemCallError
-				STDERR.puts("MQTT: #{@mqtt.host} disconnected!".red) if @connected
-				@connected = false;
-
-				@conChangeMutex.unlock if @conChangeMutex.owned?
-				@mqtt.clean_session = false;
-				sleep 2
-			end
-		end
-	end
-	private :mqtt_resub_thread
-
-	# 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.
-	# "INT" is trapped, ensuring a smooth exit on Ctrl-C
-	def lockAndListen()
-		Signal.trap("INT") {
-			exit 0
-		}
-
-		puts "Main thread paused."
-		Thread.stop();
-	end
-	def flush_pubqueue()
-		unless @packetQueue.empty?
-			print "Finishing sending of MQTT messages ... "
-			begin
-				Timeout.timeout(4) {
-					until @packetQueue.empty? do
-						sleep 0.05;
-					end
-				}
-			rescue Timeout::Error
-				puts "Timed out, aborting."
-			else
-				puts "Done."
-			end
-		end
-	end
-	private :flush_pubqueue
-
-	# 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);
-
-		@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
-			STDERR.puts "MQTT: #{@mqtt.host} did not connect!".red
-		end
-
-		@publisherThread = Thread.new do
-			mqtt_push_thread();
-		end
-		@publisherThread.abort_on_exception = true;
-
-		at_exit {
-			flush_pubqueue();
-			@connected = false;
-			@listenerThread.kill();
-			ensure_clean_exit();
-		}
 	end
 end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mqtt-sub_handler
 version: !ruby/object:Gem::Version
-  version: 0.1.6.2
+  version: 0.1.6.4
 platform: ruby
 authors:
 - Xasin
@@ -39,19 +39,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !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