Comment enregistrer une nouvelle connexion Websocket avec gooptic

l'éditeur php Yuzai vous présentera comment enregistrer une nouvelle connexion websocket avec gooptic. GoOptic est une bibliothèque websocket open source en langage Go permettant de créer des applications de communication hautes performances en temps réel. Pour enregistrer une nouvelle connexion websocket, vous devez d'abord importer la bibliothèque GoOptic dans votre programme Go. Vous pouvez ensuite utiliser les fonctions fournies par GoOptic pour créer un serveur websocket et spécifier l'adresse et le port sur lesquels écouter. Ensuite, vous pouvez utiliser la fonction HandleFunc fournie par GoOptic pour gérer divers événements de la connexion websocket, tels que la réception de messages, l'envoi de messages, etc. Enfin, appelez la fonction Serve fournie par GoOptic pour démarrer le serveur websocket afin qu'il puisse accepter de nouvelles connexions. Avec ces étapes, vous pouvez réussir à enregistrer une nouvelle connexion Websocket avec gooptic.

Contenu de la question

J'essaie de configurer un simple serveur Websocket qui devrait fournir du contenu au client à des intervalles inconnus.

Mon code ressemble actuellement à ceci :

router.go

func setuproutes(app *fiber.app) error {

    app.get("/whop/validate", handler.handlewhopvalidate)
    /*other non-websocket routes*/

    /*...*/

    app.get("/ws/monitor", websocket.new(wshandler.handlewsmonitor))

    app.use(func(c *fiber.ctx) error {
        c.sendstatus(404)
        return c.next()
    })

    return nil
}

handler.go

package handlers

import (
    "fmt"
    "log"

    "github.com/gofiber/websocket/v2"
)

var register = make(chan *websocket.conn)
var unregister = make(chan *websocket.conn)

func handlewsmonitor(c *websocket.conn) {
    go socketlistener()
    defer func() {
        unregister <- c
        //may need to check whether connection is already closed before re-closing?
        c.close()
    }()
    //sends conn into channel
    register <- c
    for {
        messagetype, message, err := c.readmessage()
        if err != nil {
            if websocket.isunexpectedcloseerror(err, websocket.closegoingaway, websocket.closeabnormalclosure) {
                log.println("read error:", err)
            }
            return
        }
        if messagetype == websocket.textmessage {
            log.println("got textmessage:", string(message))
        } else {
            log.println("received message of type:", messagetype)
        }
    }
}

func socketlistener() {
    for {
        select {
        case c := <-register:
            messagetype, message, err := c.readmessage()
            if err != nil {
                log.println(err)
                unregister <- c
                return
            }

            fmt.printf("got message of type: %d\nmessage:%s\n", messagetype, string(message))
            fmt.printf("connection params: %s\n", c.params("id"))
            //append to list of co
        case c := <-unregister:
            //remove conection from list of clients
            c.close()
            fmt.printf("closed connection\n")

        }

    }
}

Le problème que j'ai est que lorsque je me connecte à websocket, mon cas de sélection d'enregistrement est manquant (je souhaite enregistrer la connexion client à la carte en utilisant l'uuid que j'ai fourni au client plus tôt) .

client.go

package main

import (
    "flag"
    "log"
    "net/url"

    "github.com/fasthttp/websocket"
)

type Client struct {
    C *websocket.Conn
}

func main() {
    addr := flag.String("addr", "localhost:8080", "http service address")
    u := url.URL{
        Scheme:   "ws",
        Host:     *addr,
        Path:     "/ws/monitor",
        RawQuery: "id=12",
    }
    wsClient := &Client{}

    log.Printf("connecting to %s\n", u.String())
    // Connect to the WebSocket server
    conn, resp, err := websocket.DefaultDialer.Dial(u.String(), nil)
    if err != nil {
        log.Fatal("Dial:", err)
    }
    wsClient.C = conn
    if resp != nil {
        log.Println("Got response:", resp)
    }
    defer wsClient.closeConn()
}

func (client *Client) closeConn() {
    err := client.C.WriteMessage(
        websocket.CloseMessage,
        websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""),
    )
    if err != nil {
        log.Println("Write close:", err)
        return
    }
    client.C.Close()
    log.Println("Connection closed")
}

Y a-t-il quelque chose qui manque dans

handler.go ou dois-je adopter une approche différente lorsque j'utilise le client pour me connecter au serveur ?

Solution de contournement

Selon mes tests, le cas sélectionné du registre fonctionne (le code que j'ai utilisé est joint au bas de cette réponse).

Mais j'ai trouvé d'autres problèmes dans le code :

Une impasse survient entre
1. unregister chan 是无缓冲的，socketlistener 中的 unregister <- c​​ 将被阻塞。当代码到达 unregister <- c​​ 时，它和 case c := <-unregister.
2. On dirait que nous n'en avons besoin que d'un seul socketlistener goroutine。如果是这种情况，应将其移至 handlewsmonitor pour l'ensemble du serveur.
3. handlewsmonitor 和 socketlistener 都从连接中读取。 socketlistenerQuelles sont vos responsabilités ? Il semble qu'il ne devrait pas être lu à partir de la connexion.

En y repensant, il semble qu'il puisse être complètement supprimé directement dans handlewsmonitor中的地图上添加连接和删除连接。 socketlistener. La simplicité devrait être un objectif clé du design. Voir le principe du baiser.

package main

import (
    "log"

    "github.com/gofiber/fiber/v2"
    "github.com/gofiber/websocket/v2"
)

var (
    register   = make(chan *websocket.Conn)
    unregister = make(chan *websocket.Conn)
)

func main() {
    // Make it easy to find out which line prints the log.
    log.SetFlags(log.Lshortfile)
    app := fiber.New()

    app.Get("/ws/monitor", websocket.New(HandleWsMonitor))

    log.Fatal(app.Listen(":8080"))
}

func HandleWsMonitor(c *websocket.Conn) {
    // It seems the we only need one SocketListener goroutine for the whole server.
    // If this is the case, the next line should be moved outside of this func.
    go SocketListener()
    defer func() {
        unregister <- c
        c.Close()
    }()

    register <- c
    for {
        messageType, message, err := c.ReadMessage()
        if err != nil {
            if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
                log.Println("read error:", err)
            }
            return
        }
        if messageType == websocket.TextMessage {
            log.Println("got textmessage:", string(message))
        } else {
            log.Println("received message of type:", messageType)
        }
    }
}

func SocketListener() {
    for {
        select {
        case c := <-register:
            // This did appear in the log.
            log.Println("case c := <-register")
            messageType, message, err := c.ReadMessage()
            if err != nil {
                log.Println(err)
                // unregister is unbuffered, the sending will be blocked.
                unregister <- c
                // If we use only one SocketListener goroutine then it should
                // not return here.
                return
            }

            log.Printf("Got message of type: %d\nMessage:%s\n", messageType, string(message))
            log.Printf("Connection Params: %s\n", c.Params("id"))
        case c := <-unregister:
            c.Close()
            log.Println("Closed connection")

        }
    }
}

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!