Fondamantal nan transfè done serye

Pou moun ki chache Dedye a konprann rezo ak pwotokòl.

Yon ti tan

Atik la diskite Basics yo nan transmisyon done serye, aplike egzanp sou Go, ki gen ladan UDP ak TCP. Baze sou tan, два, twa ak liv "Computer Networks. Top-Down Approach", otreman tout moun ap diskite sèlman Tannenbaum ak Oliferov.

Pwotokòl kouch transpò

Bay yon koneksyon lojik ant pwosesis aplikasyon ki kouri sou diferan lame. Soti nan yon pèspektiv aplikasyon, yon koneksyon lojik sanble ak yon kanal ki konekte dirèkteman pwosesis yo.

Pwotokòl kouch transpò yo sipòte pa sistèm fen, men pa pa routeurs rezo (eksepte - DPI). Sou bò moun k ap voye a, kouch transpò a konvèti done kouch aplikasyon an li resevwa nan pwosesis aplikasyon an voye nan pake kouch transpò ki rele segman.

Sa a se fè pa divize (si sa nesesè) mesaj yo kouch aplikasyon an fragman epi ajoute yon header kouch transpò nan chak nan yo.

Kouch transpò a Lè sa a, pase segman nan kouch rezo moun k la, kote segman an encapsulé nan yon pake kouch rezo (datagram) epi voye. Nan fen k ap resevwa a, kouch rezo a ekstrè segman kouch transpò a soti nan datagram la epi pase li jiska kouch transpò a. Apre sa, kouch transpò a trete segman resevwa a pou done li yo vin disponib pou aplikasyon k ap resevwa a.

Prensip transmisyon done serye

Transmisyon done serye sou yon chanèl konplètman an sekirite

Ka ki pi senp la. Bò ki voye a tou senpleman resevwa done ki soti nan kouch anwo a, kreye yon pake ki gen li, epi voye li nan kanal la.

Sèvè

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 + надежный канал
    }
}

Kliyan

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

Transmisyon done serye sou yon kanal ak erè posib

Pwochen etap la se asime ke tout pake transmèt yo resevwa nan lòd yo te voye, men Bits yo nan yo ka pèvèti akòz lefèt ke kanal la pafwa transmèt done ak distorsion.

Nan ka sa a, yo itilize mekanis sa yo:

• deteksyon erè;
• fidbak;
• retransmisyon.

Pwotokòl transfè done serye ki gen mekanis menm jan an pou repete transmisyon plizyè fwa yo rele pwotokòl Automatic Repeat reQuest (ARQ).
Anplis de sa, li vo konsidere posiblite pou erè nan resi, lè pati k ap resevwa a pa pral resevwa okenn enfòmasyon sou rezilta yo nan transfè a nan dènye pake a.
Solisyon an nan pwoblèm sa a, tou yo itilize nan TCP, se ajoute yon nouvo jaden nan pake a done ki gen nimewo a sekans nan pake a.

Transmisyon done fyab sou yon chanèl enfidèl sijè a distòsyon ak pèt pake

Ansanm ak deformation, malerezman, gen pèt pake nan rezo a.
Ak pou rezoud pwoblèm sa a, mekanis yo nesesè:

• detèmine reyalite a nan pèt pake;
• re-livrezon pake ki pèdi yo bay pati k ap resevwa a.

Anplis de sa nan pèt la nan pake a, li nesesè bay pou posiblite pou pèt resi a oswa, si pa gen anyen ki pèdi, livrezon li yo ak yon reta enpòtan. Nan tout ka yo, se menm bagay la fè: pake a retransmèt. Pou kontwole tan, mekanis sa a sèvi ak yon revèy dekont, ki pèmèt ou detèmine fen entèval datant la. Se konsa, nan pake a nèt TPCKeepAlive mete sou 15 segonn pa default:

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

Bò ki voye a bezwen kòmanse yon revèy chak fwa yon pake transmèt (tou de premye ak dezyèm fwa a), okipe entèripsyon nan revèy la epi sispann li.

Se konsa, nou te vin abitye ak konsèp kle yo nan pwotokòl transfè done serye:

• chèk sòm;
• nimewo sekans pake;
• revèy;
• resi pozitif ak negatif.

Men, se pa tout!

Pwotokòl transfè done serye ak pipelining

Nan variant ke nou te deja konsidere, pwotokòl livrezon serye a trè efikas. Li kòmanse "ralanti" transmisyon ki bay nan kanal kominikasyon an kòm RTT a ogmante. Pou ogmante efikasite li yo ak pi byen itilize kapasite chanèl kominikasyon an, yo itilize pipelining.

Itilizasyon tiyo a mennen nan:

• ogmante seri nimewo sekans yo, paske tout pake voye yo (eksepte retransmisyon) dwe idantifye yon fason inik;
• nesesite pou ogmante tanpon sou kote transmèt ak k ap resevwa yo.

Ranje nimewo sekans ak kondisyon gwosè tanpon yo depann de aksyon pwotokòl la pran an repons a koripsyon pake, pèt, ak reta. Nan ka pipelining, gen de metòd pou korije erè:

• retounen N pake tounen;
• repetisyon selektif.

Ale tounen N pakè - pwotokòl fenèt glisman

Moun k ap voye a dwe sipòte twa kalite evènman:

• rele pa yon pwotokòl pi wo nivo. Lè yo rele fonksyon an voye done "ki soti anwo", bò ki voye an premye tcheke degre nan ranpli nan fenèt la (ki se, prezans nan N voye mesaj k ap tann resi yo). Si fenèt la vid, yon nouvo pake pwodui ak transmèt, ak valè varyab yo mete ajou. Sinon, bò voye a retounen done nan kouch siperyè a, e sa a se yon endikasyon implicite ke fenèt la plen. Tipikman kouch anwo a ap eseye transmèt done yo ankò apre kèk tan. Nan yon aplikasyon reyèl, moun k la ta ka swa tampon done yo (olye pou yo voye li imedyatman) oswa gen yon mekanis senkronizasyon (tankou yon semafò oswa drapo) ki ta pèmèt kouch siperyè a rele fonksyon an voye sèlman lè fenèt la vid. .
• k ap resevwa konfimasyon. Nan pwotokòl la, pou yon pake ki gen nimewo sekans N, yo bay yon rekonesans jeneral ki endike ke tout pake ki gen nimewo sekans anvan N yo te resevwa avèk siksè.
• entèval datant lan te ekspire. Pou detèmine reyalite pèt ak reta nan pake ak resi, pwotokòl la itilize yon revèy. Si entèval timeout la ekspire, bò k ap voye a renvoie tout pake ki pa rekonèt yo.

Repetisyon selektif

Lè gwosè fenèt la ak pwodwi reta debi pwopagasyon yo gwo, yon gwo kantite pakè ka nan tiyo a. Nan yon ka konsa, yon sèl erè pake ka lakòz yon gwo kantite pake yo dwe retransmèt, pi fò nan yo pa te obligatwa.

Egzanp

Pi bon an teyorik pratik yo kolekte nan aplikasyon pratik Tchp. Men, si yon moun konnen ki jan pi byen - akeyi.

Sèvè

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

Kliyan

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

Sòti

Mekanis pou asire transfè done ak itilizasyon serye

Mekanis
Aplikasyon, kòmantè

Tcheke sòm
Itilize pou detekte erè ti jan nan yon pake transmèt

Li tap konometre
Konte entèval timeout la epi li endike lè li ekspire. Lèt la vle di ke ak yon wo degre de pwobabilite pake a oswa resi li yo pèdi pandan transmisyon. Si yo delivre yon pake ak yon reta, men li pa pèdi (eksirasyon prematire entèval tan an), oswa yon resi pèdi, retransmisyon mennen nan yon pake kopi sou bò k ap resevwa a.

Nimewo seri
Itilize pou nimewo sekans nan pake done ki transmèt soti nan moun k ap resevwa a. Diferans nan nimewo sekans pake resevwa yo pèmèt reseptè a detekte pèt pake. Menm nimewo sekans pake yo vle di ke pake yo se kopi youn ak lòt

Konfimasyon
Jenere nan fen k ap resevwa a epi ki endike nan fen a voye ke pake ki koresponn lan oswa gwoup pake yo te resevwa avèk siksè. Tipikman rekonesans la gen nimewo yo sekans nan pake resevwa avèk siksè. Tou depan de pwotokòl la, konfimasyon endividyèl ak gwoup yo distenge

Konfimasyon negatif
Itilize pa moun k ap resevwa a pou enfòme moun k ap voye a ke yo te resevwa pakèt la mal. Yon rekonesans negatif anjeneral gen ladan nimewo sekans pake a ki pa te resevwa kòrèkteman

Fenèt, conveyorization
Limite seri nimewo sekans ki ka itilize pou transmèt pake yo. Multicast ak handshake ka ogmante siyifikativman debi pwotokòl konpare ak ap tann pou rekonesans. Kòm nou pral wè, gwosè fenèt la ka kalkile ki baze sou resepsyon ak kapasite tanpon nan fen k ap resevwa a, osi byen ke nivo chaj rezo a.

Plis egzanp lè l sèvi avèk Go pou rezo

В depo.

Sous: www.habr.com