mqttopia 0.1.20 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79c7db296f5f4dfd2db80af02eddd1d43798b0e18175aab756b150adbe38bcca
-  data.tar.gz: 189124b048379437624b76a850d97bf4d3ae23c8eed6fcca427cf1fc0275c969
+  metadata.gz: e187ae43b2ef47585aa3e90f989bf95e4b6a5a2ce5435050b6197b1de69d5867
+  data.tar.gz: f28d85e56435d9a70eff252b638c98d1506de4ca58678a09de79cf01bf6ed9e4
 SHA512:
-  metadata.gz: 6644b34775b0a900bcd5527f5a918e7ab09a331ad747d31505f74a28df843e4edac8b3ff06240b36645cbf4a528b47d1690e7f2167a4863bc425c991fb9606d9
-  data.tar.gz: c5778d6141e09c7aaf6e95b6a86dc66c62091db9f9566b07f9224e3f610b9da76f945724ef9ef54f01fa1cf7834ecb389741e8190be276eba9e20b25ec571995
+  metadata.gz: 38e1e64174271e7df513c72fd8f2475cb35de740407e93c5ecadb6552ccd435d9e1c9a6c79436b1b5b9d20525180c6138abfb2584b0e46334e3ac6a2fdecbdd4
+  data.tar.gz: 3052bd4fe4f365a2bc4e58894ef043df13f2ef43af3eb33ab110f72a4f1db2243bbd670eb9cafeafe2d658891e3c6076b0c98d2fd941af06cfaaf4ac4877ff52

data/.gemrc

@@ -0,0 +1,8 @@
+---
+:backtrace: false
+:bulk_threshold: 1000
+:update_sources: true
+:verbose: true
+:sources:
+- https://rubygems.org/
+- https://rubygems.pkg.github.com/go-illa

data/.rubocop.yml

@@ -28,7 +28,7 @@ Style/ClassVars:
 Layout/LineLength:
   Max: 120
 Metrics/ClassLength:
-  Max: 120
+  Max: 180
 Metrics/MethodLength:
   Max: 30
 Metrics/AbcSize:
@@ -38,4 +38,8 @@ Lint/MissingSuper:
 Lint/RescueException:
   Enabled: false
 Style/RedundantFetchBlock:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/PerceivedComplexity:
   Enabled: false

data/MQTT_SUBSCRIPTIONS.md

@@ -17,7 +17,7 @@ This subscription handles trip metrics and serializes the data related to trips,
     "l": 100,
     "cs": "2"
   },
-  "connt": "wf",
+  "connS":{"type":"Connected","connt":"MOBILE","subType":"LTE"},
   "pws": -1,
   "gps": -1,
   "nlog": 585,
@@ -40,7 +40,11 @@ This subscription handles trip metrics and serializes the data related to trips,
   trip_id: 123,
   metrics: {
     location_permission: "BACKGROUND_FINE",
-    connection_type: "wf",
+    connection: {
+      connection_type: "MOBILE",
+      connection_sub_type: "LTE",
+      connection_status: "Connected"
+    },
     battery: {
       battery_level: 100,
       charging_status: "UNKNOWN",
@@ -84,16 +88,6 @@ This subscription handles trip metrics and serializes the data related to trips,
     "-4": "DISABLED"
   }
   ```
-- **connection_type**
-  ```json
-  {
-    "wf": "WIFI",
-    "cel": "CELLULAR",
-    "et": "ETHERNET",
-    "nc": "NO_CONNECTION",
-    "uk": "UNKNOWN"
-  }
-  ```
 - **charging_status**
   ```json
     {
@@ -118,7 +112,7 @@ payload = {
     "l": 100,
     "cs": "2"
   },
-  "connt": "wf",
+  "connS":{"type":"Connected","connt":"MOBILE","subType":"LTE"},
   "pws": -1,
   "gps": -1,
   "nlog": 585,

data/lib/mqttopia/client.rb

@@ -7,11 +7,14 @@ require_relative "subscriptions/redirect"
 
 module Mqttopia
   class Client
-    @instance = nil
+    @instance_mutex = Mutex.new
+
     attr_reader :mqtt_client, :debugging, :debugging_topic
 
     def self.instance
-      @instance ||= new
+      @instance_mutex.synchronize do
+        @instance ||= new
+      end
     end
 
     private_class_method :new
@@ -23,51 +26,84 @@ module Mqttopia
       ssl: Mqttopia.ssl
     )
       @mqtt_client = MQTT::Client.new(
+        version: Mqttopia.version,
         port: port,
         username: username,
         password: password,
         ssl: ssl,
-        keep_alive: 15,
-        ack_timeout: 5
+        client_id: SecureRandom.hex(3) + "-#{Mqttopia.client_id}",
+        keep_alive: Mqttopia.keep_alive,
+        will_topic: Mqttopia.will_topic,
+        will_retain: Mqttopia.will_retain,
+        will_payload: Mqttopia.will_payload,
+        will_qos: Mqttopia.will_qos,
+        ack_timeout: Mqttopia.ack_timeout
       )
+      @subscriptions = {}
+      @subscription_thread_mutex ||= Mutex.new
       @debugging = Mqttopia.debugging
-      @debugging_topic = "mqttopia/test/debugging"
-    rescue Exception => e
+      @debugging_topic = Mqttopia.debugging_topic
+    rescue StandardError => e
       log_error("initialize", e)
     end
 
     def connect
-      host = active_host(Mqttopia.hosts)
-      raise ArgumentError, "No hosts available" if host.nil?
+      retry_count = 0
+      max_retries = 15
+
+      loop do
+        host = active_host(Mqttopia.hosts)
+        raise ArgumentError, "No hosts available" if host.nil?
+
+        mqtt_client.host = host
+        mqtt_client.connect
 
-      mqtt_client.host = host
-      mqtt_client.connect
-    rescue Exception => e
-      disconnect_and_log("connect", e)
+        retry_count = 0 # Reset retry count on successful connection
+        break # Exit the loop once connected
+      rescue StandardError => e
+        retry_count += 1
+        disconnect_and_log("connect", e)
+
+        if retry_count >= max_retries
+          log_error("connect", "Terminating connection attempts after #{max_retries} failures")
+          break # Stop retrying after max retries
+        end
+
+        sleep(2 * retry_count) # Delay before retrying to prevent rapid retries
+      end
+    end
+
+    def publish(topic, message = nil, qos = 0)
+      self.class.publish(topic, message, qos)
     end
 
     def self.publish(topic, message = nil, qos = 0)
+      # Publishes a message to a topic.
+      #
       client = new
+      # @param message [String, NilClass] Message to publish, defaults to nil
+      # @param qos [Integer] Quality of service, defaults to 0
+      #
+      # @return [Boolean] True if publish succeeded, false otherwise
       client.connect
 
-      # publish(topic, payload = '', retain = false, qos = 0)
       client.mqtt_client.publish(topic, message, false, qos)
       client.disconnect
 
       Mqttopia::Logger.debug("\n#{message}\n") if client.debugging
       true
-    rescue Exception => e
+    rescue StandardError => e
       Mqttopia::Logger.error("\nMqttopia::Client -> publish: #{e}\n")
       false
     end
 
-    def subscribe(topic, qos = 0, &block)
+    def subscribe(topic, listener_event = nil, qos = 0, &block)
       return unless ensure_connection
       raise StandardError, "Blocked Topic" if [debugging_topic].include?(topic)
 
       mqtt_client.subscribe(topic => qos)
-      create_subscription_thread(qos, &block)
-    rescue Exception => e
+      register_subscription(listener_event, &block)
+    rescue StandardError => e
       disconnect_and_log("subscribe", e)
     end
 
@@ -82,6 +118,8 @@ module Mqttopia
     private
 
     def active_host(hosts = Mqttopia.hosts, port = Mqttopia.port, timeout = 10)
+      return if hosts.nil? || hosts.empty?
+
       hosts.each do |host|
         Socket.tcp(host, port, connect_timeout: timeout) do |sock|
           sock.close
@@ -93,30 +131,65 @@ module Mqttopia
       nil # Return nil if no reachable host is found
     end
 
-    def create_subscription_thread(qos)
-      Thread.new do
-        mqtt_client.get do |topic, message|
-          log_debug("Received RAW message on topic #{topic}: #{message} with QOS #{qos}")
+    def register_subscription(listener_event = nil, &block)
+      return unless block_given?
 
-          response = safe_mqtt_response(topic, message)
+      @subscriptions[listener_event] = block # Store callback for this topic
 
-          if debugging && topic.exclude?(debugging_topic)
-            Mqttopia::Client.publish(debugging_topic,
-                                     { 'topic_name': topic,
-                                       'mqttopia_response': response }, 2)
-          end
+      start_subscription_thread unless @subscription_thread
+    end
+
+    def start_subscription_thread
+      @subscription_thread_mutex.synchronize do
+        return if @subscription_thread
+
+        @subscription_thread ||= Thread.new do
+          retry_count = 0
+          max_retries = 15
 
-          yield response if response
+          loop do
+            mqtt_client.get do |topic, message|
+              handle_subscription_message(topic, message)
+            end
+
+            retry_count = 0 # Reset retry count i
+            f successful
+          rescue StandardError => e
+            retry_count += 1
+            log_error("subscription_thread", e)
+
+            if retry_count >= max_retries
+              log_error("subscription_thread", "Terminating after #{max_retries} failed attempts")
+              break # Exit the loop and terminate the thread
+            end
+
+            sleep(2 * retry_count) # Delay before retrying
+            retry # Restart loop if under max retries
+          end
         end
       end
     end
 
+    def handle_subscription_message(topic, message)
+      response = safe_mqtt_response(topic, message)
+
+      if debugging && topic.exclude?(debugging_topic)
+        Mqttopia::Client.publish(debugging_topic, { 'topic_name': topic, 'mqttopia_response': response })
+      end
+
+      return unless response.is_a?(Hash) && response[:event]
+
+      @subscriptions.each do |subscribed_topic, callback|
+        callback.call(response[:data]) if subscribed_topic.to_s == response[:event]
+      end
+    end
+
     def safe_mqtt_response(topic_name, raw_payload)
-      Mqttopia::Subscriptions::Redirect.new(
+      ::Mqttopia::Subscriptions::Redirect.new(
         topic_name: topic_name,
         payload: parse_json(raw_payload)
       ).call
-    rescue Exception => e
+    rescue StandardError => e
       log_error("safe_mqtt_response", e) if debugging
       nil
     end
@@ -139,11 +212,10 @@ module Mqttopia
       Mqttopia::Logger.error("\nMqttopia::Client -> #{method}: #{error_details(error)}\n")
     end
 
-    def log_debug(message)
-      Mqttopia::Logger.debug("\n#{message}\n") if debugging
-    end
-
     def disconnect_and_log(method, error)
+      @subscription_thread_mutex.synchronize do
+        Thread.kill(@subscription_thread) if @subscription_thread
+      end
       disconnect
       log_error(method, error)
     end

data/lib/mqttopia/logger.rb

@@ -7,23 +7,35 @@ module Mqttopia
     class << self
       # Initialize the logger
       def logger
-        @logger ||= Mqttopia.logger # Default to logging to STDOUT
+        @logger ||= Mqttopia.logger
+      end
+
+      def logger_level
+        @logger_level ||= Mqttopia.logger_level
       end
 
       # Allow users to set a custom logger (e.g., logging to a file)
-      attr_writer :logger
+      attr_writer :logger, :logger_level
 
       # Simple wrapper for logging debug messages
-      delegate :debug, to: :logger
+      def debug(msg)
+        logger.debug(msg) if %i[debug].include?(logger_level)
+      end
 
       # Wrapper for logging info messages
-      delegate :info, to: :logger
+      def info(msg)
+        logger.info(msg) if %i[debug info].include?(logger_level)
+      end
 
       # Wrapper for logging warn messages
-      delegate :warn, to: :logger
+      def warn(msg)
+        logger.warn(msg) if %i[debug info warn].include?(logger_level)
+      end
 
       # Wrapper for logging error messages
-      delegate :error, to: :logger
+      def error(msg)
+        logger.error(msg) if %i[debug info warn error].include?(logger_level)
+      end
     end
   end
 end

data/lib/mqttopia/serializers/trip_metric.rb

@@ -5,7 +5,7 @@ module Mqttopia
     module TripMetric
       module_function
 
-      KEYS = %i[ts locPerms connt batt battPwOp pws notf gps nlog loc].freeze
+      KEYS = %i[ts locPerms connS batt battPwOp pws notf gps nlog loc].freeze
 
       def serialize(body)
         return unless valid_metric?(body[:metrics])
@@ -21,7 +21,7 @@ module Mqttopia
       def serialize_metrics(metrics)
         {
           location_permission: location_permission_mapper(metrics[:locPerms]),
-          connection_type: connection_type_mapper(metrics[:connt]),
+          connection: serialize_connection(metrics[:connS]),
           battery: serialize_battery(metrics[:batt], metrics[:battPwOp], metrics[:pws]),
           notification_permission: metrics[:notf]&.zero?,
           gps: metrics[:gps]&.zero?,
@@ -30,6 +30,16 @@ module Mqttopia
         }
       end
 
+      def serialize_connection(connt_s)
+        return unless connt_s
+
+        {
+          connection_type: connt_s[:type],
+          connection_sub_type: connt_s[:subType],
+          connection_status: connt_s[:connt]
+        }
+      end
+
       def serialize_battery(battery, optimization_status, power_saving_mode)
         return unless battery
 
@@ -63,16 +73,6 @@ module Mqttopia
         }.fetch(permission&.to_s) { "UNKNOWN" }
       end
 
-      def connection_type_mapper(connection_type)
-        {
-          "wf" => "WIFI",
-          "cel" => "CELLULAR",
-          "et" => "ETHERNET",
-          "nc" => "NO_CONNECTION",
-          "uk" => "UNKNOWN"
-        }.fetch(connection_type) { "UNKNOWN" }
-      end
-
       def charging_status_mapper(charging_status)
         {
           "0" => "UNKNOWN",

data/lib/mqttopia/serializers/trip_point.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Mqttopia
+  module Serializers
+    module TripPoint
+      module_function
+
+      KEYS = %i[lat lon ts ctp_id trip_id].freeze
+
+      def serialize(body)
+        return unless valid_point?(body[:point])
+
+        {
+          trip_id: body[:trip_id],
+          point: serialize_point(body[:point]),
+          logged_at: body.dig(:point, :ts)&.to_s,
+          received_at: current_timestamp
+        }
+      end
+
+      def serialize_point(point)
+        {
+          latitude: point[:lat],
+          longitude: point[:lon],
+          accuracy: point[:acc],
+          altitude: point[:alt],
+          current_trip_point_id: point[:ctp_id]
+        }
+      end
+
+      def valid_point?(point)
+        point.is_a?(Hash) && KEYS.all? { |key| point.key?(key) }
+      end
+
+      def current_timestamp
+        DateTime.now.strftime("%Q")
+      end
+    end
+  end
+end

data/lib/mqttopia/subscriptions/redirect.rb

@@ -2,6 +2,7 @@
 
 require_relative "services/trip_metrics"
 require_relative "services/test_debug"
+require_relative "services/trip_points"
 require_relative "../topics/services"
 
 module Mqttopia
@@ -16,14 +17,17 @@ module Mqttopia
       end
 
       def call
-        Mqttopia::Topics::Services::KEYS.each_value do |value|
-          next unless topic_name.match(value[:regex])
+        Mqttopia::Topics::Services::KEYS.each do |key, value|
+          next unless topic_name.match?(value[:regex])
 
-          return value[:service].safe_constantize.call(
-            topic_name,
-            payload,
-            { serializer: value[:serializer] }
-          )
+          return {
+            event: key&.to_s,
+            data: value[:service].safe_constantize.call(
+              topic_name,
+              payload,
+              { serializer: value[:serializer] }
+            )
+          }
         end
 
         Mqttopia::Logger.warn "No matching topic found for #{topic_name}" if debugging

data/lib/mqttopia/subscriptions/services/base.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../../helpers/data_extractor"
+
 module Mqttopia
   module Subscriptions
     module Services

data/lib/mqttopia/subscriptions/services/trip_metrics.rb

@@ -2,7 +2,6 @@
 
 require "active_model"
 require_relative "../../serializers/trip_metric"
-require_relative "../../helpers/data_extractor"
 require_relative "./base"
 
 module Mqttopia

data/lib/mqttopia/subscriptions/services/trip_points.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "active_model"
+require_relative "../../serializers/trip_point"
+require_relative "./base"
+
+module Mqttopia
+  module Subscriptions
+    module Services
+      class TripPoints < Mqttopia::Subscriptions::Services::Base
+        class TripPointsInvalidError < ArgumentError
+        end
+
+        attr_reader :trip_id, :point, :options, :user_id
+
+        validates :trip_id, presence: true, numericality: { only_integer: true, greater_than: 0 }
+        validates :point, presence: true
+        # validate :point_json_format
+
+        def initialize(trip_id:, point:, options: {})
+          @trip_id = trip_id
+          @point = point
+          @options = options
+          @user_id = options[:user_id]
+        end
+
+        def self.call(topic, payload, options = {})
+          trip_id = topic.include?("trips/") && topic.match(%r{trips/[^/]+}) && extract_trip_id(topic)
+          options[:user_id] = topic.include?("user/") && topic.match(%r{user/[^/]+}) && extract_user_id(topic)
+
+          new(trip_id: trip_id, point: payload, options: options).process
+        end
+
+        def process
+          raise TripPointsInvalidError, errors.full_messages.to_sentence unless valid?
+
+          Mqttopia::Serializers::TripPoint.serialize({
+                                                       trip_id: trip_id,
+                                                       point: point
+                                                     })
+        end
+      end
+    end
+  end
+end

data/lib/mqttopia/topics/services.rb

@@ -10,6 +10,12 @@ module Mqttopia
           serializer: "Mqttopia::Serializers::TripMetric",
           regex: %r{\Ailla/trips/(?<trip_id>\d+)/trip_metric/send(?:/user/(?<user_id>\d+))?\z}
         },
+        trip_point: {
+          topic_name: "illa/trips/:trip_id/driver_trip_point/send/user/:user_id",
+          service: "Mqttopia::Subscriptions::Services::TripPoints",
+          serializer: "Mqttopia::Serializers::TripPoint",
+          regex: %r{\Ailla/trips/(?<trip_id>\d+)/driver_trip_point/send(?:/user/(?<user_id>\d+))?\z}
+        },
         test_debug: {
           topic_name: "test",
           service: "Mqttopia::Subscriptions::Services::TestDebug",

data/lib/mqttopia/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mqttopia
-  VERSION = "0.1.20"
+  VERSION = "0.2.0"
 end

data/lib/mqttopia.rb

@@ -13,12 +13,38 @@ Dir[File.expand_path("tasks/**/*.rake", __dir__)].each { |task| load task }
 module Mqttopia
   class Error < StandardError; end
 
-  mattr_accessor :hosts, :port, :username, :password, :ssl, :logger, :debugging
+  mattr_accessor :version,
+                 :hosts,
+                 :port,
+                 :username,
+                 :password,
+                 :ssl,
+                 :logger,
+                 :logger_level,
+                 :keep_alive,
+                 :will_topic,
+                 :will_retain,
+                 :will_payload,
+                 :will_qos,
+                 :ack_timeout,
+                 :client_id,
+                 :debugging,
+                 :debugging_topic
 
+  @@version = "3.1.1"
   @@port = 1883
   @@ssl = true
+  @@will_topic = nil
+  @@will_retain = false
+  @@will_payload = nil
+  @@will_qos = 0
+  @@keep_alive = 15
+  @@ack_timeout = 10
   @@logger = ::Logger.new($stdout)
+  @@logger_level = :info
   @@debugging = false
+  @@debugging_topic = "mqttopia/test/debugging"
+  @@client_id = "mqttopia-#{Mqttopia::VERSION}"
 
   def self.configure
     yield self

data/lib/tasks/initialize.rake

@@ -34,11 +34,7 @@ namespace :mqttopia do
       # $client.publish('test/topic', 'Hello, MQTT')
     RUBY
 
-    if File.exist?(file_name)
-      puts "Skipping: #{file_name} already exists"
-    else
-      File.write(file_name, content)
-      puts "Created: #{file_name}"
-    end
+
+    File.write(file_name, content) unless File.exist?(file_name)
   end
 end

data/mqttopia.gemspec

@@ -16,6 +16,7 @@ Gem::Specification.new do |spec|
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/go-illa/mqttopia"
   spec.metadata["changelog_uri"] = "https://github.com/go-illa/mqttopia"
+  spec.metadata["github_repo"] = "https://github.com/go-illa/mqttopia"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mqttopia
 version: !ruby/object:Gem::Version
-  version: 0.1.20
+  version: 0.2.0
 platform: ruby
 authors:
 - Illa Tech
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-14 00:00:00.000000000 Z
+date: 2025-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -171,6 +171,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gemrc"
 - ".rubocop.yml"
 - CHANGELOG.md
 - MQTT_SUBSCRIPTIONS.md
@@ -185,10 +186,12 @@ files:
 - lib/mqttopia/logger.rb
 - lib/mqttopia/serializers/test_debug.rb
 - lib/mqttopia/serializers/trip_metric.rb
+- lib/mqttopia/serializers/trip_point.rb
 - lib/mqttopia/subscriptions/redirect.rb
 - lib/mqttopia/subscriptions/services/base.rb
 - lib/mqttopia/subscriptions/services/test_debug.rb
 - lib/mqttopia/subscriptions/services/trip_metrics.rb
+- lib/mqttopia/subscriptions/services/trip_points.rb
 - lib/mqttopia/topics/services.rb
 - lib/mqttopia/version.rb
 - lib/tasks/initialize.rake
@@ -200,6 +203,7 @@ metadata:
   homepage_uri: https://github.com/go-illa
   source_code_uri: https://github.com/go-illa/mqttopia
   changelog_uri: https://github.com/go-illa/mqttopia
+  github_repo: https://github.com/go-illa/mqttopia
 post_install_message: "\n      [MQTTOPIA] Please make sure to run `rails generate
   mqttopia:install`\n      "
 rdoc_options: []