nl 0.2.4 → 0.4.1

data/sig/generated/nl/datatypes.rbs

@@ -0,0 +1,181 @@
+# Generated from lib/nl/datatypes.rb with RBS::Inline
+
+module Nl
+  interface _DataType
+    def encode: (Encoder, untyped, ?context: untyped) -> void
+
+    def decode: (Decoder, ?context: untyped, ?nlattr_type_flags: Integer) -> untyped
+
+    def nlattr_type_flags: (?untyped, ?context: untyped) -> Integer
+
+    def coerce: (untyped, ?context: untyped) -> untyped
+  end
+
+  module DataTypes
+    class Base
+      def initialize: (?check: untyped) -> untyped
+
+      def nlattr_type_flags: (?untyped _value, ?context: untyped) -> untyped
+
+      def coerce: (untyped value, ?context: untyped) -> untyped
+
+      private def checked: (untyped value) -> untyped
+    end
+
+    class Scalar < Base
+      def initialize: (untyped type, check: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    class VariableInteger < Base
+      UINT32_RANGE: untyped
+
+      UINT64_RANGE: untyped
+
+      SINT32_RANGE: untyped
+
+      SINT64_RANGE: untyped
+
+      def initialize: (untyped byte_order, signed: untyped, check: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    class String < Base
+      def initialize: (check: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    class Binary < Base
+      def initialize: (check: untyped, ?length: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    # An array whose elements are packed consecutively without per-element
+    # headers or alignment padding.
+    class PackedArray < Base
+      def initialize: (untyped sub_type, ?check: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped values, ?context: untyped) -> untyped
+
+      def coerce: (untyped values, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    class Struct < Base
+      def initialize: (untyped type, ?check: untyped, ?consume_remaining: untyped) -> untyped
+
+      def coerce: (untyped value, ?context: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    class Flag < Base
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    class Bitfield32 < Base
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    class Pad < Base
+      def initialize: (?untyped length) -> untyped
+
+      def encode: (untyped encoder, untyped _value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    class NestedAttributes < Base
+      def initialize: (untyped attribute_set, ?selector_bindings: untyped) -> untyped
+
+      def nlattr_type_flags: (?untyped _value, ?context: untyped) -> untyped
+
+      def coerce: (untyped value, ?context: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+
+      private def selectors: (untyped context) -> untyped
+    end
+
+    class SubMessage < Base
+      class Format < Data
+        attr_reader type(): untyped
+
+        attr_reader selector_bindings(): untyped
+
+        attr_reader nested(): untyped
+
+        def self.new: (untyped type, untyped selector_bindings, untyped nested) -> instance
+                    | (type: untyped, selector_bindings: untyped, nested: untyped) -> instance
+
+        def self.members: () -> [ :type, :selector_bindings, :nested ]
+
+        def members: () -> [ :type, :selector_bindings, :nested ]
+      end
+
+      def initialize: (untyped selector, untyped formats) -> untyped
+
+      def nlattr_type_flags: (?untyped value, context: untyped) -> untyped
+
+      def coerce: (untyped value, context: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, context: untyped, ?nlattr_type_flags: untyped) -> untyped
+
+      private def selectors: (untyped format, untyped context) -> untyped
+    end
+
+    # Nested attributes whose type numbers are keys rather than members of
+    # an attribute set. Each level is returned as an Integer-keyed Hash;
+    # values at the innermost level are decoded as @attribute_set.
+    class NestTypeValue < Base
+      def initialize: (untyped attribute_set, untyped levels, ?selector_bindings: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def coerce: (?untyped value, ?context: untyped, **untyped keywords) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+
+      private def encode_level: (untyped encoder, untyped values, untyped levels, untyped external_selectors) -> untyped
+
+      private def coerce_level: (untyped values, untyped levels, untyped external_selectors) -> untyped
+
+      private def decode_level: (untyped decoder, untyped levels, untyped external_selectors) -> untyped
+
+      private def selectors: (untyped context) -> untyped
+    end
+
+    class IndexedArray < Base
+      def initialize: (untyped sub_type) -> untyped
+
+      def encode: (untyped encoder, untyped values, ?context: untyped) -> untyped
+
+      def coerce: (untyped values, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+  end
+end

data/sig/generated/nl/decoder.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/nl/decoder.rb with RBS::Inline
+
+module Nl
+  class Decoder
+    class Error < StandardError
+    end
+
+    class OutOfBounds < Error
+      def initialize: (?untyped message) -> untyped
+    end
+
+    class Unterminated < Error
+      def initialize: (?untyped message) -> untyped
+    end
+
+    def initialize: (untyped buffer, ?untyped offset, ?untyped length) -> untyped
+
+    def available?: (?untyped size) -> untyped
+
+    def remaining: () -> untyped
+
+    def limit: (untyped size) -> untyped
+
+    def skip: (?untyped length) -> untyped
+
+    def get_string: (?untyped length) -> untyped
+
+    def get_buffer: (?untyped length) -> untyped
+
+    def get_zstring: (?unterminated_ok: untyped) -> untyped
+
+    def get_value: (untyped type) -> untyped
+
+    def get_values: (untyped types) -> untyped
+
+    def align_to: (untyped alignment) -> untyped
+  end
+end

data/sig/generated/nl/encoder.rbs

@@ -0,0 +1,29 @@
+# Generated from lib/nl/encoder.rb with RBS::Inline
+
+module Nl
+  class Encoder
+    attr_reader position: untyped
+
+    def initialize: (?untyped capacity) -> untyped
+
+    def reserve: (untyped size) -> untyped
+
+    def put_string: (untyped value) -> untyped
+
+    def put_zstring: (untyped value) -> untyped
+
+    def put_value: (untyped type, untyped value) -> untyped
+
+    def put_values: (untyped types, untyped values) -> untyped
+
+    def align_to: (untyped alignment) -> untyped
+
+    def put_value_at: (untyped offset, untyped type, untyped value) -> untyped
+
+    def put_values_at: (untyped offset, untyped types, untyped values) -> untyped
+
+    def buffer: () -> untyped
+
+    def measure: (untyped type, ?untyped offset) -> untyped
+  end
+end

data/sig/generated/nl/endian.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/nl/endian.rb with RBS::Inline
+
+module Nl
+  module Endian
+    # sizeof(int)
+    SIZEOF_INT: untyped
+
+    # sizeof(long)
+    SIZEOF_LONG: untyped
+
+    # sizeof(long long)
+    SIZEOF_LLONG: untyped
+
+    # Little-endian scalar types.
+    module Little
+    end
+
+    # Big-endian scalar types.
+    module Big
+    end
+
+    # Host-endian scalar types.
+    #
+    # This module includes either {Little} or {Big} depending on the host's native byte order.
+    module Host
+    end
+  end
+end

data/sig/generated/nl/error.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/nl/error.rb with RBS::Inline
+
+module Nl
+  class Error < StandardError
+  end
+
+  class ProtocolViolation < Error
+  end
+
+  class ExhaustedSequenceNumber < Error
+  end
+
+  class TimeoutError < Error
+  end
+
+  class ClosedError < Error
+  end
+
+  class NotificationLossError < Error
+  end
+
+  class UnknownMulticastGroupError < Error
+  end
+
+  class UnresolvedMulticastGroupError < Error
+  end
+end

data/sig/generated/nl/exchange.rbs

@@ -0,0 +1,75 @@
+# Generated from lib/nl/exchange.rb with RBS::Inline
+
+module Nl
+  # State machine for one Netlink request/reply exchange.
+  #
+  # Dump exchanges are known to be multipart from the request and remain open
+  # through NLMSG_DONE. Some Linux Generic Netlink dump handlers construct
+  # replies with genlmsg_iput(), which leaves NLM_F_MULTI unset despite that
+  # multipart lifetime. Dump mode therefore accepts data with or without the
+  # flag; reply mode still uses it to detect a multipart do response.
+  #
+  # Some operations also return multipart data for a do request, although YNL
+  # cannot declare such a reply. Reply mode handles this kernel behavior by
+  # retaining the first data message, draining the remainder, and completing
+  # on NLMSG_DONE instead of ACK.
+  class Exchange
+    class Item < Data
+      attr_reader value(): untyped
+
+      def self.new: (untyped value) -> instance
+                  | (value: untyped) -> instance
+
+      def self.members: () -> [ :value ]
+
+      def members: () -> [ :value ]
+    end
+
+    class Complete < Data
+      def self.new: () -> instance
+                  | () -> instance
+
+      def self.members: () -> [ ]
+
+      def members: () -> [ ]
+    end
+
+    COMPLETE: untyped
+
+    class Failure < Data
+      attr_reader exception(): untyped
+
+      def self.new: (untyped exception) -> instance
+                  | (exception: untyped) -> instance
+
+      def self.members: () -> [ :exception ]
+
+      def members: () -> [ :exception ]
+    end
+
+    MODES: untyped
+
+    attr_reader mode: untyped
+
+    # @rbs (mode: :dump | :no_reply | :reply) -> void
+    def initialize: (mode: :dump | :no_reply | :reply) -> void
+
+    def accept: (untyped frame) -> untyped
+
+    def cancel: () -> untyped
+
+    def cancelled?: () -> untyped
+
+    def complete?: () -> untyped
+
+    def result: () -> untyped
+
+    private def accept_ack: () -> untyped
+
+    private def accept_reply: (untyped frame) -> untyped
+
+    private def complete: (untyped value) -> untyped
+
+    private def fail_with: (untyped exception) -> untyped
+  end
+end

data/sig/generated/nl/family.rbs

@@ -0,0 +1,71 @@
+# Generated from lib/nl/family.rb with RBS::Inline
+
+module Nl
+  type executor = :thread | :fiber
+
+  interface _Connection
+    def exchange: (Raw::Endpoint endpoint, Symbol kind, Class request_class, Class reply_class, Hash[Symbol, untyped] args) ?{ (untyped) -> void } -> untyped
+
+    def exchange_async: (Raw::Endpoint endpoint, Symbol kind, Class request_class, Class reply_class, Hash[Symbol, untyped] args, ?stream_capacity: Integer?) -> (Async::Future[untyped] | Async::Stream[untyped])
+
+    def async_capable?: () -> bool
+
+    def register_notifications: (Raw::Endpoint, Hash[Integer, Class]) -> NotificationChannel
+
+    def add_memberships: (Array[Integer]) -> nil
+
+    def drop_memberships: (Array[Integer]) -> nil
+
+    def receive_notification: (Raw::Endpoint, ?timeout: Numeric?) -> untyped
+
+    def close: () -> nil
+  end
+
+  interface _FamilyClass[out F]
+    def new: (_Connection, endpoint: Raw::Endpoint) -> F
+  end
+
+  class Family
+    DEFAULT_NOTIFICATION_CAPACITY: untyped
+
+    module Session
+      def close: () -> nil
+    end
+
+    # --
+    #  @rbs connection: _Connection
+    #  @rbs endpoint: Raw::Endpoint
+    #  @rbs return: instance
+    def initialize: (_Connection connection, endpoint: Raw::Endpoint) -> instance
+
+    private def exchange_message: (untyped kind, untyped request_class, untyped reply_class, untyped args) ?{ (?) -> untyped } -> untyped
+
+    def async_capable?: () -> bool
+
+    # Adds multicast memberships to the existing family socket. Membership is
+    # additive and remains active until explicitly removed or the owner closes.
+    def subscribe: (*untyped groups) -> untyped
+
+    def unsubscribe: (*untyped groups) -> untyped
+
+    def receive_notification: (?timeout: untyped) -> untyped
+
+    def each_notification: () ?{ (?) -> untyped } -> untyped
+
+    # Builds a generated asynchronous-operation facade with a narrowly scoped
+    # callback, so the facade does not need access to Family's private API.
+    # --
+    # @rbs operations_class: Class
+    # @rbs stream_capacity: Integer?
+    # @rbs return: untyped
+    private def build_async_facade: (Class operations_class, ?stream_capacity: Integer?) -> untyped
+
+    private def exchange_message_async: (untyped kind, untyped request_class, untyped reply_class, untyped args, ?stream_capacity: untyped) -> untyped
+
+    private def notification_classes: () -> untyped
+
+    private def multicast_groups: () -> untyped
+
+    private def multicast_group_ids: (untyped names) -> untyped
+  end
+end

data/sig/generated/nl/genl/client.rbs

@@ -0,0 +1,74 @@
+# Generated from lib/nl/genl/client.rb with RBS::Inline
+
+module Nl
+  module Genl
+    # Dynamically resolved information for a generic Netlink family.
+    #
+    # @!attribute [r] id
+    #   @return [Integer] the assigned family ID
+    # @!attribute [r] multicast_groups
+    #   @return [Hash<String, Integer>] multicast group names mapped to their IDs
+    class FamilyInfo < Data
+      attr_reader id(): Integer
+
+      attr_reader multicast_groups(): Hash[String, Integer]
+
+      def self.new: (Integer id, Hash[String, Integer] multicast_groups) -> instance
+                  | (id: Integer, multicast_groups: Hash[String, Integer]) -> instance
+
+      def self.members: () -> [ :id, :multicast_groups ]
+
+      def members: () -> [ :id, :multicast_groups ]
+    end
+
+    # Owns one generic Netlink connection shared by compatible families.
+    class Client
+      # Opens a generic Netlink client.
+      #
+      # @overload open(resolver:, executor: nil, notification_capacity: Nl::Connection::DEFAULT_NOTIFICATION_CAPACITY)
+      #   The caller is responsible for closing the client.
+      #   @param [#call] resolver a callable that resolves a family name to {FamilyInfo}
+      #   @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      #   @param [Integer] notification_capacity the maximum number of queued notifications
+      #   @return [Client] the opened client
+      # @overload open(resolver:, executor: nil, notification_capacity: Nl::Connection::DEFAULT_NOTIFICATION_CAPACITY, &block)
+      #   The client is automatically closed after the block returns.
+      #   @param [#call] resolver a callable that resolves a family name to {FamilyInfo}
+      #   @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      #   @param [Integer] notification_capacity the maximum number of queued notifications
+      #   @yieldparam [Client] client the opened client
+      #   @return [Object] the value returned from the block
+      # @rbs (resolver: ^(instance, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) -> instance
+      #    | [R] (resolver: ^(instance, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) { (instance) -> R } -> R
+      def self.open: (resolver: ^(instance, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) -> instance
+                   | [R] (resolver: ^(instance, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) { (instance) -> R } -> R
+
+      # @param [#call] resolver a callable that resolves a family name to {FamilyInfo}
+      # @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      # @param [Integer] notification_capacity the maximum number of queued notifications
+      # @rbs (resolver: ^(instance, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) -> void
+      def initialize: (resolver: ^(instance, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) -> void
+
+      # Builds a family backed by this client's connection.
+      #
+      # @param [Class<Family>] family_class a generic Netlink family class
+      # @return [Family] an instance of `family_class`
+      # @raise [TypeError] if +family_class+ does not inherit from {Family}
+      # @rbs [F < Family] (_FamilyClass[F] family_class) -> F
+      def family: [F < Family] (_FamilyClass[F] family_class) -> F
+
+      # Closes the underlying Netlink connection.
+      #
+      # @return [void]
+      # @rbs () -> void
+      def close: () -> void
+
+      # Resolves and caches information for a family by name.
+      #
+      # @param [String] name the generic Netlink family name
+      # @return [FamilyInfo] the resolved family information
+      # @rbs (String name) -> FamilyInfo
+      private def family_info: (String name) -> FamilyInfo
+    end
+  end
+end

data/sig/generated/nl/genl/protocol.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/nl/genl/protocol.rb with RBS::Inline
+
+module Nl
+  module Genl
+    # A generated Generic Netlink family bound to nlctrl-provided information.
+    class Endpoint < Raw::Endpoint
+      attr_reader info: untyped
+
+      def initialize: (untyped definition, untyped info) -> untyped
+
+      def family_id: () -> untyped
+
+      def version: () -> untyped
+
+      def frame_type: (untyped _message_class) -> untyped
+
+      def multicast_group_id: (untyped name, untyped _value) -> untyped
+    end
+
+    # Socket-wide Generic Netlink wire behavior.
+    class Protocol < Raw::Protocol
+      def initialize: () -> untyped
+
+      def encode_message: (untyped encoder, untyped endpoint, untyped request, seq: untyped, pid: untyped) -> untyped
+
+      def notification_channel_key: (untyped endpoint) -> untyped
+
+      def notification_route_keys: (untyped endpoint, untyped _classes) -> untyped
+
+      def notification_frame_key: (untyped header) -> untyped
+
+      def notification_frame?: (untyped endpoint, untyped header, untyped _payload) -> untyped
+
+      def notification_class: (untyped endpoint, untyped header, untyped payload, untyped classes) -> untyped
+    end
+  end
+end

data/sig/generated/nl/genl/wire.rbs

@@ -0,0 +1,113 @@
+# Generated from lib/nl/genl/wire.rb with RBS::Inline
+
+module Nl
+  module Genl
+    # Constants from <linux/genetlink.h>
+    module Constants
+      GENL_NAMSIZ: ::Integer
+
+      GENL_MIN_ID: untyped
+
+      GENL_MAX_ID: ::Integer
+
+      GENL_HDRLEN: ::Integer
+
+      GENL_ID_GENERATE: ::Integer
+
+      GENL_ID_CTRL: untyped
+
+      GENL_ID_VFS_DQUOT: untyped
+
+      GENL_ID_PMCRAID: untyped
+
+      CTRL_CMD_UNSPEC: ::Integer
+
+      CTRL_CMD_NEWFAMILY: ::Integer
+
+      CTRL_CMD_DELFAMILY: ::Integer
+
+      CTRL_CMD_GETFAMILY: ::Integer
+
+      CTRL_CMD_NEWOPS: ::Integer
+
+      CTRL_CMD_DELOPS: ::Integer
+
+      CTRL_CMD_GETOPS: ::Integer
+
+      CTRL_CMD_NEWMCAST_GRP: ::Integer
+
+      CTRL_CMD_DELMCAST_GRP: ::Integer
+
+      CTRL_CMD_GETMCAST_GRP: ::Integer
+
+      CTRL_ATTR_UNSPEC: ::Integer
+
+      CTRL_ATTR_FAMILY_ID: ::Integer
+
+      CTRL_ATTR_FAMILY_NAME: ::Integer
+
+      CTRL_ATTR_VERSION: ::Integer
+
+      CTRL_ATTR_HDRSIZE: ::Integer
+
+      CTRL_ATTR_MAXATTR: ::Integer
+
+      CTRL_ATTR_OPS: ::Integer
+
+      CTRL_ATTR_MCAST_GROUPS: ::Integer
+
+      CTRL_ATTR_OP_UNSPEC: ::Integer
+
+      CTRL_ATTR_OP_ID: ::Integer
+
+      CTRL_ATTR_OP_FLAGS: ::Integer
+
+      CTRL_ATTR_MCAST_GRP_UNSPEC: ::Integer
+
+      CTRL_ATTR_MCAST_GRP_NAME: ::Integer
+
+      CTRL_ATTR_MCAST_GRP_ID: ::Integer
+    end
+
+    include Constants
+
+    # Header prepended to a Generic Netlink payload after the Netlink header.
+    #
+    # This corresponds to Linux's +struct genlmsghdr+.
+    #
+    # @!attribute [rw] cmd
+    #   @return [Integer] family-specific command identifier
+    # @!attribute [rw] version
+    #   @return [Integer] family-specific protocol version
+    # @!attribute [rw] reserved
+    #   @return [Integer] reserved field, which must be zero
+    class GenlMsgHdr < Struct[Integer]
+      attr_accessor cmd(): Integer
+
+      attr_accessor version(): Integer
+
+      attr_accessor reserved(): Integer
+
+      def self.new: (?Integer cmd, ?Integer version, ?Integer reserved) -> instance
+                  | (?cmd: Integer, ?version: Integer, ?reserved: Integer) -> instance
+    end
+
+    class GenlMsgHdr
+      FORMAT: untyped
+
+      # Decodes a header from the decoder's current position.
+      #
+      # @param [Decoder] decoder the source decoder
+      # @return [GenlMsgHdr] the decoded header
+      # @rbs (Decoder decoder) -> instance
+      def self.decode: (Decoder decoder) -> instance
+
+      # Encodes this header at the encoder's current position.
+      #
+      # @param [Encoder] encoder the destination encoder
+      # @return [void]
+      # @rbs (Encoder encoder) -> void
+      def encode: (Encoder encoder) -> void
+    end
+  end
+end