cztop 0.1.0

data/lib/cztop/polymorphic_zsock_methods.rb

@@ -0,0 +1,24 @@
+module CZTop
+
+  # These are methods that can be used on a {Socket} as well as an {Actor}.
+  # @see http://api.zeromq.org/czmq3-0:zsock
+  module PolymorphicZsockMethods
+    # Sends a signal.
+    # @param status [Integer] signal (0-255)
+    def signal(status = 0)
+      ::CZMQ::FFI::Zsock.signal(ffi_delegate, status)
+    end
+
+    # Waits for a signal.
+    # @return [Integer] the received signal
+    def wait
+      ::CZMQ::FFI::Zsock.wait(ffi_delegate)
+    end
+
+    # Set socket to use unbounded pipes (HWM=0); use this in cases when you are
+    # totally certain the message volume can fit in memory.
+    def set_unbounded
+      ::CZMQ::FFI::Zsock.set_unbounded(ffi_delegate)
+    end
+  end
+end

data/lib/cztop/proxy.rb

@@ -0,0 +1,149 @@
+module CZTop
+  # Steerable proxy which switches messages between a frontend and a backend
+  # socket.
+  #
+  # This is implemented using an {Actor}.
+  #
+  # @see http://api.zeromq.org/czmq3-0:zproxy
+  class Proxy
+    include ::CZMQ::FFI
+
+    # function pointer to the `zmonitor()` function
+    ZPROXY_FPTR = ::CZMQ::FFI.ffi_libraries.each do |dl|
+      fptr = dl.find_function("zproxy")
+      break fptr if fptr
+    end
+    raise LoadError, "couldn't find zproxy()" if ZPROXY_FPTR.nil?
+
+    def initialize
+      @actor = Actor.new(ZPROXY_FPTR)
+    end
+
+    # @return [Actor] the actor behind this proxy
+    attr_reader :actor
+
+    # Terminates the proxy.
+    # @return [void]
+    def terminate
+      @actor.terminate
+    end
+
+    # Enable verbose logging of commands and activity.
+    # @return [void]
+    def verbose!
+      @actor << "VERBOSE"
+      @actor.wait
+    end
+
+    # Returns a configurator object which you can use to configure the
+    # frontend socket.
+    # @return [Configurator] (memoized) frontend configurator
+    def frontend
+      @frontend ||= Configurator.new(self, :frontend)
+    end
+
+    # Returns a configurator object which you can use to configure the backend
+    # socket.
+    # @return [Configurator] (memoized) backend configurator
+    def backend
+      @backend ||= Configurator.new(self, :backend)
+    end
+
+    # Captures all proxied messages and delivers them to a PULL socket bound
+    # to the specified endpoint.
+    # @note The PULL socket has to be bound before calling this method.
+    # @param endpoint [String] the endpoint to which the PULL socket is bound to
+    # @return [void]
+    def capture(endpoint)
+      @actor << ["CAPTURE", endpoint]
+      @actor.wait
+    end
+
+    # Pauses proxying of any messages.
+    # @note This causes any messages to be queued up and potentialy hit the
+    #   high-water mark on the frontend or backend socket, causing messages to
+    #   be dropped or writing applications to block.
+    # @return [void]
+    def pause
+      @actor << "PAUSE"
+      @actor.wait
+    end
+
+    # Resume proxying of messages.
+    # @note This is only needed after a call to {#pause}, not to start the
+    #   proxy. Proxying starts as soon as the frontend and backend sockets are
+    #   properly attached.
+    # @return [void]
+    def resume
+      @actor << "RESUME"
+      @actor.wait
+    end
+
+    # Used to configure the socket on one side of a {Proxy}.
+    class Configurator
+      # @return [Array<Symbol>] supported socket types
+      SOCKET_TYPES = %i[
+        PAIR PUB SUB REQ REP
+        DEALER ROUTER PULL PUSH
+        XPUB XSUB
+      ]
+
+      # @param proxy [Proxy] the proxy instance
+      # @param side [Symbol] :frontend or :backend
+      def initialize(proxy, side)
+        @proxy = proxy
+        @side = case side
+                when :frontend then "FRONTEND"
+                when :backend then "BACKEND"
+                else raise ArgumentError, "invalid side: #{side.inspect}"
+                end
+      end
+
+      # @return [Proxy] the proxy this {Configurator} works on
+      attr_reader :proxy
+
+      # @return [String] the side, either "FRONTEND" or "BACKEND"
+      attr_reader :side
+
+      # Creates and binds a serverish socket.
+      # @param socket_type [Symbol] one of {SOCKET_TYPES}
+      # @param endpoint [String] endpoint to bind to
+      # @raise [ArgumentError] if the given socket type is invalid
+      # @return [void]
+      def bind(socket_type, endpoint)
+        unless SOCKET_TYPES.include?(socket_type)
+          raise ArgumentError, "invalid socket type: #{socket_type}"
+        end
+        @proxy.actor << [ @side, socket_type.to_s, endpoint ]
+        @proxy.actor.wait
+      end
+
+      # Set ZAP domain for authentication.
+      # @param domain [String] the ZAP domain
+      def domain=(domain)
+        @proxy.actor << [ "DOMAIN", @side, domain ]
+        @proxy.actor.wait
+      end
+
+      # Configure PLAIN authentication on this socket.
+      # @note You'll have to use a {CZTop::Authenticator}.
+      def PLAIN_server!
+        @proxy.actor << [ "PLAIN", @side ]
+        @proxy.actor.wait
+      end
+
+      # Configure CURVE authentication on this socket.
+      # @note You'll have to use a {CZTop::Authenticator}.
+      # @param cert [Certificate] this server's certificate,
+      #   so remote clients are able to authenticate this server
+      def CURVE_server!(cert)
+        public_key = cert.public_key
+        secret_key = cert.secret_key or
+          raise ArgumentError, "no secret key in certificate"
+
+        @proxy.actor << [ "CURVE", @side, public_key, secret_key ]
+        @proxy.actor.wait
+      end
+    end
+  end
+end

data/lib/cztop/send_receive_methods.rb

@@ -0,0 +1,35 @@
+module CZTop
+
+  # These are methods that can be used on a {Socket} as well as an {Actor},
+  # but actually just pass through to methods of {Message} (which take
+  # a polymorphic reference, in Ruby as well as in C).
+  # @see http://api.zeromq.org/czmq3-0:zmsg
+  module SendReceiveMethods
+    # Sends a message.
+    #
+    # @param message [Message, String, Array<parts>] the message to send
+    # @raise [IO::EAGAINWaitWritable] if send timeout has been reached (see
+    #   {ZsockOptions::OptionsAccessor#sndtimeo=})
+    # @raise [Interrupt, ArgumentError, SystemCallError] anything raised by
+    #   {Message#send_to}
+    # @return [self]
+    # @see Message.coerce
+    # @see Message#send_to
+    def <<(message)
+      Message.coerce(message).send_to(self)
+      self
+    end
+
+    # Receives a message.
+    #
+    # @return [Message]
+    # @raise [IO::EAGAINWaitReadable] if receive timeout has been reached (see
+    #   {ZsockOptions::OptionsAccessor#rcvtimeo=})
+    # @raise [Interrupt, ArgumentError, SystemCallError] anything raised by
+    #   {Message.receive_from}
+    # @see Message.receive_from
+    def receive
+      Message.receive_from(self)
+    end
+  end
+end

data/lib/cztop/socket/types.rb

@@ -0,0 +1,207 @@
+module CZTop
+  class Socket
+    #  Socket types. Each constant in this namespace holds the type code used
+    #  for the zsock_new() function.
+    module Types
+      PAIR = 0
+      PUB = 1
+      SUB = 2
+      REQ = 3
+      REP = 4
+      DEALER = 5
+      ROUTER = 6
+      PULL = 7
+      PUSH = 8
+      XPUB = 9
+      XSUB = 10
+      STREAM = 11
+      SERVER = 12
+      CLIENT = 13
+    end
+
+    # All the available type codes, mapped to their Symbol equivalent.
+    # @return [Hash<Integer, Symbol>]
+    TypeNames = Hash[
+      Types.constants.map { |name| i = Types.const_get(name); [ i, name ] }
+    ].freeze
+
+    # @param type [Symbol, Integer] type from {Types} or like +:PUB+
+    # @return [REQ, REP, PUSH, PULL, ... ] the new socket
+    # @see Types
+    # @example Creating a socket by providing its type as a parameter
+    #   my_sock = CZTop::Socket.new_by_type(:DEALER, "tcp://example.com:4000")
+    def self.new_by_type(type)
+      case type
+      when Integer
+        type_code = type
+        type_name = TypeNames[type_code] or
+          raise ArgumentError, "invalid type %p" % type
+        type_class = Socket.const_get(type_name)
+      when Symbol
+        type_code = Types.const_get(type)
+        type_class = Socket.const_get(type)
+      else
+        raise ArgumentError, "invalid socket type: %p" % type
+      end
+      ffi_delegate = Zsock.new(type_code)
+      sock = type_class.allocate
+      sock.attach_ffi_delegate(ffi_delegate)
+      sock
+    end
+
+    # Client socket for the ZeroMQ Client-Server Pattern.
+    # @see http://rfc.zeromq.org/spec:41
+    class CLIENT < Socket
+      # @param endpoints [String] endpoints to connect to
+      def initialize(endpoints = nil)
+        attach_ffi_delegate(Zsock.new_client(endpoints))
+      end
+    end
+
+    # Server socket for the ZeroMQ Client-Server Pattern.
+    # @see http://rfc.zeromq.org/spec:41
+    class SERVER < Socket
+      # @param endpoints [String] endpoints to bind to
+      def initialize(endpoints = nil)
+        attach_ffi_delegate(Zsock.new_server(endpoints))
+      end
+    end
+
+    # Request socket for the ZeroMQ Request-Reply Pattern.
+    # @see http://rfc.zeromq.org/spec:28
+    class REQ < Socket
+      # @param endpoints [String] endpoints to connect to
+      def initialize(endpoints = nil)
+        attach_ffi_delegate(Zsock.new_req(endpoints))
+      end
+    end
+
+    # Reply socket for the ZeroMQ Request-Reply Pattern.
+    # @see http://rfc.zeromq.org/spec:28
+    class REP < Socket
+      # @param endpoints [String] endpoints to bind to
+      def initialize(endpoints = nil)
+        attach_ffi_delegate(Zsock.new_rep(endpoints))
+      end
+    end
+
+    # Dealer socket for the ZeroMQ Request-Reply Pattern.
+    # @see http://rfc.zeromq.org/spec:28
+    class DEALER < Socket
+      # @param endpoints [String] endpoints to connect to
+      def initialize(endpoints = nil)
+        attach_ffi_delegate(Zsock.new_dealer(endpoints))
+      end
+    end
+
+    # Router socket for the ZeroMQ Request-Reply Pattern.
+    # @see http://rfc.zeromq.org/spec:28
+    class ROUTER < Socket
+      # @param endpoints [String] endpoints to bind to
+      def initialize(endpoints = nil)
+        attach_ffi_delegate(Zsock.new_router(endpoints))
+      end
+
+      # Send a message to a specific receiver. This is a shorthand for when
+      # you send a message to a specific receiver with no hops in between.
+      # @param receiver [String] receiving peer's socket identity
+      # @param message [Message] the message to send
+      # @note Do NOT use the message afterwards. It'll have been modified and
+      #   destroyed.
+      def send_to(receiver, message)
+        message = Message.coerce(message)
+        message.prepend ""       # separator frame
+        message.prepend receiver # receiver envelope
+        self << message
+      end
+    end
+
+    # Publish socket for the ZeroMQ Publish-Subscribe Pattern.
+    # @see http://rfc.zeromq.org/spec:29
+    class PUB < Socket
+      # @param endpoints [String] endpoints to bind to
+      def initialize(endpoints = nil)
+        attach_ffi_delegate(Zsock.new_pub(endpoints))
+      end
+    end
+
+    # Subscribe socket for the ZeroMQ Publish-Subscribe Pattern.
+    # @see http://rfc.zeromq.org/spec:29
+    class SUB < Socket
+      # @param endpoints [String] endpoints to connect to
+      # @param subscription [String] what to subscribe to
+      def initialize(endpoints = nil, subscription = nil)
+        attach_ffi_delegate(Zsock.new_sub(endpoints, subscription))
+      end
+
+      # Subscribes to the given prefix string.
+      # @param prefix [String] prefix string to subscribe to
+      # @return [void]
+      def subscribe(prefix)
+        ffi_delegate.set_subscribe(prefix)
+      end
+
+      # Unsubscribes from the given prefix.
+      # @param prefix [String] prefix string to unsubscribe from
+      # @return [void]
+      def unsubscribe(prefix)
+        ffi_delegate.set_unsubscribe(prefix)
+      end
+    end
+
+    # Extended publish socket for the ZeroMQ Publish-Subscribe Pattern.
+    # @see http://rfc.zeromq.org/spec:29
+    class XPUB < Socket
+      # @param endpoints [String] endpoints to bind to
+      def initialize(endpoints = nil)
+        attach_ffi_delegate(Zsock.new_xpub(endpoints))
+      end
+    end
+
+    # Extended subscribe socket for the ZeroMQ Publish-Subscribe Pattern.
+    # @see http://rfc.zeromq.org/spec:29
+    class XSUB < Socket
+      # @param endpoints [String] endpoints to connect to
+      def initialize(endpoints = nil)
+        attach_ffi_delegate(Zsock.new_xsub(endpoints))
+      end
+    end
+
+    # Push socket for the ZeroMQ Pipeline Pattern.
+    # @see http://rfc.zeromq.org/spec:30
+    class PUSH < Socket
+      # @param endpoints [String] endpoints to connect to
+      def initialize(endpoints = nil)
+        attach_ffi_delegate(Zsock.new_push(endpoints))
+      end
+    end
+
+    # Pull socket for the ZeroMQ Pipeline Pattern.
+    # @see http://rfc.zeromq.org/spec:30
+    class PULL < Socket
+      # @param endpoints [String] endpoints to bind to
+      def initialize(endpoints = nil)
+        attach_ffi_delegate(Zsock.new_pull(endpoints))
+      end
+    end
+
+    # Pair socket for inter-thread communication.
+    # @see http://rfc.zeromq.org/spec:31
+    class PAIR < Socket
+      # @param endpoints [String] endpoints to connect to
+      def initialize(endpoints = nil)
+        attach_ffi_delegate(Zsock.new_pair(endpoints))
+      end
+    end
+
+    # Stream socket for the native pattern over. This is useful when
+    # communicating with a non-ZMQ peer, done over TCP.
+    # @see http://api.zeromq.org/4-2:zmq-socket#toc16
+    class STREAM < Socket
+      # @param endpoints [String] endpoints to connect to
+      def initialize(endpoints = nil)
+        attach_ffi_delegate(Zsock.new_stream(endpoints))
+      end
+    end
+  end
+end

data/lib/cztop/socket.rb

@@ -0,0 +1,106 @@
+module CZTop
+  # Represents a CZMQ::FFI::Zsock.
+  class Socket
+    include HasFFIDelegate
+    extend CZTop::HasFFIDelegate::ClassMethods
+    include ZsockOptions
+    include SendReceiveMethods
+    include PolymorphicZsockMethods
+    include CZMQ::FFI
+
+    # @!group CURVE Security
+
+    # Enables CURVE security and makes this socket a CURVE server.
+    # @param cert [Certificate] this server's certificate,
+    #   so remote clients are able to authenticate this server
+    # @note You'll have to use a {CZTop::Authenticator}.
+    # @return [void]
+    def CURVE_server!(cert)
+      options.CURVE_server = true
+      cert.apply(self) # NOTE: desired: raises if no secret key in cert
+    end
+
+    # Enables CURVE security and makes this socket a CURVE client.
+    # @param client_cert [Certificate] client's certificate, to secure
+    #   communication (and be authenticated by the server)
+    # @param server_cert [Certificate] the remote server's certificate, so
+    #   this socket is able to authenticate the server
+    # @return [void]
+    # @raise [SecurityError] if the server's secret key is set in server_cert,
+    #   which means it's not secret anymore
+    # @raise [SystemCallError] if there's no secret key in client_cert
+    def CURVE_client!(client_cert, server_cert)
+      if server_cert.secret_key
+        raise SecurityError, "server's secret key not secret"
+      end
+
+      client_cert.apply(self) # NOTE: desired: raises if no secret key in cert
+      options.CURVE_serverkey = server_cert.public_key
+    end
+
+    # @!endgroup
+
+    # @return [String] last bound endpoint, if any
+    def last_endpoint
+      ffi_delegate.endpoint
+    end
+
+    # Connects to an endpoint.
+    # @param endpoint [String]
+    # @return [void]
+    # @raise [ArgumentError] if the endpoint is incorrect
+    def connect(endpoint)
+      rc = ffi_delegate.connect("%s", :string, endpoint)
+      raise ArgumentError, "incorrect endpoint: %p" % endpoint if rc == -1
+    end
+
+    # Disconnects from an endpoint.
+    # @param endpoint [String]
+    # @raise [ArgumentError] if the endpoint is incorrect
+    def disconnect(endpoint)
+      rc = ffi_delegate.disconnect("%s", :string, endpoint)
+      raise ArgumentError, "incorrect endpoint: %p" % endpoint if rc == -1
+    end
+
+    # Closes and destroys the native socket.
+    # @note Don't try to use it anymore afterwards.
+    def close
+      ffi_delegate.destroy
+    end
+
+    # @return [Integer] last automatically selected, bound TCP port, if any
+    # @return [nil] if not bound to a TCP port yet
+    attr_reader :last_tcp_port
+
+    # Binds to an endpoint.
+    # @note When binding to an automatically selected TCP port, this will set
+    #   {#last_tcp_port}.
+    # @param endpoint [String]
+    # @return [void]
+    # @raise [SystemCallError] in case of failure
+    def bind(endpoint)
+      rc = ffi_delegate.bind("%s", :string, endpoint)
+      raise_zmq_err("unable to bind to %p" % endpoint) if rc == -1
+      @last_tcp_port = rc if rc > 0
+    end
+
+    # Unbinds from an endpoint.
+    # @param endpoint [String]
+    # @return [void]
+    # @raise [ArgumentError] if the endpoint is incorrect
+    def unbind(endpoint)
+      rc = ffi_delegate.unbind("%s", :string, endpoint)
+      raise ArgumentError, "incorrect endpoint: %p" % endpoint if rc == -1
+    end
+
+    # Inspects this {Socket}.
+    # @return [String] shows class, native address, and {#last_endpoint}
+    def inspect
+      "#<%s:0x%x last_endpoint=%p>" % [
+        self.class,
+        to_ptr.address,
+        last_endpoint
+      ]
+    end
+  end
+end

data/lib/cztop/version.rb

@@ -0,0 +1,3 @@
+module CZTop
+  VERSION = "0.1.0"
+end

data/lib/cztop/z85.rb

@@ -0,0 +1,157 @@
+module CZTop
+  # Represents a CZMQ::FFI::Zarmour in Z85 mode.
+  #
+  # Use this class to encode to and from the Z85 encoding algorithm.
+  # @see http://rfc.zeromq.org/spec:32
+  class Z85
+    include HasFFIDelegate
+    extend CZTop::HasFFIDelegate::ClassMethods
+
+    def initialize
+      attach_ffi_delegate(CZMQ::FFI::Zarmour.new)
+      ffi_delegate.set_mode(:mode_z85)
+    end
+
+    # Encodes to Z85.
+    # @param input [String] possibly binary input data
+    # @return [String] Z85 encoded data as ASCII string
+    # @raise [ArgumentError] if input length isn't divisible by 4 with no
+    #   remainder
+    # @raise [SystemCallError] if this fails
+    def encode(input)
+      raise ArgumentError, "wrong input length" if input.bytesize % 4 > 0
+      input = input.dup.force_encoding(Encoding::BINARY)
+      ptr = ffi_delegate.encode(input, input.bytesize)
+      raise_zmq_err if ptr.null?
+      z85 = ptr.read_string
+      z85.encode!(Encoding::ASCII)
+      return z85
+    end
+
+    # Decodes from Z85.
+    # @param input [String] Z85 encoded data
+    # @return [String] original data as binary string
+    # @raise [ArgumentError] if input length isn't divisible by 5 with no
+    #   remainder
+    # @raise [SystemCallError] if this fails
+    def decode(input)
+      raise ArgumentError, "wrong input length" if input.bytesize % 5 > 0
+      FFI::MemoryPointer.new(:size_t) do |size_ptr|
+        buffer_ptr = ffi_delegate.decode(input, size_ptr)
+        raise_zmq_err if buffer_ptr.null?
+        decoded_string = buffer_ptr.read_string(_size(size_ptr) - 1)
+        return decoded_string
+      end
+    end
+
+    private
+
+    # Gets correct size, depending on the platform.
+    # @return [Integer]
+    # @see https://github.com/ffi/ffi/issues/398
+    # @see https://github.com/ffi/ffi/issues/333
+    def _size(size_ptr)
+      if RUBY_ENGINE == "jruby"
+        # NOTE: JRuby FFI doesn't have #read_uint64, nor does it have
+        # Pointer::SIZE
+        return size_ptr.read_ulong_long
+      end
+
+      if ::FFI::Pointer::SIZE == 8 # 64 bit
+        size_ptr.read_uint64
+      else
+        size_ptr.read_uint32
+      end
+    end
+
+    # Z85 with simple padding. This allows you to {#encode} input of any
+    # length.
+    #
+    # = Encoding Procedure
+    #
+    # If the data to be encoded is empty (0 bytes), it is encoded to the empty
+    # string, just like in Z85.
+    #
+    # Otherwise, a length information is prepended and, if needed, padding (1,
+    # 2, or 3 NULL bytes) is appended to bring the resulting blob to
+    # a multiple of 4 bytes.
+    #
+    # The length information is encoded similarly to lengths of messages
+    # (frames) in ZMTP. Up to 127 bytes, the data's length is encoded with
+    # a single byte (specifically, with the 7 least significant bits in it).
+    #
+    #   +--------+-------------------------------+------------+
+    #   | length |              data             |   padding  |
+    #   | 1 byte |        up to 127 bytes        |  0-3 bytes |
+    #   +--------+-------------------------------+------------+
+    #
+    # If the data is 128 bytes or more, the most significant bit will be set
+    # to indicate that fact, and a 64 bit unsigned integer in network byte
+    # order is appended after this first byte to encode the length of the
+    # data.  This means that up to 16EiB (exbibytes) can be encoded, which
+    # will be enough for the foreseeable future.
+    #
+    #   +--------+-----------+----------------------------------+------------+
+    #   |  big?  |   length  |                data              |   padding  |
+    #   | 1 byte |  8 bytes  |      128 bytes or much more      |  0-3 bytes |
+    #   +--------+-----------+----------------------------------+------------+
+    #
+    # The resulting blob is encoded using {CZTop::Z85#encode}.
+    # {CZTop::Z85#decode} does the inverse.
+    #
+    # @note Warning: This won't be compatible with other implementations of
+    #   Z85. Only use this if you really need padding, like when you can't
+    #   guarantee the input for {#encode} is always a multiple of 4 bytes.
+    #
+    class Padded < Z85
+      # Encododes to Z85, with padding if needed.
+      #
+      # If input isn't empty, 8 additional bytes for the encoded length will
+      # be prepended. If needed, 1 to 3 bytes of padding will be appended.
+      #
+      # If input is empty, returns the empty string.
+      #
+      # @param input [String] possibly binary input data
+      # @return [String] Z85 encoded data as ASCII string, including encoded
+      #   length and padding
+      # @raise [SystemCallError] if this fails
+      def encode(input)
+        return super if input.empty?
+        length = input.bytesize
+        if length < 1<<7 # up to 127 bytes
+          encoded_length = [length].pack("C")
+
+        else # larger input
+          low = length & 0xFFFFFFFF
+          high = (length >> 32) & 0xFFFFFFFF
+          encoded_length = [ 1<<7, high, low ].pack("CNN")
+        end
+        padding = "\0" * ((4 - ((length+1) % 4)) % 4)
+        super("#{encoded_length}#{input}#{padding}")
+      end
+
+      # Decodes from Z85 with padding.
+      #
+      # @param input [String] Z85 encoded data (including encoded length and
+      #   padding, or empty string)
+      # @return [String] original data as binary string
+      # @raise [ArgumentError] if input is invalid or truncated
+      # @raise [SystemCallError] if this fails
+      def decode(input)
+        return super if input.empty?
+        decoded = super
+        length = decoded.byteslice(0, 1).unpack("C")[0]
+        if (1<<7 & length).zero? # up to 127 bytes
+          decoded = decoded.byteslice(1, length) # extract payload
+
+        else # larger input
+          length = decoded.byteslice(1, 8).unpack("NN")
+                     .inject(0) { |sum, i| (sum << 32) + i }
+          decoded = decoded.byteslice(9, length) # extract payload
+        end
+        raise ArgumentError, "input truncated" if decoded.bytesize < length
+        return decoded
+      end
+    end
+  end
+end