protocol-zmtp 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5372fe6734b5faeded3069e3b510a7ff648458508c82e3a6c2b9d353ebd57179
-  data.tar.gz: b6e5cb324afac1deece4df0a0c8cc3aadbfa2ca3a31d29b38ece87dcea777c82
+  metadata.gz: edfecc19ca6c0befbc5835da0fbfc1fc364007207f10e6f1de64c733d48f2336
+  data.tar.gz: d6616b661ee77e73191ed6f33e0a3c5b73b04e6b3fe8e8e5cac30067ae75bb42
 SHA512:
-  metadata.gz: 21ec084b6bf898ed867c9c80700a3d9fad53146798d906a1cadeaed25f28745fa56d47f350e35e6af55e9ba5f7c8c7919342d2bba8e21d6068f585fb54105cc8
-  data.tar.gz: 90812f6950f8f558a9f33a7f57c2142c63b7c21bab6d4a5d2e788bdb5c9b26154a41b50dde097852e7bfab46e901d706c34d81b6acca0bfa5fd920bfcc655fe7
+  metadata.gz: 4520a2435a1490fcfb7aebd070f58d10e97a05da685a3c36a47417db2e82b8d7ef48d0c5d19ee6c7db99c7b5da552cd4fec2f061aee3fd9e55908d7d30cf301d
+  data.tar.gz: d8c6f26fe3197a25f32e5c5a6668d53eb8cecf109dbe084b00c63b2fcb396cbe05dfd37c9b01ecbc39a960f35ce56ca70fa02c49761e9e0065246ffffeb36437

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

@@ -130,9 +130,9 @@ module Protocol
         # @param ttl [Numeric] time-to-live in seconds (sent as deciseconds)
         # @param context [String] optional context bytes (up to 16 bytes)
         # @return [Command]
-        def self.ping(ttl: 0, context: "".b)
+        def self.ping(ttl: 0, context: EMPTY_BINARY)
           ttl_ds = (ttl * 10).to_i
-          new("PING", [ttl_ds].pack("n") + context.b)
+          new("PING", [ttl_ds].pack("n") + (context.encoding == Encoding::BINARY ? context : context.b))
         end
 
 
@@ -140,8 +140,8 @@ module Protocol
         #
         # @param context [String] context bytes echoed from the PING
         # @return [Command]
-        def self.pong(context: "".b)
-          new("PONG", context.b)
+        def self.pong(context: EMPTY_BINARY)
+          new("PONG", context.encoding == Encoding::BINARY ? context : context.b)
         end
 
 
@@ -150,7 +150,7 @@ module Protocol
         # @return [Array(Numeric, String)] [ttl_seconds, context_bytes]
         def ping_ttl_and_context
           ttl_ds  = @data.unpack1("n")
-          context = @data.bytesize > 2 ? @data.byteslice(2..) : "".b
+          context = @data.bytesize > 2 ? @data.byteslice(2..) : EMPTY_BINARY
           [ttl_ds / 10.0, context]
         end
 

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

@@ -28,42 +28,6 @@ module Protocol
         FLAG_BYTES = Array.new(256) { |i| i.chr.b.freeze }.freeze
 
 
-        # @return [String] frame body (binary)
-        attr_reader :body
-
-        # @param body [String] frame body
-        # @param more [Boolean] more frames follow
-        # @param command [Boolean] this is a command frame
-        def initialize(body, more: false, command: false)
-          @body    = body.b
-          @more    = more
-          @command = command
-        end
-
-
-        # @return [Boolean] true if more frames follow in this message
-        def more?    = @more
-
-        # @return [Boolean] true if this is a command frame
-        def command? = @command
-
-        # Encodes to wire bytes.
-        #
-        # @return [String] binary wire representation (flags + size + body)
-        def to_wire
-          size  = @body.bytesize
-          flags = 0
-          flags |= FLAGS_MORE if @more
-          flags |= FLAGS_COMMAND if @command
-
-          if size > SHORT_MAX
-            FLAG_BYTES[flags | FLAGS_LONG] + [size].pack("Q>") + @body
-          else
-            FLAG_BYTES[flags] + FLAG_BYTES[size] + @body
-          end
-        end
-
-
         # Encodes a multi-part message into a single wire-format string.
         # The result can be written to multiple connections without
         # re-encoding each time (useful for fan-out patterns like PUB).
@@ -72,71 +36,152 @@ module Protocol
         # @return [String] frozen binary wire representation
         #
         def self.encode_message(parts)
-          buf  = String.new(encoding: Encoding::BINARY)
+          if parts.size == 1
+            s    = parts.first.bytesize
+            wire = s > SHORT_MAX ? 9 + s : 2 + s
+          else
+            wire = 0
+            j    = 0
+
+            while j < parts.size
+              s     = parts[j].bytesize
+              wire += s > SHORT_MAX ? 9 + s : 2 + s
+              j    += 1
+            end
+          end
+
+          buf  = String.new(capacity: wire, encoding: Encoding::BINARY)
           last = parts.size - 1
           i    = 0
+
           while i < parts.size
             body  = parts[i]
             body  = body.b unless body.encoding == Encoding::BINARY
             size  = body.bytesize
             flags = i < last ? FLAGS_MORE : 0
+
             if size > SHORT_MAX
-              buf << FLAG_BYTES[flags | FLAGS_LONG] << [size].pack("Q>") << body
+              buf << FLAG_BYTES[flags | FLAGS_LONG]
+              buf << [size].pack("Q>")
+              buf << body
             else
-              buf << FLAG_BYTES[flags] << FLAG_BYTES[size] << body
+              buf << FLAG_BYTES[flags]
+              buf << FLAG_BYTES[size]
+              buf << body
             end
+
             i += 1
           end
+
           buf.freeze
         end
 
 
         # Reads one frame from an IO-like object.
         #
-        # @param io [#read_exactly] must support read_exactly(n)
+        # Uses #peek to buffer just enough header bytes (2 for short frames,
+        # 9 for long), then drains header + body in a single #read_exactly.
+        # This is 2 calls for both short and long frames, vs the naive 3 for
+        # long. A speculative read_exactly(9) would be unsafe: a <7-byte
+        # short frame at idle would hang waiting for bytes that never arrive,
+        # or consume bytes from the next frame on a mixed stream.
+        #
+        # @param io [#peek, #read_exactly]
         # @return [Frame]
         # @raise [Error] on invalid frame
         # @raise [EOFError] if the connection is closed
         def self.read_from(io, max_message_size: nil)
-          # Every valid frame has at least 2 header bytes (flags + 1 size
-          # byte for short frames, or flags + first size byte for long).
-          # Fetching both up-front gives short frames a 2-call read path
-          # (header + body) instead of 3.
-          head  = io.read_exactly(2)
-          flags = head.getbyte(0)
+          buf = io.peek do |b|
+            next false if b.bytesize < 2
+            (b.getbyte(0) & FLAGS_LONG) == 0 || b.bytesize >= 9
+          end
+
+          raise EOFError, "Stream finished before reading frame header" if buf.bytesize < 2
 
+          flags   = buf.getbyte(0)
           more    = (flags & FLAGS_MORE) != 0
           long    = (flags & FLAGS_LONG) != 0
           command = (flags & FLAGS_COMMAND) != 0
-          size    = long ? read_long_size(io, head.getbyte(1)) : head.getbyte(1)
+
+          if long
+            raise EOFError, "Stream finished before reading long frame size" if buf.bytesize < 9
+
+            size = (buf.getbyte(1) << 56) |
+                   (buf.getbyte(2) << 48) |
+                   (buf.getbyte(3) << 40) |
+                   (buf.getbyte(4) << 32) |
+                   (buf.getbyte(5) << 24) |
+                   (buf.getbyte(6) << 16) |
+                   (buf.getbyte(7) << 8)  |
+                    buf.getbyte(8)
+            header_size = 9
+          else
+            size        = buf.getbyte(1)
+            header_size = 2
+          end
 
           if max_message_size && size > max_message_size
             raise Error, "frame size #{size} exceeds max_message_size #{max_message_size}"
           end
 
-          body = size > 0 ? io.read_exactly(size) : EMPTY_BINARY
+          if size.zero?
+            io.read_exactly(header_size)
+            return new(EMPTY_BINARY, more: more, command: command)
+          end
 
-          new(body, more: more, command: command)
+          wire = io.read_exactly(header_size + size)
+          new(wire.byteslice(header_size, size), more: more, command: command)
         end
 
 
-        # Reads the remaining 7 bytes of a long frame's 8-byte big-endian
-        # size field and combines them with +msb+ (already consumed as the
-        # second byte of the 2-byte speculative header read).
-        #
-        # @param io [#read_exactly]
-        # @param msb [Integer] first (most-significant) byte of the size
-        # @return [Integer] full 64-bit frame size
+        # @return [String] frame body (binary)
+        attr_reader :body
+
+
+        # @param body [String] frame body
+        # @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
+          @more    = more
+          @command = command
+        end
+
+
+        # @return [Boolean] true if more frames follow in this message
+        def more?
+          @more
+        end
+
+
+        # @return [Boolean] true if this is a command frame
+        def command?
+          @command
+        end
+
+
+        # Encodes to wire bytes.
         #
-        def self.read_long_size(io, msb)
-          rest = io.read_exactly(7)
-
-          (msb << 56) |
-            (rest.getbyte(0) << 48) | (rest.getbyte(1) << 40) |
-            (rest.getbyte(2) << 32) | (rest.getbyte(3) << 24) |
-            (rest.getbyte(4) << 16) | (rest.getbyte(5) << 8)  |
-             rest.getbyte(6)
+        # @return [String] binary wire representation (flags + size + body)
+        def to_wire
+          size   = @body.bytesize
+          flags  = 0
+          flags |= FLAGS_MORE if @more
+          flags |= FLAGS_COMMAND if @command
+
+          if size > SHORT_MAX
+            buf = String.new(capacity: 9 + size, encoding: Encoding::BINARY)
+            buf << FLAG_BYTES[flags | FLAGS_LONG]
+            buf << [size].pack("Q>")
+            buf << @body
+          else
+            buf = String.new(capacity: 2 + size, encoding: Encoding::BINARY)
+            buf << FLAG_BYTES[flags]
+            buf << FLAG_BYTES[size]
+            buf << @body
+          end
         end
+
       end
     end
   end

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

@@ -34,7 +34,7 @@ module Protocol
         # @return [String] binary frame body
         def body(prefix, cancel: false)
           flag = cancel ? FLAG_CANCEL : FLAG_SUBSCRIBE
-          (flag + prefix.b).b
+          flag + (prefix.encoding == Encoding::BINARY ? prefix : prefix.b)
         end
 
 

data/lib/protocol/zmtp/connection.rb

@@ -15,33 +15,42 @@ module Protocol
       # @return [String] peer's socket type (from READY handshake)
       attr_reader :peer_socket_type
 
+
       # @return [String] peer's identity (from READY handshake)
       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 [Hash{String => String}, nil] full peer READY property hash
       #   (set after a successful handshake; nil before)
       attr_reader :peer_properties
 
+
       # @return [Integer, nil] peer ZMTP major version (from greeting)
       attr_reader :peer_major
 
+
       # @return [Integer, nil] peer ZMTP minor version (from greeting);
       #   0 for ZMTP 3.0 peers, 1 for ZMTP 3.1+
       attr_reader :peer_minor
 
-      # @return [Object] transport IO (#read_exactly, #write, #flush, #close)
+
+      # @return [Object] transport IO (#peek, #read_exactly, #write, #flush, #close)
       attr_reader :io
 
+
       # @return [Float, nil] monotonic timestamp of last received frame
       attr_reader :last_received_at
 
-      # @param io [#read_exactly, #write, #flush, #close] transport IO
+
+      # @param io [#peek, #read_exactly, #write, #flush, #close] transport IO
       # @param socket_type [String] our socket type name (e.g. "REQ")
       # @param identity [String] our identity
       # @param as_server [Boolean] whether we are the server side
@@ -79,14 +88,12 @@ module Protocol
       # @return [void]
       # @raise [Error] on handshake failure
       def handshake!
-        result = @mechanism.handshake!(
-          @io,
+        result = @mechanism.handshake! @io,
           as_server:   @as_server,
           socket_type: @socket_type,
           identity:    @identity,
           qos:         @qos,
-          qos_hash:    @qos_hash,
-        )
+          qos_hash:    @qos_hash
 
         @peer_socket_type = result[:peer_socket_type]
         @peer_identity    = result[:peer_identity]
@@ -198,15 +205,19 @@ module Protocol
       # @raise [EOFError] if connection is closed
       def receive_message
         frames = []
+
         loop do
           frame = read_frame
+
           if frame.command?
             yield frame if block_given?
             next
           end
+
           frames << frame.body.freeze
           break unless frame.more?
         end
+
         frames.freeze
       end
 
@@ -244,6 +255,7 @@ module Protocol
             close
             raise
           end
+
           touch_heartbeat
 
           frame = @mechanism.decrypt(frame) if @mechanism.encrypted?
@@ -259,6 +271,7 @@ module Protocol
               next
             end
           end
+
           return frame
         end
       end
@@ -326,9 +339,11 @@ module Protocol
         last      = parts.size - 1
 
         i = 0
+
         while i < parts.size
           part = parts[i]
           more = i < last
+
           if encrypted
             body = part.encoding == Encoding::BINARY ? part : part.b
             @io.write(@mechanism.encrypt(body, more: more))
@@ -336,18 +351,23 @@ module Protocol
             body  = part.encoding == Encoding::BINARY ? part : part.b
             size  = body.bytesize
             flags = more ? Codec::Frame::FLAGS_MORE : 0
+
             buf.clear
+
             if size > Codec::Frame::SHORT_MAX
               [flags | Codec::Frame::FLAGS_LONG, size].pack("CQ>", buffer: buf)
             else
               [flags, size].pack("CC", buffer: buf)
             end
+
             @io.write(buf)
             @io.write(body)
           end
+
           i += 1
         end
       end
+
     end
   end
 end

data/lib/protocol/zmtp/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protocol-zmtp
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Patrik Wenger