nl 0.3.0 → 0.4.2

data/lib/nl/sub_message.rb

@@ -0,0 +1,94 @@
+require_relative 'structured_payload'
+
+module Nl
+  module Selector
+    class MissingSelectorValueError < StandardError
+      attr_reader :scope, :index
+
+      def initialize(scope, index)
+        @scope = scope
+        @index = index
+        super()
+      end
+    end
+
+    class UnknownSelectorValueError < StandardError
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+        super()
+      end
+    end
+
+    module Reference
+      def select(context, formats)
+        value = read(context)
+        formats.fetch(value) do
+          return yield(value) if block_given?
+          raise UnknownSelectorValueError.new(value)
+        end
+      end
+    end
+
+    Local = Data.define(:index) do
+      include Reference
+
+      def read(context)
+        context.fetch_local(index)
+      end
+    end
+
+    External = Data.define(:index) do
+      include Reference
+
+      def read(context)
+        context.fetch_external(index)
+      end
+    end
+
+    class State
+      def initialize(local_count, external)
+        @local = Array.new(local_count)
+        @external = external
+      end
+
+      def set_local(index, value)
+        @local[index] = value
+      end
+
+      def fetch_local(index)
+        fetch(@local, index) { raise MissingSelectorValueError.new(:local, index) }
+      end
+
+      def fetch_external(index)
+        fetch(@external, index) { raise MissingSelectorValueError.new(:external, index) }
+      end
+
+      def fetch(values, key)
+        value = values[key]
+        value.nil? ? yield : value
+      end
+    end
+  end
+
+  # A selector-specific payload containing an optional fixed header followed by
+  # an optional set of Netlink attributes.
+  class SubMessage
+    include StructuredPayload
+  end
+
+  # An unrecognized selector-specific payload retained without interpretation.
+  class RawSubMessage < SubMessage
+    attr_reader :payload, :nlattr_type_flags
+
+    def initialize(payload, nlattr_type_flags:)
+      @payload = payload
+      @nlattr_type_flags = nlattr_type_flags
+    end
+
+    def encode(encoder, external_selectors: [])
+      encoder.put_string(payload)
+    end
+  end
+end

data/lib/nl/version.rb

@@ -1,3 +1,3 @@
 module Nl
-  VERSION = '0.3.0'
+  VERSION = '0.4.2'
 end

data/lib/nl.rb

@@ -1,13 +1,12 @@
 require_relative 'nl/error'
-require_relative 'nl/core'
+require_relative 'nl/bitfield32'
+require_relative 'nl/raw/wire'
+require_relative 'nl/structured_payload'
+require_relative 'nl/sub_message'
 require_relative 'nl/notification'
 require_relative 'nl/connection'
 require_relative 'nl/family'
+require_relative 'nl/raw'
 require_relative 'nl/genl'
 require_relative 'nl/socket'
 require_relative 'nl/version'
-
-module Nl
-  include Core
-  include Genl
-end

data/sig/generated/nl/async/dispatcher.rbs

@@ -0,0 +1,53 @@
+# Generated from lib/nl/async/dispatcher.rb with RBS::Inline
+
+module Nl
+  module Async
+    # Owns the single receive loop for a socket and routes replies by sequence.
+    class Dispatcher
+      class Pending < Data
+        attr_reader exchange(): untyped
+
+        attr_reader endpoint(): untyped
+
+        attr_reader reply_class(): untyped
+
+        attr_reader sink(): untyped
+
+        def self.new: (untyped exchange, untyped endpoint, untyped reply_class, untyped sink) -> instance
+                    | (exchange: untyped, endpoint: untyped, reply_class: untyped, sink: untyped) -> instance
+
+        def self.members: () -> [ :exchange, :endpoint, :reply_class, :sink ]
+
+        def members: () -> [ :exchange, :endpoint, :reply_class, :sink ]
+      end
+
+      def initialize: (untyped socket, protocol: untyped, notifications: untyped, ?executor: untyped) -> untyped
+
+      def exchange: (untyped endpoint, untyped kind, untyped request_class, untyped reply_class, untyped args) ?{ (?) -> untyped } -> untyped
+
+      def exchange_async: (untyped endpoint, untyped kind, untyped request_class, untyped reply_class, untyped args, ?stream_capacity: untyped) -> untyped
+
+      def async_capable?: () -> true
+
+      def receive_notification: (untyped endpoint, ?timeout: untyped) -> untyped
+
+      def close: () -> untyped
+
+      private def receive_loop: () -> untyped
+
+      private def fail_receive_loop: (untyped error) -> untyped
+
+      private def dispatch_datagram: (untyped buffer) -> untyped
+
+      private def dispatch_outcome: (untyped key, untyped pending, untyped outcome) -> untyped
+
+      private def complete_pending: (untyped key, untyped pending, untyped value) -> untyped
+
+      private def discard: (untyped key) -> untyped
+
+      private def fail_pending: (untyped key, untyped error) -> untyped
+
+      private def fail_all: (untyped error) -> untyped
+    end
+  end
+end

data/sig/generated/nl/async/driver.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/nl/async/driver.rb with RBS::Inline
+
+module Nl
+  module Async
+    module Drivers
+      class Thread
+        def start: () ?{ (?) -> untyped } -> untyped
+
+        def stop: (untyped task) -> untyped
+      end
+
+      class Fiber
+        def start: () ?{ (?) -> untyped } -> untyped
+
+        def stop: (untyped _task) -> untyped
+      end
+    end
+
+    def self.driver: (untyped name) -> untyped
+  end
+end

data/sig/generated/nl/async/mailbox.rbs

@@ -0,0 +1,32 @@
+# Generated from lib/nl/async/mailbox.rb with RBS::Inline
+
+module Nl
+  module Async
+    # A thread-safe, scheduler-aware, single-consumer mailbox.
+    class Mailbox
+      class FullError < StandardError
+      end
+
+      def initialize: (?capacity: untyped) -> untyped
+
+      # Adds a value without executing consumer code.
+      # @rbs (untyped) -> bool
+      def push: (untyped) -> bool
+
+      # Adds a completion/error event even when the value capacity is full.
+      def push_terminal: (untyped value) -> untyped
+
+      private def push_value: (untyped value, enforce_capacity: untyped) -> untyped
+
+      # Removes the next value, suspending through the current thread or Fiber scheduler if empty.
+      # @rbs (?timeout: Numeric?) -> untyped
+      def pop: (?timeout: Numeric?) -> untyped
+
+      def close: () -> untyped
+
+      def closed?: () -> untyped
+
+      def empty?: () -> untyped
+    end
+  end
+end

data/sig/generated/nl/async/operation.rbs

@@ -0,0 +1,123 @@
+# Generated from lib/nl/async/operation.rb with RBS::Inline
+
+module Nl
+  module Async
+    module Events
+      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 Done < Data
+        def self.new: () -> instance
+                    | () -> instance
+
+        def self.members: () -> [ ]
+
+        def members: () -> [ ]
+      end
+
+      class Error < Data
+        attr_reader exception(): untyped
+
+        def self.new: (untyped exception) -> instance
+                    | (exception: untyped) -> instance
+
+        def self.members: () -> [ :exception ]
+
+        def members: () -> [ :exception ]
+      end
+    end
+
+    class ConcurrentConsumptionError < StandardError
+    end
+
+    class StreamOverflowError < StandardError
+    end
+
+    # Future for the result of an already-started, single-reply operation.
+    # @rbs generic out Result
+    class Future[out Result]
+      def self.build: (?mailbox: untyped, ?on_close: untyped) -> untyped
+
+      def initialize: (mailbox: untyped, on_close: untyped) -> untyped
+
+      # @rbs (?timeout: Numeric?) -> Result
+      def await: (?timeout: Numeric?) -> Result
+
+      alias value await
+
+      def ready?: () -> bool
+
+      # Stops local delivery. The dispatcher still drains the Netlink exchange.
+      def close: () -> nil
+
+      private def settle_done: (untyped value) -> untyped
+
+      private def settle_failed: (untyped error) -> untyped
+
+      private def terminal_result: () -> untyped
+
+      class Sink
+        def initialize: (untyped mailbox) -> untyped
+
+        def succeed: (untyped value) -> untyped
+
+        def finish: () -> untyped
+
+        def fail: (untyped exception) -> untyped
+      end
+    end
+
+    # Single-pass consumer handle for a multipart Netlink operation.
+    # @rbs generic out Item
+    class Stream[out Item]
+      include Enumerable[Item]
+
+      def self.build: (?mailbox: untyped, ?on_close: untyped) -> untyped
+
+      def initialize: (mailbox: untyped, on_close: untyped) -> untyped
+
+      # @rbs () { (Item) -> void } -> self
+      #    | () -> Enumerator[Item, self]
+      def each: () { (Item) -> void } -> self
+              | () -> Enumerator[Item, self]
+
+      # @rbs (?timeout: Numeric?) -> Item
+      def next: (?timeout: Numeric?) -> Item
+
+      # Stops local delivery. The dispatcher still drains the Netlink exchange.
+      def close: () -> nil
+
+      def closed?: () -> bool
+
+      private def current_state: () -> untyped
+
+      private def open?: () -> untyped
+
+      private def claim_consumer!: () -> untyped
+
+      private def mark_completed: () -> untyped
+
+      private def mark_failed: (untyped error) -> untyped
+
+      private def terminal_result: (?next_item: untyped) -> untyped
+
+      class Sink
+        def initialize: (untyped mailbox) -> untyped
+
+        def push: (untyped value) -> untyped
+
+        def finish: () -> untyped
+
+        def fail: (untyped exception) -> untyped
+      end
+    end
+  end
+end

data/sig/generated/nl/async.rbs

@@ -0,0 +1,9 @@
+# Generated from lib/nl/async.rb with RBS::Inline
+
+module Nl
+  # Asynchronous request handling support.
+  module Async
+    class UnavailableError < StandardError
+    end
+  end
+end

data/sig/generated/nl/attribute_set.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/nl/attribute_set.rb with RBS::Inline
+
+module Nl
+  class AttributeSet
+    class Attribute < Struct[untyped]
+      attr_accessor value(): untyped
+
+      def self.new: (?untyped value) -> instance
+                  | (?value: untyped) -> instance
+    end
+
+    class Attribute
+      MULTI: bool
+
+      ORDER: untyped
+
+      SELECTOR_SLOT: untyped
+
+      def self.multi?: () -> untyped
+
+      def self.decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+
+      def encode: (untyped encoder, ?context: untyped) -> untyped
+    end
+
+    def initialize: (untyped attributes) -> untyped
+
+    def []: (untyped type) -> untyped
+
+    def <<: (untyped attr) -> untyped
+
+    SELECTOR_NAMES: untyped
+
+    private def encode1: (untyped encoder, untyped attr, untyped context) -> untyped
+
+    def encode: (untyped encoder, ?external_selectors: untyped) -> untyped
+
+    private def selector_name: (untyped error) -> untyped
+
+    private def self.decode1: (untyped decoder, untyped context) -> untyped
+
+    def self.decode: (untyped decoder, ?external_selectors: untyped) -> untyped
+
+    def self.build_attributes: (?untyped params, ?external_selectors: untyped, **untyped keywords) -> untyped
+
+    private def self.coerce: (untyped datatype, untyped value, untyped context) -> untyped
+
+    private def self.selector_name: (untyped error) -> untyped
+  end
+end

data/sig/generated/nl/bitfield32.rbs

@@ -0,0 +1,41 @@
+# Generated from lib/nl/bitfield32.rb with RBS::Inline
+
+module Nl
+  # A 32-bit value paired with a mask selecting the meaningful bits.
+  class Bitfield32
+    UINT32_RANGE: untyped
+
+    # A 32-bit flags
+    # @return [Integer]
+    attr_reader value: Integer
+
+    # A 32-bit mask selecting the meaningful bits
+    # @return [Integer]
+    attr_reader selector: Integer
+
+    # @param [Integer] value
+    # @param [Integer] selector
+    # @rbs (Integer value, Integer selector) -> void
+    def initialize: (Integer value, Integer selector) -> void
+
+    # Returns 1 or 0 for a selected bit, or nil for an unselected bit.
+    # @param [Integer] index Bits are indexed from the least significant bit, starting at zero.
+    # @return [0, 1, nil]
+    # @rbs (Integer index) -> (0 | 1 | nil)
+    def []: (Integer index) -> (0 | 1 | nil)
+
+    # Selects and sets or clears a bit. Assigning nil unselects it.
+    # @param [Integer] index Bits are indexed from the least significant bit, starting at zero.
+    # @param [0, 1, nil] state
+    # @rbs (Integer index, (0 | 1 | nil) state) -> (0 | 1 | nil)
+    def []=: (Integer index, 0 | 1 | nil state) -> (0 | 1 | nil)
+
+    # Converts a bit index to a bit mask
+    # @rbs (Integer index) -> Integer
+    private def bit_mask: (Integer index) -> Integer
+
+    # Validates if an Integer fits in uint32
+    # @rbs (Integer integer, Symbol name) -> void
+    private def validate_uint32: (Integer integer, Symbol name) -> void
+  end
+end

data/sig/generated/nl/blocking_transport.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/nl/blocking_transport.rb with RBS::Inline
+
+module Nl
+  # Drives one exchange at a time with blocking socket operations.
+  class BlockingTransport
+    class ConcurrentOperationError < StandardError
+    end
+
+    class UnexpectedSequenceError < StandardError
+      attr_reader expected: untyped
+
+      attr_reader actual: untyped
+
+      def initialize: (untyped expected, untyped actual) -> untyped
+    end
+
+    def initialize: (untyped socket, protocol: untyped, notifications: untyped) -> untyped
+
+    def exchange: (untyped endpoint, untyped kind, untyped request_class, untyped reply_class, untyped args) -> untyped
+
+    def async_capable?: () -> false
+
+    def receive_notification: (untyped endpoint, ?timeout: untyped) -> untyped
+
+    def close: () -> void
+
+    private def receive: (untyped endpoint, untyped expected_key, untyped reply_class) -> untyped
+
+    private def receive_notifications: () -> untyped
+
+    private def receive_datagram: () -> untyped
+  end
+end

data/sig/generated/nl/connection.rbs

@@ -0,0 +1,26 @@
+# Generated from lib/nl/connection.rb with RBS::Inline
+
+module Nl
+  # Owns one Netlink socket and the facilities shared by families using it.
+  class Connection
+    DEFAULT_NOTIFICATION_CAPACITY: ::Integer
+
+    def initialize: (protocol: untyped, ?executor: untyped, ?notification_capacity: untyped) -> untyped
+
+    def exchange: () -> untyped
+
+    def exchange_async: () -> untyped
+
+    def async_capable?: () -> untyped
+
+    def register_notifications: (untyped endpoint, untyped classes) -> untyped
+
+    def add_memberships: (untyped group_ids) -> untyped
+
+    def drop_memberships: (untyped group_ids) -> untyped
+
+    def receive_notification: (untyped endpoint, ?timeout: untyped) -> untyped
+
+    def close: () -> untyped
+  end
+end

data/sig/generated/nl/datagram.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/nl/datagram.rb with RBS::Inline
+
+module Nl
+  # Splits Netlink datagrams into aligned header/payload frames.
+  module Datagram
+    # @rbs (IO::Buffer buffer) { (Raw::NlMsgHdr, IO::Buffer) -> void } -> nil
+    #    | (IO::Buffer buffer) -> Enumerator[[Raw::NlMsgHdr, IO::Buffer], nil]
+    def self.each_frame: (IO::Buffer buffer) { (Raw::NlMsgHdr, IO::Buffer) -> void } -> nil
+                       | (IO::Buffer buffer) -> Enumerator[[ Raw::NlMsgHdr, IO::Buffer ], nil]
+  end
+end