sping 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5ab53904c197ff35bab0d5fc29f26b5ada7c1ded24548b30d42df12d3df6837
-  data.tar.gz: 8bd57a7d33c5f39f1eb76ad2551550fafecc5836f373b3c3675648e620afebe1
+  metadata.gz: 74faa9103509651e47d2f098c22b66fae80ca1ba0b71b132aa636d26bf1e0f04
+  data.tar.gz: 9ae6b44c52ded9e1999eb3fe467216b6d640747d11a8b69f4eed864efeb30a03
 SHA512:
-  metadata.gz: 90e021acc0d54dace745238c35566efacdd5be77d8db2f9ecd6e6aa1ed8d71ee89c552fb4674be23e1adcf244987154e1975364731eff78e76ad5dd7006ec3df
-  data.tar.gz: 336910fef1e87548f060a4a70547b272d78362828274dd5b21ed011a821a66ed71c7ece447045ca717a169676fa872594cbbd9e649e701731c63cd812c7f7bba
+  metadata.gz: c08fcd7358309abe6a7f67044bbf267f31cba483786dc387b78ef14e8ce32801b067bd2ca8e2a545e141d3ffe843d004a4427d1a91cba1cbdd8d154679344653
+  data.tar.gz: 56ea68be301c25d116657775aabf26a9fb9fdf41cf2224ff9dcd72be1b897f20b076e9d0f4a1154ec777c53f20eeff173ded69985c993c99169198290f66a092

data/bin/sping

@@ -7,10 +7,10 @@ require 'msgpack'
 require_relative '../lib/session_manager'
 
 MessagePack::DefaultFactory.register_type(
-    MessagePack::Timestamp::TYPE,
-    Time,
-    packer: MessagePack::Time::Packer,
-    unpacker: MessagePack::Time::Unpacker
+  MessagePack::Timestamp::TYPE,
+  Time,
+  packer: MessagePack::Time::Packer,
+  unpacker: MessagePack::Time::Unpacker
 )
 
 $logger = Logger.new $stdout
@@ -21,18 +21,18 @@ sess_mgr.run
 sess_mgr.run_server
 
 ARGV.each do |host|
-    sess_mgr.new_session(host)
+  sess_mgr.new_session(host)
 end
 
 Signal.trap('INT') do
-    puts "Stop server..."
-    sess_mgr.stop_server
+  puts 'Stop server...'
+  sess_mgr.stop_server
 
-    puts "Stop sessions..."
-    sess_mgr.stop_sessions
+  puts 'Stop sessions...'
+  sess_mgr.stop_sessions
 
-    puts "Stop client..."
-    sess_mgr.stop
+  puts 'Stop client...'
+  sess_mgr.stop
 end
 
 sess_mgr.join

data/lib/last_acks.rb

@@ -2,20 +2,33 @@
 # sharable_constant_value: literal
 
 class LastAcks
+  attr_reader :size
 
-    attr_reader :acks, :size
+  def initialize(size = 32)
+    @size = size
+    @acks = []
+    @acks_mutex = Mutex.new
 
-    def initialize(size = 32)
-        @size = 32
-        @acks = []
+    @size.times do |index|
+      @acks[index] = {
+        'R' => 0,
+        'U' => Time.at(0),
+        'X' => Time.at(0)
+      }
     end
+  end
 
-    def add_ack(ack)
-        @acks << ack
-
-        if @acks.length > @size
-            @acks.shift
-        end
+  def acks
+    @acks_mutex.synchronize do
+      return @acks.dup
     end
+  end
+
+  def add_ack(ack)
+    @acks_mutex.synchronize do
+      @acks << ack
 
+      @acks.shift if @acks.length > @size
+    end
+  end
 end

data/lib/session.rb

@@ -2,228 +2,224 @@
 # sharable_constant_value: literal
 
 module SPing
+  class SessionError < StandardError; end
+  class TCPHandshakeError < SessionError; end
 
-    class SessionError < StandardError; end
-    class TCPHandshakeError < SessionError; end
+  class Session
+    attr_reader :created, :last_rx, :madebyme
+    attr_accessor :session_id, :tcp_handshake_complete, :udp_handshake_complete
 
-    class Session
+    require 'socket'
+    require 'timeout'
+    require 'msgpack'
+    require_relative 'last_acks'
 
-        attr_reader :created, :last_rx, :madebyme
-        attr_accessor :session_id, :tcp_handshake_complete, :udp_handshake_complete
+    def initialize(host, port, socket, madebyme)
+      @host = host
+      @port = port
+      @socket = socket
+      @created = Time.now
+      @madebyme = madebyme
 
-        require 'socket'
-        require 'timeout'
-        require 'msgpack'
-        require_relative 'last_acks'
+      @tcp_handshake_complete = false
+      @udp_handshake_complete = false
 
-        def initialize(host, port, socket, madebyme)
-            @host = host
-            @port = port
-            @socket = socket
-            @created = Time.now
-            @madebyme = madebyme
+      @last_acks = LastAcks.new
+    end
 
-            @tcp_handshake_complete = false
-            @udp_handshake_complete = false
+    def do_tcp_handshake1(socket, session_id)
+      socket.write "sping-0.3-https://codeberg.org/mark22k/sping\r\n"
+      socket.flush
 
-            @last_acks = LastAcks.new
-        end
+      invite = socket.readpartial 6
 
-        def do_tcp_handshake1(socket, session_id)
-            socket.write "sping-0.3-https://codeberg.org/mark22k/sping\r\n"
-            socket.flush
+      raise TCPHandshakeError, 'Peer didn\'t invite us.' unless invite.chomp == 'INVITE'
 
-            invite = socket.readpartial 6
+      @session_id = session_id
 
-            if invite.chomp != "INVITE"
-                raise TCPHandshakeError, 'Peer didn\'t invite us.'
-            end
+      socket.write "#{session_id}\r\n"
+      socket.flush
 
-            @session_id = session_id
+      socket.close
 
-            socket.write "#{session_id}\r\n"
-            socket.flush
+      @tcp_handshake_complete = true
+    end
 
-            socket.close
+    def do_tcp_handshake2
+      socket = TCPSocket.new @host, @port
+      banner = socket.readpartial 9001
+      if banner.length > 9000
+        socket.close
+        raise TCPHandshakeError, 'Host banner too big'
+      end
 
-            @tcp_handshake_complete = true
-        end
+      unless banner.start_with? 'sping-0.3-'
+        socket.close
+        raise TCPHandshakeError, 'Host banner not sping'
+      end
 
-        def do_tcp_handshake2
-            socket = TCPSocket.new @host, @port
-            banner = socket.readpartial 9001
-            if banner.length > 9000
-                socket.close
-                raise TCPHandshakeError, 'Host banner too big'
-            end
+      @remote_version = banner.chomp
+      $logger.info "Peer uses the following program version: #{@remote_version.dump}"
 
-            if ! banner.start_with? 'sping-0.3-'
-                socket.close
-                raise TCPHandshakeError, 'Host banner not sping'
-            end
+      socket.write "INVITE\r\n"
+      socket.flush
 
-            @remote_version = banner.chomp
-            $logger.info "Peer uses the following program version: #{@remote_version.dump}"
+      invite_buf = socket.readpartial 32
+      if invite_buf.length > 31 || invite_buf.empty?
+        socket.close
+        raise TCPHandshakeError, 'Invite banner wrong size'
+      end
 
-            socket.write "INVITE\r\n"
-            socket.flush
+      @session_id = invite_buf.chomp.to_i
 
-            inviteBuf = socket.readpartial 32
-            if inviteBuf.length > 31 || inviteBuf.length.zero?
-                socket.close
-                raise TCPHandshakeError, 'Invite banner wrong size'
-            end
+      socket.close
 
-            @session_id = inviteBuf.chomp.to_i
+      @tcp_handshake_complete = true
+    end
 
-            socket.close
+    def set_endpoint(host, port)
+      @host = host
+      @port = port
+    end
 
-            @tcp_handshake_complete = true
-        end
+    def start_udp_handshake_sender(send_interval = 5)
+      raise 'UDP handshake sender is already running.' if @udp_handshake_sender
 
-        def set_endpoint(host, port)
-            @host = host
-            @port = port
+      @udp_handshake_sender = Thread.new(send_interval) do |th_send_interval|
+        loop do
+          send_udp_handshake
+          sleep th_send_interval
         end
+      end
+    end
 
-        def start_udp_handshake_sender(send_interval = 5)
-            raise 'UDP handshake sender is already running.' if @udp_handshake_sender
+    def send_udp_handshake
+      packet = {
+        'Y' => 'h'.ord,
+        'M' => 11_181,
+        'V' => 3,
+        'S' => @session_id
+      }.to_msgpack
 
-            @udp_handshake_sender = Thread.new(send_interval) do |send_interval|
-                loop do
-                    self.send_udp_handshake
-                    sleep send_interval
-                end
-            end
-        end
+      $logger.debug "Send UDP handshake to #{@host} port #{@port}."
+      @socket.send packet, 0, @host, @port
+    end
 
-        def send_udp_handshake
-            packet = {
-                'Y' => 'h'.ord,
-                'M' => 11181,
-                'V' => 3,
-                'S' => @session_id
-            }.to_msgpack
+    def stop_udp_handshake_sender
+      raise 'UDP handshake sender is not running and therefore cannot be terminated.' unless @udp_handshake_sender
 
-            $logger.debug "Send UDP handshake to #{@host} port #{@port}."
-            @socket.send packet, 0, @host, @port
-        end
+      @udp_handshake_sender.kill
+      @udp_handshake_sender = nil
+    end
 
-        def stop_udp_handshake_sender
-            raise 'UDP handshake sender is not running and therefore cannot be terminated.' unless @udp_handshake_sender
-            @udp_handshake_sender.kill
-            @udp_handshake_sender = nil
-        end
+    def udp_handshake_recived
+      stop_udp_handshake_sender if @madebyme
+      @udp_handshake_complete = true
+    end
+
+    def start_pinger
+      raise 'Pinger is already running.' if @pinger
 
-        def udp_handshake_recived
-            stop_udp_handshake_sender if @madebyme
-            @udp_handshake_complete = true
+      @pinger = Thread.new do
+        loop do
+          ping
+          sleep 1
         end
+      end
+    end
 
-        def start_pinger
-            raise 'Pinger is already running.' if @pinger
+    def stop_pinger
+      raise 'Pinger sender is not running and therefore cannot be terminated.' unless @pinger
 
-            @pinger = Thread.new do
-                loop do
-                    self.ping
-                    sleep 1
-                end
-            end
-        end
+      @pinger.kill
+      @pinger = nil
+    end
 
-        def stop_pinger
-            raise 'Pinger sender is not running and therefore cannot be terminated.' unless @pinger
-            @pinger.kill
-            @pinger = nil
-        end
+    def ping
+      current_id = (Time.now.to_i % 255) + 1
+      data = {
+        'Y' => 't'.ord,
+        'M' => 11_181,
+        'S' => @session_id,
+        'I' => current_id,
+        'T' => Time.now,
+        'E' => 0,
+        'A' => @last_acks.acks
+      }.to_msgpack
+
+      $logger.debug "Send ping to #{@host} port #{@port}."
+      @socket.send data, 0, @host, @port
+    end
 
-        def ping
-            current_id = Time.now.to_i % 255 + 1
-            data = {
-                'Y' => 't'.ord,
-                'M' => 11181,
-                'S' => @session_id,
-                'I' => current_id,
-                'T' => Time.now,
-                'E' => 0,
-                'A' => @last_acks.acks
-            }.to_msgpack
-
-            $logger.debug "Send ping to #{@host} port #{@port}."
-            @socket.send data, 0, @host, @port
-        end
+    def stop
+      @pinger&.kill
+      @udp_handshake_sender&.kill
+    end
+
+    def handle_ping(packet, rxtime, peeraddr)
+      if packet['E'] != 0
+        $logger.error "Package displays an error message: #{packet['E']} Processing aborted."
+        return
+      end
+
+      id = packet['I']
+      txtime = packet['T']
+      remote_last_acks = packet['A']
+
+      ack = {
+        'R' => id,
+        'U' => txtime,
+        'X' => rxtime
+      }
+
+      @last_acks.add_ack(ack)
+      @last_rx = rxtime
+
+      # This is the A
+      # The peer is B
+      # TX => Time from A to B
+      # RX => Time from B to A
+
+      # Remove zero acks
+      remote_last_acks.reject! { |block_ack| block_ack['R'].zero? }
+
+      # Sort by TX time
+      remote_last_acks.sort_by! { |block_ack| block_ack['U'] }
+
+      newest_remote_ack = remote_last_acks.last.to_h
+
+      # Calculate loss
+      tx_loss = 0
+      rx_loss = 0
+      exchanges = 0
+
+      if remote_last_acks.length == 32
+        # We have enough data
+        exchanges = 32
+        remote_acks = remote_last_acks.map { |ack| ack['R'] }
+        local_acks = @last_acks.acks.map { |ack| ack['R'] }
+
+        tip_id = (Time.now.to_i % 255) + 1
+        starting = tip_id - 32
+
+        last_ids = if tip_id > 32
+                     (starting..tip_id).to_a
+                   else
+                     ((255 + starting)..255).to_a + (1..tip_id).to_a
+                   end
 
-        def stop
-            @pinger&.kill
-            @udp_handshake_sender&.kill
+        last_ids[0...-1].each do |id|
+          tx_loss += 1 unless remote_acks.include? id
         end
 
-        def handle_ping packet, rxtime, peeraddr
-            if packet['E'] != 0
-                $logger.error "Package displays an error message: #{packet['E']} Processing aborted."
-                return
-            end
-
-            id = packet['I']
-            txtime = packet['T']
-            lastAcks = packet['A']
-
-            ack = {
-                'R' => id,
-                'U' => txtime,
-                'X' => rxtime
-            }
-
-            @last_acks.add_ack(ack)
-            @last_rx = rxtime
-
-            # This is the A
-            # The peer is B
-            # TX => Time from A to B
-            # RX => Time from B to A
-
-            # Remove zero acks
-            lastAcks.reject! { |ack| ack['R'] == 0 }
-
-            # Sort by TX time
-            lastAcks.sort_by! { |ack| ack['U'] }
-
-            newest_remote_ack = lastAcks.last.to_h
-
-            # Calculate loss
-            tx_loss = 0
-            rx_loss = 0
-            exchanges = 0
-
-            if lastAcks.length == 32
-                # We have enough data
-                exchanges = 32
-                remote_acks = lastAcks.map { |ack| ack['R'] }
-                local_acks = @last_acks.acks.map { |ack| ack['R'] }
-
-                tip_id = Time.now.to_i % 255 + 1
-                starting = tip_id - 32
-
-                last_ids = nil
-                if tip_id > 32
-                    last_ids = (starting..tip_id).to_a
-                else
-                    last_ids = ((255 + starting)..255).to_a + (1..tip_id).to_a
-                end
-
-                last_ids[0...-1].each do |id|
-                    tx_loss += 1 unless remote_acks.include? id
-                end
-
-                last_ids[1..-1].each do |id|
-                    rx_loss += 1 unless local_acks.include? id
-                end
-            end
-
-            tx_latency = ((newest_remote_ack['X'].to_f - newest_remote_ack['U'].to_f) * 1000.0).round(6)
-            rx_latency = ((rxtime - txtime) * 1000.0).round(6)
-            puts "[#{peeraddr}] RX: #{rx_latency}ms TX: #{tx_latency}ms [Loss RX: #{rx_loss}/#{exchanges} | Loss TX: #{tx_loss}/#{exchanges}]"
+        last_ids[1..].each do |id|
+          rx_loss += 1 unless local_acks.include? id
         end
+      end
 
+      tx_latency = ((newest_remote_ack['X'].to_f - newest_remote_ack['U'].to_f) * 1000.0).round(6)
+      rx_latency = ((rxtime - txtime) * 1000.0).round(6)
+      puts "[#{peeraddr}] RX: #{rx_latency}ms TX: #{tx_latency}ms [Loss RX: #{rx_loss}/#{exchanges} | Loss TX: #{tx_loss}/#{exchanges}]"
     end
+  end
 end

data/lib/session_manager.rb

@@ -2,261 +2,275 @@
 # sharable_constant_value: literal
 
 module SPing
+  class SessionManagerError < StandardError; end
+  class OutOfSessions < SessionManagerError; end
 
-    class SessionManagerError < StandardError; end
-    class OutOfSessions < SessionManagerError; end
+  class SessionManager
+    require 'socket'
+    require 'timeout'
+    require_relative 'session'
 
-    class SessionManager
+    def initialize(host = '::', port = 6924)
+      @host = host
+      @port = port
 
-        require 'socket'
-        require 'timeout'
-        require_relative 'session'
+      @sessions = {}
+      @sessions_mutex = Mutex.new
 
-        def initialize(port = 6924)
-            @port = port
+      @socket = UDPSocket.new(Socket::AF_INET6)
+      @socket.bind @host, @port
+    end
 
-            @sessions = {}
-            @pingers = {}
+    def new_session(host, port = 6924)
+      $logger.info "Add new session for host #{host} port #{port}."
+      session = SPing::Session.new host, port, @socket, true
 
-            @socket = UDPSocket.new(Socket::AF_INET6)
-            @socket.bind "::", @port
-        end
+      counter = 0
+      loop do
+        session_id = request_session session
+        break if session_id
 
-        def new_session(host, port = 6924)
-            $logger.info "Add new session for host #{host} port #{port}."
-            session = SPing::Session.new host, port, @socket, true
-
-            begin
-                counter = 0
-                loop do
-                    begin
-                        session.do_tcp_handshake2
-                    rescue Errno::ECONNRESET, EOFError, IO::TimeoutError, TCPHandshakeError => e
-                        $logger.warn "TCP handshake failed: #{e.message}"
-                        return
-                    end
-                    if ! @sessions.key? session.session_id
-                        break
-                    end
-                    if counter > 5
-                        raise OutOfSessions, 'The peer could not name a session ID that had not yet been assigned.'
-                    end
-                    counter += 1
-                end
-            rescue OutOfSessions => e
-                $logger.error "Out of session: #{e.message}"
-                return
-            end
-
-            $logger.info "TCP handshake for host #{host} port #{port} successful. Session ID is #{session.session_id}."
-
-            $logger.info "Perform UDP handshake for session ID #{session.session_id}."
-            session.start_udp_handshake_sender
-
-            @sessions[session.session_id] = session
+        # rubocop:disable Style/IfUnlessModifier
+        if counter > 5
+          raise OutOfSessions, 'The peer could not name a session ID that had not yet been assigned.'
         end
+        # rubocop:enable Style/IfUnlessModifier
 
-        def del_session(session_id)
-            $logger.debug "Delete session with session id #{session_id}"
+        counter += 1
+      end
 
-            @sessions[session_id].stop
-            @sessions.delete(session_id)
-        end
+      $logger.info "TCP handshake for host #{host} port #{port} successful. Session ID is #{session.session_id}."
 
-        def stop_sessions
-            @sessions.each do |session_id, session|
-                session.stop
-            end
-        end
+      $logger.info "Perform UDP handshake for session ID #{session.session_id}."
+      session.start_udp_handshake_sender
+    rescue Errno::ECONNRESET, EOFError, IO::TimeoutError, TCPHandshakeError => e
+      $logger.warn "TCP handshake failed: #{e.message}"
+    rescue OutOfSessions => e
+      $logger.error "Out of session: #{e.message}"
+    end
 
-        def join
-            @runner&.join
-            @gc_thread&.join
-            @server_thread&.join
-        end
+    def del_session(session_id)
+      $logger.debug "Delete session with session id #{session_id}"
 
-        def run
-            raise 'Client is already running.' if @runner
-            raise 'GC is already running.' if @gc
-
-            @runner = Thread.new do
-                loop do
-                    Thread.new(@socket.recvfrom(10000)) do |buf|
-                        handle_packet buf
-                    end
-                end
-            end
-            @gc_thread = Thread.new do
-                loop do
-                    do_gc
-                    sleep 10
-                end
-            end
-        end
+      @sessions_mutex.synchronize do
+        @sessions[session_id].stop
+        @sessions.delete(session_id)
+      end
+    end
 
-        def run_server
-            raise 'Server is already running.' if @server_thread
-            raise 'Server already exist.' if @server
+    def stop_sessions
+      @sessions.each do |_session_id, session|
+        session.stop
+      end
+    end
 
-            @server = TCPServer.new '::', @port
+    def join
+      @runner&.join
+      @gc_thread&.join
+      @server_thread&.join
+    end
 
-            @server_thread = Thread.new do
-                loop do
-                    Thread.new(@server.accept) do |client|
-                        handle_client client
-                    end
-                end
-            end
+    def run
+      raise 'Client is already running.' if @runner
+      raise 'GC is already running.' if @gc
 
-            return @server_thread
+      @runner = Thread.new do
+        loop do
+          Thread.new(@socket.recvfrom(10_000)) do |buf|
+            handle_packet buf
+          end
         end
+      end
+      @gc_thread = Thread.new do
+        loop do
+          do_gc
+          sleep 10
+        end
+      end
+    end
 
-        def stop_server
-            raise 'Server thread is not running.' unless @server_thread
-
-            @server_thread.kill
-            @server_thread = nil
+    def run_server
+      raise 'Server is already running.' if @server_thread
+      raise 'Server already exist.' if @server
 
-            raise 'Server is not running.' unless @server
+      @server = TCPServer.new @host, @port
 
-            @server.close
-            @server = nil
+      @server_thread = Thread.new do
+        loop do
+          Thread.new(@server.accept) do |client|
+            handle_client client
+          end
         end
+      end
 
-        def stop
-            raise 'Session manager is not running.' unless @runner
+      return @server_thread
+    end
 
-            @runner.kill
-            @runner = nil
+    def stop_server
+      raise 'Server thread is not running.' unless @server_thread
 
-            raise 'Session GC is not running.' unless @gc_thread
+      @server_thread.kill
+      @server_thread = nil
 
-            @gc_thread.kill
-            @gc_thread = nil
-        end
+      raise 'Server is not running.' unless @server
 
-        def generate_session_id
-            Timeout::timeout(30, OutOfSessions, 'No session ID could be generated which has not yet been used.') do
-                session_id = rand(2 ** 32 - 1)
-                while @sessions.key? session_id
-                    session_id = rand(2 ** 32 - 1)
-                end
+      @server.close
+      @server = nil
+    end
+
+    def stop
+      raise 'Session manager is not running.' unless @runner
+
+      @runner.kill
+      @runner = nil
 
-                return session_id
-            end
+      raise 'Session GC is not running.' unless @gc_thread
+
+      @gc_thread.kill
+      @gc_thread = nil
+    end
+
+    def generate_session_id
+      Timeout.timeout(30, OutOfSessions, 'No session ID could be generated which has not yet been used.') do
+        loop do
+          session_id = rand (2**32) - 1
+          return session_id unless @sessions.key? session_id
         end
+      end
+    end
 
-        private
-
-        def do_gc
-            $logger.debug 'Remove outdated sessions.'
-            @sessions.keys.each do |session_id|
-                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.
-                if ! (session.tcp_handshake_complete && session.udp_handshake_complete)
-                    # Handshake incomplete
-                    if (Time.now.to_i - session.created.to_i) > 60
-                        # TCP and/or UDP take more than 60 seconds.
-                        $logger.debug "UDP handshake for session id #{session_id} timed out."
-                        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.
-                    $logger.debug "Session id #{session_id} without activity for over thirty seconds."
-                    del_session session_id
-                end
-            end
+    private
+
+    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,
+      # 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.
+        if !(session.tcp_handshake_complete && session.udp_handshake_complete)
+          # Handshake incomplete
+          if (Time.now.to_i - session.created.to_i) > 60
+            # TCP and/or UDP take more than 60 seconds.
+            $logger.debug "UDP handshake for session id #{session_id} timed out."
+            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.
+          $logger.debug "Session id #{session_id} without activity for over thirty seconds."
+          del_session session_id
         end
+      end
+    end
 
-        def handle_packet buf
-            rxtime = Time.now
-
-            peeraddr = buf[1][2]
-            peerport = buf[1][1]
-            $logger.debug "Packet received from #{peeraddr} port #{peerport}."
-
-            packet = MessagePack.unpack(buf[0])
-
-            # Check whether the Magic Number is the correct one.
-            if packet['M'] != 11181
-                $logger.warn 'Package contains incorrect magic number. Processing is canceled.'
-                return
-            end
-
-            type = packet['Y'].chr
-            case type
-            when 'h'
-                handle_udp_handshake packet, peeraddr, peerport
-            when 't'
-                handle_ping packet, rxtime, peeraddr, peerport
-            else
-                $logger.warn "Package is of unknown type: #{type}"
-            end
+    def request_session(session)
+      session.do_tcp_handshake2
+
+      @sessions_mutex.synchronize do
+        unless @sessions.key? session.session_id
+          @sessions[session.session_id] = session
+          return session.session_id
         end
+      end
+
+      return nil
+    end
+
+    def handle_packet(buf)
+      rxtime = Time.now
+
+      peeraddr = buf[1][2]
+      peerport = buf[1][1]
+      $logger.debug "Packet received from #{peeraddr} port #{peerport}."
+
+      packet = MessagePack.unpack(buf[0])
+
+      # 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
+      end
+
+      type = packet['Y'].chr
+      case type
+      when 'h'
+        handle_udp_handshake packet, peeraddr, peerport
+      when 't'
+        handle_ping packet, rxtime, peeraddr, peerport
+      else
+        $logger.warn "Package is of unknown type: #{type}"
+      end
+    end
 
-        def handle_udp_handshake packet, peeraddr, peerport
-            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
-
-                session.set_endpoint peeraddr, peerport
-
-                if ! 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."
-
-                session.start_pinger
-            else
-                $logger.warn 'UDP handshake received for uninitiated session.'
-                return
-            end
+    def handle_udp_handshake(packet, peeraddr, peerport)
+      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
 
-        def handle_ping packet, rxtime, peeraddr, peerport
-            session_id = packet['S']
-            session = @sessions[session_id]
-            if session && 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}."
-            end
+        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
 
-        def handle_client(client)
-            host = client.peeraddr[3]
-            port = client.peeraddr[1]
-            session = SPing::Session.new host, port, @socket, false
-
-            $logger.debug "Session request from host #{host} port #{port}."
-
-            begin
-                session.do_tcp_handshake1 client, self.generate_session_id
-            rescue Errno::ECONNRESET, EOFError, IO::TimeoutError, TCPHandshakeError => e
-                $logger.warn "Could not establish a new session with Peer: #{e.message}"
-                return
-            rescue OutOfSessions => e
-                $logger.error "Could not establish a new session with Peer: #{e.message}"
-                return
-            end
-        
-            @sessions[session.session_id] = 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
+      else
+        $logger.warn 'UDP handshake received for uninitiated session.'
+        return
+      end
+    end
+
+    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}."
+      end
+    end
+
+    def handle_client(client)
+      host = client.peeraddr[3]
+      port = client.peeraddr[1]
+      session = SPing::Session.new host, port, @socket, false
+
+      $logger.debug "Session request from host #{host} port #{port}."
+
+      session_id = nil
+
+      @sessions_mutex.synchronize do
+        session_id = generate_session_id
+        @sessions[session_id] = session
+      end
+
+      session.do_tcp_handshake1 client, session_id
+    rescue Errno::ECONNRESET, EOFError, IO::TimeoutError, TCPHandshakeError => e
+      $logger.warn "Could not establish a new session with Peer: #{e.message}"
+      del_session session_id
+    rescue OutOfSessions => e
+      $logger.error "Could not establish a new session with Peer: #{e.message}"
+      del_session session_id
     end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sping
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Marek Küthe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-07 00:00:00.000000000 Z
+date: 2023-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack