fix: introduce const for broadcast interval

- change ticker to use BROADCAST_INTERVAL constant
- define BROADCAST_INTERVAL as 1 second

🤖

README.md

@@ -34,17 +34,17 @@ Here are the available commands:
 | `pause`          | Pauses the current session            | `{"command": "pause", "password": ""}`                                                                                        |
 | `resume`         | Resumes a paused session              | `{"command": "resume", "password": ""}`                                                                                       |
 | `reset`          | Stops and resets the current session  | `{"command": "reset", "password": ""}`                                                                                        |
-| `updateSettings` | Update Pomodoro settings              | `{"command": "updateSettings", "password": "", "settings": {"work": 600, "shortBreak": 60, "longBreak": 300, "sessions": 2}}` |
+| `updateSettings` | Update Pomodoro settings              | `{"command": "updateSettings", "password": "", "settings": {"focus": 600, "shortBreak": 60, "longBreak": 300, "sessions": 2}}` |
 
 #### Update Settings Command (`updateSettings`)
 
-The `updateSettings` command allows clients to modify the Pomodoro timer configuration, including the length of work sessions, short breaks, long breaks, and the total number of sessions in a cycle. This command must include a valid password to be accepted by the server. The updateSettings command can be used when the timer is stopped.
+The `updateSettings` command allows clients to modify the Pomodoro timer configuration, including the length of focus sessions, short breaks, long breaks, and the total number of sessions in a cycle. This command must include a valid password to be accepted by the server. The updateSettings command can be used when the timer is stopped.
 
 - Fields in the `settings` Object:
-  - `work`: Length of the work session (in seconds).
+  - `focus`: Length of the focus session (in seconds).
   - `shortBreak`: Length of the short break (in seconds).
   - `longBreak`: Length of the long break (in seconds).
-  - `sessions`: Total number of work/break sessions in the Pomodoro cycle.
+  - `sessions`: Total number of focus/break sessions in the Pomodoro cycle.
 
 All fields are mandatory and may not be ommitted.
 
@@ -52,14 +52,14 @@ All fields are mandatory and may not be ommitted.
 
 The server periodically (every second) sends JSON-encoded messages to all connected clients to update them on the current state of the Pomodoro session. These messages contain the following fields:
 
-- mode: Indicates the current phase of the Pomodoro session ("Work", "ShortBreak", "LongBreak", "End" or "Idle").
+- mode: Indicates the current phase of the Pomodoro session ("Focus", "ShortBreak", "LongBreak", "End" or "Idle").
   - "End" is send only once, after all sessions are finished
 - settings: Contains the current Pomodoro settings:
-    -  work: Length of the work session in seconds (e.g., 1500 for 25 minutes).
+    -  focus: Length of the focus session in seconds (e.g., 1500 for 25 minutes).
     -  shortBreak: Length of the short break in seconds (e.g., 300 for 5 minutes).
     -  longBreak: Length of the long break in seconds (e.g., 900 for 15 minutes).
-    -  sessions: The total number of work/break sessions (e.g., 4).
+    -  sessions: The total number of focus/break sessions (e.g., 4).
-- session: The current session number (e.g., 1 for the first work session).
+- session: The current session number (e.g., 1 for the first focus session).
 - time_left: The remaining time for the current mode, in seconds (e.g., 900 for 15 minutes).
 - ongoing: Whether a Pomodoro session is currently ongoing.
 - paused: Whether the timer is paused.
@@ -67,11 +67,11 @@ The server periodically (every second) sends JSON-encoded messages to all connec
 
 | Message Type      | Example                                                                                                                                                                       |
 | ---               | ---                                                                                                                                                                           |
-| Welcome Message   | {"mode":"Idle", "settings":{"work":1500, "shortBreak":300, "longBreak":900, "sessions":4}, "session":0, "time_left":1500, "ongoing":false, "paused":false, "version":"0"}    |
+| Welcome Message   | {"mode":"Idle", "settings":{"focus":1500, "shortBreak":300, "longBreak":900, "sessions":4}, "session":0, "time_left":1500, "ongoing":false, "paused":false, "version":"0"}    |
-| Session Running   | {"mode":"Work", "settings":{"work":1500, "shortBreak":300, "longBreak":900, "sessions":4}, "session":1, "time_left":900, "ongoing":true, "paused":false, "version":"0"}      |
+| Session Running   | {"mode":"Focus", "settings":{"focus":1500, "shortBreak":300, "longBreak":900, "sessions":4}, "session":1, "time_left":900, "ongoing":true, "paused":false, "version":"0"}      |
-| Session Running   | {"mode":"ShortBreak", "settings":{"work":1500, "shortBreak":300, "longBreak":900, "sessions":4}, "session":2, "time_left":50, "ongoing":true, "paused":false, "version":"0"} |
+| Session Running   | {"mode":"ShortBreak", "settings":{"focus":1500, "shortBreak":300, "longBreak":900, "sessions":4}, "session":2, "time_left":50, "ongoing":true, "paused":false, "version":"0"} |
-| Session Paused    | {"mode":"Work", "settings":{"work":1500, "shortBreak":300, "longBreak":900, "sessions":4}, "session":2, "time_left":456, "ongoing":true, "paused":true, "version":"0"}       |
+| Session Paused    | {"mode":"Focus", "settings":{"focus":1500, "shortBreak":300, "longBreak":900, "sessions":4}, "session":2, "time_left":456, "ongoing":true, "paused":true, "version":"0"}       |
-| Session End/Reset | {"mode":"End", "settings":{"work":1500, "shortBreak":300, "longBreak":900, "sessions":4}, "session":0, "time_left":0, "ongoing":false, "paused":false, "version":"0"}        |
+| Session End/Reset | {"mode":"End", "settings":{"focus":1500, "shortBreak":300, "longBreak":900, "sessions":4}, "session":0, "time_left":0, "ongoing":false, "paused":false, "version":"0"}        |
 
 ## Testing
 

cmd/server/main.go

@@ -19,15 +19,22 @@ var (
 	listenAddress = flag.String("listenAddress", shared.DefaultServerConfig.ListenAddress, "IP address to listen on")
 	listenPort    = flag.Int("listenPort", shared.DefaultServerConfig.ListenPort, "Port to listen on")
 	password      = flag.String("password", "", "Control password for pomodoro session (optional)")
-	showVersionFlag = flag.Bool("version", false, "Output version")
+	showVersion   = flag.Bool("version", false, "Output version")
 )
 
 // Start the pomodoro server
 func Start() {
+	// Update usage output
+	flag.Usage = func() {
+		fmt.Fprintf(flag.CommandLine.Output(), "Usage of %s:\n", "GoTomato")
+		flag.PrintDefaults()
+		fmt.Println("\nPoint your client to 'ws://<listenAddress>:<listenPort>'")
+	}
+
 	flag.Parse()
 
 	// show server and protocl version and exit
-	if *showVersionFlag {
+	if *showVersion {
 		fmt.Printf("GoTomato v%s\n", metadata.GoTomatoVersion)
 		fmt.Printf("Protocol-Version: %s\n", metadata.ProtocolVersion)
 		os.Exit(0)
@@ -45,8 +52,9 @@ func Start() {
 
 	// start connection handler and broadcast
 	r := http.NewServeMux()
-	r.HandleFunc("/ws", websocket.HandleConnection)
+	r.HandleFunc("/", websocket.HandleConnection)
 	go websocket.SendPermanentBroadCastMessage()
+	go websocket.RemoveStaleClients()
 
 	helper.Logger.Info("GoTomato started", "version", metadata.GoTomatoVersion)
 	helper.Logger.Info("Websocket listening", "address", listen)

index.html

@@ -40,8 +40,8 @@
 			<input type="text" id="password" placeholder="Password" />
 		</p>
 		<p>
-			<label for="workDuration">Work Duration (seconds):</label>
+			<label for="focusDuration">Focus Duration (seconds):</label>
-			<input type="number" id="workDuration" placeholder="Work time in seconds" value="900" />
+			<input type="number" id="foucsDuration" placeholder="Focus time in seconds" value="900" />
 			<br />
 			<label for="shortBreakDuration">Short Break Duration (seconds):</label>
 			<input type="number" id="shortBreakDuration" placeholder="Short break in seconds" value="300" />
@@ -64,7 +64,7 @@
 	<button id="resetButton" style="display: none;">Reset</button>
 
 	<script>
-		var ws = new WebSocket("ws://localhost:8080/ws");
+		var ws = new WebSocket("ws://localhost:8080");
 		var isPaused = false; // Track if the timer is paused
 
 		ws.onopen = function () {
@@ -98,7 +98,7 @@
 		document.getElementById("saveButton").addEventListener("click", function () {
 			// Get the values from the input fields
 			var password = document.getElementById("password").value;
-			var work = parseInt(document.getElementById("workDuration").value);
+			var focus = parseInt(document.getElementById("focusDuration").value);
 			var shortBreak = parseInt(document.getElementById("shortBreakDuration").value);
 			var longBreak = parseInt(document.getElementById("longBreakDuration").value);
 			var sessions = parseInt(document.getElementById("sessions").value);
@@ -108,7 +108,7 @@
 				command: "updateSettings",
 				password: password,
 				settings: {
-					work: work,
+					focus: focus,
 					shortBreak: shortBreak,
 					longBreak: longBreak,
 					sessions: sessions

internal/pomodoro/pomodoro.go

@@ -26,7 +26,7 @@ func waitForTimer(t Timer) bool {
 	}
 }
 
-// RunPomodoro iterates the Pomodoro work/break sessions
+// RunPomodoro iterates the Pomodoro focus/break sessions
 func RunPomodoro() {
 	mu.Lock()
 	shared.State.Ongoing = true
@@ -40,9 +40,9 @@ func RunPomodoro() {
 
 		shared.State.Session = session
 
-		// Work
+		// Focus
-		shared.State.Mode = "Work"
+		shared.State.Mode = "Focus"
-		timer.StartAsync(pomodoroConfig.Work)
+		timer.StartAsync(pomodoroConfig.Focus)
 		if !waitForTimer(timer) {
 			break
 		}
@@ -74,7 +74,7 @@ func RunPomodoro() {
 
 	shared.State.Mode = "Idle"
 	shared.State.Session = 0
-	shared.State.TimeLeft = shared.State.Settings.Work
+	shared.State.TimeLeft = shared.State.Settings.Focus
 }
 
 func ResetPomodoro() {
@@ -111,6 +111,6 @@ func IsPomodoroPaused() bool {
 func UpdateSettings(settings models.PomodoroConfig) {
 	if settings != (models.PomodoroConfig{}) {
 		shared.State.Settings = settings
-		shared.State.TimeLeft = settings.Work
+		shared.State.TimeLeft = settings.Focus
 	}
 }

internal/shared/configDefaults.go

@@ -10,7 +10,7 @@ var DefaultServerConfig = models.ServerConfig{
 
 // The default pomodoro config if nothing else is set
 var DefaultPomodoroConfig = models.PomodoroConfig{
-	Work:       25 * 60,
+	Focus:      25 * 60,
 	ShortBreak: 5 * 60,
 	LongBreak:  15 * 60,
 	Sessions:   4,

internal/shared/state.go

@@ -10,7 +10,7 @@ var State = models.ServerMessage{
 	Mode:            "Idle",
 	Settings:        DefaultPomodoroConfig,
 	Session:         0,
-	TimeLeft:        DefaultPomodoroConfig.Work,
+	TimeLeft:        DefaultPomodoroConfig.Focus,
 	Ongoing:         false,
 	Paused:          false,
 	ProtocolVersion: metadata.ProtocolVersion,

internal/websocket/broadcast.go

@@ -11,22 +11,27 @@ import (
 
 // Sends continous messages to all connected WebSocket clients
 func SendPermanentBroadCastMessage() {
-	tick := time.NewTicker(time.Second)
+	ticker := time.NewTicker(BROADCAST_INTERVAL * time.Second)
-	for {
+	defer ticker.Stop()
+
+	for range ticker.C {
 		// Marshal the message into JSON format
 		jsonMessage, err := json.Marshal(shared.State)
 		if err != nil {
 			helper.Logger.Error("Error marshalling message:", "msg", err)
 			return
 		}
+
 		// Iterate over all connected clients and broadcast the message
+		mu.Lock()
 		for _, client := range Clients {
-			err := client.SendMessage(websocket.TextMessage, jsonMessage)
+			// Send message to client
+			client.Conn.SetWriteDeadline(time.Now().Add(SEND_TIMEOUT * time.Second))
+			err := client.Conn.WriteMessage(websocket.TextMessage, jsonMessage)
 			if err != nil {
-				helper.Logger.Error("Error broadcasting to client:", "msg", err)
+				helper.Logger.Error("Error broadcasting to client:", "msg", err, "host", client.RealIP, "clients", len(Clients))
-				// The client is responsible for closing itself on error
 			}
 		}
-		<-tick.C
+		mu.Unlock()
 	}
 }

internal/websocket/client_commands.go

@@ -10,7 +10,7 @@ import (
 )
 
 func checkSettings(settings models.PomodoroConfig) bool {
-	return settings.Work > 0 && settings.ShortBreak > 0 && settings.LongBreak > 0 && settings.Sessions > 0
+	return settings.Focus > 0 && settings.ShortBreak > 0 && settings.LongBreak > 0 && settings.Sessions > 0
 }
 
 // Listens for commands from a client and handles them
@@ -21,7 +21,10 @@ func handleClientCommands(c models.WebsocketClient) {
 
 		_, message, err := ws.ReadMessage()
 		if err != nil {
+			// remove client on error/disconnect
+			mu.Lock()
 			delete(Clients, ws.LocalAddr())
+			mu.Unlock()
 			helper.Logger.Info("Client disconnected:", "msg", err, "host", c.RealIP, "clients", len(Clients))
 			break
 		}

internal/websocket/handle_connection.go

@@ -2,18 +2,13 @@ package websocket
 
 import (
 	"github.com/gorilla/websocket"
-	"net"
 	"net/http"
-	"sync"
+	"time"
 
 	"git.smsvc.net/pomodoro/GoTomato/internal/helper"
 	"git.smsvc.net/pomodoro/GoTomato/pkg/models"
 )
 
-// Clients is a map of connected WebSocket clients, where each client is represented by the WebsocketClient struct
-var Clients = make(map[net.Addr]*models.WebsocketClient)
-var mu sync.Mutex // Mutex to protect access to the Clients map
-
 // Upgrade HTTP requests to WebSocket connections
 var upgrader = websocket.Upgrader{
 	CheckOrigin: func(r *http.Request) bool { return true },
@@ -32,8 +27,14 @@ func HandleConnection(w http.ResponseWriter, r *http.Request) {
 	// Register the new client
 	client := models.WebsocketClient{
 		Conn:     ws,
+		LastPong: time.Now(),
 		RealIP:   r.RemoteAddr,
 	}
+	client.Conn.SetPongHandler(func(s string) error {
+		client.LastPong = time.Now()
+		return nil
+	})
+
 	mu.Lock()
 	Clients[ws.LocalAddr()] = &client
 	mu.Unlock()

internal/websocket/staleClients.go

@@ -0,0 +1,34 @@
+package websocket
+
+import (
+	"time"
+
+	"git.smsvc.net/pomodoro/GoTomato/internal/helper"
+	"git.smsvc.net/pomodoro/GoTomato/pkg/models"
+	"github.com/gorilla/websocket"
+)
+
+// Check and remove stale clients
+func RemoveStaleClients() {
+	ticker := time.NewTicker(STALE_CHECK_INTERVALL * time.Second)
+	defer ticker.Stop()
+
+	for range ticker.C {
+		mu.Lock()
+		for _, client := range Clients {
+			client.Conn.SetWriteDeadline(time.Now().Add(SEND_TIMEOUT * time.Second))
+			client.Conn.WriteMessage(websocket.PingMessage, nil)
+
+			if isStale(client) {
+				helper.Logger.Info("Removing stale client", "host", client.RealIP, "lastPong", client.LastPong.Format(time.RFC3339))
+				client.Conn.Close()
+				delete(Clients, client.Conn.LocalAddr())
+			}
+		}
+		mu.Unlock()
+	}
+}
+
+func isStale(client *models.WebsocketClient) bool {
+	return time.Since(client.LastPong) > (STALE_CLIENT_TIMEOUT * time.Second)
+}

internal/websocket/vars.go

@@ -0,0 +1,19 @@
+package websocket
+
+import (
+	"net"
+	"sync"
+
+	"git.smsvc.net/pomodoro/GoTomato/pkg/models"
+)
+
+const BROADCAST_INTERVAL = 1
+const SEND_TIMEOUT = 10
+const STALE_CLIENT_TIMEOUT = 90
+const STALE_CHECK_INTERVALL = 30
+
+// Clients is a map of connected WebSocket clients, where each client is represented by the WebsocketClient struct
+var Clients = make(map[net.Addr]*models.WebsocketClient)
+
+// Mutex to protect access to the Clients map
+var mu sync.Mutex

pkg/models/client.go

@@ -1,9 +1,9 @@
 package models
 
 import (
-	"github.com/gorilla/websocket"
+	"time"
 
-	"git.smsvc.net/pomodoro/GoTomato/internal/helper"
+	"github.com/gorilla/websocket"
 )
 
 // Represents a command from the client (start/stop)
@@ -16,16 +16,6 @@ type ClientCommand struct {
 // Represents a single client
 type WebsocketClient struct {
 	Conn     *websocket.Conn
+	LastPong time.Time
 	RealIP   string
 }
-
-// Sends a message to the websocket.
-// Automatically locks and unlocks the client mutex, to ensure that only one goroutine can write at a time.
-func (c *WebsocketClient) SendMessage(messageType int, data []byte) error {
-	err := c.Conn.WriteMessage(messageType, data)
-	if err != nil {
-		helper.Logger.Error("Error writing to WebSocket:", "msg", err)
-		c.Conn.Close() // Close the connection on error
-	}
-	return err
-}

pkg/models/config.go

@@ -4,7 +4,7 @@ import "fmt"
 
 // Represents the configuration of a pomodoro
 type PomodoroConfig struct {
-	Work       int `json:"work"`       // Length of work sessions in seconds
+	Focus      int `json:"focus"`      // Length of focus sessions in seconds
 	ShortBreak int `json:"shortBreak"` // Length of short break in seconds
 	LongBreak  int `json:"longBreak"`  // Length of long break in seconds
 	Sessions   int `json:"sessions"`   // Number of total sessions
@@ -12,7 +12,7 @@ type PomodoroConfig struct {
 
 // Stringer interface for the PomodocoConfig model
 func (c PomodoroConfig) String() string {
-	return fmt.Sprintf("{work: %d, short: %d, long: %d, sessions: %d}", c.Work, c.ShortBreak, c.LongBreak, c.Sessions)
+	return fmt.Sprintf("{focus: %d, short: %d, long: %d, sessions: %d}", c.Focus, c.ShortBreak, c.LongBreak, c.Sessions)
 }
 
 // Represents the server configuration

pkg/models/server.go

@@ -2,7 +2,7 @@ package models
 
 // Represents the data sent to the client via WebSocket
 type ServerMessage struct {
-	Mode            string         `json:"mode"`      // "Idle", "Work", "ShortBreak", "LongBreak" or "End"
+	Mode            string         `json:"mode"`      // "Idle", "Focus", "ShortBreak", "LongBreak" or "End"
 	Settings        PomodoroConfig `json:"settings"`  // The currrent pomodoro settings
 	Session         int            `json:"session"`   // Current session number
 	TimeLeft        int            `json:"time_left"` // Remaining time in seconds