სანდო მონაცემთა გადაცემის საფუძვლები

მათ, ვინც ცდილობს ეძღვნება ქსელებისა და პროტოკოლების გაგებას.

მოკლედ

სტატიაში განხილულია მონაცემთა საიმედო გადაცემის საფუძვლები, ახორციელებს მაგალითებს Go, მათ შორის UDP და TCP. Დაფუძნებული დრო, два, სამ და წიგნები "კომპიუტერული ქსელები. ზემოდან ქვემოთ მიდგომა", თორემ ყველა განიხილავს მხოლოდ ტანენბაუმს და ოლიფეროვს.

სატრანსპორტო ფენის პროტოკოლი

უზრუნველყოფს ლოგიკურ კავშირს სხვადასხვა ჰოსტზე გაშვებულ აპლიკაციის პროცესებს შორის. აპლიკაციის თვალსაზრისით, ლოგიკური კავშირი ჰგავს არხს, რომელიც პირდაპირ აკავშირებს პროცესებს.

სატრანსპორტო ფენის პროტოკოლები მხარდაჭერილია ბოლო სისტემებით, მაგრამ არა ქსელის მარშრუტიზატორებით (გარდა - DPI). გამგზავნის მხარეს, სატრანსპორტო ფენა გარდაქმნის აპლიკაციის ფენის მონაცემებს, რომელსაც იგი იღებს განაცხადის გაგზავნის პროცესიდან სატრანსპორტო ფენის პაკეტებად, რომელსაც სეგმენტები ეწოდება.

ეს ხდება აპლიკაციის ფენის შეტყობინებების ფრაგმენტებად დაყოფით (საჭიროების შემთხვევაში) და თითოეულ მათგანს სატრანსპორტო ფენის სათაურის დამატებით.

სატრანსპორტო ფენა შემდეგ გადასცემს სეგმენტს გამგზავნის ქსელის შრეში, სადაც სეგმენტი ჩასმულია ქსელის ფენის პაკეტში (მონაცემთაგრამა) და იგზავნება. მიმღების ბოლოში, ქსელის ფენა ამოიღებს სატრანსპორტო ფენის სეგმენტს დატაგრამიდან და გადასცემს მას სატრანსპორტო ფენას. შემდეგი, სატრანსპორტო ფენა ამუშავებს მიღებულ სეგმენტს ისე, რომ მისი მონაცემები ხელმისაწვდომი გახდეს მიმღები განაცხადისთვის.

მონაცემთა საიმედო გადაცემის პრინციპები

მონაცემთა საიმედო გადაცემა სრულიად უსაფრთხო არხზე

უმარტივესი შემთხვევა. გაგზავნის მხარე უბრალოდ იღებს მონაცემებს ზედა ფენიდან, ქმნის მის შემცველ პაკეტს და აგზავნის არხზე.

სერვერი

package main

import (
    "log"
    "net"
)

func main() {
    // IP-адрес сервера и порт
    serverAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:12000")
    if err != nil {
        log.Fatal(err)
    }

    // создаем сокет с портом
    serverConn, err := net.ListenUDP("udp", serverAddr)
    if err != nil {
        log.Fatal(err)
    }
    // отложенное закрытие соединения
    defer serverConn.Close()

    // создаем буфер для данных
    buf := make([]byte, 1024)

    // ждем соединение
    for {
        // читаем запрос
        n, addr, err := serverConn.ReadFromUDP(buf)
        // передаем данные в ВЕРХНИЙ уровень: в нашем случае stdout
        println(string(buf[0:n]), " form ", addr.IP.String())
        if err != nil {
            log.Fatal(err)
        }
        // ответа нет, т.к. это UDP + надежный канал
    }
}

დამკვეთი

package main

import (
    "fmt"
    "log"
    "net"
    "time"
)

func main() {
    // IP-адрес сервера и порт
    serverAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:12000")
    if err != nil {
        log.Fatal(err)
    }
    // локальный IP-адрес и порт
    localAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
    if err != nil {
        log.Fatal(err)
    }
    // установка соединения
    conn, err := net.DialUDP("udp", localAddr, serverAddr)
    if err != nil {
        log.Fatal(err)
    }
    // отложенное закрытие соединения
    defer conn.Close()

    for {
        // получение данных от ВЕРХНЕГО уровня
        fmt.Print("Введите строчное предложение > ")
        var msg string
        _, err := fmt.Scanf("%s", &msg)
        if err != nil {
            log.Fatal(err)
        }
        // передается поток байт, а не строка
        buf := []byte(msg)
        // запись (передача) в соединение
        _, err = conn.Write(buf)
        if err != nil {
            log.Fatal(err)
        }
        // 1 секундочку
        time.Sleep(time.Second * 1)
    }
}

მონაცემთა საიმედო გადაცემა არხზე შესაძლო შეცდომებით

შემდეგი ნაბიჯი არის ვივარაუდოთ, რომ ყველა გადაცემული პაკეტი მიიღება იმ თანმიმდევრობით, რომლითაც ისინი გაგზავნეს, მაგრამ მათში არსებული ბიტები შეიძლება დაზიანდეს იმის გამო, რომ არხი ზოგჯერ გადასცემს მონაცემებს დამახინჯებით.

ამ შემთხვევაში გამოიყენება შემდეგი მექანიზმები:

• შეცდომის გამოვლენა;
• უკუკავშირი;
• ხელახალი გადაცემა.

მონაცემთა გადაცემის სანდო პროტოკოლებს, რომლებსაც აქვთ გადაცემის მრავალჯერ გამეორების მსგავსი მექანიზმები, ეწოდება Automatic Repeat ReQuest (ARQ) პროტოკოლები.
გარდა ამისა, გასათვალისწინებელია ქვითრებში შეცდომების შესაძლებლობა, როდესაც მიმღები მხარე არ მიიღებს ინფორმაციას ბოლო პაკეტის გადაცემის შედეგების შესახებ.
ამ პრობლემის გადაწყვეტა, რომელიც ასევე გამოიყენება TCP-ში, არის მონაცემთა პაკეტში ახალი ველის დამატება, რომელიც შეიცავს პაკეტის რიგით ნომერს.

მონაცემთა საიმედო გადაცემა არასანდო არხზე, რომელიც ექვემდებარება პაკეტის დამახინჯებას და დაკარგვას

დამახინჯებასთან ერთად, სამწუხაროდ, ქსელში ხდება პაკეტების დაკარგვა.
და ამ პრობლემის გადასაჭრელად საჭიროა მექანიზმები:

• პაკეტის დაკარგვის ფაქტის დადგენა;
• დაკარგული პაკეტების ხელახალი მიწოდება მიმღებ მხარეს.

გარდა ამისა, პაკეტის დაკარგვის გარდა, აუცილებელია ქვითრის დაკარგვის ან, თუ არაფერი დაიკარგა, მისი მიწოდება მნიშვნელოვანი დაგვიანებით. ყველა შემთხვევაში, იგივე კეთდება: პაკეტი ხელახლა იგზავნება. დროის გასაკონტროლებლად ეს მექანიზმი იყენებს უკუმთვლელ ტაიმერს, რომელიც საშუალებას გაძლევთ განსაზღვროთ ლოდინის ინტერვალის დასასრული. ასე რომ, პაკეტში წმინდა TCPKeepAlive ნაგულისხმევად დაყენებულია 15 წამზე:

// defaultTCPKeepAlive is a default constant value for TCPKeepAlive times
// See golang.org/issue/31510
const (
    defaultTCPKeepAlive = 15 * time.Second
)

გაგზავნის მხარემ უნდა დაიწყოს ტაიმერი ყოველ ჯერზე პაკეტის გადაცემისას (პირველად და მეორედ), გაუმკლავდეს ტაიმერის შეფერხებებს და შეაჩეროს იგი.

ასე რომ, ჩვენ გავეცანით საიმედო მონაცემთა გადაცემის პროტოკოლების ძირითად ცნებებს:

• საკონტროლო ჯამები;
• პაკეტების თანმიმდევრული ნომრები;
• ტაიმერები;
• დადებითი და უარყოფითი ქვითრები.

მაგრამ ეს ყველაფერი არ არის!

სანდო მონაცემთა გადაცემის პროტოკოლი მილსადენით

იმ ვარიანტში, რომელიც უკვე განვიხილეთ, მიწოდების საიმედო პროტოკოლი ძალიან არაეფექტურია. ის იწყებს საკომუნიკაციო არხის მიერ მოწოდებული გადაცემის „შენელებას“, როდესაც RTT იზრდება. მისი ეფექტურობის გასაზრდელად და საკომუნიკაციო არხის სიმძლავრის უკეთ გამოსაყენებლად გამოიყენება მილსადენი.

მილსადენის გამოყენება იწვევს:

• მიმდევრობის რიცხვების დიაპაზონის გაზრდა, ვინაიდან ყველა გაგზავნილი პაკეტი (გარდა ხელახალი გადაცემისა) უნდა იყოს ცალსახად იდენტიფიცირებული;
• გადამცემ და მიმღებ მხარეებზე ბუფერების გაზრდის აუცილებლობა.

თანმიმდევრობის რიცხვის დიაპაზონი და ბუფერის ზომის მოთხოვნები დამოკიდებულია იმ ქმედებებზე, რომლებსაც პროტოკოლი ახორციელებს პაკეტის კორუფციის, დაკარგვისა და დაგვიანების საპასუხოდ. მილსადენის შემთხვევაში, შეცდომების გამოსწორების ორი გზა არსებობს:

• N პაკეტის უკან დაბრუნება;
• შერჩევითი გამეორება.

N პაკეტის უკან დაბრუნება - მოცურების ფანჯრის პროტოკოლი

გამგზავნმა უნდა მხარი დაუჭიროს სამი სახის მოვლენას:

• დარეკვა უფრო მაღალი დონის პროტოკოლით. როდესაც მონაცემთა გაგზავნის ფუნქციას უწოდებენ "ზემოდან", გაგზავნის მხარე ჯერ ამოწმებს ფანჯრის შევსების ხარისხს (ანუ N გაგზავნილი შეტყობინებების არსებობა, რომლებიც ელოდება ქვითრების მიღებას). თუ ფანჯარა ცარიელია, ახალი პაკეტი გენერირებული და გადაცემულია და ცვლადი მნიშვნელობები განახლდება. წინააღმდეგ შემთხვევაში, გაგზავნის მხარე აბრუნებს მონაცემებს ზედა ფენაში და ეს არის იმპლიციტური მითითება, რომ ფანჯარა სავსეა. როგორც წესი, ზედა ფენა შეეცდება მონაცემთა გადაცემას გარკვეული დროის შემდეგ. რეალურ აპლიკაციაში, გამომგზავნი სავარაუდოდ ან ბუფერული იქნება მონაცემების (ნაცვლად დაუყოვნებლივ გაგზავნის ნაცვლად) ან სინქრონიზაციის მექანიზმს (როგორიცაა სემაფორი ან დროშა), რომელიც ზედა ფენას საშუალებას მისცემს გამოიძახოს გაგზავნის ფუნქცია მხოლოდ მაშინ, როდესაც ფანჯარა ცარიელია. .
• დადასტურების მიღება. პროტოკოლში, N მიმდევრობითი ნომრის მქონე პაკეტისთვის, გაიცემა ზოგადი აღიარება, რომელიც მიუთითებს, რომ N-ის წინა ნომრის მქონე ყველა პაკეტი წარმატებით იქნა მიღებული.
• ლოდინის ინტერვალი ამოიწურა. პაკეტების და ქვითრების დაკარგვისა და დაგვიანების ფაქტების დასადგენად, პროტოკოლი იყენებს ტაიმერს. თუ ვადის ამოწურვის ინტერვალი ამოიწურება, გამგზავნი მხარე ხელახლა აგზავნის ყველა გაგზავნილ დაუდასტურებელ პაკეტს.

შერჩევითი გამეორება

როდესაც ფანჯრის ზომა და გამტარუნარიანობა-გავრცელების დაყოვნების პროდუქტი დიდია, დიდი რაოდენობით პაკეტები შეიძლება იყოს მილსადენში. ასეთ შემთხვევაში, ერთი პაკეტის შეცდომამ შეიძლება გამოიწვიოს დიდი რაოდენობის პაკეტების ხელახალი გადაცემა, რომელთა უმეტესობა არ იყო საჭირო.

მაგალითი

დაბრუნება თეორიული პრაქტიკაში გროვდება პრაქტიკა TCP. და თუ ვინმემ იცის საუკეთესოდ - მისასალმებელი.

სერვერი

package main

import (
    "bufio"
    "fmt"
    "log"
    "net"
    "strings"
)

func main() {
    // создаем сокет с портом 
    ln, err := net.Listen("tcp", ":8081")
    if err != nil {
        log.Fatalln(err)
    }
    // ожидание вызова
    conn, _ := ln.Accept()

    for {
        // считывание данных
        msg, err := bufio.NewReader(conn).ReadString('n')
        if err != nil {
            log.Fatalln(err)
        }
        // вывод сообщения в stdout
        fmt.Print("Message Received:", string(msg))
        // перевод строки в верхний регистр
        newMsg := strings.ToUpper(msg)
        // отправка данных
        conn.Write([]byte(newMsg + "n"))
    }
}

დამკვეთი

package main

import (
    "bufio"
    "fmt"
    "log"
    "net"
    "os"
)

func main() {
    // установка соединения
    conn, err := net.Dial("tcp", "127.0.0.1:8081")
    if err != nil {
        log.Fatalln(err)
    }

    for {
        // считывание данных с stdin
        reader := bufio.NewReader(os.Stdin)
        fmt.Print("Text to send: ")
        // построчно
        text, err := reader.ReadString('n')
        if err != nil {
            log.Fatalln(err)
        }
        // отправка
        fmt.Fprintf(conn, text+"n")
        // прием
        msg, err := bufio.NewReader(conn).ReadString('n')
        if err != nil {
            log.Fatalln(err)
        }
        // вывод полученного ответа
        fmt.Print("Msg from Server: " + msg)
    }
}

გამოყვანის

მექანიზმები მონაცემთა საიმედო გადაცემისა და გამოყენების უზრუნველსაყოფად

მექანიზმი
განცხადება, კომენტარი

შეამოწმეთ ჯამი
გამოიყენება გადაცემულ პაკეტში ბიტის შეცდომების დასადგენად

ტაიმერი
ითვლის დროის ამოწურვის ინტერვალს და მიუთითებს, როდის გავიდა ის. ეს უკანასკნელი ნიშნავს, რომ დიდი ალბათობით პაკეტი ან მისი მიღება იკარგება გადაცემის დროს. თუ პაკეტი მიეწოდება დაგვიანებით, მაგრამ არ დაიკარგება (დროის ვადაზე ადრე გასვლა), ან ქვითარი დაიკარგა, ხელახალი გადაცემა იწვევს პაკეტს დუბლიკატამდე მიმღებ მხარეს.

Სერიული ნომერი
გამოიყენება გამგზავნიდან მიმღებამდე გადაცემული მონაცემთა პაკეტების თანმიმდევრული ნუმერაციისთვის. მიღებული პაკეტების რიგით ნომრებში არსებული ხარვეზები მიმღებს საშუალებას აძლევს აღმოაჩინოს პაკეტის დაკარგვა. იგივე პაკეტის თანმიმდევრული ნომრები ნიშნავს, რომ პაკეტები ერთმანეთის დუბლიკატებია

დადასტურება
გენერირებულია მიმღების მიერ და მიუთითებს გაგზავნის ბოლოს, რომ შესაბამისი პაკეტი ან პაკეტების ჯგუფი წარმატებით იქნა მიღებული. როგორც წესი, დადასტურება შეიცავს წარმატებით მიღებული პაკეტების თანმიმდევრულ ნომრებს. პროტოკოლიდან გამომდინარე, განასხვავებენ ინდივიდუალურ და ჯგუფურ დადასტურებებს

უარყოფითი დადასტურება
გამოიყენება მიმღების მიერ, რათა აცნობოს გამგზავნს, რომ პაკეტი არასწორად იქნა მიღებული. უარყოფითი აღიარება ჩვეულებრივ მოიცავს იმ პაკეტის რიგით ნომერს, რომელიც არ იქნა მიღებული სწორად

ფანჯარა, კონვეიორიზაცია
შეზღუდეთ რიგითი რიცხვების დიაპაზონი, რომელიც შეიძლება გამოყენებულ იქნას პაკეტების გადასაცემად. Multicast და handshake შეიძლება მნიშვნელოვნად გაზარდოს პროტოკოლის გამტარუნარიანობა აღიარების მოლოდინთან შედარებით. როგორც დავინახავთ, ფანჯრის ზომა შეიძლება გამოითვალოს მიმღები დასასრულის მიღებისა და ბუფერული შესაძლებლობების, ასევე ქსელის დატვირთვის დონის მიხედვით.

Go-ს ქსელში გამოყენების სხვა მაგალითები

В საცავები.

წყარო: www.habr.com