Warum kommuniziert mein Go-Unix-Socket nur in eine Richtung?

Bidirektionale Unix-Socket-Kommunikation in Go

Unix-Sockets bieten einen praktischen Mechanismus zur Implementierung der prozessübergreifenden Kommunikation innerhalb eines Systems. In Go können Netzwerkoperationen mithilfe des Net-Pakets ausgeführt werden. Beim Versuch, eine bidirektionale Kommunikation über Unix-Sockets aufzubauen, kann es gelegentlich vorkommen, dass nur eine Richtung funktioniert.

Eine mögliche Ursache für dieses Verhalten ist eine unzureichende Fehlerbehandlung. Im gegebenen Beispiel fehlte beim Schreibvorgang des Servers die Fehlerbehandlung, was zu potenziellem Datenverlust führte. Indem wir eine Panikfunktion hinzufügen, wenn während des Schreibvorgangs ein Fehler auftritt, stellen wir sicher, dass jeglicher Datenverlust sofort erkennbar ist.

Darüber hinaus verhinderte das Fehlen einer Fehlerbehandlung für den Lesevorgang innerhalb der Goroutine des Clients, dass der Client empfangen konnte alle vom Server gesendeten Daten. Das Einschließen der Fehlerbehandlung und das Hinzufügen eines Aufrufs an eine separate Reader-Goroutine zur Verarbeitung eingehender Daten vom Server behebt dieses Problem.

Hier ist eine modifizierte Version des Beispiels mit der erforderlichen Fehlerbehandlung Anpassungen:

Server

package main

import (
    "log"
    "net"
)

func echoServer(c net.Conn) {
    for {
        buf := make([]byte, 512)
        nr, err := c.Read(buf)
        if err != nil {
            return
        }

        data := buf[0:nr]
        println("Server got:", string(data))
        _, err = c.Write(data)
        if err != nil {
            log.Fatal("Write: ", err)
        }
    }
}

func main() {
    l, err := net.Listen("unix", "/tmp/echo.sock")
    if err != nil {
        log.Fatal("listen error:", err)
    }

    for {
        fd, err := l.Accept()
        if err != nil {
            log.Fatal("accept error:", err)
        }

        go echoServer(fd)
    }
}

Client

package main

import (
    "io"
    "log"
    "net"
    "time"
)

func reader(r io.Reader) {
    buf := make([]byte, 1024)
    for {
        n, err := r.Read(buf[:])
        if err != nil {
            return
        }
        println("Client got:", string(buf[0:n]))
    }
}

func main() {
    c, err := net.Dial("unix", "/tmp/echo.sock")
    if err != nil {
        panic(err)
    }
    defer c.Close()

    go reader(c)
    for {
        _, err := c.Write([]byte("hi"))
        if err != nil {
            log.Fatal("write error:", err)
            break
        }
        time.Sleep(1e9)
    }
}

Mit diesen Änderungen in Kraft, Es wird eine bidirektionale Kommunikation zwischen Client und Server hergestellt, die das Senden und Empfangen von Daten über Unix ermöglicht Steckdose.

Das obige ist der detaillierte Inhalt vonWarum kommuniziert mein Go-Unix-Socket nur in eine Richtung?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!