Trying to send a message from websocket inside the same port - go

Question

I'm writing a chat using WebSocket with gorilla https://github.com/gorilla/websocket
It's working. But now I need to send a message from a consumer of rabbitMQ that I created. The idea is to be a Bot that answers some questions.
The problem is. That I don't know how to send a message without been using a WebSocket dial request which doesn't work, it giver this error.
dial:websocket: bad handshake
Should I create an separated go main with a different port so I can send the message? Or is it possible to do it inside the same main package?
This is the websocket code
package socket
import (
"chatGo/src/domain/message"
"chatGo/src/domain/message/repository"
"chatGo/src/infrastructure/queue"
"fmt"
"github.com/gin-gonic/gin"
"github.com/gorilla/websocket"
"github.com/novalagung/gubrak/v2"
"log"
"net/http"
"strings"
)
const messageNewUser = "New User"
const messageChat = "Chat"
const messageLeave = "Leave"
const maxMessageSize = 1024 * 1024 // 1kb
var connections = make([]*webSocketConnection, 0)
type payload struct {
Message string
}
type response struct {
From string
Type string
Message string
}
type webSocketConnection struct {
*websocket.Conn
Username string
}
func Execute(c *gin.Context, db repository.GormDB, qBroker *queue.Broker) {
upgrader := websocket.Upgrader{
ReadBufferSize: maxMessageSize,
WriteBufferSize: maxMessageSize,
}
currentGorillaConn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
if err != nil {
http.Error(c.Writer, "Could not open websocket connection", http.StatusBadRequest)
}
username := c.Query("username")
currentConn := webSocketConnection{Conn: currentGorillaConn, Username: username}
connections = append(connections, &currentConn)
go handleIO(&currentConn, db, qBroker)
}
func handleIO(currentConn *webSocketConnection, db repository.GormDB, qBroker *queue.Broker) {
defer func() {
if r := recover(); r != nil {
log.Println("ERROR", fmt.Sprintf("%v", r))
}
}()
messageEntitiy := message.NewMessage(currentConn.Username, messageNewUser, "")
broadcastMessage(currentConn, messageEntitiy)
messageStr := fmt.Sprintf("User %s: connected", currentConn.Username)
messageEntitiy = message.NewMessage(currentConn.Username, messageNewUser, messageStr)
db.Create(messageEntitiy)
for {
payload := payload{}
err := currentConn.ReadJSON(&payload)
if err != nil {
if strings.Contains(err.Error(), "websocket: close") {
messageEntitiy := message.NewMessage(currentConn.Username, messageLeave, "")
broadcastMessage(currentConn, messageEntitiy)
ejectConnection(currentConn)
messageStr := fmt.Sprintf("User %s: disconnect", currentConn.Username)
messageEntitiy = message.NewMessage(currentConn.Username, messageLeave, messageStr)
db.Create(messageEntitiy)
return
}
log.Println("ERROR", err.Error())
continue
}
trimStr := strings.TrimSpace(payload.Message)
splitStr := strings.Split(trimStr, "=")
if splitStr[0] == "/stock" {
_ = qBroker.PublishMessage("bot-send", splitStr[1])
} else {
messageEntitiy := message.NewMessage(currentConn.Username, messageChat, payload.Message)
db.Create(messageEntitiy)
}
broadcastMessage(currentConn, messageEntitiy)
}
}
func ejectConnection(currentConn *webSocketConnection) {
filtered := gubrak.From(connections).Reject(func(each *webSocketConnection) bool {
return each == currentConn
}).Result()
connections = filtered.([]*webSocketConnection)
}
func broadcastMessage(currentConn *webSocketConnection, message message.Message) {
for _, eachConn := range connections {
if eachConn == currentConn {
continue
}
eachConn.WriteJSON(response{
From: currentConn.Username,
Type: message.Kind,
Message: message.Message,
})
}
}
I tried this code to send an message using dial
var addr = flag.String("addr", "localhost:8081", "http service address")
test2 := func(msg string) {
u := url.URL{Scheme: "ws", Host: *addr, Path: "/echo"}
log.Printf("connecting to %s", u.String())
c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
if err != nil {
log.Fatal("dial:", err)
}
defer c.Close()
err = c.WriteMessage(websocket.TextMessage, []byte(msg))
if err != nil {
log.Println("write:", err)
return
}
Edit 1:
It was missing the handler. I fixed this with the correct handler.
But now If I send I get this error
u := url.URL{Scheme: "ws", Host: *addr, Path: "/socket/ws?username=Bot"}
ERROR invalid character 'T' looking for beginning of value
But my idea would be to send with and Query param, but when I do a get a bad handshake 404
u := url.URL{Scheme: "ws", Host: *addr, Path: "/socket/ws?username=Bot"}
dial:websocket: bad handshake 404