មូលដ្ឋានគ្រឹះនៃការផ្ទេរទិន្នន័យដែលអាចទុកចិត្តបាន។

ដល់អ្នកទាំងឡាយណា ស្វែងរក ឧទ្ទិសដល់ការយល់ដឹងអំពីបណ្តាញ និងពិធីការ។

សង្ខេប

អត្ថបទពិភាក្សាអំពីមូលដ្ឋានគ្រឹះនៃការបញ្ជូនទិន្នន័យដែលអាចទុកចិត្តបាន អនុវត្តឧទាហរណ៍នៅលើ Goរួមទាំង UDP និង TCP ។ អាស្រ័យ​លើ ដង, два, បី និងសៀវភៅ "បណ្តាញកុំព្យូទ័រ។ វិធីសាស្រ្តពីលើចុះក្រោម" បើមិនដូច្នេះទេអ្នកគ្រប់គ្នាកំពុងពិភាក្សាតែ Tannenbaum និង Oliferov ប៉ុណ្ណោះ។

ពិធីការស្រទាប់ដឹកជញ្ជូន

ផ្តល់នូវការតភ្ជាប់ឡូជីខលរវាងដំណើរការកម្មវិធីដែលកំពុងដំណើរការលើម៉ាស៊ីនផ្សេងៗគ្នា។ តាមទស្សនៈកម្មវិធី ការតភ្ជាប់ឡូជីខលមើលទៅដូចជាឆានែលដែលភ្ជាប់ដំណើរការដោយផ្ទាល់។

ពិធីការស្រទាប់ដឹកជញ្ជូន ត្រូវបានគាំទ្រដោយប្រព័ន្ធបញ្ចប់ ប៉ុន្តែមិនមែនដោយរ៉ោតទ័របណ្តាញទេ (លើកលែងតែ - DPI & ‧;) នៅផ្នែកអ្នកផ្ញើ ស្រទាប់ដឹកជញ្ជូនបំប្លែងទិន្នន័យស្រទាប់កម្មវិធីដែលវាទទួលបានពីដំណើរការបញ្ជូនកម្មវិធីទៅជាកញ្ចប់ដឹកជញ្ជូនហៅថា segments ។

នេះត្រូវបានធ្វើដោយការបំបែក (បើចាំបាច់) សារស្រទាប់កម្មវិធីទៅជាបំណែក ហើយបន្ថែមបឋមកថាស្រទាប់ដឹកជញ្ជូនទៅពួកវានីមួយៗ។

បន្ទាប់មក ស្រទាប់ដឹកជញ្ជូនឆ្លងកាត់ផ្នែកទៅស្រទាប់បណ្តាញរបស់អ្នកផ្ញើ ដែលផ្នែកត្រូវបានរុំព័ទ្ធក្នុងកញ្ចប់ទិន្នន័យស្រទាប់បណ្តាញ (datagram) ហើយផ្ញើ។ នៅចុងបញ្ចប់នៃការទទួល ស្រទាប់បណ្តាញទាញយកផ្នែកស្រទាប់ដឹកជញ្ជូនចេញពី datagram ហើយបញ្ជូនវាឡើងទៅស្រទាប់ដឹកជញ្ជូន។ បន្ទាប់មក ស្រទាប់ដឹកជញ្ជូនដំណើរការផ្នែកដែលបានទទួល ដូច្នេះទិន្នន័យរបស់វាមានសម្រាប់កម្មវិធីទទួល។

គោលការណ៍នៃការបញ្ជូនទិន្នន័យដែលអាចទុកចិត្តបាន។

ការបញ្ជូនទិន្នន័យដែលអាចទុកចិត្តបានលើប៉ុស្តិ៍ដែលមានសុវត្ថិភាពទាំងស្រុង

ករណីសាមញ្ញបំផុត។ ផ្នែកបញ្ជូនគ្រាន់តែទទួលទិន្នន័យពីស្រទាប់ខាងលើ បង្កើតកញ្ចប់ព័ត៌មានដែលមានវា ហើយបញ្ជូនវាទៅឆានែល។

ម៉ាស៊ីនមេ

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

ការបញ្ជូនទិន្នន័យដែលអាចទុកចិត្តបានលើឆានែលដែលមានកំហុសដែលអាចកើតមាន

ជំហានបន្ទាប់គឺត្រូវសន្មត់ថាកញ្ចប់ព័ត៌មានដែលបានបញ្ជូនទាំងអស់ត្រូវបានទទួលតាមលំដាប់លំដោយដែលពួកគេត្រូវបានផ្ញើ ប៉ុន្តែប៊ីតនៅក្នុងពួកវាអាចនឹងត្រូវខូច ដោយសារតែពេលខ្លះឆានែលបញ្ជូនទិន្នន័យជាមួយនឹងការបង្ខូចទ្រង់ទ្រាយ។

ក្នុងករណីនេះយន្តការខាងក្រោមត្រូវបានប្រើ៖

• ការរកឃើញកំហុស;
• មតិកែលម្អ;
• ការបញ្ជូនបន្ត។

ពិធីការផ្ទេរទិន្នន័យដែលអាចទុកចិត្តបានដែលមានយន្តការស្រដៀងគ្នាសម្រាប់ការបញ្ជូនម្តងទៀតច្រើនដងត្រូវបានគេហៅថា ពិធីការ 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 packets - ពិធីការបង្អួចរអិល

អ្នកផ្ញើត្រូវតែគាំទ្រព្រឹត្តិការណ៍បីប្រភេទ៖

• ហៅតាមពិធីការកម្រិតខ្ពស់។ នៅពេលដែលមុខងារបញ្ជូនទិន្នន័យត្រូវបានគេហៅថា "ពីខាងលើ" ភាគីផ្ញើដំបូងពិនិត្យមើលកម្រិតនៃការបំពេញបង្អួច (នោះគឺវត្តមានរបស់ N បានផ្ញើសារដែលកំពុងរង់ចាំការទទួលបង្កាន់ដៃ) ។ ប្រសិនបើបង្អួចទទេ កញ្ចប់ព័ត៌មានថ្មីត្រូវបានបង្កើត និងបញ្ជូន ហើយតម្លៃអថេរត្រូវបានធ្វើបច្ចុប្បន្នភាព។ បើមិនដូច្នេះទេ ភាគីបញ្ជូនត្រឡប់ទិន្នន័យទៅស្រទាប់ខាងលើ ហើយនេះគឺជាការចង្អុលបង្ហាញថា បង្អួចពេញហើយ។ ជាធម្មតាស្រទាប់ខាងលើនឹងព្យាយាមបញ្ជូនទិន្នន័យម្តងទៀតបន្ទាប់ពីពេលខ្លះ។ នៅក្នុងកម្មវិធីពិត អ្នកផ្ញើទំនងជានឹងរារាំងទិន្នន័យ (ជំនួសឱ្យការផ្ញើភ្លាមៗ) ឬមានយន្តការធ្វើសមកាលកម្ម (ដូចជា semaphore ឬទង់) ដែលនឹងអនុញ្ញាតឱ្យស្រទាប់ខាងលើហៅមុខងារផ្ញើតែនៅពេលដែលបង្អួចទទេ។ .
• ទទួលបានការបញ្ជាក់។ នៅក្នុងពិធីការ សម្រាប់កញ្ចប់ព័ត៌មានដែលមានលេខលំដាប់ 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 និងការចាប់ដៃអាចបង្កើនដំណើរការពិធីការយ៉ាងសំខាន់បើប្រៀបធៀបទៅនឹងការរង់ចាំការទទួលស្គាល់។ ដូចដែលយើងនឹងឃើញ ទំហំបង្អួចអាចត្រូវបានគណនាដោយផ្អែកលើសមត្ថភាពទទួល និងសតិបណ្ដោះអាសន្ននៃចុងទទួល ក៏ដូចជាកម្រិតផ្ទុកបណ្តាញ

ឧទាហរណ៍បន្ថែមទៀតនៃការប្រើប្រាស់ Go សម្រាប់បណ្តាញ

В ឃ្លាំង.

ប្រភព: www.habr.com