Pourquoi mon socket Go Unix ne communique-t-il que dans un sens ?

Communication bidirectionnelle par socket Unix dans Go

Les sockets Unix fournissent un mécanisme pratique pour implémenter la communication inter-processus au sein d'un système. Dans Go, les opérations de mise en réseau peuvent être effectuées à l'aide du package net. Parfois, lorsque vous tentez d'établir une communication bidirectionnelle à l'aide de sockets Unix, il peut sembler qu'une seule direction fonctionne.

Une cause possible de ce comportement est une gestion insuffisante des erreurs. Dans l'exemple donné, l'opération d'écriture du serveur manquait de gestion des erreurs, ce qui entraînait une perte potentielle de données. En ajoutant une panique lorsqu'une erreur survient lors de l'opération d'écriture, nous garantissons que toute perte de données est immédiatement apparente.

De plus, au sein de la goroutine du client, l'absence de gestion des erreurs pour l'opération de lecture empêchait le client de recevoir toutes les données envoyées par le serveur. L'inclusion de la gestion des erreurs et l'ajout d'un appel à une goroutine de lecteur distincte pour gérer les données entrantes du serveur résolvent ce problème.

Voici une version modifiée de l'exemple avec la gestion des erreurs nécessaire ajustements :

Serveur

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

Avec ces modifications en place, une communication bidirectionnelle entre le client et le serveur est établie, permettant à la fois l'envoi et la réception de données via Unix prise.

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!