public/pogdark-api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request 'ws-refactor' (#3) from ws-refactor into master
All checks were successful
Build Pogdark API / Build Pogdark API (push) Successful in 14s
Details

Browse Source 
Reviewed-on: #3
This commit is contained in:
whysman 2025-02-26 17:00:27 +00:00
commit 779de059af
1 changed files with 90 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
main.go
View File

@ -32,6 +32,7 @@ type Message struct {
Name string `json:"Name"`
Image string `json:"Image"`
Status string `json:"Status"`
Theme string `json:"Theme"`
Timestamp string `json:"Timestamp"`
}
@ -44,6 +45,7 @@ type Config struct {
type Client struct {
conn *websocket.Conn
mu sync.Mutex
}
type Server struct {
@ -110,7 +112,7 @@ func (s *Server) addClient(client *Client) {
s.mu.Lock()
defer s.mu.Unlock()
s.clients[client] = true
broadcastAllRecordsToClient(client)
sendAllRecordsToClient(client)
}
func (s *Server) removeClient(client *Client) {
@ -154,62 +156,30 @@ func (s *Server) handleConnections(w http.ResponseWriter, r *http.Request) {
}
}
func broadcastAllRecords(s *Server) {
allRecords, err := fetchAllRecords()
if err != nil {
log.Println("Error fetching all records:", err)
}
if len(allRecords) > 0 {
var message Message
for _, msgContent := range allRecords {
err = json.Unmarshal([]byte(msgContent), &message)
if err != nil {
log.Println("Unable to marshal JSON due to: ", err)
}
fmt.Printf("Broadcasting %s,%s,%s,%s to %d clients\n", message.Id, message.Status, message.Name, message.Timestamp, len(s.clients))
func broadcastSingleRecord(s *Server, message Message) {
for client := range s.clients {
if err := client.conn.WriteMessage(websocket.TextMessage, []byte(msgContent)); err != nil {
log.Println("Failed to broadcast update:", err)
}
}
}
sendMessageToClient(client, message)
}
}
func broadcastRemovedRecords(s *Server, message Message) {
func sendMessageToClient(client *Client, message Message) {
var msgJSON, err = json.Marshal(message)
if err != nil {
log.Println("Error marshalling json:", err)
return
}
fmt.Printf("Broadcasting removal: %s,%s,%s,%s to %d clients\n", message.Id, message.Status, message.Name, message.Timestamp, len(s.clients))
go sendToClient(client, msgJSON)
}
for client := range s.clients {
func sendToClient(client *Client, msgJSON []byte) {
client.mu.Lock()
defer client.mu.Unlock()
if err := client.conn.WriteMessage(websocket.TextMessage, msgJSON); err != nil {
log.Println("Failed to broadcast update:", err)
return
}
log.Println("Failed to send message to client:", err)
}
}
func broadcastExpiredRecords(s *Server, removed string) {
var message = Message{Id: removed, Name: "", Image: "", Status: "removed", Timestamp: ""}
var msgJSON, err = json.Marshal(message)
if err != nil {
log.Println("Error marshalling json:", err)
return
}
fmt.Printf("Broadcasting expiration: %s to %d clients\n", string(msgJSON), len(s.clients))
for client := range s.clients {
if err := client.conn.WriteMessage(websocket.TextMessage, msgJSON); err != nil {
log.Println("Failed to broadcast update:", err)
return
}
}
}
func broadcastAllRecordsToClient(c *Client) {
func sendAllRecordsToClient(client *Client) {
allRecords, err := fetchAllRecords()
if err != nil {
log.Println("Error fetching all records:", err)
@ -221,10 +191,8 @@ func broadcastAllRecordsToClient(c *Client) {
if err != nil {
log.Println("Unable to marshal JSON due to: ", err)
}
fmt.Printf("Broadcasting %s,%s,%s,%s\n", message.Id, message.Status, message.Name, message.Timestamp)
if err := c.conn.WriteMessage(websocket.TextMessage, []byte(msgContent)); err != nil {
log.Println("Failed to broadcast update:", err)
}
fmt.Printf("Broadcasting %s,%s,%s,%s,%s\n", message.Id, message.Status, message.Name, message.Theme, message.Timestamp)
go sendToClient(client, []byte(msgContent))
}
}
@ -233,7 +201,7 @@ func (s *Server) listenForExpirationEvents() {
defer func(ps *redis.PubSub) {
err := ps.Close()
if err != nil {
log.Println("Error closing redis pubsub:", err)
}
}(ps)
@ -242,8 +210,9 @@ func (s *Server) listenForExpirationEvents() {
expiredID := msg.Payload
fmt.Println(expiredID)
// Broadcast expiration event
broadcastExpiredRecords(s, expiredID)
fmt.Printf("Done Broadcasting Expiration\n")
var message = Message{Id: expiredID, Name: "", Image: "", Status: "removed", Theme: "", Timestamp: ""}
fmt.Printf("Broadcasting expiration: %s to %d clients\n", message, len(s.clients))
broadcastSingleRecord(s, message)
}
}
@ -263,12 +232,10 @@ func fetchAllRecords() (map[string]string, error) {
}
records[key] = value
}
return records, nil
}
/*
func getState(w http.ResponseWriter, r *http.Request) {
func getState(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
http.Error(w, "Only POST method is allowed", http.StatusMethodNotAllowed)
return
@ -284,7 +251,7 @@ func fetchAllRecords() (map[string]string, error) {
http.Error(w, "Invalid JSON format", http.StatusBadRequest)
return
}
fmt.Println(request)
if request.Id == "" {
fmt.Println("Missing or empty Id field")
http.Error(w, "Missing or empty Id field", http.StatusBadRequest)
@ -319,8 +286,8 @@ func fetchAllRecords() (map[string]string, error) {
if err != nil {
http.Error(w, "Failed to encode response", http.StatusInternalServerError)
}
}
*/
}
func setState(w http.ResponseWriter, r *http.Request, s *Server) {
if r.Method != http.MethodPost {
http.Error(w, "Only POST method is allowed", http.StatusMethodNotAllowed)
@ -340,17 +307,13 @@ func setState(w http.ResponseWriter, r *http.Request, s *Server) {
http.Error(w, "Failed to delete key from Redis", http.StatusInternalServerError)
return
}
broadcastRemovedRecords(s, message)
w.WriteHeader(http.StatusOK)
return
}
fmt.Printf("Broadcasting removal: %s,%s,%s,%s to %d clients\n", message.Id, message.Status, message.Name, message.Timestamp, len(s.clients))
} else {
msgJSON, err := json.Marshal(message)
if err != nil {
http.Error(w, "Failed to encode message", http.StatusInternalServerError)
return
}
timeout := 20 * time.Second
err = redisClient.Set(ctx, message.Id, msgJSON, timeout).Err()
if err != nil {
@ -358,8 +321,10 @@ func setState(w http.ResponseWriter, r *http.Request, s *Server) {
http.Error(w, "Failed to store data", http.StatusInternalServerError)
return
}
fmt.Printf("Broadcasting message: %s,%s,%s,%s,%s to %d clients\n", message.Id, message.Status, message.Name, message.Theme, message.Timestamp, len(s.clients))
}
broadcastAllRecords(s)
broadcastSingleRecord(s, message)
w.WriteHeader(http.StatusOK)
}
@ -420,7 +385,7 @@ func main() {
// Register routes on the mux router
router.HandleFunc("/ws", server.handleConnections).Methods("GET")
//router.HandleFunc("/get", getState).Methods("POST")
router.HandleFunc("/get", getState).Methods("POST")
router.HandleFunc("/set", func(w http.ResponseWriter, r *http.Request) {
setState(w, r, server)
}).Methods("POST")