Initial commit: Эфир мессенджер
This commit is contained in:
305
internal/websocket/client.go
Normal file
305
internal/websocket/client.go
Normal file
@@ -0,0 +1,305 @@
|
||||
package websocket
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"log"
|
||||
"messenger/internal/models"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/gorilla/websocket"
|
||||
)
|
||||
|
||||
const (
|
||||
writeWait = 10 * time.Second
|
||||
pongWait = 60 * time.Second
|
||||
pingPeriod = (pongWait * 9) / 10
|
||||
maxMessageSize = 512 * 1024
|
||||
)
|
||||
|
||||
type Client struct {
|
||||
hub *Hub
|
||||
conn *websocket.Conn
|
||||
send chan []byte
|
||||
user *models.User
|
||||
userID int64
|
||||
rooms map[int64]bool
|
||||
mu sync.RWMutex
|
||||
lastPing time.Time
|
||||
}
|
||||
|
||||
func NewClient(hub *Hub, conn *websocket.Conn, user *models.User) *Client {
|
||||
return &Client{
|
||||
hub: hub,
|
||||
conn: conn,
|
||||
send: make(chan []byte, 256),
|
||||
user: user,
|
||||
userID: user.ID,
|
||||
rooms: make(map[int64]bool),
|
||||
lastPing: time.Now(),
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) ReadPump() {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
log.Printf("Recovered in ReadPump: %v", r)
|
||||
}
|
||||
c.hub.GetUnregisterChan() <- c
|
||||
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))
|
||||
c.mu.Lock()
|
||||
c.lastPing = time.Now()
|
||||
c.mu.Unlock()
|
||||
return nil
|
||||
})
|
||||
|
||||
for {
|
||||
_, message, err := c.conn.ReadMessage()
|
||||
if err != nil {
|
||||
if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
|
||||
log.Printf("WebSocket error: %v", err)
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
log.Printf("Received message from client %d: %s", c.userID, string(message))
|
||||
c.handleMessage(message)
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) WritePump() {
|
||||
ticker := time.NewTicker(pingPeriod)
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
log.Printf("Recovered in WritePump: %v", r)
|
||||
}
|
||||
ticker.Stop()
|
||||
c.conn.Close()
|
||||
}()
|
||||
|
||||
for {
|
||||
select {
|
||||
case message, ok := <-c.send:
|
||||
c.conn.SetWriteDeadline(time.Now().Add(writeWait))
|
||||
if !ok {
|
||||
c.conn.WriteMessage(websocket.CloseMessage, []byte{})
|
||||
return
|
||||
}
|
||||
|
||||
if err := c.conn.WriteMessage(websocket.TextMessage, message); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
case <-ticker.C:
|
||||
c.conn.SetWriteDeadline(time.Now().Add(writeWait))
|
||||
if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) handleMessage(raw []byte) {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
log.Printf("Recovered in handleMessage: %v", r)
|
||||
}
|
||||
}()
|
||||
|
||||
msg, err := ParseMessage(raw)
|
||||
if err != nil {
|
||||
c.sendError(400, "Invalid message format")
|
||||
return
|
||||
}
|
||||
|
||||
switch msg.Type {
|
||||
case MsgTypeNewMessage:
|
||||
c.handleNewMessage(msg.Data)
|
||||
case MsgTypeTyping:
|
||||
c.handleTyping(msg.Data)
|
||||
case MsgTypeReadReceipt:
|
||||
c.handleReadReceipt(msg.Data)
|
||||
case MsgTypeEditMessage:
|
||||
c.handleEditMessage(msg.Data)
|
||||
case MsgTypeDeleteMessage:
|
||||
c.handleDeleteMessage(msg.Data)
|
||||
case MsgTypePing:
|
||||
c.handlePing()
|
||||
default:
|
||||
c.sendError(400, "Unknown message type")
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) handleNewMessage(data []byte) {
|
||||
var req NewMessageRequest
|
||||
if err := json.Unmarshal(data, &req); err != nil {
|
||||
log.Printf("Failed to parse new_message: %v", err)
|
||||
c.sendError(400, "Invalid new_message data")
|
||||
return
|
||||
}
|
||||
|
||||
log.Printf("New message from user %d to chat %d: %s", c.userID, req.ChatID, req.Plaintext)
|
||||
|
||||
if !c.isMemberOfChat(req.ChatID) {
|
||||
log.Printf("User %d is not a member of chat %d", c.userID, req.ChatID)
|
||||
c.sendError(403, "Not a member of this chat")
|
||||
return
|
||||
}
|
||||
|
||||
c.hub.GetBroadcastChan() <- &BroadcastMessage{
|
||||
Type: MsgTypeNewMessage,
|
||||
ChatID: req.ChatID,
|
||||
SenderID: c.userID,
|
||||
Data: req,
|
||||
Client: c,
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) handleTyping(data []byte) {
|
||||
var req TypingRequest
|
||||
if err := json.Unmarshal(data, &req); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
resp := TypingResponse{
|
||||
ChatID: req.ChatID,
|
||||
UserID: c.userID,
|
||||
IsTyping: req.IsTyping,
|
||||
}
|
||||
|
||||
msgBytes, _ := CreateMessage(MsgTypeUserTyping, resp)
|
||||
|
||||
c.hub.roomsMu.RLock()
|
||||
room, exists := c.hub.rooms[req.ChatID]
|
||||
c.hub.roomsMu.RUnlock()
|
||||
|
||||
if exists {
|
||||
room.Broadcast(msgBytes, c)
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) handleReadReceipt(data []byte) {
|
||||
var req ReadReceiptRequest
|
||||
if err := json.Unmarshal(data, &req); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
c.hub.broadcast <- &BroadcastMessage{
|
||||
Type: MsgTypeReadReceipt,
|
||||
MessageID: req.MessageID,
|
||||
UserID: c.userID,
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) handleEditMessage(data []byte) {
|
||||
var req EditMessageRequest
|
||||
if err := json.Unmarshal(data, &req); err != nil {
|
||||
c.sendError(400, "Invalid edit_message data")
|
||||
return
|
||||
}
|
||||
|
||||
c.hub.broadcast <- &BroadcastMessage{
|
||||
Type: MsgTypeEditMessage,
|
||||
MessageID: req.MessageID,
|
||||
SenderID: c.userID,
|
||||
Data: req,
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) handleDeleteMessage(data []byte) {
|
||||
var req DeleteMessageRequest
|
||||
if err := json.Unmarshal(data, &req); err != nil {
|
||||
c.sendError(400, "Invalid delete_message data")
|
||||
return
|
||||
}
|
||||
|
||||
c.hub.broadcast <- &BroadcastMessage{
|
||||
Type: MsgTypeDeleteMessage,
|
||||
MessageID: req.MessageID,
|
||||
SenderID: c.userID,
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) handlePing() {
|
||||
c.mu.Lock()
|
||||
c.lastPing = time.Now()
|
||||
c.mu.Unlock()
|
||||
|
||||
pongMsg, _ := CreateMessage(MsgTypePong, nil)
|
||||
select {
|
||||
case c.send <- pongMsg:
|
||||
default:
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) sendError(code int, message string) {
|
||||
errResp := ErrorResponse{
|
||||
Code: code,
|
||||
Message: message,
|
||||
}
|
||||
|
||||
msgBytes, _ := CreateMessage(MsgTypeError, errResp)
|
||||
select {
|
||||
case c.send <- msgBytes:
|
||||
default:
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) isMemberOfChat(chatID int64) bool {
|
||||
c.mu.RLock()
|
||||
defer c.mu.RUnlock()
|
||||
return c.rooms[chatID]
|
||||
}
|
||||
|
||||
func (c *Client) JoinRoom(chatID int64) {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
c.rooms[chatID] = true
|
||||
}
|
||||
|
||||
func (c *Client) LeaveRoom(chatID int64) {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
delete(c.rooms, chatID)
|
||||
}
|
||||
|
||||
func (c *Client) GetRooms() []int64 {
|
||||
c.mu.RLock()
|
||||
defer c.mu.RUnlock()
|
||||
|
||||
rooms := make([]int64, 0, len(c.rooms))
|
||||
for chatID := range c.rooms {
|
||||
rooms = append(rooms, chatID)
|
||||
}
|
||||
return rooms
|
||||
}
|
||||
|
||||
func (c *Client) SendMessage(msg []byte) {
|
||||
select {
|
||||
case c.send <- msg:
|
||||
default:
|
||||
log.Printf("Client %d send channel full", c.userID)
|
||||
c.hub.GetUnregisterChan() <- c
|
||||
c.conn.Close()
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) GetUserID() int64 {
|
||||
return c.userID
|
||||
}
|
||||
|
||||
func (c *Client) GetUser() *models.User {
|
||||
return c.user
|
||||
}
|
||||
|
||||
func (c *Client) IsAlive() bool {
|
||||
c.mu.RLock()
|
||||
defer c.mu.RUnlock()
|
||||
return time.Since(c.lastPing) < pongWait
|
||||
}
|
||||
414
internal/websocket/hub.go
Normal file
414
internal/websocket/hub.go
Normal file
@@ -0,0 +1,414 @@
|
||||
package websocket
|
||||
|
||||
import (
|
||||
"context"
|
||||
"messenger/internal/pkg/logger"
|
||||
"messenger/internal/service"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
type BroadcastMessage struct {
|
||||
Type MessageType
|
||||
ChatID int64
|
||||
MessageID int64
|
||||
UserID int64
|
||||
SenderID int64
|
||||
Data interface{}
|
||||
Client *Client
|
||||
}
|
||||
|
||||
type Hub struct {
|
||||
register chan *Client
|
||||
unregister chan *Client
|
||||
broadcast chan *BroadcastMessage
|
||||
clients map[int64]*Client
|
||||
clientsMu sync.RWMutex
|
||||
rooms map[int64]*Room
|
||||
roomsMu sync.RWMutex
|
||||
messageService *service.MessageService
|
||||
chatService *service.ChatService
|
||||
running bool
|
||||
mu sync.RWMutex
|
||||
}
|
||||
|
||||
func NewHub(messageService *service.MessageService, chatService *service.ChatService) *Hub {
|
||||
return &Hub{
|
||||
register: make(chan *Client),
|
||||
unregister: make(chan *Client),
|
||||
broadcast: make(chan *BroadcastMessage, 256),
|
||||
clients: make(map[int64]*Client),
|
||||
rooms: make(map[int64]*Room),
|
||||
messageService: messageService,
|
||||
chatService: chatService,
|
||||
running: true,
|
||||
}
|
||||
}
|
||||
|
||||
func (h *Hub) Run() {
|
||||
logger.Info("WebSocket Hub started")
|
||||
|
||||
for h.running {
|
||||
select {
|
||||
case client := <-h.register:
|
||||
h.handleRegister(client)
|
||||
case client := <-h.unregister:
|
||||
h.handleUnregister(client)
|
||||
case broadcast := <-h.broadcast:
|
||||
h.handleBroadcast(broadcast)
|
||||
}
|
||||
}
|
||||
|
||||
logger.Info("WebSocket Hub stopped")
|
||||
}
|
||||
|
||||
func (h *Hub) Stop() {
|
||||
h.mu.Lock()
|
||||
defer h.mu.Unlock()
|
||||
|
||||
h.running = false
|
||||
close(h.register)
|
||||
close(h.unregister)
|
||||
close(h.broadcast)
|
||||
|
||||
h.clientsMu.Lock()
|
||||
for _, client := range h.clients {
|
||||
func() {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
logger.Warn("Recovered while closing client", "error", r)
|
||||
}
|
||||
}()
|
||||
close(client.send)
|
||||
client.conn.Close()
|
||||
}()
|
||||
}
|
||||
h.clients = make(map[int64]*Client)
|
||||
h.clientsMu.Unlock()
|
||||
}
|
||||
|
||||
func (h *Hub) handleRegister(client *Client) {
|
||||
h.clientsMu.Lock()
|
||||
if oldClient, exists := h.clients[client.userID]; exists {
|
||||
func() {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
logger.Warn("Recovered while closing old client", "error", r)
|
||||
}
|
||||
}()
|
||||
close(oldClient.send)
|
||||
oldClient.conn.Close()
|
||||
}()
|
||||
}
|
||||
h.clients[client.userID] = client
|
||||
h.clientsMu.Unlock()
|
||||
|
||||
go h.addClientToChats(client)
|
||||
go h.notifyUserOnline(client.userID, true)
|
||||
|
||||
logger.Info("Client registered", "user_id", client.userID)
|
||||
}
|
||||
|
||||
func (h *Hub) handleUnregister(client *Client) {
|
||||
h.clientsMu.Lock()
|
||||
delete(h.clients, client.userID)
|
||||
h.clientsMu.Unlock()
|
||||
|
||||
// Закрываем канал безопасно
|
||||
func() {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
logger.Warn("Recovered while closing send channel", "error", r)
|
||||
}
|
||||
}()
|
||||
close(client.send)
|
||||
}()
|
||||
|
||||
h.roomsMu.Lock()
|
||||
for _, room := range h.rooms {
|
||||
room.RemoveClient(client)
|
||||
}
|
||||
h.roomsMu.Unlock()
|
||||
|
||||
go h.notifyUserOnline(client.userID, false)
|
||||
|
||||
logger.Info("Client unregistered", "user_id", client.userID)
|
||||
}
|
||||
|
||||
func (h *Hub) handleBroadcast(broadcast *BroadcastMessage) {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
logger.Error("Panic in handleBroadcast", "error", r)
|
||||
}
|
||||
}()
|
||||
|
||||
switch broadcast.Type {
|
||||
case MsgTypeNewMessage:
|
||||
h.handleNewMessageBroadcast(broadcast)
|
||||
case MsgTypeReadReceipt:
|
||||
h.handleReadReceiptBroadcast(broadcast)
|
||||
case MsgTypeEditMessage:
|
||||
h.handleEditMessageBroadcast(broadcast)
|
||||
case MsgTypeDeleteMessage:
|
||||
h.handleDeleteMessageBroadcast(broadcast)
|
||||
}
|
||||
}
|
||||
|
||||
func (h *Hub) handleNewMessageBroadcast(broadcast *BroadcastMessage) {
|
||||
req, ok := broadcast.Data.(NewMessageRequest)
|
||||
if !ok {
|
||||
logger.Error("Invalid broadcast data for new_message")
|
||||
return
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
|
||||
message, err := h.messageService.SendMessage(ctx, broadcast.Client.userID, req.ChatID, req.Plaintext, req.AttachmentID)
|
||||
if err != nil {
|
||||
logger.Error("Failed to save message", "error", err)
|
||||
broadcast.Client.sendError(500, "Failed to send message")
|
||||
return
|
||||
}
|
||||
|
||||
response := NewMessageResponse{
|
||||
ID: message.ID,
|
||||
ChatID: message.ChatID,
|
||||
SenderID: message.SenderID,
|
||||
Plaintext: message.Plaintext,
|
||||
CreatedAt: message.CreatedAt,
|
||||
TempID: req.TempID,
|
||||
}
|
||||
|
||||
msgBytes, err := CreateMessage(MsgTypeNewMessageResp, response)
|
||||
if err != nil {
|
||||
logger.Error("Failed to create message", "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
h.roomsMu.RLock()
|
||||
room, exists := h.rooms[req.ChatID]
|
||||
h.roomsMu.RUnlock()
|
||||
|
||||
if exists {
|
||||
room.BroadcastToAll(msgBytes)
|
||||
}
|
||||
}
|
||||
|
||||
func (h *Hub) handleReadReceiptBroadcast(broadcast *BroadcastMessage) {
|
||||
ctx := context.Background()
|
||||
|
||||
err := h.messageService.MarkMessageAsRead(ctx, broadcast.MessageID, broadcast.UserID)
|
||||
if err != nil {
|
||||
logger.Error("Failed to mark message as read", "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
message, err := h.messageService.GetMessageByID(ctx, broadcast.MessageID)
|
||||
if err != nil {
|
||||
logger.Error("Failed to get message for read receipt", "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
response := ReadReceiptResponse{
|
||||
MessageID: broadcast.MessageID,
|
||||
UserID: broadcast.UserID,
|
||||
ReadAt: time.Now(),
|
||||
}
|
||||
|
||||
msgBytes, err := CreateMessage(MsgTypeMessageRead, response)
|
||||
if err != nil {
|
||||
logger.Error("Failed to create read receipt message", "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
h.roomsMu.RLock()
|
||||
room, exists := h.rooms[message.ChatID]
|
||||
h.roomsMu.RUnlock()
|
||||
|
||||
if exists {
|
||||
room.BroadcastToAll(msgBytes)
|
||||
}
|
||||
}
|
||||
|
||||
func (h *Hub) handleEditMessageBroadcast(broadcast *BroadcastMessage) {
|
||||
req, ok := broadcast.Data.(EditMessageRequest)
|
||||
if !ok {
|
||||
logger.Error("Invalid broadcast data for edit_message")
|
||||
return
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
|
||||
err := h.messageService.EditMessage(ctx, broadcast.SenderID, req.MessageID, req.Plaintext)
|
||||
if err != nil {
|
||||
logger.Error("Failed to edit message", "error", err)
|
||||
if broadcast.Client != nil {
|
||||
broadcast.Client.sendError(403, "Failed to edit message")
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
message, err := h.messageService.GetMessageByID(ctx, req.MessageID)
|
||||
if err != nil {
|
||||
logger.Error("Failed to get edited message", "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
response := EditMessageResponse{
|
||||
MessageID: req.MessageID,
|
||||
NewPlaintext: req.Plaintext,
|
||||
EditedAt: time.Now(),
|
||||
}
|
||||
|
||||
msgBytes, err := CreateMessage(MsgTypeMessageEdited, response)
|
||||
if err != nil {
|
||||
logger.Error("Failed to create edit message", "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
h.roomsMu.RLock()
|
||||
room, exists := h.rooms[message.ChatID]
|
||||
h.roomsMu.RUnlock()
|
||||
|
||||
if exists {
|
||||
room.BroadcastToAll(msgBytes)
|
||||
}
|
||||
}
|
||||
|
||||
func (h *Hub) handleDeleteMessageBroadcast(broadcast *BroadcastMessage) {
|
||||
ctx := context.Background()
|
||||
|
||||
message, err := h.messageService.GetMessageByID(ctx, broadcast.MessageID)
|
||||
if err != nil {
|
||||
logger.Error("Failed to get message for deletion", "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
canDelete, err := h.messageService.CanDeleteMessage(ctx, broadcast.SenderID, broadcast.MessageID)
|
||||
if err != nil || !canDelete {
|
||||
logger.Error("User cannot delete message", "user_id", broadcast.SenderID, "message_id", broadcast.MessageID)
|
||||
if broadcast.Client != nil {
|
||||
broadcast.Client.sendError(403, "Cannot delete this message")
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
err = h.messageService.DeleteMessage(ctx, broadcast.MessageID)
|
||||
if err != nil {
|
||||
logger.Error("Failed to delete message", "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
response := DeleteMessageResponse{
|
||||
MessageID: broadcast.MessageID,
|
||||
DeletedAt: time.Now(),
|
||||
}
|
||||
|
||||
msgBytes, err := CreateMessage(MsgTypeMessageDeleted, response)
|
||||
if err != nil {
|
||||
logger.Error("Failed to create delete message", "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
h.roomsMu.RLock()
|
||||
room, exists := h.rooms[message.ChatID]
|
||||
h.roomsMu.RUnlock()
|
||||
|
||||
if exists {
|
||||
room.BroadcastToAll(msgBytes)
|
||||
}
|
||||
}
|
||||
|
||||
func (h *Hub) addClientToChats(client *Client) {
|
||||
ctx := context.Background()
|
||||
|
||||
chats, err := h.chatService.GetUserChats(ctx, client.userID)
|
||||
if err != nil {
|
||||
logger.Error("Failed to get user chats", "user_id", client.userID, "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
for _, chat := range chats {
|
||||
h.roomsMu.Lock()
|
||||
room, exists := h.rooms[chat.ID]
|
||||
if !exists {
|
||||
room = NewRoom(chat.ID)
|
||||
h.rooms[chat.ID] = room
|
||||
}
|
||||
h.roomsMu.Unlock()
|
||||
|
||||
room.AddClient(client)
|
||||
}
|
||||
|
||||
logger.Info("Client added to rooms", "user_id", client.userID, "room_count", len(chats))
|
||||
}
|
||||
|
||||
func (h *Hub) notifyUserOnline(userID int64, isOnline bool) {
|
||||
// Защита от паники
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
logger.Warn("Recovered in notifyUserOnline", "error", r)
|
||||
}
|
||||
}()
|
||||
|
||||
response := UserOnlineResponse{
|
||||
UserID: userID,
|
||||
IsOnline: isOnline,
|
||||
}
|
||||
|
||||
msgBytes, err := CreateMessage(MsgTypeUserOnline, response)
|
||||
if err != nil {
|
||||
logger.Error("Failed to create user online message", "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
h.roomsMu.RLock()
|
||||
defer h.roomsMu.RUnlock()
|
||||
|
||||
for _, room := range h.rooms {
|
||||
if room.HasClientByUserID(userID) {
|
||||
room.BroadcastToAll(msgBytes)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (h *Hub) GetRoom(chatID int64) (*Room, bool) {
|
||||
h.roomsMu.RLock()
|
||||
defer h.roomsMu.RUnlock()
|
||||
room, exists := h.rooms[chatID]
|
||||
return room, exists
|
||||
}
|
||||
|
||||
func (h *Hub) GetClient(userID int64) (*Client, bool) {
|
||||
h.clientsMu.RLock()
|
||||
defer h.clientsMu.RUnlock()
|
||||
client, exists := h.clients[userID]
|
||||
return client, exists
|
||||
}
|
||||
|
||||
func (h *Hub) SendToUser(userID int64, message []byte) bool {
|
||||
h.clientsMu.RLock()
|
||||
client, exists := h.clients[userID]
|
||||
h.clientsMu.RUnlock()
|
||||
|
||||
if exists {
|
||||
client.SendMessage(message)
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// GetRegisterChan возвращает канал для регистрации клиентов
|
||||
func (h *Hub) GetRegisterChan() chan<- *Client {
|
||||
return h.register
|
||||
}
|
||||
|
||||
// GetUnregisterChan возвращает канал для отмены регистрации клиентов
|
||||
func (h *Hub) GetUnregisterChan() chan<- *Client {
|
||||
return h.unregister
|
||||
}
|
||||
|
||||
// GetBroadcastChan возвращает канал для широковещательных сообщений
|
||||
func (h *Hub) GetBroadcastChan() chan<- *BroadcastMessage {
|
||||
return h.broadcast
|
||||
}
|
||||
136
internal/websocket/message.go
Normal file
136
internal/websocket/message.go
Normal file
@@ -0,0 +1,136 @@
|
||||
package websocket
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"time"
|
||||
)
|
||||
|
||||
type MessageType string
|
||||
|
||||
const (
|
||||
MsgTypeNewMessage MessageType = "new_message"
|
||||
MsgTypeTyping MessageType = "typing"
|
||||
MsgTypeReadReceipt MessageType = "read_receipt"
|
||||
MsgTypeEditMessage MessageType = "edit_message"
|
||||
MsgTypeDeleteMessage MessageType = "delete_message"
|
||||
MsgTypePing MessageType = "ping"
|
||||
|
||||
MsgTypeNewMessageResp MessageType = "new_message"
|
||||
MsgTypeUserTyping MessageType = "user_typing"
|
||||
MsgTypeMessageRead MessageType = "message_read"
|
||||
MsgTypeMessageEdited MessageType = "message_edited"
|
||||
MsgTypeMessageDeleted MessageType = "message_deleted"
|
||||
MsgTypeUserOnline MessageType = "user_online"
|
||||
MsgTypeUserOffline MessageType = "user_offline"
|
||||
MsgTypePong MessageType = "pong"
|
||||
MsgTypeError MessageType = "error"
|
||||
)
|
||||
|
||||
type WSMessage struct {
|
||||
Type MessageType `json:"type"`
|
||||
Data json.RawMessage `json:"data,omitempty"`
|
||||
Timestamp time.Time `json:"timestamp"`
|
||||
}
|
||||
|
||||
type NewMessageRequest struct {
|
||||
ChatID int64 `json:"chat_id"`
|
||||
Plaintext string `json:"plaintext"`
|
||||
AttachmentID *int64 `json:"attachment_id,omitempty"`
|
||||
TempID string `json:"temp_id,omitempty"`
|
||||
}
|
||||
|
||||
type NewMessageResponse struct {
|
||||
ID int64 `json:"id"`
|
||||
ChatID int64 `json:"chat_id"`
|
||||
SenderID int64 `json:"sender_id"`
|
||||
Plaintext string `json:"plaintext"`
|
||||
Attachment *AttachmentInfo `json:"attachment,omitempty"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
TempID string `json:"temp_id,omitempty"`
|
||||
}
|
||||
|
||||
type AttachmentInfo struct {
|
||||
ID int64 `json:"id"`
|
||||
FileName string `json:"file_name"`
|
||||
FileSize int64 `json:"file_size"`
|
||||
MimeType string `json:"mime_type"`
|
||||
}
|
||||
|
||||
type TypingRequest struct {
|
||||
ChatID int64 `json:"chat_id"`
|
||||
IsTyping bool `json:"is_typing"`
|
||||
}
|
||||
|
||||
type TypingResponse struct {
|
||||
ChatID int64 `json:"chat_id"`
|
||||
UserID int64 `json:"user_id"`
|
||||
IsTyping bool `json:"is_typing"`
|
||||
}
|
||||
|
||||
type ReadReceiptRequest struct {
|
||||
MessageID int64 `json:"message_id"`
|
||||
}
|
||||
|
||||
type ReadReceiptResponse struct {
|
||||
MessageID int64 `json:"message_id"`
|
||||
UserID int64 `json:"user_id"`
|
||||
ReadAt time.Time `json:"read_at"`
|
||||
}
|
||||
|
||||
type EditMessageRequest struct {
|
||||
MessageID int64 `json:"message_id"`
|
||||
Plaintext string `json:"plaintext"`
|
||||
}
|
||||
|
||||
type EditMessageResponse struct {
|
||||
MessageID int64 `json:"message_id"`
|
||||
NewPlaintext string `json:"new_plaintext"`
|
||||
EditedAt time.Time `json:"edited_at"`
|
||||
}
|
||||
|
||||
type DeleteMessageRequest struct {
|
||||
MessageID int64 `json:"message_id"`
|
||||
}
|
||||
|
||||
type DeleteMessageResponse struct {
|
||||
MessageID int64 `json:"message_id"`
|
||||
DeletedAt time.Time `json:"deleted_at"`
|
||||
}
|
||||
|
||||
type UserOnlineResponse struct {
|
||||
UserID int64 `json:"user_id"`
|
||||
IsOnline bool `json:"is_online"`
|
||||
LastSeen *time.Time `json:"last_seen,omitempty"`
|
||||
}
|
||||
|
||||
type ErrorResponse struct {
|
||||
Code int `json:"code"`
|
||||
Message string `json:"message"`
|
||||
}
|
||||
|
||||
func ParseMessage(raw []byte) (*WSMessage, error) {
|
||||
var msg WSMessage
|
||||
if err := json.Unmarshal(raw, &msg); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &msg, nil
|
||||
}
|
||||
|
||||
func CreateMessage(msgType MessageType, data interface{}) ([]byte, error) {
|
||||
var dataBytes json.RawMessage
|
||||
if data != nil {
|
||||
bytes, err := json.Marshal(data)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
dataBytes = bytes
|
||||
}
|
||||
|
||||
msg := WSMessage{
|
||||
Type: msgType,
|
||||
Data: dataBytes,
|
||||
Timestamp: time.Now(),
|
||||
}
|
||||
|
||||
return json.Marshal(msg)
|
||||
}
|
||||
118
internal/websocket/room.go
Normal file
118
internal/websocket/room.go
Normal file
@@ -0,0 +1,118 @@
|
||||
package websocket
|
||||
|
||||
import (
|
||||
"sync"
|
||||
)
|
||||
|
||||
type Room struct {
|
||||
ID int64
|
||||
Clients map[*Client]bool
|
||||
mu sync.RWMutex
|
||||
}
|
||||
|
||||
func NewRoom(chatID int64) *Room {
|
||||
return &Room{
|
||||
ID: chatID,
|
||||
Clients: make(map[*Client]bool),
|
||||
}
|
||||
}
|
||||
|
||||
func (r *Room) AddClient(client *Client) {
|
||||
r.mu.Lock()
|
||||
defer r.mu.Unlock()
|
||||
|
||||
r.Clients[client] = true
|
||||
client.JoinRoom(r.ID)
|
||||
}
|
||||
|
||||
func (r *Room) RemoveClient(client *Client) {
|
||||
r.mu.Lock()
|
||||
defer r.mu.Unlock()
|
||||
|
||||
if _, exists := r.Clients[client]; exists {
|
||||
delete(r.Clients, client)
|
||||
client.LeaveRoom(r.ID)
|
||||
}
|
||||
}
|
||||
|
||||
func (r *Room) Broadcast(message []byte, excludeClient *Client) {
|
||||
r.mu.RLock()
|
||||
defer r.mu.RUnlock()
|
||||
|
||||
for client := range r.Clients {
|
||||
if excludeClient != nil && client == excludeClient {
|
||||
continue
|
||||
}
|
||||
|
||||
// Безопасная отправка с проверкой закрытого канала
|
||||
func() {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
// Канал закрыт, игнорируем
|
||||
}
|
||||
}()
|
||||
select {
|
||||
case client.send <- message:
|
||||
default:
|
||||
// Канал заполнен или закрыт
|
||||
}
|
||||
}()
|
||||
}
|
||||
}
|
||||
|
||||
func (r *Room) BroadcastToAll(message []byte) {
|
||||
r.Broadcast(message, nil)
|
||||
}
|
||||
|
||||
func (r *Room) GetClientCount() int {
|
||||
r.mu.RLock()
|
||||
defer r.mu.RUnlock()
|
||||
return len(r.Clients)
|
||||
}
|
||||
|
||||
func (r *Room) GetClients() []*Client {
|
||||
r.mu.RLock()
|
||||
defer r.mu.RUnlock()
|
||||
|
||||
clients := make([]*Client, 0, len(r.Clients))
|
||||
for client := range r.Clients {
|
||||
clients = append(clients, client)
|
||||
}
|
||||
return clients
|
||||
}
|
||||
|
||||
func (r *Room) IsEmpty() bool {
|
||||
r.mu.RLock()
|
||||
defer r.mu.RUnlock()
|
||||
return len(r.Clients) == 0
|
||||
}
|
||||
|
||||
func (r *Room) HasClient(client *Client) bool {
|
||||
r.mu.RLock()
|
||||
defer r.mu.RUnlock()
|
||||
_, exists := r.Clients[client]
|
||||
return exists
|
||||
}
|
||||
|
||||
func (r *Room) GetUserIDs() []int64 {
|
||||
r.mu.RLock()
|
||||
defer r.mu.RUnlock()
|
||||
|
||||
userIDs := make([]int64, 0, len(r.Clients))
|
||||
for client := range r.Clients {
|
||||
userIDs = append(userIDs, client.userID)
|
||||
}
|
||||
return userIDs
|
||||
}
|
||||
|
||||
func (r *Room) HasClientByUserID(userID int64) bool {
|
||||
r.mu.RLock()
|
||||
defer r.mu.RUnlock()
|
||||
|
||||
for client := range r.Clients {
|
||||
if client.userID == userID {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
Reference in New Issue
Block a user