mqtt-core 0.0.1.ci.release

data/lib/mqtt/core/type/list.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module MQTT
+  module Core
+    module Type
+      # list of type
+      class List
+        attr_reader :type
+
+        def initialize(type)
+          @type = type
+        end
+
+        def item_type
+          type
+        end
+
+        def default_value
+          []
+        end
+
+        def read(io)
+          result = []
+          result << type.read(io) until io.eof?
+          result.freeze
+        end
+
+        def write(value, io)
+          value&.each { |v| type.write(v, io) }
+        end
+
+        # @return [Array<#type>]
+        def from(arr, **)
+          arr ||= []
+          arr = [arr] unless arr.respond_to?(:map)
+          arr.map { |v| type.from(v, **) }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/mqtt/core/type/password.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module MQTT
+  module Core
+    module Type
+      # Password data - input can be a proc to pull a password
+      # converts to String with binary encoding
+      module Password
+        module_function
+
+        # return [String with binary encoding]
+        def read(io)
+          size = io.read(2)&.unpack1('S>')
+          io.read(size)
+        end
+
+        def write(value, io)
+          value ||= default_value
+          io.write([value.size, value].pack('S>A*'))
+        end
+
+        # @return [String(binary)]
+        def from(value, **)
+          return nil if value.nil?
+
+          value = value.call if value.respond_to?(:call)
+          value.to_s.b
+        end
+
+        def default_value
+          @default_value ||= ''.b.freeze
+        end
+      end
+    end
+  end
+end

data/lib/mqtt/core/type/properties.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module MQTT
+  module Core
+    module Type
+      # Properties Map (used since MQTT 5.0)
+      class Properties
+        # @!parse class PropertyType < Data; end
+        PropertyType = Data.define(:id, :name, :type, :packet_types) do
+          class << self
+            def create(id, name, type, packet_types = :all, types: {})
+              new(id, name, resolve_type(type, types), packet_types)
+            end
+
+            def resolve_type(input_type, types)
+              case input_type
+              when Symbol
+                types.fetch(input_type) { raise ProtocolError, "Unknown property type #{input_type}" }
+              when Array
+                List.new(resolve_type(input_type.first, types))
+              else
+                input_type
+              end
+            end
+          end
+
+          def initialize(id:, name:, type:, packet_types: [:all])
+            super
+          end
+
+          def from(value)
+            type.from(value)
+          end
+
+          def read(io, into)
+            if type.is_a?(Type::List)
+              (into[name] ||= []) << type.item_type.read(io)
+            else
+              into[name] = type.read(io)
+            end
+          end
+
+          def write(value, io, write_type: type)
+            if write_type.is_a?(Type::List)
+              value.each { |item| write(item, io, write_type: type.item_type) }
+            else
+              VarInt.write(id, io)
+              write_type.write(value, io)
+            end
+          end
+
+          def for_packet?(packet_type_name)
+            return true if packet_types == :all
+
+            packet_types.include?(packet_type_name)
+          end
+        end
+
+        def initialize(packet_type_name, property_types)
+          @property_types = property_types.select { |pt| pt.for_packet?(packet_type_name) }.freeze
+          @property_map =
+            Hash.new { |_h, k| raise ProtocolError, "Unknown property type #{k} for #{packet_type_name}" }
+                .merge!(@property_types.to_h { |pt| [pt.name, pt] })
+                .merge!(@property_types.to_h { |pt| [pt.id, pt] })
+                .freeze
+        end
+
+        def sub_properties
+          @property_types.to_h { |pt| [pt.name, pt.type] }
+        end
+
+        def read(io)
+          default_value.tap do |output|
+            # Where properties is the last thing in a packet and there are no properties, the length property
+            # is not required to be set
+            next if io.eof?
+
+            Packet.read_sio(io) do |sio|
+              until sio.eof?
+                id = VarInt.read(sio)
+                property_type = @property_map.fetch(id) do
+                  raise ProtocolError, format('Unknown property id 0x%02x', id)
+                end
+                property_type.read(sio, output)
+              end
+            end
+          end
+        end
+
+        def write(values, io)
+          Packet.write_sio(io) do |sio|
+            values.each_pair do |name, value|
+              property_type = @property_map.fetch(name) { raise ProtocolError, "Unknown property name #{name}" }
+              property_type.write(value, sio)
+            end
+          end
+        end
+
+        # @param [Hash|nil] values
+        def from(values, data:)
+          values ||= default_value
+          raise ArgumentError 'Properties values must be a Hash' unless values.respond_to?(:each_pair)
+
+          # properties with entries at the top level of the data structure override the underlying hash value
+          @property_types.filter_map do |property_type|
+            property_type.name.tap { |name| values[name] = data.delete(name) if data.key?(name) }
+          end
+
+          # now make sure every entry in values is valid and converted to type
+          values.filter_map do |(name, value)|
+            property_type = @property_map.fetch(name) { raise ArgumentError, "Unknown property name #{name}" }
+            next nil unless (filled_value = property_type.from(value))
+
+            [name, filled_value]
+          end.to_h.freeze
+        end
+
+        def default_value
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/mqtt/core/type/reason_codes.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'fixed_int'
+
+module MQTT
+  module Core
+    module Type
+      # A type that resolves to a reason code
+      class ReasonCodes
+        # @!parse class ReasonCode < ::Data; end
+        ReasonCode = Data.define(:code, :name, :packet_types, :error) do
+          def for_packet?(packet_type_name)
+            code == 0xff || packet_types.include?(packet_type_name)
+          end
+
+          def success?
+            !failed?
+          end
+
+          def failed?
+            code >= 0x80
+          end
+
+          def to_s
+            format '%<name>s(0x%02<code>x)', name:, code:
+          end
+        end
+
+        def initialize(valid_codes)
+          @reason_code_map = valid_codes.to_h { |rc| [rc.code, rc] }
+        end
+
+        def fetch(...)
+          @reason_code_map.fetch(...)
+        end
+
+        def read(io)
+          # if (s)io is at eof then the reason code is assumed to be success
+          fetch(Int8.read(io) || 0x00) { |rc| raise ProtocolError, "Invalid Reason Code #{rc}" }
+        end
+
+        def write(value, io)
+          # use from here as sometimes the code is applied as a default
+          Int8.write(from(value).code, io)
+        end
+
+        def from(input_value, **)
+          input_value = input_value.code if input_value.is_a?(ReasonCode)
+          raise ArgumentError, "Invalid Reason Code #{input_value}" unless input_value.respond_to?(:to_i)
+
+          fetch(input_value.to_i) { |rc| raise ArgumentError, "Invalid Reason Code #{rc}" }
+        end
+
+        def default_value
+          fetch(0x00)
+        end
+      end
+    end
+  end
+end

data/lib/mqtt/core/type/remaining.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module MQTT
+  module Core
+    module Type
+      # remaining payload, no length prefix, reads to EOF (StringIO) and writes the whole value as binary
+      # string
+      module Remaining
+        module_function
+
+        def read(io)
+          # read to end of file (which only works because it is only ever used with a StringIO
+          io.read
+        end
+
+        def write(value, io)
+          io.write(value.to_s.b)
+        end
+
+        def from(value, **)
+          value.to_s
+        end
+
+        def default_value
+          ''.b
+        end
+      end
+    end
+  end
+end

data/lib/mqtt/core/type/shape.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module MQTT
+  module Core
+    module Type
+      # Base module for structured MQTT types {Packet} and {SubType}
+      module Shape
+        Field = Data.define(:name, :type, :condition) do
+          def write(obj, io)
+            type.write(obj.send(name), io) if obj.instance_exec(&condition)
+          end
+
+          def read(obj, io)
+            value = type.read(io) if obj.instance_exec(&condition)
+            value = type.default_value if value.nil? && type.respond_to?(:default_value)
+            value
+          end
+        end
+
+        # methods for defining fields
+        module Definition
+          attr_reader :fields
+
+          def flags(*flags)
+            Type::BitFlags.new(*flags)
+          end
+
+          def list(type, **fields, &)
+            if fields.any?
+              klass = Class.new(Type::SubType)
+              klass.instance_variable_set(
+                :@fields, resolve_fields(fields).tap { |resolved| define_field_methods(resolved, klass:) }
+              )
+              # Define additional methods and aliases (after field methods are defined!)
+              klass.class_eval(&) if block_given?
+              type = const_set(type.to_s.split('_').map(&:capitalize).join, klass)
+            elsif type.is_a?(Symbol)
+              type = self::VALUE_TYPES[type]
+            end
+
+            Type::List.new(type)
+          end
+
+          def resolve_fields(fields)
+            fields.map do |(name, type)|
+              type, condition = field_type_for(type)
+              Field.new(name:, type:, condition:)
+            end
+          end
+
+          def field_type_for(type_info)
+            return field_type_for({ type: type_info, if: true }) unless type_info.is_a?(Hash)
+
+            type, type_if = type_info.values_at(:type, :if)
+            type = self::VALUE_TYPES[type] if type.is_a?(Symbol)
+            condition =
+              case type_if
+              when Symbol
+                -> { send(type_if) }
+              when Proc
+                type_if
+              else
+                -> { true }
+              end
+            [type, condition]
+          end
+
+          # Avoid name clashes
+          def sub_property_method(_name, property_name)
+            property_name
+          end
+
+          def define_field_methods(fields, klass: self)
+            fields.map do |field|
+              name, type, _condition = field.deconstruct
+
+              if type.respond_to?(:sub_properties)
+                define_property_readers(name, type, klass:)
+                define_hash_reader(name, type, klass:)
+              else
+                klass.define_method(name) { @data[name] }
+              end
+            end
+          end
+
+          def define_property_readers(name, type, klass:)
+            type.sub_properties.each_key do |property_name|
+              method = klass.sub_property_method(name, property_name) if klass.respond_to?(:sub_property_method)
+              klass.define_method(method || property_name) { @data.dig(name, property_name) }
+            end
+          end
+
+          def define_hash_reader(name, type, klass:)
+            klass.define_method(name) do
+              type.sub_properties.keys.filter_map do |property_name|
+                method = klass.sub_property_method(name, property_name) if klass.respond_to?(:sub_property_method)
+                value = send(method || property_name)
+                [property_name, value] unless value.nil?
+              end.to_h.freeze
+            end
+          end
+        end
+
+        def initialize(*deserialize_args, **data)
+          @data = {}
+          apply_data(defaults)
+          if deserialize_args.any?
+            deserialize(*deserialize_args)
+          else
+            apply_data(data) if data.any?
+            apply_overrides(@data)
+          end
+          validate if respond_to?(:validate, true)
+          @data.freeze
+        end
+
+        def serialize(io)
+          serialize_fields(self.class.fields, io)
+        end
+
+        def to_h
+          @data
+        end
+
+        def deconstruct_keys(*keys)
+          to_h.slice(keys)
+        end
+
+        private
+
+        # rubocop:disable Metrics/AbcSize
+        def apply_data(data)
+          self.class.fields.each do |f|
+            # source @data (defaults)
+            # data[f.name] if data.key?(f.name) - overwrites or merges with defaults
+            # properties if data[sub_property_name]
+            if f.type.respond_to?(:sub_properties)
+              result = @data[f.name] ||= {}
+              result.merge!(data.delete(f.name)) if data.key?(f.name)
+              f.type.sub_properties.each do |property_name, property_type|
+                result[property_name] = property_type.from(data.delete(property_name)) if data.key?(property_name)
+              end
+            elsif data.key?(f.name)
+              @data[f.name] = f.type.from(data.delete(f.name))
+            end
+          end
+          raise ArgumentError, "Unused data for #{self.class.name} - #{data}" unless data.empty?
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        # applied in the same way as user supplied data
+        def defaults
+          {}
+        end
+
+        def apply_overrides(data)
+          # do nothing by default
+        end
+
+        def serialize_fields(fields, io)
+          fields.each { |f| f.write(self, io) }
+        end
+
+        def deserialize_fields(fields, io)
+          fields.filter_map do |f|
+            value = f.read(self, io)
+            [f.name, value] if value
+          end.to_h
+        end
+
+        def deserialize(io)
+          @data.merge!(deserialize_fields(self.class.fields, io))
+        end
+      end
+    end
+  end
+end

data/lib/mqtt/core/type/sub_type.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'shape'
+
+module MQTT
+  module Core
+    module Type
+      # Class representing an MQTT SubType (defined for structured lists)
+      class SubType
+        include Shape
+
+        class << self
+          # @!attribute [r] fields
+          #   @return [Array] fields injected by List
+          attr_reader :fields
+
+          def read(io)
+            new(io)
+          end
+
+          def write(value, io)
+            value.serialize(io)
+          end
+
+          # TODO: if we had a subtype that was not within a list
+          #       then we'd probably list the fields and pull top level content from the data
+          def from(value, **)
+            new(**value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mqtt/core/type/utf8_string.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module MQTT
+  module Core
+    module Type
+      # UTF8 Encoded String written with length as prefix
+      module UTF8String
+        module_function
+
+        def read(io)
+          size = io.read(2)&.unpack1('S>')
+          io.read(size).force_encoding(Encoding::UTF_8).tap { |s| raise EncodingError unless valid_utf8?(s) }
+        end
+
+        def from(value, **)
+          return nil if value.nil?
+
+          value = value.to_s
+          return value if valid_utf8?(value)
+
+          value.encode(Encoding::UTF_8).tap { |s| raise EncodingError unless valid_utf8?(s) }
+        end
+
+        def write(value, io)
+          value ||= default_value
+          io.write([value.size, value].pack('S>A*'))
+        end
+
+        def default_value
+          @default_value ||= ''.encode(Encoding::UTF_8).freeze
+        end
+
+        def valid_utf8?(str)
+          str.encoding == Encoding::UTF_8 && str.valid_encoding? && !str.include?("\u0000")
+        end
+      end
+    end
+  end
+end

data/lib/mqtt/core/type/utf8_string_pair.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module MQTT
+  module Core
+    module Type
+      # Key value pair as UTF8 encoded strings
+      module UTF8StringPair
+        module_function
+
+        def read(io)
+          [UTF8String.read(io), UTF8String.read(io)].freeze
+        end
+
+        def from(value, **)
+          raise ArgumentError, 'Value must be Array<String,String>' unless value.is_a?(Array) && value.size == 2
+
+          value.map { |v| UTF8String.from(v) }.freeze
+        end
+
+        def write(value, io)
+          raise ProtocolError, 'Value must be Array<String,String>' unless value.is_a?(Array) && value.size == 2
+
+          UTF8String.write(value[0], io)
+          UTF8String.write(value[1], io)
+        end
+      end
+    end
+  end
+end

data/lib/mqtt/core/type/var_int.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module MQTT
+  module Core
+    module Type
+      # Variable Byte Integer
+      module VarInt
+        module_function
+
+        # Maximum variable integer (hence maximum packet size = 256MB)
+        MAX_INTVAR = 268_435_455
+
+        def read(io)
+          value = 0
+          multiplier = 1
+
+          loop do
+            encoded_byte = io.readbyte
+            return value unless encoded_byte
+
+            value += (encoded_byte & 0x7F) * multiplier
+
+            raise ProtocolError, 'Malformed Variable Byte Integer' if multiplier > 0x80**3
+
+            multiplier *= 0x80
+
+            return value if encoded_byte.nobits?(128)
+          end
+        end
+
+        def from(value)
+          value ||= 0
+          raise ArgumentError, 'Vaiue must be Integer' unless value.respond_to?(:to_int)
+
+          value = value.to_i
+          raise ArgumentError, "Value out of range (0 - #{MAX_INTVAR})" unless value.between?(0, MAX_INTVAR)
+
+          value
+        end
+
+        def write(value, io)
+          value ||= 0
+          raise ProtocolError, "Value out of range (0 - #{MAX_INTVAR})" unless value.between?(0, MAX_INTVAR)
+
+          loop do
+            encoded_byte = value % 0x80
+            value /= 0x80
+            encoded_byte |= 0x80 if value.positive?
+            io.write([encoded_byte].pack('C'))
+            break if value.zero?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mqtt/core/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative '../version'
+
+module MQTT
+  module Core
+    # The version number of the MQTT Core gem
+    VERSION = MQTT::VERSION
+  end
+end

data/lib/mqtt/core.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'logger'
+require_relative 'open'
+require_relative 'core/client'

data/lib/mqtt/errors.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module MQTT
+  # Super-class for other MQTT related exceptions
+  class Error < StandardError
+    # included in protocol specific errors that are retriable
+    module Retriable
+    end
+  end
+
+  # Raised if there is a problem with data received from a remote host
+  class ProtocolError < Error; end
+
+  # Raised when trying to perform a function but no connection is available
+  class ConnectionError < Error; end
+
+  # Raised in the disconnect handler when the client expects a session, but the broker does not have one.
+  class SessionNotPresent < Error; end
+
+  # Raised in the disconnect handler when the client session has expired before it can reconnect to the broker.
+  class SessionExpired < Error; end
+
+  # A ResponseError will be raised from packet acknowledgements
+  class ResponseError < Error; end
+
+  RETRIABLE_NETWORK_ERRORS = [
+    Errno::ECONNABORTED,   # Connection aborted
+    Errno::ECONNRESET,     # Connection reset
+    Errno::EHOSTUNREACH,   # No route to host
+    Errno::ENETUNREACH,    # Network unreachable
+    Errno::EPIPE,          # Broken pipe
+    Errno::ETIMEDOUT,      # Connection timed out
+    Errno::EINVAL,         # Invalid argument (Windows-specific)
+    SocketError,           # DNS and basic socket errors
+    IOError                # Generic IO errors (including IO::TimeoutError)
+  ].freeze
+end