Kaip užtikrinti garantuotą duomenų pristatymą per UDP protokolą?

UDP garantuotas pristatymas, būdamas bejungimo protokolas ir be garantijos pristatymo, reikalauja patikimumo mechanizmų įgyvendinimo programos lygyje arba naudojant middleware. Pagrindiniai požiūriai apima:

1. Patvirtinimo mechanizmai (Acknowledgements - ACK): Siuntėjas įtraukia į kiekvieną datagramą identifikatorių (pavyzdžiui, eilės numerį). Gavėjas siunčia patvirtinimą apie priėmimą kiekvienam sėkmingai gautam datagramui.
2. Perkėlimo mechanizmai (Retransmission): Siuntėjas nustato laikmatį po datagramos siuntimo. Jei patvirtinimas negaunamas iki laikmačio pabaigos, datagramas laikomas prarastu ir siunčiamas pakartotinai.
3. Dublikato kontrolės mechanizmai: Gavėjas stebi gautų datagramų identifikatorius ir atmeta dublikatus, jei jie atsiranda pakartotinės siuntimo metu.
4. Tvarkos kontrolės mechanizmai: Nors UDP nepažada tvarkos, programa gali naudoti eilės numerius datagramų perrikiavimui gavėjo pusėje.
5. Srauto kontrolė: Jei reikia, galima įgyvendinti mechanizmą, kuris užkerta kelią gavėjo buferio perpildymui.

Šių mechanizmų įgyvendinimas reikalauja daug pastangų programos lygyje arba naudojant specializuotas bibliotekas/protokolus, sukurtus virš UDP, pavyzdžiui:

• Reliable User Datagram Protocol (RUDP): UDP išplėtimas, pridedantis patikimumą.
• Quic: Transporto protokolas, sukurtas Google, veikia virš UDP ir siūlo funkcionalumą, panašų į TCP (patikimumas, srauto valdymas, saugumas), bet su patobulintu jungimosi laiku ir mažesniu paketų praradimo poveikiu.
• Realiam laikui skirtų protokolų su daliniu patikimumu: Pavyzdžiui, Secure Real-time Transport Protocol (SRTP) gali apimti pasirenkamus patikimumo mechanizmus.

Pavyzdinė scheminė logika siuntėjo pusėje:

# pseudo-kodas aiškumui

data_to_send = [...] # datagramų sąrašas
sent_packets = {}    # žodynas: eilės numeris -> (duomenys, siuntimo laikas)
next_seq_num = 0
ack_timeout = 0.1    # sekundės
max_retransmissions = 5

for data in data_to_send:
    packet = (next_seq_num, data)
    send_udp(packet)
    sent_packets[next_seq_num] = (packet, time.time(), 0) # paketas, siuntimo laikas, pakartojimų skaičius
    next_seq_num += 1

while sent_packets:
    # Laukiame patvirtinimo
    acks = receive_acks() # imitacija patvirtinimų gavimo
    for seq_num in acks:
        if seq_num in sent_packets:
            del sent_packets[seq_num] # Pašaliname iš laukiančių patvirtinimo

    # Tikriname laikmačius ir pakartotinai siunčiame
    current_time = time.time()
    packets_to_retransmit = []
    for seq_num, (packet, send_time, retransmit_count) in sent_packets.items():
        if current_time - send_time > ack_timeout:
            if retransmit_count < max_retransmissions:
                packets_to_retransmit.append(seq_num)
            else:
                # Pakenktas galutinai po MaxRetransmissions
                handle_packet_loss(seq_num)
                del sent_packets[seq_num]

    for seq_num in packets_to_retransmit:
        packet, _, retransmit_count = sent_packets[seq_num]
        send_udp(packet)
        sent_packets[seq_num] = (packet, time.time(), retransmit_count + 1) # atnaujinti laiką ir skaičių

Ši realizacija iš esmės sukuria virš UDP patikimumo protokolą, panašų į TCP. Konkretus požiūris priklauso nuo programos reikalavimų (pavyzdžiui, vėlavimo, pralaidumo). Daugeliu atvejų, kai reikalingas patikimumas, geriau naudoti paruoštus protokolus (TCP, QUIC) arba patikrintas bibliotekas.