sping 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74faa9103509651e47d2f098c22b66fae80ca1ba0b71b132aa636d26bf1e0f04
-  data.tar.gz: 9ae6b44c52ded9e1999eb3fe467216b6d640747d11a8b69f4eed864efeb30a03
+  metadata.gz: 7dc97d43dd1c7805574269a6ebbe8113c49c431bdfa46783b8e43ebef14063a5
+  data.tar.gz: ffb03def610179c609ffd4046cd5a7da5659e73b83ae867a123a2fcf62309b72
 SHA512:
-  metadata.gz: c08fcd7358309abe6a7f67044bbf267f31cba483786dc387b78ef14e8ce32801b067bd2ca8e2a545e141d3ffe843d004a4427d1a91cba1cbdd8d154679344653
-  data.tar.gz: 56ea68be301c25d116657775aabf26a9fb9fdf41cf2224ff9dcd72be1b897f20b076e9d0f4a1154ec777c53f20eeff173ded69985c993c99169198290f66a092
+  metadata.gz: 637dc51c01d6f89bb26a6175d3ac0f0a16921398db3244164efea4b1de457cd3ef1329f3b4ee6eed69a1a57961a6c0d64c31fab7f4fb1fed150183212d830b96
+  data.tar.gz: 5bc1661058eb425277ed0d37429b5b0e8376690a6665aeb85e8bda35b96b85fd3a4025f0b4cc2020aef7b9e1f847b24845b6db9e841705749a7db3a20e4e9ee3

data/README.md

@@ -1,3 +1,5 @@
 # sping
 
-This is a reimplementation of [sping](https://github.com/benjojo/sping/) in Ruby.
+Program for measuring asymmetric latencies.
+
+This is a reimplementation in Ruby of the reference implementation of the sping protocol in Go. The program provides both the client and server part to measure asymmetric latencies between two peers.

data/lib/errors.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+# sharable_constant_value: literal
+
+# SPing / Splitted Ping is a protocol for measuring asymmetric latencies.
+module SPing
+  # Generic SPing error.
+  class SPingError < StandardError; end
+
+  # Error that occurred while managing the sessions.
+  class SessionManagerError < SPingError; end
+
+  # Error that is thrown when there are not enough session IDs available to establish a
+  # connection to a peer or to accept new ones.
+  # This indicates either a programmer error or an overload of the server.
+  class OutOfSessions < SessionManagerError; end
+
+  # Error that occurs in connection with a session.
+  class SessionError < SPingError; end
+
+  # Error during the TCP handshake
+  class TCPHandshakeError < SessionError; end
+
+  # Error due to the peer (i.e. not self-inflicted).
+  class PeerError < SPingError; end
+
+  # Package was not coded correctly.
+  class InvalidPacketError < PeerError; end
+
+  # The package was coded correctly, but the content is invalid.
+  class InvalidMessageError < InvalidPacketError; end
+
+  # A packet has been received which cannot be clearly assigned to SPing
+  # and therefore cannot be processed further.
+  class UnknownPacketError < InvalidPacketError; end
+
+  # The peer has signaled an error.
+  class SignalizedError < PeerError; end
+
+  # The peer uses a version of sping that is not supported.
+  class UnsupportedVersionError < PeerError; end
+
+  # The package could not be assigned to a current session.
+  class UnknownSessionError < PeerError; end
+end

data/lib/last_acks.rb

@@ -1,34 +1,43 @@
 # frozen_string_literal: true
 # sharable_constant_value: literal
 
-class LastAcks
-  attr_reader :size
+# SPing / Splitted Ping is a protocol for measuring asymmetric latencies.
+module SPing
+  # A kind of circular buffer, which consists of 32 acks at any given time. If no acks are available,
+  # empty ones are created. If a new ack is added (which would result in 33 acks), one is removed.
+  class LastAcks
+    # Creates a new circular buffer for acks
+    def initialize
+      # Array in which the acks are stored.
+      @acks = []
+      # Mutex, which ensures that the array is not accessed simultaneously.
+      @acks_mutex = Mutex.new
 
-  def initialize(size = 32)
-    @size = size
-    @acks = []
-    @acks_mutex = Mutex.new
-
-    @size.times do |index|
-      @acks[index] = {
-        'R' => 0,
-        'U' => Time.at(0),
-        'X' => Time.at(0)
-      }
+      # Initiallize the circular buffer with 32 empty acks.
+      32.times do |index|
+        @acks[index] = {
+          'R' => 0,
+          'U' => Time.at(0),
+          'X' => Time.at(0)
+        }
+      end
     end
-  end
 
-  def acks
-    @acks_mutex.synchronize do
-      return @acks.dup
+    # Returns a copy of the last 32 acks.
+    # @return [Array] Last 32 Acks
+    def acks
+      @acks_mutex.synchronize do
+        return @acks.dup
+      end
     end
-  end
-
-  def add_ack(ack)
-    @acks_mutex.synchronize do
-      @acks << ack
 
-      @acks.shift if @acks.length > @size
+    # Adds a new ack and deletes the oldest one
+    # @param ack [Hash] New ack to be added
+    def add_ack(ack)
+      @acks_mutex.synchronize do
+        @acks << ack
+        @acks.shift
+      end
     end
   end
 end

data/lib/session.rb

@@ -1,69 +1,118 @@
 # frozen_string_literal: true
 # sharable_constant_value: literal
 
+# SPing / Splitted Ping is a protocol for measuring asymmetric latencies.
 module SPing
-  class SessionError < StandardError; end
-  class TCPHandshakeError < SessionError; end
+  # Inclusion of all possible SPing-specific errors.
+  require_relative 'errors'
 
+  # Models or represents a session with a peer.
   class Session
-    attr_reader :created, :last_rx, :madebyme
-    attr_accessor :session_id, :tcp_handshake_complete, :udp_handshake_complete
+    # Time when the session was created. This is necessary so that the session GC knows when a
+    # non-initialized session can be deleted.
+    # @return [Time]
+    attr_reader :created
+    # Time when the last ping packet was received by the peer. This is important so that the session
+    # GC knows when a session is considered inactive and can be deleted.
+    # @return [Time]
+    attr_reader :last_rx
+    # Indicates whether the session has been initialized. true if we have initiated it.
+    # false if the peer has initiated it.
+    # @return [TrueClass, FalseClass]
+    attr_reader :madebyme
+    # Indicates whether a TCP handshake has been carried out (successfully).
+    # @return [TrueClass, FalseClass]
+    attr_reader :tcp_handshake_complete
+    # Indicates whether a UDP handshake has been carried out (successfully).
+    # @return [TrueClass, FalseClass]
+    attr_reader :udp_handshake_complete
+    # The session ID in the range from 1 to 2**32 - 1.
+    # @return [Integer]
+    attr_reader :session_id
 
     require 'socket'
     require 'timeout'
     require 'msgpack'
     require_relative 'last_acks'
 
+    # Creates a new session
+    # @param host [#to_s] Host of the peer
+    # @param port [#to_i] Port of the peer
+    # @param socket [UDPSocket] UDP socket via which the pings and the UDP handshake are to be sent.
+    # @param madebyme [TrueClass, FalseClass] Indicates whether we have initiated the session.
     def initialize(host, port, socket, madebyme)
-      @host = host
-      @port = port
+      # Assign the passed parameters to instance variables.
+      @host = host.to_s
+      @port = port.to_i
       @socket = socket
-      @created = Time.now
       @madebyme = madebyme
 
+      # Initialize assignment of other instance variables
+      @created = Time.now
+
       @tcp_handshake_complete = false
       @udp_handshake_complete = false
 
-      @last_acks = LastAcks.new
+      @last_acks = SPing::LastAcks.new
     end
 
+    # Initiates a TCP handshake.
+    # @param socket [TCPSocket] Socket via which the handshake is to be sent
+    #   (and responses are to be expected).
+    # @param session_id [Integer] Session ID which is to be sent to the peer
+    #   and which is to be used for the current session.
     def do_tcp_handshake1(socket, session_id)
+      # Send the banner
       socket.write "sping-0.3-https://codeberg.org/mark22k/sping\r\n"
+      # and make sure that it is no longer in the send buffer.
       socket.flush
 
+      # See if the peer invites us to create a session with them.
       invite = socket.readpartial 6
-
       raise TCPHandshakeError, 'Peer didn\'t invite us.' unless invite.chomp == 'INVITE'
 
+      # Send the session ID
       @session_id = session_id
-
       socket.write "#{session_id}\r\n"
+      # and make sure that it is no longer in the send buffer.
       socket.flush
 
+      # This means that the TCP handshake is successful. The socket can be closed
+      # and the corresponding instance variable can be set.
       socket.close
 
       @tcp_handshake_complete = true
     end
 
+    # Receives a TCP handshake from a peer.
+    # The peer specified when the session is created is consulted for this purpose.
     def do_tcp_handshake2
+      # Establish a connection and receive the banner.
       socket = TCPSocket.new @host, @port
+
+      # If the banner is too large, close the socket and throw an error.
+      # The handshake was not successful.
       banner = socket.readpartial 9001
       if banner.length > 9000
         socket.close
         raise TCPHandshakeError, 'Host banner too big'
       end
 
+      # If the banner does not match the SPing service, close the socket and
+      # throw an error. The handshake was not successful.
       unless banner.start_with? 'sping-0.3-'
         socket.close
-        raise TCPHandshakeError, 'Host banner not sping'
+        raise TCPHandshakeError, 'Host banner not sping or unsupported version of sping.'
       end
 
       @remote_version = banner.chomp
       $logger.info "Peer uses the following program version: #{@remote_version.dump}"
 
+      # Invite the peer to start a session with us.
       socket.write "INVITE\r\n"
       socket.flush
 
+      # If the session ID is too long or none was received, close the socket and throw an error.
       invite_buf = socket.readpartial 32
       if invite_buf.length > 31 || invite_buf.empty?
         socket.close
@@ -77,15 +126,21 @@ module SPing
       @tcp_handshake_complete = true
     end
 
+    # Sets the endpoint consisting of the host and port of the remote end. This is done
+    # each time a new packet is received and ensures that the current endpoint is always available.
+    # @param host [#to_s]
+    # @param port [#to_i]
     def set_endpoint(host, port)
-      @host = host
-      @port = port
+      @host = host.to_s
+      @port = port.to_i
     end
 
+    # Starts a thread which sends the UDP handshake at regular intervals.
+    # @param send_interval [#to_i] The interval at which the UDP handshakes are to be sent.
     def start_udp_handshake_sender(send_interval = 5)
       raise 'UDP handshake sender is already running.' if @udp_handshake_sender
 
-      @udp_handshake_sender = Thread.new(send_interval) do |th_send_interval|
+      @udp_handshake_sender = Thread.new(send_interval.to_i) do |th_send_interval|
         loop do
           send_udp_handshake
           sleep th_send_interval
@@ -93,6 +148,7 @@ module SPing
       end
     end
 
+    # Send a single UDP handshake
     def send_udp_handshake
       packet = {
         'Y' => 'h'.ord,
@@ -105,6 +161,7 @@ module SPing
       @socket.send packet, 0, @host, @port
     end
 
+    # Stop the UDP handshake sender. UDP handshakes are then no longer sent at any interval.
     def stop_udp_handshake_sender
       raise 'UDP handshake sender is not running and therefore cannot be terminated.' unless @udp_handshake_sender
 
@@ -112,11 +169,13 @@ module SPing
       @udp_handshake_sender = nil
     end
 
+    # Informs the session that a UDP handshake has been received.
     def udp_handshake_recived
       stop_udp_handshake_sender if @madebyme
       @udp_handshake_complete = true
     end
 
+    # Starts a thread which sends ping or time messages to the peer at one-second intervals.
     def start_pinger
       raise 'Pinger is already running.' if @pinger
 
@@ -128,6 +187,7 @@ module SPing
       end
     end
 
+    # Stops the thread, which sends ping or time messages to the peer at regular intervals.
     def stop_pinger
       raise 'Pinger sender is not running and therefore cannot be terminated.' unless @pinger
 
@@ -135,6 +195,7 @@ module SPing
       @pinger = nil
     end
 
+    # Sends a ping message to the peer.
     def ping
       current_id = (Time.now.to_i % 255) + 1
       data = {
@@ -151,21 +212,45 @@ module SPing
       @socket.send data, 0, @host, @port
     end
 
+    # Stops all threads associated with the session. This means that the session to the peer is as good as dead.
     def stop
       @pinger&.kill
       @udp_handshake_sender&.kill
     end
 
+    # Handler that receives and processes a receiving ping packet or time message. The current statistics are output.
+    # @param packet [Hash]
+    # @param rxtime [Time]
+    # @param peeraddr [#to_s]
     def handle_ping(packet, rxtime, peeraddr)
-      if packet['E'] != 0
-        $logger.error "Package displays an error message: #{packet['E']} Processing aborted."
-        return
+      if !(packet.keys - %w[M Y E I T A S]).empty? ||
+         # M, Y are already checked in handle_packet from session manager
+         !packet['E'].is_a?(Integer) ||
+         !packet['I'].is_a?(Integer) ||
+         !packet['T'].is_a?(Time) ||
+         !packet['A'].is_a?(Array)
+        raise InvalidPacketError, 'The peer has sent an invalid message. The ping packet is incorrectly coded.'
       end
 
+      raise SignalizedError, "Package displays an error message: #{packet['E']} Processing aborted." if packet['E'] != 0
+
       id = packet['I']
       txtime = packet['T']
       remote_last_acks = packet['A']
 
+      if remote_last_acks.length != 32
+        raise InvalidMessageError, 'The peer has sent an invalid message. It does not contain any 32-Acks.'
+      end
+
+      remote_last_acks.each do |block_ack|
+        if !(block_ack.keys - %w[R U X]).empty? ||
+           !block_ack['R'].is_a?(Integer) ||
+           !block_ack['U'].is_a?(Time) ||
+           !block_ack['X'].is_a?(Time)
+          raise InvalidMessageError, 'The peer has sent an invalid message. An Ack is formatted invalid.'
+        end
+      end
+
       ack = {
         'R' => id,
         'U' => txtime,

data/lib/session_manager.rb

@@ -1,18 +1,23 @@
 # frozen_string_literal: true
 # sharable_constant_value: literal
 
+# SPing / Splitted Ping is a protocol for measuring asymmetric latencies.
 module SPing
-  class SessionManagerError < StandardError; end
-  class OutOfSessions < SessionManagerError; end
+  # Inclusion of all possible SPing-specific errors.
+  require_relative 'errors'
 
+  # Container, which contains a collection of sessions and manages them.
   class SessionManager
     require 'socket'
     require 'timeout'
     require_relative 'session'
 
+    # Creates a new Session Manager, which can (and will) manage a number of sessions.
+    # @param host [#to_s] Host to which messages are to be bound and from which messages are sent accordingly.
+    # @param port [#to_i] Port
     def initialize(host = '::', port = 6924)
-      @host = host
-      @port = port
+      @host = host.to_s
+      @port = port.to_i
 
       @sessions = {}
       @sessions_mutex = Mutex.new
@@ -21,9 +26,12 @@ module SPing
       @socket.bind @host, @port
     end
 
+    # Initiates a new session with a peer.
+    # @param host [#to_s]
+    # @param port [#to_s, #to_i]
     def new_session(host, port = 6924)
       $logger.info "Add new session for host #{host} port #{port}."
-      session = SPing::Session.new host, port, @socket, true
+      session = SPing::Session.new host.to_s, port.to_i, @socket, true
 
       counter = 0
       loop do
@@ -49,6 +57,8 @@ module SPing
       $logger.error "Out of session: #{e.message}"
     end
 
+    # Stops all threads connected to a session ID and removes the session from the Session Manager administration.
+    # @param session_id [Integer] Session ID of the session to be removed.
     def del_session(session_id)
       $logger.debug "Delete session with session id #{session_id}"
 
@@ -58,18 +68,21 @@ module SPing
       end
     end
 
+    # Stops all sessions or the threads that are connected to them.
     def stop_sessions
       @sessions.each do |_session_id, session|
         session.stop
       end
     end
 
+    # Waits and blocks until the Session Manager is no longer running.
     def join
       @runner&.join
       @gc_thread&.join
       @server_thread&.join
     end
 
+    # Starts the Session Manager.
     def run
       raise 'Client is already running.' if @runner
       raise 'GC is already running.' if @gc
@@ -89,6 +102,7 @@ module SPing
       end
     end
 
+    # Starts the server functionality of the Session Manager.
     def run_server
       raise 'Server is already running.' if @server_thread
       raise 'Server already exist.' if @server
@@ -106,6 +120,7 @@ module SPing
       return @server_thread
     end
 
+    # Stops the server functionality of the Session Manager.
     def stop_server
       raise 'Server thread is not running.' unless @server_thread
 
@@ -118,6 +133,7 @@ module SPing
       @server = nil
     end
 
+    # Stops the Session Manager. The server functionality must be stopped separately.
     def stop
       raise 'Session manager is not running.' unless @runner
 
@@ -130,6 +146,12 @@ module SPing
       @gc_thread = nil
     end
 
+    private
+
+    # Generates a new session ID that was not yet in use at the time of the check.
+    # If none could be generated within half a minute - for example because all
+    # session IDs have already been assigned - an error is thrown.
+    # @return [Integer]
     def generate_session_id
       Timeout.timeout(30, OutOfSessions, 'No session ID could be generated which has not yet been used.') do
         loop do
@@ -139,19 +161,23 @@ module SPing
       end
     end
 
-    private
-
+    # Removes obsolete sessions. This includes sessions that are older than one minute but
+    # have not been activated a double time. And sessions that have not
+    # received any packets for half a minute.
     def do_gc
       $logger.debug 'Remove outdated sessions.'
       # rubocop:disable Style/HashEachMethods
-      # You cannot run through a map and edit it at the same time. Since this is necessary due to the threading,
+      # You cannot run through a map and edit it at the same time. Since this is
+      # necessary due to the threading,
       # a snapshot of the key variable is run through.
       @sessions.keys.each do |session_id|
         # rubocop:enable Style/HashEachMethods
 
         session = @sessions[session_id]
-        # It is possible that sessions no longer exist here, as we may have session IDs that have already been deleted.
-        # However, we can ignore this aspect here, as we are the only function that deletes sessions.
+        # It is possible that sessions no longer exist here, as we may have
+        # session IDs that have already been deleted.
+        # However, we can ignore this aspect here, as we are the only
+        # function that deletes sessions.
         if !(session.tcp_handshake_complete && session.udp_handshake_complete)
           # Handshake incomplete
           if (Time.now.to_i - session.created.to_i) > 60
@@ -160,13 +186,16 @@ module SPing
             del_session session_id
           end
         elsif (Time.now.to_i - session.last_rx.to_i) > 30
-          # 30 seconds have elapsed since the last ping from the peer was received. The peer is probably dead.
+          # 30 seconds have elapsed since the last ping from the peer was received.
+          # The peer is probably dead.
           $logger.debug "Session id #{session_id} without activity for over thirty seconds."
           del_session session_id
         end
       end
     end
 
+    # Receives a TCP handshake for a session and then has it
+    # managed by the Session Manager.
     def request_session(session)
       session.do_tcp_handshake2
 
@@ -180,6 +209,9 @@ module SPing
       return nil
     end
 
+    # Handler for a received packet. The function catches errors and outputs them.
+    # It also forwards the packet to the corresponding handler according to the
+    # session ID and type of packet.
     def handle_packet(buf)
       rxtime = Time.now
 
@@ -187,12 +219,20 @@ module SPing
       peerport = buf[1][1]
       $logger.debug "Packet received from #{peeraddr} port #{peerport}."
 
-      packet = MessagePack.unpack(buf[0])
+      packet = MessagePack.unpack(buf[0]).to_h
+
+      if !packet.key?('M') ||
+         !packet.key?('Y') ||
+         !packet.key?('S') ||
+         !packet['M'].is_a?(Integer) ||
+         !packet['Y'].is_a?(Integer) ||
+         !packet['S'].is_a?(Integer)
+        raise InvalidMessageError, 'The peer has sent an invalid message. The packet is incorrectly coded.'
+      end
 
       # Check whether the Magic Number is the correct one.
       if packet['M'] != 11_181
-        $logger.warn 'Package contains incorrect magic number. Processing is canceled.'
-        return
+        raise UnknownPacketError, 'Package contains incorrect magic number. Processing is canceled.'
       end
 
       type = packet['Y'].chr
@@ -202,54 +242,60 @@ module SPing
       when 't'
         handle_ping packet, rxtime, peeraddr, peerport
       else
-        $logger.warn "Package is of unknown type: #{type}"
+        raise UnknownPacketError, "Package is of unknown type: #{type}"
       end
+    rescue MessagePack::MalformedFormatError => e
+      $logger.error "Packet cannot be decoded: #{e.message}"
+    rescue PeerError => e
+      $logger.error "Perr error: #{e.message}"
     end
 
+    # Handler for a receiving UDP handshake.
     def handle_udp_handshake(packet, peeraddr, peerport)
+      if !(packet.keys - %w[M Y V S]).empty? ||
+         # M, Y are already checked in handle_packet from session manager
+         !packet['V'].is_a?(Integer)
+        raise InvalidMessageError, 'The peer has sent an invalid message. The handshake packet is incorrectly coded.'
+      end
+
       session_id = packet['S']
       session = @sessions[session_id]
-      if session
-        if packet['V'] != 3
-          $logger.warn "UDP handshake uses an unsupported version: #{packet['V']}"
-          return
-        end
+      raise UnknownSessionError, 'UDP handshake received for uninitiated session.' unless session
+      raise UnsupportedVersionError, "UDP handshake uses an unsupported version: #{packet['V']}" if packet['V'] != 3
 
-        session.set_endpoint peeraddr, peerport
+      session.set_endpoint peeraddr, peerport
 
-        unless session.madebyme
-          # If the session was not started by me, the other peer expects a
-          # confirmation of the handshake in which the same is sent back.
-          $logger.debug "Send UDP Handshake back for session id #{session_id}."
-          session.send_udp_handshake
-        end
-
-        if session.udp_handshake_complete
-          $logger.warn 'UDP handshake is received, although a previous one was already successful.'
-          return
-        end
-
-        session.udp_handshake_recived
-        $logger.info "UDP handshake for session ID #{session_id} was successful."
+      unless session.madebyme
+        # If the session was not started by me, the other peer expects a
+        # confirmation of the handshake in which the same is sent back.
+        $logger.debug "Send UDP Handshake back for session id #{session_id}."
+        session.send_udp_handshake
+      end
 
-        session.start_pinger
-      else
-        $logger.warn 'UDP handshake received for uninitiated session.'
+      if session.udp_handshake_complete
+        $logger.warn 'UDP handshake is received, although a previous one was already successful.'
         return
       end
+
+      session.udp_handshake_recived
+      $logger.info "UDP handshake for session ID #{session_id} was successful."
+
+      session.start_pinger
     end
 
+    # Handler for a receiving ping or a receiving time message.
     def handle_ping(packet, rxtime, peeraddr, peerport)
       session_id = packet['S']
       session = @sessions[session_id]
-      if session&.tcp_handshake_complete && session&.udp_handshake_complete
-        session.set_endpoint peeraddr, peerport
-        session.handle_ping packet, rxtime, peeraddr
-      else
-        $logger.warn "Ping packet received for non-initiated session id #{session_id}."
+      unless session&.tcp_handshake_complete && session&.udp_handshake_complete
+        raise UnknownSessionError, "Ping packet received for non-initiated session id #{session_id}."
       end
+
+      session.set_endpoint peeraddr, peerport
+      session.handle_ping packet, rxtime, peeraddr
     end
 
+    # Handler to establish a session for the request of a peer.
     def handle_client(client)
       host = client.peeraddr[3]
       port = client.peeraddr[1]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sping
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Marek Küthe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-09 00:00:00.000000000 Z
+date: 2023-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -30,8 +30,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.7.2
-description: This is a reimplementation of [sping](https://github.com/benjojo/sping/)
-  in Ruby.
+description: This is a reimplementation in Ruby of the reference implementation of
+  the sping protocol in Go. The program provides both the client and server part to
+  measure asymmetric latencies between two peers.
 email: m.k@mk16.de
 executables:
 - sping
@@ -43,6 +44,7 @@ files:
 - LICENSE
 - README.md
 - bin/sping
+- lib/errors.rb
 - lib/last_acks.rb
 - lib/session.rb
 - lib/session_manager.rb
@@ -68,8 +70,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.21
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
-summary: Reimplementation of sping in Ruby.
+summary: Program for measuring asymmetric latencies.
 test_files: []