Muhimman Abubuwan Canja wurin Bayanai Na Gaskiya

Zuwa ga wadanda nema Ƙaddamar da fahimtar hanyoyin sadarwa da ladabi.

A takaice

Labarin yayi magana akan tushen ingantaccen watsa bayanai, yana aiwatar da misalai akan Go, ciki har da UDP da TCP. Bisa ga sau, два, uku da kuma littattafan "Cibiyoyin Sadarwar Kwamfuta. Hanyar Hanya na Top-Down", in ba haka ba kowa yana tattaunawa kawai Tannenbaum da Oliferov.

Ka'idar layin sufuri

Yana ba da alaƙa mai ma'ana tsakanin aikace-aikacen aikace-aikacen da ke gudana akan runduna daban-daban. Daga yanayin aikace-aikacen, haɗin ma'ana yana kama da tashar da ke haɗa matakai kai tsaye.

Ka'idojin layin sufuri ana goyan bayan tsarin ƙarshe, amma ba ta hanyar hanyoyin sadarwa ba (sai dai - DPI). A gefen mai aikawa, layin sufuri yana canza bayanan Layer na aikace-aikacen da yake karba daga tsarin aika aikace-aikacen zuwa fakitin jigilar jigilar kayayyaki da ake kira segments.

Ana yin wannan ta hanyar rarraba (idan ya cancanta) saƙonnin Layer na aikace-aikacen zuwa guntu da ƙara taken layin sufuri zuwa kowannensu.

Sa'an nan layin sufuri ya wuce sashin zuwa layin cibiyar sadarwa na mai aikawa, inda aka lullube sashin a cikin fakitin layin sadarwa (datagram) kuma a aika. A ƙarshen karɓar, layin hanyar sadarwa yana fitar da sashin layin jigilar kayayyaki daga bayanan da aka haɗe kuma ya wuce shi har zuwa layin sufuri. Bayan haka, layin sufuri yana aiwatar da sashin da aka karɓa don bayanansa ya zama samuwa ga aikace-aikacen karɓa.

Ka'idodin ingantaccen watsa bayanai

Amintaccen watsa bayanai akan tashoshi mai cikakken tsaro

Harka mafi sauki. Bangaren aikawa kawai yana karɓar bayanan daga saman saman, ya ƙirƙira fakitin da ke ɗauke da shi, ya aika zuwa tashar.

Server

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

Abokin Ciniki

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

Amintaccen watsa bayanai akan tashar tare da yuwuwar kurakurai

Mataki na gaba shine a ɗauka cewa duk fakitin da aka watsa ana karɓar su ta hanyar da aka aika su, amma abubuwan da ke cikin su na iya lalacewa saboda gaskiyar cewa tashar wani lokaci tana watsa bayanai tare da murdiya.

A wannan yanayin, ana amfani da waɗannan hanyoyin:

• gano kuskure;
• martani;
• sake watsawa.

Dogaro da ka'idojin canja wurin bayanai waɗanda ke da irin wannan tsarin don maimaita watsawa sau da yawa ana kiran su ka'idojin maimaita maimaitawa ta atomatik (ARQ).
Bugu da ƙari, yana da daraja la'akari da yiwuwar kurakurai a cikin rasit, lokacin da mai karɓa ba zai sami wani bayani game da sakamakon canja wurin fakiti na ƙarshe ba.
Maganin wannan matsala, wanda kuma ake amfani dashi a cikin TCP, shine ƙara sabon filin zuwa fakitin bayanan da ke ɗauke da jerin jerin fakitin.

Amintaccen watsa bayanai akan tashoshi mara inganci wanda ke tattare da murdiya da asara

Tare da murdiya, rashin alheri, akwai asarar fakiti a cikin hanyar sadarwa.
Kuma don magance wannan matsala, ana buƙatar hanyoyin:

• ƙayyade gaskiyar asarar fakiti;
• sake isar da fakitin da aka bata ga jam'iyyar da ke karba.

Bugu da ƙari, ban da asarar fakitin, wajibi ne don samar da yiwuwar asarar rasidin ko, idan babu abin da ya ɓace, isar da shi tare da jinkiri mai mahimmanci. A kowane hali, ana yin abu ɗaya: ana sake aikawa da fakitin. Don sarrafa lokaci, wannan tsarin yana amfani da ƙidayar ƙidayar lokaci, wanda ke ba ku damar ƙayyade ƙarshen tazarar jira. Don haka a cikin kunshin net An saita TCPKeepAlive zuwa daƙiƙa 15 ta tsohuwa:

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

Bangaren aikawa yana buƙatar fara mai ƙidayar lokaci a duk lokacin da aka aika fakiti (duka na farko da na biyu), rike katsewa daga mai ƙidayar lokaci kuma dakatar da shi.

Don haka, mun saba da mahimman ra'ayoyi na amintattun ka'idojin canja wurin bayanai:

• checksums;
• jerin lambobin fakiti;
• masu lokaci;
• tabbatacce kuma korau rasit.

Amma ba duka ba!

Amintaccen tsarin canja wurin bayanai tare da bututun mai

A cikin bambance-bambancen da muka riga muka yi la'akari, amintaccen ƙa'idar bayarwa ba ta da inganci sosai. Ya fara "jinkirin" watsawar da tashar sadarwa ke bayarwa yayin da RTT ke ƙaruwa. Don haɓaka ingancinsa kuma mafi kyawun amfani da ƙarfin tashar sadarwa, ana amfani da bututun mai.

Yin amfani da bututu yana haifar da:

• haɓaka kewayon lambobin jeri, tunda duk fakitin da aka aika (ban da sake aikawa) dole ne a gano su musamman;
• buƙatar ƙara buffers akan bangarorin watsawa da karɓa.

Matsakaicin adadin jeri da buƙatun girman buffer sun dogara da ayyukan da ƙa'idar ke ɗauka don mayar da martani ga ɓarna, asara, da jinkiri. Game da bututun, akwai hanyoyi guda biyu don gyara kurakurai:

• mayar da fakitin N baya;
• maimaita maimaitawa.

Komawa fakiti N - yarjejeniya ta taga zamiya

Dole ne mai aikawa ya goyi bayan nau'ikan al'amura guda uku:

• kira ta hanyar yarjejeniya mafi girma. Lokacin da ake kira aikin aika bayanan "daga sama", ɓangaren aikawa yana fara duba matakin cika taga (wato, kasancewar N aika saƙonnin da ke jiran karɓar rasit). Idan taga babu komai, ana samar da sabon fakiti kuma ana watsa shi, kuma ana sabunta ƙima masu canzawa. In ba haka ba, gefen aikawa yana mayar da bayanai zuwa saman Layer, kuma wannan alama ce a sarari cewa taga ya cika. Yawanci Layer na sama zai yi ƙoƙarin sake watsa bayanan bayan ɗan lokaci. A cikin ainihin aikace-aikacen, mai yiwuwa mai aikawa zai iya ajiye bayanan (maimakon aika shi nan da nan) ko kuma ya sami hanyar aiki tare (kamar semaphore ko tuta) wanda zai ba da damar babban layin don kiran aikin aika kawai lokacin da taga babu kowa. .
• karbar tabbaci. A cikin ka'idar, don fakiti mai lamba N, an ba da wata sanarwa gabaɗaya wanda ke nuna cewa duk fakiti masu jerin lambobin da suka gabace N an samu nasarar karɓe su.
• lokacin jira ya ƙare. Don tantance gaskiyar asara da jinkirin fakiti da rasit, ka'idar tana amfani da mai ƙidayar lokaci. Idan tazarar lokacin ƙarewa ya ƙare, ɓangaren aikawa yana aika duk fakitin da ba a san su ba.

Zaɓin maimaitawa

Lokacin da girman taga da samfurin jinkirin haɓaka kayan aiki ya yi girma, babban adadin fakiti na iya kasancewa a cikin bututun. A irin wannan yanayin, kuskuren fakiti ɗaya na iya haifar da sake aikawa da ɗimbin fakiti, yawancin waɗanda ba a buƙata ba.

Alal misali:

Лучшие m ana tattara ayyuka a aiwatarwa a aikace TCP. Kuma idan wani ya san yadda mafi kyau - maraba.

Server

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

Abokin Ciniki

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

ƙarshe

Hanyoyi don tabbatar da ingantaccen canja wurin bayanai da amfani

Kayan aiki
Application, sharhi

Duba jimlar
Ana amfani da shi don gano kurakurai a cikin fakitin da aka watsa

Lokaci
Yana ƙidaya tazarar lokacin ƙarewa kuma yana nuna lokacin da ya ƙare. Na ƙarshe yana nufin cewa tare da babban matakin yuwuwar fakitin ko karɓar sa ya ɓace yayin watsawa. Idan an isar da fakiti tare da jinkiri, amma ba a rasa ba (karewa da wuri na lokacin ƙarewar lokaci), ko kuma an rasa rasidi, sake aikawa yana kaiwa ga fakitin kwafi akan ɓangaren karɓa.

Serial number
An yi amfani da shi don jerin lambobin fakitin bayanan da aka watsa daga mai aikawa zuwa mai karɓa. Matsaloli a cikin jerin lambobin fakitin da aka karɓa suna ba mai karɓa damar gano asarar fakiti. Lambobin jeri na fakiti iri ɗaya suna nufin cewa fakitin kwafin juna ne

Tabbatarwa
An ƙirƙira ta ƙarshen karɓa kuma yana nunawa zuwa ƙarshen aika cewa an sami nasarar karɓar fakitin da ya dace ko rukunin fakiti. Yawanci amincewar ya ƙunshi jerin lambobi na fakitin da aka samu nasara. Dangane da ƙa'idar, an bambanta tabbatarwar mutum da ƙungiya

Tabbatacce mara kyau
Mai karɓa yana amfani da shi don sanar da mai aikawa cewa fakitin an karɓi ba daidai ba. Mummunan amincewa yawanci ya haɗa da jerin jerin fakitin da ba a karɓa daidai ba

Taga, isar da sako
Iyakance kewayon jeri na lambobi waɗanda za a iya amfani da su don watsa fakiti. Multicast da musafaha na iya ƙara haɓaka kayan aikin yarjejeniya sosai idan aka kwatanta da jiran sanarwa. Kamar yadda za mu gani, za a iya ƙididdige girman girman taga bisa la'akari da damar liyafar da buffering na ƙarshen karɓa, da kuma matakin nauyin cibiyar sadarwa.

Ƙarin misalan amfani da Go don sadarwar yanar gizo

В wuraren ajiya.

source: www.habr.com