Pourquoi ma connexion Socket Go Unix est-elle unidirectionnelle et comment puis-je y remédier ?

Sockets Unix dans Go : un problème de connexion unidirectionnelle

Un défi courant lorsque l'on travaille avec des sockets Unix dans Go est que la connexion peut parfois devenir unidirectionnel. Bien que les données puissent être reçues par une partie, le renvoi des données n'entraîne aucune réponse.

Analysons un exemple de code fourni dans un fil de discussion pour identifier la cause :

Code du serveur :

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

        data := buf[0:nr]
        fmt.Printf("Received: %v", string(data))
        _, err = c.Write(data)
        if err != nil {
            panic("Write: " + err.String())
        }
    }
}

Client Code :

func main() {
    c,err := net.Dial("unix","", "/tmp/echo.sock")
    if err != nil {
        panic(err.String())
    }
    for {
        _,err := c.Write([]byte("hi\n"))
        if err != nil {
            println(err.String())
        }
        time.Sleep(1e9)
    }
}

En examinant le code, nous remarquons que le client ne lit pas la réponse envoyée par le serveur. Cela provoque un problème où le client continue d'envoyer des données au serveur mais ne reçoit jamais de réponse.

Solution :

Pour résoudre ce problème, nous devons ajouter un goroutine dans le client pour gérer la lecture de la réponse du serveur. Après avoir effectué cette modification, le code fonctionnera comme prévu :

Code serveur révisé :

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

Code client révisé :

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

Avec ces changements, le serveur peut recevoir des données du client et également renvoyer des réponses, ce qui entraîne une communication bidirectionnelle chaîne.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!