search
HomeBackend DevelopmentGolangHow to register a new websocket connection with gooptic

如何注册新的 websocket 连接 gooptic

php Xiaobian Yuzai will introduce you how to register a new websocket connection with gooptic. GoOptic is an open source Go language websocket library for building high-performance, real-time communication applications. To register a new websocket connection, you first need to import the GoOptic library in your Go program. You can then use the functions provided by GoOptic to create a websocket server and specify the address and port to listen on. Next, you can use the HandleFunc function provided by GoOptic to handle various events of the websocket connection, such as receiving messages, sending messages, etc. Finally, call the Serve function provided by GoOptic to start the websocket server so that it can accept new connections. With these steps, you can successfully register a new websocket connection with gooptic.

Question content

I'm trying to set up a simple websocket server that should serve some content to the client at unknown intervals.

My code currently looks like this:

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

        }

    }
}

The problem I'm having is that when I connect to the websocket, my registration select case is missing (I want to register the client connection to the map using the uuid previously provided to the client).

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")
}
Is there something missing in

handler.go or should I take a different approach when connecting to the server using the client?

Workaround

According to my testing, the register's select case does hit (the code I used is attached at the bottom of this answer).

But I found other problems in the code:

  1. unregister chan is unbuffered, unregister in <code>socketlistener will be blocked. When the code reaches unregister , a deadlock occurs between it and <code>case c := .
  2. It seems that our entire server only needs one socketlistener goroutine. If this is the case, it should be moved outside handlewsmonitor.
  3. handlewsmonitor and socketlistener both read from the connection. What are the responsibilities of socketlistener? It seems it shouldn't read from the connection.

Thinking about it again, it seems that you can add and delete connections directly on the map in handlewsmonitor. socketlistener can be completely deleted. Simplicity should be a key goal of design. See kiss principles.

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

        }
    }
}

The above is the detailed content of How to register a new websocket connection with gooptic. For more information, please follow other related articles on the PHP Chinese website!

Statement
This article is reproduced at:stackoverflow. If there is any infringement, please contact admin@php.cn delete
Logging Errors Effectively in Go ApplicationsLogging Errors Effectively in Go ApplicationsApr 30, 2025 am 12:23 AM

Effective Go application error logging requires balancing details and performance. 1) Using standard log packages is simple but lacks context. 2) logrus provides structured logs and custom fields. 3) Zap combines performance and structured logs, but requires more settings. A complete error logging system should include error enrichment, log level, centralized logging, performance considerations, and error handling modes.

Empty Interfaces ( interface{} ) in Go: Use Cases and ConsiderationsEmpty Interfaces ( interface{} ) in Go: Use Cases and ConsiderationsApr 30, 2025 am 12:23 AM

EmptyinterfacesinGoareinterfaceswithnomethods,representinganyvalue,andshouldbeusedwhenhandlingunknowndatatypes.1)Theyofferflexibilityforgenericdataprocessing,asseeninthefmtpackage.2)Usethemcautiouslyduetopotentiallossoftypesafetyandperformanceissues,

Comparing Concurrency Models: Go vs. Other LanguagesComparing Concurrency Models: Go vs. Other LanguagesApr 30, 2025 am 12:20 AM

Go'sconcurrencymodelisuniqueduetoitsuseofgoroutinesandchannels,offeringalightweightandefficientapproachcomparedtothread-basedmodelsinlanguageslikeJava,Python,andRust.1)Go'sgoroutinesaremanagedbytheruntime,allowingthousandstorunconcurrentlywithminimal

Go's Concurrency Model: Goroutines and Channels ExplainedGo's Concurrency Model: Goroutines and Channels ExplainedApr 30, 2025 am 12:04 AM

Go'sconcurrencymodelusesgoroutinesandchannelstomanageconcurrentprogrammingeffectively.1)Goroutinesarelightweightthreadsthatalloweasyparallelizationoftasks,enhancingperformance.2)Channelsfacilitatesafedataexchangebetweengoroutines,crucialforsynchroniz

Interfaces and Polymorphism in Go: Achieving Code ReusabilityInterfaces and Polymorphism in Go: Achieving Code ReusabilityApr 29, 2025 am 12:31 AM

InterfacesandpolymorphisminGoenhancecodereusabilityandmaintainability.1)Defineinterfacesattherightabstractionlevel.2)Useinterfacesfordependencyinjection.3)Profilecodetomanageperformanceimpacts.

What is the role of the 'init' function in Go?What is the role of the 'init' function in Go?Apr 29, 2025 am 12:28 AM

TheinitfunctioninGorunsautomaticallybeforethemainfunctiontoinitializepackagesandsetuptheenvironment.It'susefulforsettingupglobalvariables,resources,andperformingone-timesetuptasksacrossanypackage.Here'showitworks:1)Itcanbeusedinanypackage,notjusttheo

Interface Composition in Go: Building Complex AbstractionsInterface Composition in Go: Building Complex AbstractionsApr 29, 2025 am 12:24 AM

Interface combinations build complex abstractions in Go programming by breaking down functions into small, focused interfaces. 1) Define Reader, Writer and Closer interfaces. 2) Create complex types such as File and NetworkStream by combining these interfaces. 3) Use ProcessData function to show how to handle these combined interfaces. This approach enhances code flexibility, testability, and reusability, but care should be taken to avoid excessive fragmentation and combinatorial complexity.

Potential Pitfalls and Considerations When Using init Functions in GoPotential Pitfalls and Considerations When Using init Functions in GoApr 29, 2025 am 12:02 AM

InitfunctionsinGoareautomaticallycalledbeforethemainfunctionandareusefulforsetupbutcomewithchallenges.1)Executionorder:Multipleinitfunctionsrunindefinitionorder,whichcancauseissuesiftheydependoneachother.2)Testing:Initfunctionsmayinterferewithtests,b

See all articles

Hot AI Tools

Undresser.AI Undress

Undresser.AI Undress

AI-powered app for creating realistic nude photos

AI Clothes Remover

AI Clothes Remover

Online AI tool for removing clothes from photos.

Undress AI Tool

Undress AI Tool

Undress images for free

Clothoff.io

Clothoff.io

AI clothes remover

Video Face Swap

Video Face Swap

Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Tools

Dreamweaver CS6

Dreamweaver CS6

Visual web development tools

SAP NetWeaver Server Adapter for Eclipse

SAP NetWeaver Server Adapter for Eclipse

Integrate Eclipse with SAP NetWeaver application server.

PhpStorm Mac version

PhpStorm Mac version

The latest (2018.2.1) professional PHP integrated development tool

Atom editor mac version download

Atom editor mac version download

The most popular open source editor

Safe Exam Browser

Safe Exam Browser

Safe Exam Browser is a secure browser environment for taking online exams securely. This software turns any computer into a secure workstation. It controls access to any utility and prevents students from using unauthorized resources.