વિશ્વસનીય ડેટા ટ્રાન્સફરની મૂળભૂત બાબતો

જેઓ માટે શોધે છે નેટવર્ક્સ અને પ્રોટોકોલ્સને સમજવા માટે સમર્પિત.

સંક્ષિપ્તમાં

લેખ વિશ્વસનીય ડેટા ટ્રાન્સમિશનની મૂળભૂત બાબતોની ચર્ચા કરે છે, તેના પર ઉદાહરણો લાગુ કરે છે 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)
    }
}

સંભવિત ભૂલો સાથે ચેનલ પર વિશ્વસનીય ડેટા ટ્રાન્સમિશન

આગળનું પગલું એ ધારવું છે કે તમામ ટ્રાન્સમિટેડ પેકેટો જે ક્રમમાં મોકલવામાં આવ્યા હતા તે ક્રમમાં પ્રાપ્ત થયા છે, પરંતુ તેમાંના બિટ્સ એ હકીકતને કારણે દૂષિત થઈ શકે છે કે ચેનલ કેટલીકવાર વિકૃતિઓ સાથે ડેટા ટ્રાન્સમિટ કરે છે.

આ કિસ્સામાં, નીચેની પદ્ધતિઓનો ઉપયોગ કરવામાં આવે છે:

• ભૂલ શોધ;
• પ્રતિસાદ
• પુનઃપ્રસારણ.

વિશ્વસનીય ડેટા ટ્રાન્સફર પ્રોટોકોલ કે જેઓ ટ્રાન્સમિશનને ઘણી વખત પુનરાવર્તિત કરવા માટે સમાન મિકેનિઝમ ધરાવે છે તેને ઓટોમેટિક રીપીટ રીક્વેસ્ટ (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 પહેલાના અનુક્રમ નંબરો સાથેના તમામ પેકેટ સફળતાપૂર્વક પ્રાપ્ત થયા હતા.
• પ્રતીક્ષા અંતરાલ સમાપ્ત થઈ ગયો છે. પેકેટો અને રસીદોના નુકસાન અને વિલંબની હકીકતો નક્કી કરવા માટે, પ્રોટોકોલ ટાઈમરનો ઉપયોગ કરે છે. જો સમયસમાપ્તિ અંતરાલ સમાપ્ત થાય છે, તો મોકલવાની બાજુ બધા મોકલેલા અસ્વીકાર્ય પેકેટોને ફરીથી મોકલે છે.

પસંદગીયુક્ત પુનરાવર્તન

જ્યારે વિન્ડોનું કદ અને થ્રુપુટ-પ્રચાર વિલંબનું ઉત્પાદન મોટું હોય, ત્યારે મોટી સંખ્યામાં પેકેટો પાઇપલાઇનમાં હોઈ શકે છે. આવા કિસ્સામાં, એક પેકેટની ભૂલને કારણે મોટી સંખ્યામાં પેકેટો ફરીથી ટ્રાન્સમિટ થઈ શકે છે, જેમાંથી મોટા ભાગના જરૂરી ન હતા.

ઉદાહરણ:

શ્રેષ્ઠ સૈદ્ધાંતિક વ્યવહારિક અમલીકરણમાં પદ્ધતિઓ એકત્રિત કરવામાં આવે છે ટીસીપી. અને જો કોઈ જાણે છે કે કેવી રીતે શ્રેષ્ઠ - સ્વાગત છે.

સર્વર

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

નિષ્કર્ષ

વિશ્વસનીય ડેટા ટ્રાન્સફર અને ઉપયોગની ખાતરી કરવા માટેની પદ્ધતિઓ

મિકેનિઝમ
અરજી, ટિપ્પણી

સરવાળો ચેક કરો
પ્રસારિત પેકેટમાં બીટ ભૂલો શોધવા માટે વપરાય છે

ટાઈમર
સમયસમાપ્તિ અંતરાલની ગણતરી કરે છે અને તે ક્યારે સમાપ્ત થાય છે તે સૂચવે છે. બાદમાંનો અર્થ એ છે કે ઉચ્ચ સ્તરની સંભાવના સાથે પેકેટ અથવા તેની રસીદ ટ્રાન્સમિશન દરમિયાન ખોવાઈ જાય છે. જો પેકેટ વિલંબ સાથે વિતરિત કરવામાં આવે છે, પરંતુ ગુમ થયેલ નથી (સમયસમાપ્ત અંતરાલની અકાળ સમાપ્તિ), અથવા રસીદ ખોવાઈ જાય છે, તો પુનઃપ્રસારણ પ્રાપ્ત કરનાર બાજુએ ડુપ્લિકેટ પેકેટ તરફ દોરી જાય છે.

અનુક્રમ નંબર
પ્રેષકથી પ્રાપ્તકર્તા સુધી ટ્રાન્સમિટ થયેલા ડેટા પેકેટના ક્રમિક નંબરિંગ માટે વપરાય છે. પ્રાપ્ત થયેલ પેકેટના અનુક્રમ નંબરોમાં ગાબડાઓ રીસીવરને પેકેટની ખોટ શોધવાની મંજૂરી આપે છે. સમાન પેકેટ ક્રમ નંબરોનો અર્થ એ છે કે પેકેટો એકબીજાના ડુપ્લિકેટ છે

Подтверждение
પ્રાપ્ત અંત દ્વારા જનરેટ થાય છે અને મોકલવાના અંતને સૂચવે છે કે અનુરૂપ પેકેટ અથવા પેકેટોનું જૂથ સફળતાપૂર્વક પ્રાપ્ત થયું છે. સામાન્ય રીતે સ્વીકૃતિમાં સફળતાપૂર્વક પ્રાપ્ત થયેલા પેકેટોના ક્રમ નંબરો હોય છે. પ્રોટોકોલના આધારે, વ્યક્તિગત અને જૂથ પુષ્ટિકરણોને અલગ પાડવામાં આવે છે

નકારાત્મક પુષ્ટિ
પ્રેષકને જાણ કરવા માટે પ્રાપ્તકર્તા દ્વારા ઉપયોગમાં લેવાય છે કે પેકેટ ખોટી રીતે પ્રાપ્ત થયું હતું. નકારાત્મક સ્વીકૃતિમાં સામાન્ય રીતે પેકેટનો ક્રમ નંબર શામેલ હોય છે જે યોગ્ય રીતે પ્રાપ્ત થયો ન હતો

વિન્ડો, કન્વેયરાઇઝેશન
ક્રમ નંબરોની શ્રેણીને મર્યાદિત કરો જેનો ઉપયોગ પેકેટો ટ્રાન્સમિટ કરવા માટે થઈ શકે છે. સ્વીકૃતિઓની રાહ જોવાની તુલનામાં મલ્ટિકાસ્ટ અને હેન્ડશેક પ્રોટોકોલ થ્રુપુટમાં નોંધપાત્ર વધારો કરી શકે છે. જેમ આપણે જોઈશું, વિન્ડોની સાઇઝની ગણતરી રિસેપ્શન અને રિસિવિંગ એન્ડની બફરિંગ ક્ષમતાઓ તેમજ નેટવર્ક લોડ લેવલના આધારે કરી શકાય છે.

નેટવર્કિંગ માટે Go નો ઉપયોગ કરવાના વધુ ઉદાહરણો

В ભંડાર.

સોર્સ: www.habr.com