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

Compare commits

base: public:779de059af026cf5f8b20e2f642bb98b1d6503bc
Branches Tags
public:master
public:expiretime-prod
public:master-f8315afe6b
public:location-api
public:master-779de059af
public:ws-refactor
public:master-backup
..
compare: public:807bc66acbac8bcdd9ee909291e2733235c0a9f5
Branches Tags
public:master
public:expiretime-prod
public:master-f8315afe6b
public:location-api
public:master-779de059af
public:ws-refactor
public:master-backup

No commits in common. "779de059af026cf5f8b20e2f642bb98b1d6503bc" and "807bc66acbac8bcdd9ee909291e2733235c0a9f5" have entirely different histories.
779de059af ... 807bc66acb

1 changed files with 121 additions and 86 deletions
Show Stats Expand all files Collapse all files

207
main.go
View File

@ -32,7 +32,6 @@ type Message struct {
Name string `json:"Name"`
Image string `json:"Image"`
Status string `json:"Status"`
Theme string `json:"Theme"`
Timestamp string `json:"Timestamp"`
}
@ -45,7 +44,6 @@ type Config struct {
type Client struct {
conn *websocket.Conn
mu sync.Mutex
}
type Server struct {
@ -112,7 +110,7 @@ func (s *Server) addClient(client *Client) {
s.mu.Lock()
defer s.mu.Unlock()
s.clients[client] = true
sendAllRecordsToClient(client)
broadcastAllRecordsToClient(client)
}
func (s *Server) removeClient(client *Client) {
@ -156,30 +154,62 @@ func (s *Server) handleConnections(w http.ResponseWriter, r *http.Request) {
}
}
func broadcastSingleRecord(s *Server, message Message) {
for client := range s.clients {
sendMessageToClient(client, message)
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))
for client := range s.clients {
if err := client.conn.WriteMessage(websocket.TextMessage, []byte(msgContent)); err != nil {
log.Println("Failed to broadcast update:", err)
}
}
}
}
}
func sendMessageToClient(client *Client, message Message) {
func broadcastRemovedRecords(s *Server, message Message) {
var msgJSON, err = json.Marshal(message)
if err != nil {
log.Println("Error marshalling json:", err)
return
}
go sendToClient(client, msgJSON)
}
fmt.Printf("Broadcasting removal: %s,%s,%s,%s to %d clients\n", message.Id, message.Status, message.Name, message.Timestamp, len(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 send message to client:", err)
for client := range s.clients {
if err := client.conn.WriteMessage(websocket.TextMessage, msgJSON); err != nil {
log.Println("Failed to broadcast update:", err)
return
}
}
}
func sendAllRecordsToClient(client *Client) {
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) {
allRecords, err := fetchAllRecords()
if err != nil {
log.Println("Error fetching all records:", err)
@ -191,8 +221,10 @@ func sendAllRecordsToClient(client *Client) {
if err != nil {
log.Println("Unable to marshal JSON due to: ", 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))
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)
}
}
}
@ -201,7 +233,7 @@ func (s *Server) listenForExpirationEvents() {
defer func(ps *redis.PubSub) {
err := ps.Close()
if err != nil {
log.Println("Error closing redis pubsub:", err)
}
}(ps)
@ -210,9 +242,8 @@ func (s *Server) listenForExpirationEvents() {
expiredID := msg.Payload
fmt.Println(expiredID)
// Broadcast expiration event
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)
broadcastExpiredRecords(s, expiredID)
fmt.Printf("Done Broadcasting Expiration\n")
}
}
@ -232,62 +263,64 @@ func fetchAllRecords() (map[string]string, error) {
}
records[key] = value
}
return records, nil
}
func getState(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
http.Error(w, "Only POST method is allowed", http.StatusMethodNotAllowed)
return
}
fmt.Println("Checking Status")
var request struct {
Id string `json:"Id"`
}
err := json.NewDecoder(r.Body).Decode(&request)
if err != nil {
fmt.Println("Invalid JSON format")
fmt.Println(r.Body)
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)
return
}
fmt.Println(request.Id)
value, err := redisClient.Get(ctx, request.Id).Result()
if errors.Is(err, redis.Nil) {
message := Message{Id: request.Id, Status: "none", Timestamp: time.Now().Format(time.RFC3339)}
w.Header().Set("Content-Type", "application/json")
err := json.NewEncoder(w).Encode(message)
if err != nil {
/*
func getState(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
http.Error(w, "Only POST method is allowed", http.StatusMethodNotAllowed)
return
}
fmt.Println("Checking Status")
var request struct {
Id string `json:"Id"`
}
err := json.NewDecoder(r.Body).Decode(&request)
if err != nil {
fmt.Println("Invalid JSON format")
fmt.Println(r.Body)
http.Error(w, "Invalid JSON format", http.StatusBadRequest)
return
}
return
} else if err != nil {
log.Printf("Redis error: %v", err)
http.Error(w, "Error connecting to Redis", http.StatusInternalServerError)
return
}
var message Message
err = json.Unmarshal([]byte(value), &message)
if err != nil {
log.Printf("Failed to decode Redis data for Id: %s - %v", request.Id, err)
http.Error(w, "Failed to parse data", http.StatusInternalServerError)
return
}
if request.Id == "" {
fmt.Println("Missing or empty Id field")
http.Error(w, "Missing or empty Id field", http.StatusBadRequest)
return
}
fmt.Println(request.Id)
value, err := redisClient.Get(ctx, request.Id).Result()
if errors.Is(err, redis.Nil) {
message := Message{Id: request.Id, Status: "none", Timestamp: time.Now().Format(time.RFC3339)}
w.Header().Set("Content-Type", "application/json")
err := json.NewEncoder(w).Encode(message)
if err != nil {
return
}
return
} else if err != nil {
log.Printf("Redis error: %v", err)
http.Error(w, "Error connecting to Redis", http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
err = json.NewEncoder(w).Encode(message)
if err != nil {
http.Error(w, "Failed to encode response", http.StatusInternalServerError)
}
}
var message Message
err = json.Unmarshal([]byte(value), &message)
if err != nil {
log.Printf("Failed to decode Redis data for Id: %s - %v", request.Id, err)
http.Error(w, "Failed to parse data", http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
err = json.NewEncoder(w).Encode(message)
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)
@ -307,24 +340,26 @@ func setState(w http.ResponseWriter, r *http.Request, s *Server) {
http.Error(w, "Failed to delete key from Redis", http.StatusInternalServerError)
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 {
log.Printf("Failed to set key in Redis: %v", err)
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))
broadcastRemovedRecords(s, message)
w.WriteHeader(http.StatusOK)
return
}
broadcastSingleRecord(s, message)
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 {
log.Printf("Failed to set key in Redis: %v", err)
http.Error(w, "Failed to store data", http.StatusInternalServerError)
return
}
broadcastAllRecords(s)
w.WriteHeader(http.StatusOK)
}
@ -385,7 +420,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")