Websocket: [प्रश्न] क्या गोरिल्ला वेबसैट ने प्रसारण संदेश को एक सेकंड में सीमित कर दिया है?

उस समस्या का वर्णन करें जो आप कर रहे हैं
मैं एक सेकंड में 100 संदेश प्रसारित करने के लिए golang.org/x/net/websocket का उपयोग करता हूं कोई समस्या नहीं है, ग्राहक को सभी संदेश प्राप्त हो सकते हैं, लेकिन जब मैं गोरिल्ला वेबस्केट का उपयोग करता हूं, तो केवल 10 से कम संदेश प्राप्त होता है, फिर webckcket clientv भ्रष्ट हो जाएगा ।

…

संस्करणों

गो संस्करण: गो संस्करण go1.13.11 linux / amd64

पैकेज संस्करण: c3dd95aea9779669bb3daafbd84ee0530c8ce1f1

…

"मुझे कोड दिखाओ!"
पैकेज मुख्य

आयात (
"एन्कोडिंग / जसन"
"github.com/gorilla/websocket"
"लॉग"
"नेट / http"
"समय"
)

const (
// समय ने सहकर्मी को एक संदेश लिखने की अनुमति दी।
राइटवाइट = 10 * समय

// Time allowed to read the next pong message from the peer.
pongWait = 60 * time.Second

// Send pings to peer with this period. Must be less than pongWait.
pingPeriod = (pongWait * 9) / 10

// Maximum message size allowed from peer.
maxMessageSize = 512

)

var upgrader = websocket.Upgrader {
ReadBufferSize: 1024,
WriteBufferSize: 1024,
CheckOrigin: func (r * http.Request) बूल {वापसी सच},
}

var newline = [] बाइट {'\ n'}

टाइप क्लाइंट संरचना {
हब * हब
con * websocket.Conn
चैन संदेश भेजें
स्ट्रिंग देखें
}

प्रकार हब संरचना {
क्लाइंट मैप [* क्लाइंट] बूल
चैन संदेश प्रसारित करें
रजिस्टर चान * ग्राहक
अपंजीकृत चान * ग्राहक
}

func newHub () हब {वापसी और हब {प्रसारण: मेक (चान संदेश),रजिस्टर: मेक (चान * क्लाइंट),अपंजीकृत: बनाओ (चान * ग्राहक),ग्राहक: बनाना (नक्शा [ ग्राहक] बूल),
}

}

फंक (एच * हब) रन () {
के लिये {
चुनते हैं {
मामला ग्राहक: = <-h.register:
h.clients [ग्राहक] = सच
मामला ग्राहक: = <-h.unregister:
अगर _, ठीक: = h.clients [ग्राहक]; ठीक है {
हटाएं (एच। ग्राहक, ग्राहक)
बंद
}
मामला संदेश: = <-h.broadcast:
ग्राहक के लिए: = श्रेणी h.clients {
अगर client.see == message.LogName {
client.send <- संदेश
}
//चुनते हैं {
// केस client.send <- संदेश:
//चूक:
// बंद (client.send)
// हटाएं (एच। ग्राहक, ग्राहक)
//}
}
}
}
}

func (c * क्लाइंट) readPump () {
डेफ़ फंक () {
c.hub.unregister <- सी
_ = c.conn.Close ()
} ()
c.conn.SetReadLimit (maxMessageSize)
_ = c.conn.SetReadDeadline (time.Now ()। Add (pongWait)
c.conn.SetPongHandler (func (string) error {_ = c.conn.SetReadDeadline (time.Now ()। add (pongWait)); वापस nil})
के लिये {
_, संदेश, गलत: = c.conn.ReadMessage ()
अगर गलत है! = nil {
अगर websocket।
ErrorLogger.Printf ("readPump त्रुटि के साथ विफल:% v", इर)
}
टूटना
}

    type recv struct {
        LogName string `json:"logName"`
    }
    var rcv = &recv{}
    if err := json.Unmarshal(message, &rcv); err != nil {
        c.hub.unregister <- c
        ErrorLogger.Printf("%s",err)
        break
    }
    c.see = rcv.LogName
}

}

func (c * क्लाइंट) राइटपंप () {
टिकर: = समय
डेफ़ फंक () {
टिकर .टॉप ()
_ = c.conn.Close ()
} ()
के लिये {
चुनते हैं {
मामला संदेश, ठीक है: = <-send:
_ = c.conn.SetWriteDeadline (time.Now ()। Add (writeWait)
अगर! ठीक है {
// हब ने चैनल बंद कर दिया।
_ = c.conn.WriteMessage (websocket.CloseMessage, [] बाइट {})
वापसी
}

        w, err := c.conn.NextWriter(websocket.TextMessage)
        if err != nil {
            return
        }
        msgByte, _ := json.Marshal(message)
        _, _ = w.Write(msgByte)

        // Add queued chat messages to the current websocket message.
        n := len(c.send)
        _, _ = w.Write(newline)
        for i := 0; i < n; i++ {
            for msg := range c.send {
                msgByte, _ := json.Marshal(msg)
                _, err := w.Write(msgByte)
                if err != nil {
                    newHub().unregister <- c
                    ErrorLogger.Printf("%s", err)
                    break
                }
            }
        }
        if err := w.Close(); err != nil {
            return
        }
    case <-ticker.C:
        _ = c.conn.SetWriteDeadline(time.Now().Add(writeWait))
        if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
            return
        }
    }
}

}

// serveWs सहकर्मी से websocket अनुरोध संभालता है।
फंक सर्व्स (हब * हब, डब्ल्यू http.esponseWriter, आर * http.Request) {
कॉन, इरेट: = upgrader.Upgrad (w, r, nil)
अगर गलत है! = nil {
log.Fatal (इरेट)
वापसी
}
ग्राहक: = & ग्राहक {हब: हब, कॉन: कॉन, भेजें: मेक (चान संदेश, 1)}
client.hub.register <- क्लाइंट

// Allow collection of memory referenced by the caller by doing all work in
// new goroutines.
go client.writePump()
go client.readPump()

}