protocol-zmtp 0.9.0 → 0.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: edfecc19ca6c0befbc5835da0fbfc1fc364007207f10e6f1de64c733d48f2336
-  data.tar.gz: d6616b661ee77e73191ed6f33e0a3c5b73b04e6b3fe8e8e5cac30067ae75bb42
+  metadata.gz: a99947180a584a86331021fac44327f3bde68cc44c50fe6264fdb7e6018cf3af
+  data.tar.gz: 00c1b152a3763603452a42b0af92455ab02cb864d55b4cd331d0dba26396f65b
 SHA512:
-  metadata.gz: 4520a2435a1490fcfb7aebd070f58d10e97a05da685a3c36a47417db2e82b8d7ef48d0c5d19ee6c7db99c7b5da552cd4fec2f061aee3fd9e55908d7d30cf301d
-  data.tar.gz: d8c6f26fe3197a25f32e5c5a6668d53eb8cecf109dbe084b00c63b2fcb396cbe05dfd37c9b01ecbc39a960f35ce56ca70fa02c49761e9e0065246ffffeb36437
+  metadata.gz: 6e6997a555bc1ed27bd68f51935cfc0b68bf4b7b3f5055a47b2de44f63561116b309be5d933df1ffc9e8a62d72deac7a3ed918b9b323fcb41584934a8b76a684
+  data.tar.gz: 5a495e661e2e4c829a6e33d5cb3d98a0976c4606efb676f17201a7184a82753405816d7f66057154b95a2af78c3385d960e1d0a319674945454eb2218f8c81fd

data/lib/protocol/zmtp/codec/command.rb

@@ -70,20 +70,14 @@ module Protocol
         end
 
 
-        # Builds a READY command with Socket-Type, Identity, optional X-QoS,
-        # and any extra properties supplied by upper layers (e.g. an
-        # extension that injects an `X-Compression` property).
+        # Builds a READY command with Socket-Type, Identity, and any
+        # extra properties supplied by upper layers (e.g. an extension
+        # that injects +X-QoS+ or +X-Compression+).
         #
-        # @param qos [Integer] QoS level (0 = omitted)
-        # @param qos_hash [String] supported hash algorithms in preference order (e.g. "xXsS")
-        # @param metadata [Hash{String => String}] additional READY properties
+        # @param metadata [Hash{String => String}, nil] additional READY properties
         # @return [Command]
-        def self.ready(socket_type:, identity: "", qos: 0, qos_hash: "", metadata: nil)
+        def self.ready(socket_type:, identity: "", metadata: nil)
           props = { "Socket-Type" => socket_type, "Identity" => identity }
-          if qos > 0
-            props["X-QoS"]      = qos.to_s
-            props["X-QoS-Hash"] = qos_hash unless qos_hash.empty?
-          end
           props.merge!(metadata) if metadata && !metadata.empty?
           new("READY", encode_properties(props))
         end

data/lib/protocol/zmtp/codec/frame.rb

@@ -56,7 +56,6 @@ module Protocol
 
           while i < parts.size
             body  = parts[i]
-            body  = body.b unless body.encoding == Encoding::BINARY
             size  = body.bytesize
             flags = i < last ? FLAGS_MORE : 0
 
@@ -142,7 +141,7 @@ module Protocol
         # @param more [Boolean] more frames follow
         # @param command [Boolean] this is a command frame
         def initialize(body, more: false, command: false)
-          @body    = body.encoding == Encoding::BINARY ? body : body.b
+          @body    = body
           @more    = more
           @command = command
         end

data/lib/protocol/zmtp/connection.rb

@@ -20,16 +20,14 @@ module Protocol
       attr_reader :peer_identity
 
 
-      # @return [Integer] peer's QoS level (from READY handshake, 0 if absent)
-      attr_reader :peer_qos
-
-
-      # @return [String] peer's supported hash algorithms in preference order
-      attr_reader :peer_qos_hash
+      # @return [Object, nil] peer's CURVE long-term public key post-handshake
+      #   (+crypto::PublicKey+ when the mechanism is CURVE; +nil+ for NULL).
+      attr_reader :peer_public_key
 
 
       # @return [Hash{String => String}, nil] full peer READY property hash
-      #   (set after a successful handshake; nil before)
+      #   (set after a successful handshake; nil before).
+      #   Upper layers extract their own X-* properties from here.
       attr_reader :peer_properties
 
 
@@ -56,8 +54,12 @@ module Protocol
       # @param as_server [Boolean] whether we are the server side
       # @param mechanism [Mechanism::Null, Mechanism::Curve] security mechanism
       # @param max_message_size [Integer, nil] max frame size in bytes, nil = unlimited
+      # @param opts [Hash{String => String}] extra READY properties to
+      #   advertise (e.g. +"X-QoS" => "1"+). Upper-layer extensions use
+      #   this to inject their own negotiated properties without the
+      #   codec needing to know about them.
       def initialize(io, socket_type:, identity: "", as_server: false,
-                     mechanism: nil, max_message_size: nil, qos: 0, qos_hash: "")
+                     mechanism: nil, max_message_size: nil, **opts)
         @io               = io
         @socket_type      = socket_type
         @identity         = identity
@@ -65,13 +67,11 @@ module Protocol
         @mechanism        = mechanism || Mechanism::Null.new
         @peer_socket_type = nil
         @peer_identity    = nil
-        @peer_qos         = nil
-        @peer_qos_hash    = nil
+        @peer_public_key  = nil
         @peer_properties  = nil
         @peer_major       = nil
         @peer_minor       = nil
-        @qos              = qos
-        @qos_hash         = qos_hash
+        @metadata         = opts.empty? ? nil : opts.transform_keys(&:to_s)
         @mutex            = Mutex.new
         @max_message_size = max_message_size
         @last_received_at = nil
@@ -80,6 +80,7 @@ module Protocol
         # writes in place so the per-message 2-or-9 byte String allocation
         # in write_frames disappears on the hot send path.
         @header_buf = String.new(capacity: 9, encoding: Encoding::BINARY)
+        @frame_buf  = String.new(capacity: 257, encoding: Encoding::BINARY)
       end
 
 
@@ -92,13 +93,11 @@ module Protocol
           as_server:   @as_server,
           socket_type: @socket_type,
           identity:    @identity,
-          qos:         @qos,
-          qos_hash:    @qos_hash
+          metadata:    @metadata
 
         @peer_socket_type = result[:peer_socket_type]
         @peer_identity    = result[:peer_identity]
-        @peer_qos         = result[:peer_qos] || 0
-        @peer_qos_hash    = result[:peer_qos_hash] || ""
+        @peer_public_key  = result[:peer_public_key]
         @peer_properties  = result[:peer_properties]
         @peer_major       = result[:peer_major]
         @peer_minor       = result[:peer_minor]
@@ -114,6 +113,17 @@ module Protocol
       end
 
 
+      # Returns a {PeerInfo} value bundling the peer's CURVE public key
+      # and identity for use as a stable per-peer key (frozen, hash-usable).
+      # Nil before the handshake has completed.
+      #
+      # @return [PeerInfo, nil]
+      def peer_info
+        return nil unless @peer_socket_type
+        PeerInfo.new(public_key: @peer_public_key, identity: @peer_identity)
+      end
+
+
       # Sends a multi-frame message (write + flush).
       #
       # @param parts [Array<String>] message frames
@@ -179,6 +189,25 @@ module Protocol
       end
 
 
+      # Writes multiple pre-encoded wire byte strings under a single
+      # mutex acquisition.
+      #
+      # @param wire_strings [Array<String>]
+      # @return [void]
+      def write_wire_batch(wire_strings)
+        with_deferred_cancel do
+          @mutex.synchronize do
+            i = 0
+            n = wire_strings.size
+            while i < n
+              @io.write(wire_strings[i])
+              i += 1
+            end
+          end
+        end
+      end
+
+
       # Returns true if the ZMTP mechanism encrypts at the frame level
       # (e.g. CURVE, BLAKE3ZMQ).
       #
@@ -214,11 +243,11 @@ module Protocol
             next
           end
 
-          frames << frame.body.freeze
+          frames << frame.body
           break unless frame.more?
         end
 
-        frames.freeze
+        frames
       end
 
 
@@ -307,11 +336,10 @@ module Protocol
       private
 
       # Defers task cancellation around a block of wire writes so the
-      # peer never sees a half-written frame. Without this, an
-      # +Async::Cancel+ arriving between the header write and the body
-      # write (the unencrypted path issues two separate +@io.write+
-      # calls per frame) would desync the peer's framer
-      # unrecoverably.
+      # peer never sees a half-written frame or partial multipart
+      # message. Without this, an +Async::Cancel+ arriving between
+      # successive frames (or between header and body writes for long
+      # frames) would desync the peer's framer unrecoverably.
       #
       # When called outside an Async task (test fixtures, blocking
       # callers), the block runs directly -- there is no task to defer
@@ -328,15 +356,16 @@ module Protocol
 
       # Writes message parts as ZMTP frames, encrypting if needed.
       #
-      # For the unencrypted path, writes the frame header and body
-      # separately to the IO instead of allocating a wire String. This
-      # avoids copying the body just to glue a 1- or 9-byte header onto
-      # it -- significant for large messages where the body copy was
-      # the dominant allocation per send.
+      # Short frames (body <= 255 B) combine the 2-byte header and
+      # body into a reusable buffer for a single +@io.write+, halving
+      # the per-frame mutex overhead in io-stream. Long frames write
+      # header and body separately to avoid copying the body.
       def write_frames(parts)
-        encrypted = @mechanism.encrypted?
-        buf       = @header_buf
-        last      = parts.size - 1
+        encrypted  = @mechanism.encrypted?
+        buf        = @header_buf
+        fbuf       = @frame_buf
+        flag_bytes = Codec::Frame::FLAG_BYTES
+        last       = parts.size - 1
 
         i = 0
 
@@ -352,16 +381,18 @@ module Protocol
             size  = body.bytesize
             flags = more ? Codec::Frame::FLAGS_MORE : 0
 
-            buf.clear
-
             if size > Codec::Frame::SHORT_MAX
+              buf.clear
               [flags | Codec::Frame::FLAGS_LONG, size].pack("CQ>", buffer: buf)
+              @io.write(buf)
+              @io.write(body)
             else
-              [flags, size].pack("CC", buffer: buf)
+              fbuf.clear
+              fbuf << flag_bytes[flags]
+              fbuf << flag_bytes[size]
+              fbuf << body
+              @io.write(fbuf)
             end
-
-            @io.write(buf)
-            @io.write(body)
           end
 
           i += 1

data/lib/protocol/zmtp/mechanism/curve.rb

@@ -23,10 +23,6 @@ module Protocol
       class Curve
         MECHANISM_NAME = "CURVE"
 
-        # Extra READY/INITIATE properties merged in by extensions
-        # (e.g. ZMTP-Zstd's X-Compression). nil = none.
-        attr_accessor :metadata
-
 
         # Nonce prefixes.
         NONCE_PREFIX_HELLO     = "CurveZMQHELLO---"
@@ -100,10 +96,9 @@ module Protocol
             end
           end
 
-          @session_box      = nil
-          @send_nonce       = 0
-          @recv_nonce       = -1
-          @metadata = nil
+          @session_box = nil
+          @send_nonce  = 0
+          @recv_nonce  = -1
         end
 
 
@@ -139,15 +134,14 @@ module Protocol
         # @param as_server [Boolean] ignored -- uses the value from #initialize
         # @param socket_type [String] our socket type name
         # @param identity [String] our identity
-        # @param qos [Integer] QoS level
-        # @param qos_hash [String] supported hash algorithms
-        # @return [Hash] { peer_socket_type:, peer_identity:, peer_qos:, peer_qos_hash: }
+        # @param metadata [Hash{String => String}, nil] extra READY properties
+        # @return [Hash] { peer_socket_type:, peer_identity:, peer_properties: }
         # @raise [Error] on handshake failure
-        def handshake!(io, as_server:, socket_type:, identity:, qos: 0, qos_hash: "")
+        def handshake!(io, as_server:, socket_type:, identity:, metadata: nil)
           if @as_server
-            server_handshake!(io, socket_type:, identity:, qos:, qos_hash:)
+            server_handshake!(io, socket_type:, identity:, metadata:)
           else
-            client_handshake!(io, socket_type:, identity:, qos:, qos_hash:)
+            client_handshake!(io, socket_type:, identity:, metadata:)
           end
         end
 
@@ -227,7 +221,7 @@ module Protocol
         # Client-side handshake
         # ----------------------------------------------------------------
 
-        def client_handshake!(io, socket_type:, identity:, qos: 0, qos_hash: "")
+        def client_handshake!(io, socket_type:, identity:, metadata: nil)
           cn_secret = @crypto::PrivateKey.generate
           cn_public = cn_secret.public_key
 
@@ -288,18 +282,14 @@ module Protocol
           vouch           = @crypto::Box.new(sn_public, @permanent_secret).encrypt(vouch_nonce, vouch_plaintext)
 
           props = { "Socket-Type" => socket_type, "Identity" => identity }
-          if qos > 0
-            props["X-QoS"]      = qos.to_s
-            props["X-QoS-Hash"] = qos_hash unless qos_hash.empty?
-          end
-          props.merge!(@metadata) if @metadata
-          metadata = Codec::Command.encode_properties(props)
+          props.merge!(metadata) if metadata && !metadata.empty?
+          metadata_bytes = Codec::Command.encode_properties(props)
 
           initiate_box_plaintext = "".b
           initiate_box_plaintext << @permanent_public.to_s
           initiate_box_plaintext << vouch_nonce.byteslice(8, 16)
           initiate_box_plaintext << vouch
-          initiate_box_plaintext << metadata
+          initiate_box_plaintext << metadata_bytes
 
           init_short_nonce = [1].pack("Q>")
           init_nonce       = NONCE_PREFIX_INITIATE + init_short_nonce
@@ -336,8 +326,6 @@ module Protocol
           props            = Codec::Command.decode_properties(r_plaintext)
           peer_socket_type = props["Socket-Type"]
           peer_identity    = props["Identity"] || ""
-          peer_qos         = (props["X-QoS"] || "0").to_i
-          peer_qos_hash    = props["X-QoS-Hash"] || ""
 
           @session_box = session
           @send_nonce  = 1
@@ -347,8 +335,7 @@ module Protocol
           {
             peer_socket_type: peer_socket_type,
             peer_identity:    peer_identity,
-            peer_qos:         peer_qos,
-            peer_qos_hash:    peer_qos_hash,
+            peer_public_key:  @server_public,
             peer_properties:  props,
             peer_major:       @peer_major,
             peer_minor:       @peer_minor,
@@ -360,7 +347,7 @@ module Protocol
         # Server-side handshake
         # ----------------------------------------------------------------
 
-        def server_handshake!(io, socket_type:, identity:, qos: 0, qos_hash: "")
+        def server_handshake!(io, socket_type:, identity:, metadata: nil)
           io.write(Codec::Greeting.encode(mechanism: MECHANISM_NAME, as_server: true))
           io.flush
           peer_greeting = Codec::Greeting.read_from(io)
@@ -478,7 +465,7 @@ module Protocol
           end
 
           if @authenticator
-            peer = PeerInfo.new(public_key: client_permanent)
+            peer = PeerInfo.new(public_key: client_permanent, identity: "")
             unless @authenticator.call(peer)
               send_error(io, "client key not authorized")
               raise Error, "client key not authorized"
@@ -488,11 +475,7 @@ module Protocol
 
           # --- READY ---
           ready_props = { "Socket-Type" => socket_type, "Identity" => identity }
-          if qos > 0
-            ready_props["X-QoS"]      = qos.to_s
-            ready_props["X-QoS-Hash"] = qos_hash unless qos_hash.empty?
-          end
-          ready_props.merge!(@metadata) if @metadata
+          ready_props.merge!(metadata) if metadata && !metadata.empty?
           ready_metadata = Codec::Command.encode_properties(ready_props)
 
           r_short_nonce = [1].pack("Q>")
@@ -517,8 +500,7 @@ module Protocol
           {
             peer_socket_type: props["Socket-Type"],
             peer_identity:    props["Identity"] || "",
-            peer_qos:         (props["X-QoS"] || "0").to_i,
-            peer_qos_hash:    props["X-QoS-Hash"] || "",
+            peer_public_key:  client_permanent,
             peer_properties:  props,
             peer_major:       @peer_major,
             peer_minor:       @peer_minor,

data/lib/protocol/zmtp/mechanism/null.rb

@@ -11,16 +11,6 @@ module Protocol
       class Null
         MECHANISM_NAME = "NULL"
 
-        # Extra READY properties an upper layer (e.g. an OMQ extension)
-        # wants this side to advertise. Mutated before #handshake!.
-        # @return [Hash{String => String}]
-        attr_accessor :metadata
-
-
-        def initialize
-          @metadata = nil
-        end
-
 
         # Performs the full NULL handshake over +io+.
         #
@@ -32,10 +22,11 @@ module Protocol
         # @param as_server [Boolean]
         # @param socket_type [String]
         # @param identity [String]
-        # @return [Hash] { peer_socket_type:, peer_identity:, peer_qos:, peer_qos_hash:, peer_properties:, peer_major:, peer_minor: }
+        # @param metadata [Hash{String => String}, nil] extra READY properties
+        # @return [Hash] { peer_socket_type:, peer_identity:, peer_public_key:, peer_properties:, peer_major:, peer_minor: }
         # @raise [Error]
-        def handshake!(io, as_server:, socket_type:, identity:, qos: 0, qos_hash: "")
-          io.write(Codec::Greeting.encode(mechanism: MECHANISM_NAME, as_server: as_server))
+        def handshake!(io, as_server:, socket_type:, identity:, metadata: nil)
+          io.write(Codec::Greeting.encode(mechanism: MECHANISM_NAME, as_server: false))
           io.flush
 
           peer_greeting = Codec::Greeting.read_from(io)
@@ -45,11 +36,9 @@ module Protocol
           end
 
           ready_cmd = Codec::Command.ready(
-            socket_type:      socket_type,
-            identity:         identity,
-            qos:              qos,
-            qos_hash:         qos_hash,
-            metadata: @metadata,
+            socket_type: socket_type,
+            identity:    identity,
+            metadata:    metadata,
           )
           io.write(ready_cmd.to_frame.to_wire)
           io.flush
@@ -67,8 +56,6 @@ module Protocol
           props            = peer_cmd.properties
           peer_socket_type = props["Socket-Type"]
           peer_identity    = props["Identity"] || ""
-          peer_qos         = (props["X-QoS"] || "0").to_i
-          peer_qos_hash    = props["X-QoS-Hash"] || ""
 
           unless peer_socket_type
             raise Error, "peer READY missing Socket-Type"
@@ -77,8 +64,7 @@ module Protocol
           {
             peer_socket_type: peer_socket_type,
             peer_identity:    peer_identity,
-            peer_qos:         peer_qos,
-            peer_qos_hash:    peer_qos_hash,
+            peer_public_key:  nil,
             peer_properties:  props,
             peer_major:       peer_greeting[:major],
             peer_minor:       peer_greeting[:minor],

data/lib/protocol/zmtp/mechanism/plain.rb

@@ -16,22 +16,15 @@ module Protocol
         MECHANISM_NAME = "PLAIN"
 
 
-        # Extra READY/INITIATE properties an upper layer wants this side to
-        # advertise. Mutated before #handshake!.
-        # @return [Hash{String => String}]
-        attr_accessor :metadata
-
-
         # @param username [String] client username (max 255 bytes)
         # @param password [String] client password (max 255 bytes)
         # @param authenticator [#call, nil] server-side credential verifier;
         #   called as +authenticator.call(username, password)+ and must return
         #   truthy to accept the connection.  When +nil+, all credentials pass.
         def initialize(username: "", password: "", authenticator: nil)
-          @username         = username
-          @password         = password
-          @authenticator    = authenticator
-          @metadata = nil
+          @username      = username
+          @password      = password
+          @authenticator = authenticator
         end
 
 
@@ -41,9 +34,10 @@ module Protocol
         # @param as_server [Boolean]
         # @param socket_type [String]
         # @param identity [String]
-        # @return [Hash] { peer_socket_type:, peer_identity: }
+        # @param metadata [Hash{String => String}, nil] extra READY properties
+        # @return [Hash] { peer_socket_type:, peer_identity:, peer_properties: }
         # @raise [Error]
-        def handshake!(io, as_server:, socket_type:, identity:, qos: 0, qos_hash: "")
+        def handshake!(io, as_server:, socket_type:, identity:, metadata: nil)
           io.write(Codec::Greeting.encode(mechanism: MECHANISM_NAME, as_server: as_server))
           io.flush
 
@@ -54,11 +48,9 @@ module Protocol
           end
 
           if as_server
-            server_handshake! io, socket_type: socket_type, identity: identity,
-              qos: qos, qos_hash: qos_hash
+            server_handshake! io, socket_type: socket_type, identity: identity, metadata: metadata
           else
-            client_handshake! io, socket_type: socket_type, identity: identity,
-              qos: qos, qos_hash: qos_hash
+            client_handshake! io, socket_type: socket_type, identity: identity, metadata: metadata
           end
         end
 
@@ -72,7 +64,7 @@ module Protocol
         private
 
 
-        def client_handshake!(io, socket_type:, identity:, qos: 0, qos_hash: "")
+        def client_handshake!(io, socket_type:, identity:, metadata: nil)
           send_command(io, hello_command)
 
           cmd = read_command(io)
@@ -80,15 +72,9 @@ module Protocol
 
           props = {
             "Socket-Type" => socket_type,
-            "Identity" => identity
+            "Identity" => identity,
           }
-
-          if qos > 0
-            props["X-QoS"]      = qos.to_s
-            props["X-QoS-Hash"] = qos_hash unless qos_hash.empty?
-          end
-
-          props.merge!(@metadata) if @metadata && !@metadata.empty?
+          props.merge!(metadata) if metadata && !metadata.empty?
           initiate = Codec::Command.new("INITIATE", Codec::Command.encode_properties(props))
           send_command(io, initiate)
 
@@ -99,7 +85,7 @@ module Protocol
         end
 
 
-        def server_handshake!(io, socket_type:, identity:, qos: 0, qos_hash: "")
+        def server_handshake!(io, socket_type:, identity:, metadata: nil)
           cmd = read_command(io)
           raise Error, "expected HELLO, got #{cmd.name}" unless cmd.name == "HELLO"
 
@@ -116,8 +102,7 @@ module Protocol
 
           peer_info = extract_peer_info(cmd)
 
-          ready = Codec::Command.ready socket_type: socket_type, identity: identity,
-            qos: qos, qos_hash: qos_hash, metadata: @metadata
+          ready = Codec::Command.ready socket_type: socket_type, identity: identity, metadata: metadata
           send_command io, ready
 
           peer_info
@@ -165,9 +150,7 @@ module Protocol
           {
             peer_socket_type: peer_socket_type,
             peer_identity:    props["Identity"] || "",
-            peer_qos:         (props["X-QoS"] || "0").to_i,
-            peer_qos_hash:    props["X-QoS-Hash"] || "",
-            peer_properties:  props
+            peer_properties:  props,
           }
         end
 

data/lib/protocol/zmtp/peer_info.rb

@@ -2,8 +2,19 @@
 
 module Protocol
   module ZMTP
-    # Context passed to an authenticator during authentication.
-    # +public_key+ is a +crypto::PublicKey+ instance.
-    PeerInfo = Data.define(:public_key)
+    # Post-handshake identity of the peer on a {Connection}.
+    #
+    # - +public_key+ is the peer's CURVE long-term +crypto::PublicKey+,
+    #   or +nil+ when the mechanism does not authenticate a key (e.g. NULL).
+    # - +identity+ is the peer's +ZMQ_IDENTITY+ string, or +""+ when no
+    #   identity was advertised in the READY metadata.
+    #
+    # Used as a peer key by upper layers (e.g. omq-qos levels 2/3): the
+    # whole value object is frozen and equality-comparable, so it can be
+    # stored directly in a Hash without picking one anchor over the other.
+    #
+    # Also passed to CURVE authenticators during the handshake (at that
+    # point +identity+ is +""+, since it arrives post-auth).
+    PeerInfo = Data.define(:public_key, :identity)
   end
 end

data/lib/protocol/zmtp/version.rb

@@ -2,6 +2,6 @@
 
 module Protocol
   module ZMTP
-    VERSION = "0.9.0"
+    VERSION = "0.10.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protocol-zmtp
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.2
 platform: ruby
 authors:
 - Patrik Wenger
@@ -53,7 +53,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: ZMTP 3.1 wire protocol codec and connection
 test_files: []