mqtt-core 0.0.1.ci.release → 0.9.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03cdb9467d4797a91a9751dd5f0421d4f0a231a3084314dbbf9b58d34812c7a8
-  data.tar.gz: 17800776d5fc4fd0698758bbcc79fc29d64f65a7c1d7d3ce91265faf55646c2a
+  metadata.gz: 5d3ac3a37e9bd2c03f3461a9121fdb80392c4c30800185eaead46f082b6315a1
+  data.tar.gz: ab3f1dac57c2ec1bfa6903c07aad6f1b1ceaddabaac07dcccd30e8ddc76c051f
 SHA512:
-  metadata.gz: eedd90f6fe41a5e72ea11a990507c168b970e203af0a30d079ca70a76dc71b1f8bdac6c915b84b7de4abb7097ba99593683938c9e23e5f14a869d4849950ea8b
-  data.tar.gz: ced170d3f87f4fee052ddc4e5e9f282b3d3be257c0eb2c2b50278e3577e087d80f9fe1b7eb1e740474224f1244ca2b7e2f14f35c8c88a653dd80f9498b27fd57
+  metadata.gz: 5946a64c4cf7a87ec00f9c1cc7a54caf27d401293fd07f5e95f2d6f29dae474cc20ca3db462c05a2f8123deebbacb9918b581a03df02fdc15c76e6771dc87003
+  data.tar.gz: c6a1db949580d747ccf4c463eaf4e7afc417cff883c5d078f3fcf2c0fe50fbf8dcca1bf862787b350d61fd9537598c25c6ae86d5b386aa370ae2bd53c3f2a7ed

data/lib/mqtt/core/client/enumerable_subscription.rb

@@ -9,12 +9,14 @@ module MQTT
       #
       # Method variants
       #
-      #   - methods with aliases suffixed `messages` yield deconstructed topic, payload, and attributes
+      #   - methods with aliases suffixed `messages` yield deconstructed topic, payload, and version-specific attributes
+      #       * v3 - :qos, :retain
+      #       * v5 - :qos, :retain, :message_expiry_interval, :response_topic, :correlation_data, :content_type,
+      #              :user_properties
       #   - methods suffixed with `packets` yield raw `PUBLISH` packets
       #   - methods prefixed with `async` perform enumeration in a new thread
-      #   - methods suffixed with bang `!` ensure {#unsubscribe}
       #   - methods prefixed with `lazy` return lazy enumerators for advanced chaining
-      #
+      #   - methods suffixed with bang `!` ensure {#unsubscribe} when enumeration completes.
       class EnumerableSubscription < Subscription
         include Enumerable
 
@@ -28,13 +30,25 @@ module MQTT
         #   @yieldparam [String] topic the message topic.
         #   @yieldparam [String] payload the message payload.
         #   @yieldparam [Hash<Symbol>] attributes additional `PUBLISH` packet attributes.
+        #
+        #     Optional attributes may not be present. Use default values if necessary.
         #   @yieldreturn [$0]
 
+        # @!macro [new] enum_messages
+        #
+        #   Block can throw :unsubscribe to close the subscription and enumeration.
+        #   @!macro yield_messages(void)
+
         # @!macro [new] yield_packets
         #   @yield [packet]
         #   @yieldparam [Packet] packet a `PUBLISH` packet.
         #   @yieldreturn [$0]
 
+        # @!macro [new] enum_packets
+        #
+        #   Block can throw :unsubscribe to close the subscription and enumeration.
+        #   @!macro yield_packets(void)
+
         # @!macro [new] enum_return
         #   @return [void] when block given
         #   @return [Enumerator] an enumerator when no block given.
@@ -44,33 +58,27 @@ module MQTT
         #   @return [Enumerator::Lazy] a lazy enumerator when no block given.
 
         # @!macro [new] async_return
-        #   @return [self, ConcurrentMonitor::Task]
-        #     a pair containing self and the task that is iterating over the messages.
-
-        # @!macro [new] qos_note
-        #   @note QoS 1/2 packets are marked as completely handled in the session store when the given block completes.
-        #     If no block is given, completion is marked *before* the packet is returned.
+        #   @return [self, ConcurrentMonitor::Task...]
+        #     self and the task iterating over the messages.
 
         # Get one packet, blocking until available
         #
-        # @!macro qos_note
         # @!macro yield_packets(Object)
         # @return [Packet] a `PUBLISH` packet when no block given
         # @return [Object] the block result when block given
         # @return [nil] when unsubscribed or disconnected
         def get_packet(&)
-          handle(handler.dequeue, &)
+          handle(dequeue, &)
         end
 
         # Get one message, blocking until available
         #
-        # @!macro qos_note
         # @!macro yield_messages(Object)
         # @return [String, String, Hash<Symbol>] topic, payload, and attributes when no block given
         # @return [Object] the block result when block given
         # @return [nil] when unsubscribed or disconnected
         def get(&)
-          get_packet { |pkt| pkt.deconstruct_message(&) }
+          get_packet { |pkt| pkt&.deconstruct_message(&) }
         end
         alias get_message get
 
@@ -83,7 +91,7 @@ module MQTT
           get_packet do |packet|
             raise StopIteration unless packet
 
-            block_given? ? yield(packet) : packet
+            (block_given? ? yield(packet) : packet)
           end
         end
 
@@ -98,32 +106,32 @@ module MQTT
         alias read_message read
 
         # Enumerate packets
-        # @!macro yield_packets(void)
+        # @!macro enum_packets
         # @!macro enum_return
         def each_packet(&)
           return enum_for(__method__) unless block_given?
 
-          loop { read_packet(&) }
+          loop { read_packet { |pkt| catch_unsubscribe(pkt, &) } }
         end
 
         # Enumerate packets, ensuring {#unsubscribe}
-        # @!macro yield_packets(void)
+        # @!macro enum_packets
         # @!macro enum_return
         def each_packet!(&) = enum_for!(__method__, &)
 
         # Enumerate messages
-        # @!macro yield_messages(void)
+        # @!macro enum_messages
         # @!macro enum_return
-        def each
+        def each(&)
           return enum_for(__method__) unless block_given?
 
-          each_packet { |pkt| yield(*pkt.deconstruct_message) }
+          each_packet { |pkt| pkt.deconstruct_message(&) }
         end
 
         alias each_message each
 
         # Enumerate messages, ensuring {#unsubscribe}
-        # @!macro yield_messages(void)
+        # @!macro enum_messages
         # @!macro enum_return
         def each!(&) = enum_for!(__method__, &)
         alias each_message! each!
@@ -148,46 +156,53 @@ module MQTT
 
         # Return a lazy packet enumerator for advanced chaining
         # @return [Enumerator::Lazy<Packet>] lazy enumerator yielding PUBLISH packets
+        # @see each_packet
         def lazy_packets
           each_packet.lazy
         end
 
         # Return a lazy packet enumerator with auto-unsubscribe
         # @return [Enumerator::Lazy<Packet>] lazy enumerator yielding PUBLISH packets
+        # @see each_packet!
         def lazy_packets!
           each_packet!.lazy
         end
 
         # Enumerate messages in a new thread
-        # @overload async(&)
-        # @!macro yield_messages(void)
+        # @overload async(via: client, **via_opts, &)
+        # @param via [:async] used to start a new task
+        # @param via_opts [Hash<Symbol>] passed to `via.async`
+        # @!macro enum_messages
         # @!macro async_return
         # @see each
-        def async(method = :each, &)
+        def async(method = :each, via: client, **via_opts, &)
           raise ArgumentError, 'block is required for async enumeration' unless block_given?
 
-          [self, client.async("sub.#{method}") { send(method, &) }]
+          [self, via.async(**via_opts) { send(method, &) }]
         end
         alias async_messages async
 
         # Enumerate messages in a new thread, ensuring {#unsubscribe}
-        # @!macro yield_messages(void)
+        # @!macro enum_messages
         # @!macro async_return
         # @see each!
-        def async!(&) = async(:each!, &)
+        # @see async
+        def async!(**, &) = async(:each!, **, &)
         alias async_messages! async!
 
         # Enumerate packets in a new thread
-        # @!macro yield_packets(void)
+        # @!macro enum_packets
         # @!macro async_return
         # @see each_packet
-        def async_packets(&) = async(:each_packet, &)
+        # @see async
+        def async_packets(**, &) = async(:each_packet, **, &)
 
         # Enumerate packets in a new thread, ensuring {#unsubscribe}
-        # @!macro yield_packets(void)
+        # @!macro enum_packets
         # @!macro async_return
         # @see each_packet!
-        def async_packets!(&) = async(:each_packet!, &)
+        # @see async
+        def async_packets!(**, &) = async(:each_packet!, **, &)
 
         # Delegates Enumerable methods ending in `!` to {#each!}, ensuring {#unsubscribe}
         #
@@ -209,6 +224,20 @@ module MQTT
 
         private
 
+        def dequeue
+          handler.dequeue.tap do |pkt|
+            # propagate the close signal to potential multiple readers.
+            handler.enqueue(pkt) if !pkt || pkt.is_a?(StandardError)
+
+            raise pkt if pkt.is_a?(StandardError)
+          end
+        end
+
+        def catch_unsubscribe(packet, &)
+          # Yield the block, returning immediately unless :unsubscribe is thrown
+          catch(:unsubscribe) { return yield packet }.tap { unsubscribe }
+        end
+
         def respond_to_missing?(method, include_private = false)
           (method.end_with?('!') && Enumerable.public_instance_methods.include?(method[..-2].to_sym)) || super
         end

data/lib/mqtt/core/client/filesystem_session_store.rb

@@ -9,8 +9,12 @@ module MQTT
   module Core
     class Client
       # A Session Store that holds packets in the filesystem.
+      #
+      # Persists outbound QoS 1/2 packets for retry across process restarts.
+      # QoS2 inbound deduplication state (packet ids awaiting PUBREL) is also persisted.
       class FilesystemSessionStore < Qos2SessionStore
         attr_reader :client_dir, :base_dir, :session_expiry_file
+        attr_accessor :disconnect_expiry_interval
 
         # @param [String] base_dir the base directory to store session files in
         # @param [String|nil] client_id
@@ -19,16 +23,16 @@ module MQTT
         #   zero is not permitted, but nil represents never expire (server may negotiate a lower value)
         def initialize(client_id:, expiry_interval:, base_dir: Dir.mktmpdir('mqtt'))
           @base_dir = Pathname.new(base_dir)
-          @client_dir = (base_dir + client_id)
+          @client_dir = (@base_dir + client_id)
+          @disconnect_expiry_interval = nil # Default: don't change expiry on disconnect
           super(client_id:, expiry_interval:)
 
-          @session_expiry_file = (base_dir + "#{client_id}.expiry")
-          cleanup_tmp
+          @session_expiry_file = (@base_dir + "#{client_id}.expiry")
           log.info { "client_dir: #{@client_dir}, clean?: #{clean?}" }
         end
 
         def restart_clone
-          self.class.new(base_dir, client_id:, expiry_interval:)
+          self.class.new(base_dir:, client_id:, expiry_interval:)
         end
 
         def clean?
@@ -36,7 +40,7 @@ module MQTT
         end
 
         def connected!
-          client_dirs.each(&:mkpath)
+          pkt_dir.mkpath
 
           # record the previous session expiry duration so we can check it on a future restart
           session_expiry_file.open('w') { |f| f.write(expiry_interval.to_s) }
@@ -50,10 +54,10 @@ module MQTT
           return false unless session_expiry_file.exist?
 
           # choose the most recent of...
-          #   * the directory modification times (updated each time a packet file is added or removed),
+          #   * the pkt directory modification time (updated each time a packet file is added or removed),
           #   * the session_expiry_file modification time (updated on disconnect)
           # A hard crash without a clean disconnect will potentially expire a session earlier than the server
-          Time.now - (client_dirs + [session_expiry_file]).map(&:mtime).max > session_expiry_file.read.to_i
+          Time.now - [pkt_dir, session_expiry_file].select(&:exist?).map(&:mtime).max > session_expiry_file.read.to_i
         end
 
         def store_packet(packet, replace: false)
@@ -71,125 +75,38 @@ module MQTT
         end
 
         def retry_packets(&)
-          @client_dir.glob('pkt.*').sort_by(&:mtime).map { |f| f.open('r', &) }
+          pkt_dir.glob('*.mqtt').sort_by(&:mtime).map { |f| f.open('r', &) }
         end
 
         def packet_file(id)
           @client_dir + format('pkt/%04x.mqtt', id)
         end
 
-        # QOS Receive
-        # Unique ID is sortable (fixed width timestamp)
-        # qos1 live:      `/#{client_id}/qos1/#{unique_id}_#{packet_id}.live` write on PUBLISH, deleted on handled.
-        # qos2 live:      `/#{client_id}/qos2/#{unique_id}_#{packet_id}.live` (unhandled, unreleased)
-        # qos2 handled:   `/#{client_id}/qos2/#{unique_id}_#{packet_id}.handled` (handled, unreleased)
-        # qos2 released:  `/#{client_id}/qos2/#{unique_id}_#{packet_id}.released` (unhandled, released)
-        # qos2 replay:    '/#{client_id}/qos2/#{unique_id}_#{packet_id}.replay_[live|handled]
-
-        # TODO: Recover utility
-        #    * cleanup_tmp
-        #    * qos2/*.live     - rename to .replay_live or .handled
-        #    * qos2/*.released - rename to .replay_released or delete
-
-        def store_qos_received(packet, unique_id)
-          client_dir + qos_path(packet.qos, packet.id, unique_id).tap do |live_file|
-            tmp_file = live_file.sub_ext('live', 'tmp')
-            tmp_file.open('wb') { |f| packet.serialize(f) }
-            tmp_file.rename(live_file)
-          end
-        end
-
-        # Release the pending qos2 (return true if we had previously seen it)
-        def qos2_release(id)
-          qos2_live = find_qos2_file(id)
-
-          if qos2_live&.extname == '.live'
-            qos2_live.rename(qos2_live.sub_ext('.live', '.released'))
-          else
-            qos2_live&.delete
-          end
-
-          super
-        rescue Errno::ENOENT
-          retry
-        end
-
-        def qos_handled(packet, unique_id)
-          if packet.qos == 1
-            qos1_handled(packet, unique_id)
-          elsif packet.qos == 2
-            qos2_handled(packet, unique_id)
-          end
-        end
-
-        # Called once at initialize.
-        # rubocop:disable Metrics/AbcSize
+        # QoS2 inbound deduplication — recover pending packet ids from filenames
         def qos2_recover
-          # Abort if there are unmarked files to potentially replay
-          if (client_dir.glob('qos2/*.live') + client_dir.glob('qos2/*.released')).any?
-            raise SessionNotRecoverable, "Unhandled QOS2 messages in #{"#{client_dir}/qos2"}. Run recover utility"
-          end
-
-          client_dir.glob('qos2/*.replay_live').each { |q2| q2.rename(q2.sub_ext('.live')) }
-          client_dir.glob('qos2/*.replay_released').each { |q2| q2.rename(q2.sub_ext('.released')) }
-
-          client_dir.glob(%w[qos2/*.live qos2/*.handled]).map { |f| f.basename.to_s.split('_').last.to_i(16) }
+          pkt_dir.glob('qos2_*.pending').map { |f| f.basename.to_s[/qos2_([0-9a-f]+)\.pending/, 1].to_i(16) }
         end
-        # rubocop:enable Metrics/AbcSize
 
-        # Load the unhandled packets with their unique id, only called once per session store
-        def qos_unhandled_packets(&)
-          client_dir.glob(%w[qos?/*.live qos2/*.released]).sort_by(&:basename)
-                    .to_h { |f| [f.open('r', &), f.basename.to_s.split('_').first] }
+        # Mark a QoS2 packet id as pending (received, awaiting PUBREL)
+        def qos2_pending(id)
+          FileUtils.touch(qos2_pending_file(id))
         end
 
-        private
-
-        def cleanup_tmp
-          # Cleanup crashed .tmp files
-          client_dir.glob('qos?/*.tmp').each(&:delete)
-        end
-
-        # Make directories.
-        #   pkt  - packets we are sending, waiting to be acked
-        #   qos1 - qos1 packets received, waiting to be handled
-        #   qos2 - qos2 packets received, waiting to be released and handled
-        def client_dirs
-          %w[pkt qos1 qos2].map { |d| client_dir + d }
-        end
-
-        def qos2_handled(packet, unique_id)
-          live_file = client_dir + qos_path(2, packet.id, unique_id)
-          rel_file = client_dir + qos_path(2, packet.id, unique_id, 'released')
-
-          live_file.rename(live_file.sub_ext('.handled')) if live_file.exist?
-          rel_file.unlink if rel_file.exist?
+        # Release a QoS2 packet id (called before sending PUBCOMP)
+        def qos2_release(id)
+          qos2_pending_file(id).delete
         rescue Errno::ENOENT
-          retry
+          # already released
         end
 
-        def qos1_handled(packet, unique_id)
-          live_file = (client_dir + qos_path(1, packet.id, unique_id))
-          live_file.unlink
-        rescue Errno::ENOENT
-          log.warn { "qos_handled: #{live_file} unexpectedly not exists" }
-        end
+        private
 
-        # @return [String]
-        def qos_path(qos, packet_id, unique_id, ext = 'live')
-          format('qos%<qos>i/%<unique_id>s_%<packet_id>05x.%<ext>s', qos:, unique_id:, packet_id:, ext:)
+        def pkt_dir
+          @client_dir / 'pkt'
         end
 
-        def find_qos2_file(id)
-          # search live and handled separately to avoid race while renaming
-          live_files = client_dir.glob(qos_path(2, id, '*', 'live'))
-          raise ProtocolError, "QOS(#{id}): more than one packet: #{live_files}" if live_files.size > 1
-          return live_files.first if live_files.size == 1
-
-          handled_files = client_dir.glob(qos_path(2, id, '*', 'handled'))
-          raise ProtocolError, "QOS(#{id}): more than one packet: #{handled_files}" if handled_files.size > 1
-
-          handled_files.first
+        def qos2_pending_file(id)
+          @client_dir + format('pkt/qos2_%04x.pending', id)
         end
       end
     end

data/lib/mqtt/core/client/memory_session_store.rb

@@ -39,6 +39,10 @@ module MQTT
           @clean
         end
 
+        def disconnect_expiry_interval
+          0 # Memory sessions don't survive disconnect anyway
+        end
+
         def store_packet(packet, replace: false)
           raise KeyError, 'packet id already exists' if !replace && stored_packet?(packet.id)
 
@@ -57,23 +61,11 @@ module MQTT
           @store.values
         end
 
-        def qos2_recover
-          [] # nothing to recover
-        end
+        def qos2_recover = []
 
-        def qos_unhandled_packets
-          {} # nothing was persisted
-        end
+        def qos2_pending(_id) = nil
 
-        def store_qos_received(packet, unique_id)
-          # For memory store, we don't need to persist received packets
-          # This is just for tracking during the current session
-        end
-
-        def qos_handled(packet, unique_id)
-          # For memory store, we don't need to persist handled status
-          # This is just for tracking during the current session
-        end
+        def qos2_release(_id) = nil
 
         def restart_clone
           self # don't actually clone.

data/lib/mqtt/core/client/message_router.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module MQTT
+  module Core
+    class Client
+      # Routes incoming PUBLISH packets to matching subscriptions
+      #
+      # The core implementation tracks subscriptions by topic_filter. A {Trie} is used for matching wildcard filters
+      # to topics.
+      class MessageRouter
+        # A trie (prefix tree) for efficiently matching MQTT topics against wildcard patterns.
+        #
+        # - '+' matches exactly one level (segment between '/')
+        # - '#' matches zero or more remaining levels (must be last)
+        class Trie
+          # @!visibility private
+          Node = Data.define(:children, :filter) do
+            extend Forwardable
+
+            # the filters set only ever has one entry, but it is possible that a level is created as an intermediate
+            # entry
+            def initialize(children: {}, filter: nil)
+              super
+            end
+
+            def redundant?
+              empty? && filter.nil?
+            end
+
+            def_delegators :children, :empty?, :[], :[]=, :delete, :include?
+          end
+
+          def initialize
+            @root = Node.new
+          end
+
+          # @!visibility private
+
+          # Add a topic filter to the trie
+          # @param filter [String] MQTT topic filter (may contain '+' or '#')
+          # @return [self]
+          def add(filter)
+            *parents, leaf = filter.split('/')
+            parent_node = parents.reduce(@root) do |current, level|
+              current[level] ||= Node.new
+            end
+
+            leaf_node = parent_node[leaf] ||= Node.new(filter: filter)
+            parent_node[leaf] = Node.new(children: leaf_node.children, filter: filter) unless leaf_node.filter
+            self
+          end
+
+          # Remove a topic filter from the trie
+          # @param filter [String] MQTT topic filter to remove
+          # @return [self]
+          def remove(filter)
+            levels = filter.split('/')
+            remove_recursive(@root, levels, filter, 0)
+            self
+          end
+
+          # Find all topic filters that match a given topic name
+          # @param topic [String] fully-qualified MQTT topic name (no wildcards)
+          # @return [Array<String>] matching topic filters
+          def match(topic)
+            [].tap { |filters| match_recursive(@root, topic.split('/'), 0, filters) }
+          end
+
+          # Check if the trie is empty
+          # @return [Boolean]
+          def empty?
+            @root.children.empty?
+          end
+
+          private
+
+          def remove_recursive(node, levels, filter, depth)
+            level = levels[depth]
+            child = node[level]
+
+            return unless child
+
+            if depth == levels.size - 1
+              if child.empty?
+                node.delete(level)
+              elsif child.filter
+                # Remove the filter, keep the children
+                node[level] = Node.new(children: child.children)
+              end
+              return
+            end
+
+            remove_recursive(child, levels, filter, depth + 1)
+            node.children.delete(level) if child.redundant?
+          end
+
+          def match_recursive(node, levels, depth, filters)
+            # If we've matched all levels, collect this filter if it has one
+            return filters << node.filter if depth == levels.size && node.filter
+
+            # Keep going
+            level = levels[depth]
+            match_recursive(node[level], levels, depth + 1, filters) if node.include?(level)
+
+            # Also single level '+'
+            match_recursive(node['+'], levels, depth + 1, filters) if node.include?('+')
+
+            filters << node['#'].filter if node.include?('#')
+          end
+        end
+
+        include Logger
+        include ConcurrentMonitor
+        extend Forwardable
+
+        def initialize(monitor:)
+          @monitor = monitor.new_monitor
+          @subs = Hash.new { |h, k| h[k] = Set.new }
+          @topic_trie = Trie.new
+        end
+
+        # @!visibility private
+
+        # Register subscriptions for routing before SUBSCRIBE is sent
+        def register(subscription:, subscribe:)
+          synchronize do
+            register_sync(subscription:, subscribe:)
+            (subscribe.subscribed_topic_filters - subscription.topic_filters.to_a).tap do |new_filters|
+              subscription.topic_filters.merge(new_filters) if new_filters.any?
+            end
+          end
+        end
+
+        # Deregister a subscription (or specific filters) from routing (before UNSUBSCRIBE is sent)
+        # Removes the subscription from @subs for the given filters (default: all registered filters).
+        # @return [Array<String>] filters that are now inactive (no remaining subscriptions) and safe to UNSUBSCRIBE
+        def deregister(*filters, subscription:)
+          synchronize do
+            filters = subscription.topic_filters.to_a if filters.empty?
+            subscription.topic_filters.subtract(filters)
+            deregister_filters(subscription, filters)
+          end
+        end
+
+        # Route packet to matching subscriptions
+        def route(packet)
+          synchronize { subs_for(matching_filters(packet)) }
+        end
+
+        # return all subscriptions, then clear them
+        def clear
+          synchronize { all_subscriptions.tap { reset } }
+        end
+
+        private
+
+        def reset
+          @subs.clear
+          @topic_trie = Trie.new
+        end
+
+        def subs_for(filters)
+          filters.flat_map { |f| @subs.fetch(f, []).to_a }.uniq
+        end
+
+        # TODO: we used to check for duplicate filters which we don't need, but also warn about duplicated retained
+        #    messages which is still a thing for OVERLAPPING filters.
+        #    We might still need to warn about that or handled that in Subscription put
+        #    (to skip messages with retain flag after seeing one without, OR warn here if RAP or RH is set and
+        #    there are overlapping filters
+
+        def register_sync(subscription:, subscribe:, use_trie: true)
+          filters = subscribe.subscribed_topic_filters
+
+          filters.each do |filter|
+            @subs[filter] << subscription
+            @topic_trie.add(filter) if use_trie && Subscription::Filters.wildcard_filter?(filter)
+          end
+        end
+
+        # Remove subscription from given filters, clean up empty filters
+        # @return [Array<String>] filters that are now inactive (no remaining subscriptions)
+        def deregister_filters(subscription, filters)
+          filters.each_with_object([]) do |filter, inactive|
+            next unless (subs_set = @subs[filter])
+
+            subs_set.delete(subscription)
+            next unless subs_set.empty?
+
+            remove_filter(filter)
+            inactive << filter
+          end
+        end
+
+        # called by: deregister when there sre no remaining subscriptions for a filter
+        # called by: unsubscribe when successfully unsubscribed
+        def remove_filter(filter)
+          @subs.delete(filter)
+          @topic_trie.remove(filter) if Client::Subscription::Filters.wildcard_filter?(filter)
+        end
+
+        def matching_filters(pkt)
+          topic = pkt.topic_name
+          [topic, *@topic_trie.match(topic)]
+        end
+
+        def all_subscriptions
+          @subs.values.flat_map(&:to_a).uniq
+        end
+      end
+    end
+  end
+end

data/lib/mqtt/core/client/qos0_session_store.rb

@@ -21,6 +21,10 @@ module MQTT
           0
         end
 
+        def disconnect_expiry_interval
+          0 # QoS0 sessions don't persist
+        end
+
         def connected!
           @store = Set.new
         end