विश्वसनीय डेटा ट्रान्सफरची मूलभूत तत्त्वे

ज्यांना शोधतो नेटवर्क आणि प्रोटोकॉल समजून घेण्यासाठी समर्पित.

थोडक्यात

लेख विश्वसनीय डेटा ट्रान्समिशनच्या मूलभूत गोष्टींवर चर्चा करतो, उदाहरणे लागू करतो 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)
    }
}

संभाव्य त्रुटींसह चॅनेलवर विश्वसनीय डेटा ट्रान्समिशन

पुढची पायरी म्हणजे सर्व प्रसारित पॅकेट ज्या क्रमाने पाठवले गेले त्याच क्रमाने प्राप्त झाले आहेत असे गृहीत धरणे, परंतु चॅनेल कधीकधी विकृतीसह डेटा प्रसारित करते या वस्तुस्थितीमुळे त्यातील बिट्स खराब होऊ शकतात.

या प्रकरणात, खालील यंत्रणा वापरल्या जातात:

• त्रुटी शोधणे;
• अभिप्राय
• रीट्रांसमिशन

विश्वासार्ह डेटा ट्रान्सफर प्रोटोकॉल ज्यात ट्रान्समिशन अनेक वेळा पुनरावृत्ती करण्यासाठी समान यंत्रणा असते त्यांना ऑटोमॅटिक रिपीट रिक्वेस्ट (एआरक्यू) प्रोटोकॉल म्हणतात.
याव्यतिरिक्त, जेव्हा प्राप्तकर्त्या पक्षाला शेवटच्या पॅकेटच्या हस्तांतरणाच्या परिणामांबद्दल कोणतीही माहिती प्राप्त होणार नाही तेव्हा पावत्यांमधील त्रुटींची शक्यता लक्षात घेण्यासारखे आहे.
या समस्येचे निराकरण, TCP मध्ये देखील वापरले जाते, पॅकेटचा क्रम क्रमांक असलेल्या डेटा पॅकेटमध्ये नवीन फील्ड जोडणे आहे.

पॅकेट विरूपण आणि नुकसानाच्या अधीन असलेल्या अविश्वसनीय चॅनेलवर विश्वसनीय डेटा ट्रान्समिशन

विकृतीसह, दुर्दैवाने, नेटवर्कमध्ये पॅकेट तोटा आहे.
आणि या समस्येचे निराकरण करण्यासाठी, यंत्रणा आवश्यक आहे:

• पॅकेट गमावण्याची वस्तुस्थिती निश्चित करणे;
• हरवलेल्या पॅकेटची परत डिलिव्हरी प्राप्त करणार्‍या पक्षाला.

याव्यतिरिक्त, पॅकेजच्या नुकसानाव्यतिरिक्त, पावती गमावण्याची शक्यता प्रदान करणे आवश्यक आहे किंवा काहीही गमावले नसल्यास, लक्षणीय विलंबाने वितरण. सर्व प्रकरणांमध्ये, समान गोष्ट केली जाते: पॅकेट पुन्हा प्रसारित केले जाते. वेळ नियंत्रित करण्यासाठी, ही यंत्रणा काउंटडाउन टाइमर वापरते, जी तुम्हाला प्रतीक्षा मध्यांतराची समाप्ती निर्धारित करण्यास अनुमती देते. तर पॅकेजमध्ये निव्वळ TCPKeepAlive डीफॉल्टनुसार 15 सेकंदांवर सेट केले आहे:

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

पाठवणार्‍या बाजूने प्रत्येक वेळी पॅकेट प्रसारित केल्यावर टाइमर सुरू करणे आवश्यक आहे (पहिली आणि दुसरी दोन्ही वेळी), टाइमरमधून व्यत्यय हाताळणे आणि ते थांबवणे.

म्हणून, आम्ही विश्वसनीय डेटा ट्रान्सफर प्रोटोकॉलच्या मुख्य संकल्पनांशी परिचित झालो आहोत:

• चेकसम
• पॅकेजेसची क्रम संख्या;
• टाइमर;
• सकारात्मक आणि नकारात्मक पावत्या.

पण ते सर्व नाही!

पाइपलाइनिंगसह विश्वसनीय डेटा ट्रान्सफर प्रोटोकॉल

आम्ही आधीच विचारात घेतलेल्या प्रकारात, विश्वसनीय वितरण प्रोटोकॉल अतिशय अकार्यक्षम आहे. आरटीटी वाढते तसे संप्रेषण चॅनेलद्वारे प्रदान केलेले प्रसारण "धीमे" होण्यास सुरुवात होते. त्याची कार्यक्षमता वाढवण्यासाठी आणि कम्युनिकेशन चॅनेलची क्षमता अधिक चांगल्या प्रकारे वापरण्यासाठी, पाइपलाइनिंग वापरली जाते.

पाइपलाइनच्या वापरामुळे पुढील गोष्टी होतात:

• अनुक्रम संख्यांची श्रेणी वाढवणे, कारण सर्व पाठविलेले पॅकेट (पुनर्प्रेषण वगळता) अद्वितीयपणे ओळखले जाणे आवश्यक आहे;
• ट्रान्समिटिंग आणि रिसीव्हिंग बाजूंवर बफर वाढवण्याची गरज.

अनुक्रम क्रमांक श्रेणी आणि बफर आकार आवश्यकता पॅकेट भ्रष्टाचार, नुकसान आणि विलंब यांना प्रतिसाद म्हणून प्रोटोकॉल घेत असलेल्या क्रियांवर अवलंबून असतात. पाइपलाइनिंगच्या बाबतीत, त्रुटी सुधारण्यासाठी दोन पद्धती आहेत:

• एन पॅकेट परत करा;
• निवडक पुनरावृत्ती.

N पॅकेट्स मागे जाणे - स्लाइडिंग विंडो प्रोटोकॉल

प्रेषकाने तीन प्रकारच्या इव्हेंटचे समर्थन केले पाहिजे:

• उच्च स्तरीय प्रोटोकॉलद्वारे कॉल करा. जेव्हा डेटा पाठविण्याचे कार्य "वरून" म्हटले जाते, तेव्हा पाठविणारी बाजू प्रथम विंडो भरण्याची डिग्री तपासते (म्हणजे, पावती मिळण्याच्या प्रतीक्षेत N पाठवलेल्या संदेशांची उपस्थिती). विंडो रिकामी असल्यास, एक नवीन पॅकेट व्युत्पन्न आणि प्रसारित केले जाते आणि व्हेरिएबल मूल्ये अद्यतनित केली जातात. अन्यथा, पाठवणारी बाजू वरच्या स्तरावर डेटा परत करते आणि हे एक गर्भित संकेत आहे की विंडो भरली आहे. सामान्यत: वरचा स्तर काही काळानंतर पुन्हा डेटा प्रसारित करण्याचा प्रयत्न करेल. वास्तविक ऍप्लिकेशनमध्ये, प्रेषक एकतर डेटा बफर करेल (तात्काळ पाठवण्याऐवजी) किंवा सिंक्रोनाइझेशन यंत्रणा (जसे की सेमाफोर किंवा ध्वज) असेल जी विंडो रिकामी असतानाच वरच्या लेयरला सेंड फंक्शन कॉल करू शकेल. .
• पुष्टीकरण प्राप्त करणे. प्रोटोकॉलमध्ये, अनुक्रम क्रमांक N असलेल्या पॅकेटसाठी, एक सामान्य पावती जारी केली जाते जी दर्शवते की N च्या आधीच्या अनुक्रम क्रमांकांसह सर्व पॅकेट यशस्वीरित्या प्राप्त झाले आहेत.
• प्रतीक्षा मध्यांतर कालबाह्य झाले आहे. पॅकेट्स आणि पावत्यांचे नुकसान आणि विलंब यांचे तथ्य निर्धारित करण्यासाठी, प्रोटोकॉल टाइमर वापरतो. कालबाह्य अंतराल कालबाह्य झाल्यास, पाठवणारी बाजू सर्व पाठविलेले न कळलेले पॅकेट पुन्हा पाठवते.

निवडक पुनरावृत्ती

जेव्हा विंडोचा आकार आणि थ्रुपुट-प्रसार विलंब उत्पादन मोठे असते, तेव्हा मोठ्या संख्येने पॅकेट पाइपलाइनमध्ये असू शकतात. अशा परिस्थितीत, एका पॅकेट त्रुटीमुळे मोठ्या संख्येने पॅकेट्स पुन्हा प्रसारित केले जाऊ शकतात, ज्यापैकी बहुतेक आवश्यक नव्हते.

उदाहरण:

सर्वोत्तम सैद्धांतिक सराव व्यावहारिक अंमलबजावणीमध्ये एकत्रित केले जातात टीसीपी. आणि जर कोणाला माहित असेल की कसे चांगले - आपले स्वागत आहे.

Сервер

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)
    }
}

निष्कर्ष

विश्वसनीय डेटा हस्तांतरण आणि वापर सुनिश्चित करण्यासाठी यंत्रणा

यंत्रणा
अर्ज, टिप्पणी

बेरीज तपासा
प्रसारित पॅकेटमधील बिट त्रुटी शोधण्यासाठी वापरला जातो

टायमर
कालबाह्य अंतराल मोजतो आणि तो कालबाह्य झाला आहे हे सूचित करतो. नंतरचा अर्थ असा आहे की उच्च संभाव्यतेसह पॅकेट किंवा त्याची पावती ट्रान्समिशन दरम्यान गमावली जाते. जर एखादे पॅकेट विलंबाने वितरित केले गेले, परंतु ते हरवले नाही (कालबाह्य कालावधीची मुदतपूर्व कालबाह्यता), किंवा पावती हरवली असेल, तर रीट्रांसमिशनमुळे प्राप्त झालेल्या बाजूला डुप्लिकेट पॅकेट येते.

अनुक्रमांक
प्रेषकाकडून प्राप्तकर्त्याकडे प्रसारित केलेल्या डेटा पॅकेटच्या अनुक्रमिक क्रमांकासाठी वापरला जातो. प्राप्त झालेल्या पॅकेट्सच्या क्रम संख्यांमधील अंतर प्राप्तकर्त्यास पॅकेटचे नुकसान शोधू देते. समान पॅकेट क्रम संख्या म्हणजे पॅकेट एकमेकांची डुप्लिकेट आहेत

पुष्टीकरण
रिसीव्हिंग एंडद्वारे व्युत्पन्न केले जाते आणि पाठवण्याच्या टोकाला सूचित करते की संबंधित पॅकेट किंवा पॅकेट्सचा गट यशस्वीरित्या प्राप्त झाला आहे. सामान्यत: पोचपावतीमध्ये यशस्वीरित्या प्राप्त झालेल्या पॅकेटचे अनुक्रम क्रमांक असतात. प्रोटोकॉलवर अवलंबून, वैयक्तिक आणि गट पुष्टीकरण वेगळे केले जातात

नकारात्मक पुष्टीकरण
प्रेषकाला माहिती देण्यासाठी प्राप्तकर्त्याद्वारे पॅकेट चुकीच्या पद्धतीने प्राप्त झाले आहे. नकारात्मक पावतीमध्ये सहसा पॅकेटचा क्रम क्रमांक समाविष्ट असतो जो योग्यरित्या प्राप्त झाला नाही

खिडकी, कन्व्हेयरायझेशन
पॅकेट प्रसारित करण्यासाठी वापरल्या जाणार्‍या क्रम संख्यांची श्रेणी मर्यादित करा. मल्टिकास्ट आणि हँडशेक पावतींच्या प्रतीक्षेच्या तुलनेत प्रोटोकॉल थ्रुपुटमध्ये लक्षणीय वाढ करू शकतात. जसे आपण पाहणार आहोत, विंडोचा आकार रिसेप्शन आणि रिसिव्हिंग एंडच्या बफरिंग क्षमता तसेच नेटवर्क लोड लेव्हलच्या आधारे मोजला जाऊ शकतो.

नेटवर्किंगसाठी गो वापरण्याची अधिक उदाहरणे

В भांडार.

स्त्रोत: www.habr.com