implement stop program functionality

Author: GustavoCaso

README.md

@@ -221,8 +221,16 @@ meeseeks logs web-server
 Stop running programs.
 
 ```bash
-meeseeks stop web-server        # Stop specific program
-meeseeks stop                   # Stop all programs and daemon
+meeseeks stop web-server               # Stop specific program
+meeseeks stop web-server -timeout 10s  # Stop specifc program with custom timeout
+```
+
+### `meeseeks exit`
+
+Stop and programs and meeseks process. Useful to stop meeseeks when running in detached mode
+
+```bash
+meeseeks exit
 ```
 
 ### `meeseeks version`

cmd/meeseeks/stop.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"errors"
 	"flag"
 	"fmt"
 	"os"
@@ -10,22 +11,30 @@ import (
 
 func stopCommand(args []string) error {
 	fs := flag.NewFlagSet("stop", flag.ExitOnError)
+	timeout := fs.String(
+		"timeout",
+		"5s",
+		"Timeout to wait for program to exit. If exceeded and error is trigerred and the program is force kill",
+	)
 	fs.Usage = func() {
-		fmt.Fprintf(os.Stderr, "Usage: meeseeks stop [program_name]\n\n")
+		fmt.Fprintf(os.Stderr, "Usage: meeseeks stop [options] [program_name]\n\n")
 		fmt.Fprintf(os.Stderr, "Stop running programs\n")
+		fs.PrintDefaults()
 	}
 
 	if err := fs.Parse(args); err != nil {
 		return err
 	}
 
-	programName := ""
-	if fs.NArg() > 0 {
-		programName = fs.Arg(0)
+	if fs.NArg() == 0 {
+		fs.Usage()
+		return errors.New("program name required")
 	}
 
+	programName := fs.Arg(0)
+
 	client := server.NewClient(getSocketPath())
-	resp, err := client.Stop(programName)
+	resp, err := client.Stop(programName, *timeout)
 	if err != nil {
 		return err
 	}
@@ -34,6 +43,6 @@ func stopCommand(args []string) error {
 		return fmt.Errorf("%s", resp.Error)
 	}
 
-	fmt.Fprintln(os.Stdout, "Stop command executed")
+	fmt.Fprintln(os.Stdout, resp.Data)
 	return nil
 }

cmd/meeseeks/stop_test.go

@@ -9,23 +9,17 @@ func TestStopCommand_Validation(t *testing.T) {
 
 	tests := []commandTestCase{
 		{
-			name:          "stop with no daemon running",
+			name:          "stop without program",
 			args:          []string{"stop"},
 			expectedExit:  1,
-			shouldContain: "meeseeks server not running",
-		},
-		{
-			name:          "stop specific program with no daemon",
-			args:          []string{"stop", "test-program"},
-			expectedExit:  1,
-			shouldContain: "meeseeks server not running",
+			shouldContain: "program name required",
 		},
 	}
 
 	runCommandTests(t, tests)
 }
 
-func TestStopCommand(t *testing.T) {
+func TestStopCommand_MissingProgramName(t *testing.T) {
 	configContent := `programs:
   - name: "test-stop-program1"
     command: "sleep"
@@ -39,22 +33,28 @@ func TestStopCommand(t *testing.T) {
 
 	tests := []commandTestCase{
 		{
-			name:          "stop specific program - not implemented",
-			args:          []string{"stop", "test-stop-program1"},
+			name:          "stop with invalid timeout",
+			args:          []string{"stop", "-timeout", "invalid", "test-stop-program1"},
 			expectedExit:  1,
-			shouldContain: "stop command not yet implemented",
+			shouldContain: "invalid duration",
 		},
 		{
-			name:          "stop non-existing program - not implemented",
+			name:          "stop non-existing program",
 			args:          []string{"stop", "fake-program"},
 			expectedExit:  1,
-			shouldContain: "stop command not yet implemented",
+			shouldContain: "program fake-program not present",
 		},
 		{
-			name:          "stop all programs - not implemented",
-			args:          []string{"stop"},
-			expectedExit:  1,
-			shouldContain: "stop command not yet implemented",
+			name:          "stop existing program",
+			args:          []string{"stop", "test-stop-program1"},
+			expectedExit:  0,
+			shouldContain: "test-stop-program1 stopped",
+		},
+		{
+			name:          "stop with custom timeout",
+			args:          []string{"stop", "-timeout", "10s", "test-stop-program2"},
+			expectedExit:  0,
+			shouldContain: "test-stop-program2 stopped",
 		},
 	}
 
@@ -63,7 +63,8 @@ func TestStopCommand(t *testing.T) {
 
 func TestStopCommand_Help(t *testing.T) {
 	testCommandHelp(t, "stop", []string{
-		"Usage: meeseeks stop [program_name]",
+		"Usage: meeseeks stop [options] [program_name]",
 		"Stop running programs",
+		"-timeout",
 	})
 }

pkg/meeseeks/meeseek.go

@@ -14,6 +14,7 @@ import (
 type Meeseek interface {
 	AddProgram(program.Program) error
 	Start(ctx context.Context)
+	Stop(programName string, timeout time.Duration) error
 	Wait(ctx context.Context) error
 	Statistic(program string) (program.Statistics, error)
 	Statistics() []program.Statistics
@@ -102,6 +103,14 @@ func (m *meeseek) Wait(ctx context.Context) error {
 	}
 }
 
+func (m *meeseek) Stop(programName string, timeout time.Duration) error {
+	if _, ok := m.programs[programName]; !ok {
+		return fmt.Errorf("program %s not present", programName)
+	}
+
+	return m.programs[programName].Shutdown(timeout)
+}
+
 func (m *meeseek) Shutdown(timeout time.Duration) error {
 	errs := []error{}
 

pkg/meeseeks/meeseeks_test.go

@@ -432,6 +432,101 @@ func BenchmarkMeeseek_Statistics(b *testing.B) {
 	}
 }
 
+func TestMeeseek_Stop(t *testing.T) {
+	tests := []struct {
+		name        string
+		programs    []program.Program
+		stopProgram string
+		timeout     time.Duration
+		wantErr     bool
+		errMsg      string
+	}{
+		{
+			name: "stop existing program",
+			programs: []program.Program{
+				program.New("test-stop-1", "sleep", program.Args("10")),
+				program.New("test-stop-2", "sleep", program.Args("10")),
+			},
+			stopProgram: "test-stop-1",
+			timeout:     5 * time.Second,
+		},
+		{
+			name: "stop non-existing program",
+			programs: []program.Program{
+				program.New("test-stop-1", "sleep", program.Args("10")),
+			},
+			stopProgram: "non-existent",
+			timeout:     5 * time.Second,
+			wantErr:     true,
+			errMsg:      "program non-existent not present",
+		},
+		{
+			name: "stop with short timeout",
+			programs: []program.Program{
+				program.New("test-stop-3", "sleep", program.Args("10")),
+			},
+			stopProgram: "test-stop-3",
+			timeout:     1 * time.Millisecond,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m := New()
+
+			for _, prog := range tt.programs {
+				err := m.AddProgram(prog)
+				if err != nil {
+					t.Fatalf("Failed to add program: %v", err)
+				}
+			}
+
+			// Start programs
+			ctx, cancel := context.WithTimeout(t.Context(), 30*time.Second)
+			defer cancel()
+			m.Start(ctx)
+
+			// Give programs time to start
+			time.Sleep(100 * time.Millisecond)
+
+			// Test Stop method
+			err := m.Stop(tt.stopProgram, tt.timeout)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Errorf("Stop() expected error but got none")
+					return
+				}
+				if !strings.Contains(err.Error(), tt.errMsg) {
+					t.Errorf("Stop() error = %q, want error containing %q", err.Error(), tt.errMsg)
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("Stop() unexpected error = %v", err)
+			}
+
+			// Verify the program is stopped by checking its status
+			if !tt.wantErr {
+				stat, err := m.Statistic(tt.stopProgram)
+				if err != nil {
+					t.Errorf("Failed to get statistic after stop: %v", err)
+					return
+				}
+				// The program should have terminated
+				if stat.Running > 0 {
+					t.Errorf(
+						"Program %s should be stopped but %d instances are still running",
+						tt.stopProgram,
+						stat.Running,
+					)
+				}
+			}
+		})
+	}
+}
+
 func BenchmarkMeeseek_Statistic(b *testing.B) {
 	m := New()
 

pkg/server/client.go

@@ -93,10 +93,11 @@ func (c *Client) Logs(programName string) (*Response, error) {
 	return c.sendRequest("/logs", params)
 }
 
-func (c *Client) Stop(programName string) (*Response, error) {
-	params := make(map[string]string)
-	if programName != "" {
-		params["program"] = programName
+func (c *Client) Stop(programName, timeout string) (*Response, error) {
+	params := map[string]string{
+		"program": programName,
+		"timeout": timeout,
 	}
+
 	return c.sendRequest("/stop", params)
 }

pkg/server/server.go

@@ -167,9 +167,27 @@ func (s *Server) handleLogs(w http.ResponseWriter, r *http.Request) {
 	handleResponse(w, resp)
 }
 
-func (s *Server) handleStop(w http.ResponseWriter, _ *http.Request) {
+func (s *Server) handleStop(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
-	resp := Response{Success: false, Error: "stop command not yet implemented"}
+	programName := r.URL.Query().Get("program")
+	timeoutString := r.URL.Query().Get("timeout")
+	if programName == "" {
+		resp := Response{Success: false, Error: "program name required"}
+		handleResponse(w, resp)
+	}
+
+	duration, err := time.ParseDuration(timeoutString)
+	if err != nil {
+		resp := Response{Success: false, Error: fmt.Sprintf("error parsing timeout %s. %s", timeoutString, err.Error())}
+		handleResponse(w, resp)
+	}
+
+	err = s.meeseeks.Stop(programName, duration)
+	if err != nil {
+		resp := Response{Success: false, Error: err.Error()}
+		handleResponse(w, resp)
+	}
+	resp := Response{Success: true, Data: fmt.Sprintf("%s stopped", programName)}
 	handleResponse(w, resp)
 }
 

pkg/server/server_test.go

@@ -244,16 +244,16 @@ func TestServer_HTTPHandlers(t *testing.T) {
 		{
 			name: "stop command",
 			testFn: func(t *testing.T, client *Client) {
-				resp, err := client.Stop("")
+				resp, err := client.Stop("", "5s")
 				if err != nil {
 					t.Errorf("Stop() unexpected error = %v", err)
 					return
 				}
 				if resp.Success {
-					t.Errorf("Expected success=false for unimplemented stop, got %v", resp.Success)
+					t.Errorf("Expected success=false for empty program name, got %v", resp.Success)
 				}
 				if resp.Error == "" {
-					t.Errorf("Expected error message for unimplemented command")
+					t.Errorf("Expected error message for empty program name")
 				}
 			},
 		},
@@ -334,14 +334,13 @@ func TestClient_SendRequest(t *testing.T) {
 		{
 			name: "stop request",
 			testFn: func(t *testing.T, client *Client) {
-				resp, err := client.Stop("")
+				resp, err := client.Stop("test-program", "5s")
 				if err != nil {
 					t.Errorf("Stop() unexpected error = %v", err)
 					return
 				}
-				// Stop is not implemented yet, so expect failure
-				if resp.Success {
-					t.Errorf("Stop() expected success=false (unimplemented), got %v", resp.Success)
+				if !resp.Success {
+					t.Errorf("Stop() expected success=true, got %v", resp.Success)
 				}
 			},
 		},