moved logic in pc runner

Author: dzmitry-lahoda

src/api/pc_api.go

@@ -1,6 +1,7 @@
 package api
 
 import (
+	"errors"
 	"net/http"
 	"strconv"
 	"sync"
@@ -222,25 +223,20 @@ func (api *PcApi) StopProcesses(c *gin.Context) {
 // @Router			/namespace/stop/{name} [patch]
 func (api *PcApi) StopNamespace(c *gin.Context) {
 	ns := c.Param("name")
-	states, err := api.project.GetProcessesState()
+
+	stopped, err := api.project.StopNamespace(ns)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-	processNames := make([]string, 0)
-	for _, state := range states.States {
-		if state.Namespace == ns {
-			processNames = append(processNames, state.Name)
+		if errors.Is(err, app.ErrNamespaceNotFound) {
+			c.JSON(http.StatusNotFound, gin.H{"error": "no processes in namespace: " + ns})
+			return
 		}
-	}
-	if len(processNames) == 0 {
-		c.JSON(http.StatusNotFound, gin.H{"error": "no processes in namespace: " + ns})
+		if len(stopped) > 0 {
+			c.JSON(http.StatusBadRequest, stopped)
+			return
+		}
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
-	stopped, err := api.project.StopProcesses(processNames)
-	if err != nil {
-		c.JSON(http.StatusBadRequest, stopped)
-	}
 	c.JSON(http.StatusOK, stopped)
 }
 
@@ -257,41 +253,17 @@ func (api *PcApi) StopNamespace(c *gin.Context) {
 // @Router			/namespace/disable/{name} [patch]
 func (api *PcApi) DisableNamespace(c *gin.Context) {
 	name := c.Param("name")
-	states, err := api.project.GetProcessesState()
+	results, err := api.project.DisableNamespace(name)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-	names := make([]string, 0)
-	for _, state := range states.States {
-		if state.Namespace == name {
-			names = append(names, state.Name)
-		}
-	}
-	if len(names) == 0 {
-		c.JSON(http.StatusNotFound, gin.H{"error": "no processes in namespace: " + name})
-		return
-	}
-
-	results := make(map[string]string)
-	failures := 0
-	for _, processName := range names {
-		cfg, err := api.project.GetProcessInfo(processName)
-		if err != nil {
-			results[processName] = err.Error()
-			failures++
-			continue
+		if errors.Is(err, app.ErrNamespaceNotFound) {
+			c.JSON(http.StatusNotFound, gin.H{"error": "no processes in namespace: " + name})
+			return
 		}
-		cfg.Disabled = true
-		if err := api.project.UpdateProcess(cfg); err != nil {
-			results[processName] = err.Error()
-			failures++
-		} else {
-			results[processName] = "ok"
+		if len(results) > 0 {
+			c.JSON(http.StatusBadRequest, results)
+			return
 		}
-	}
-	if failures > 0 {
-		c.JSON(http.StatusBadRequest, results)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
 	c.JSON(http.StatusOK, results)
@@ -310,41 +282,17 @@ func (api *PcApi) DisableNamespace(c *gin.Context) {
 // @Router			/namespace/enable/{name} [patch]
 func (api *PcApi) EnableNamespace(c *gin.Context) {
 	ns := c.Param("name")
-	states, err := api.project.GetProcessesState()
+	results, err := api.project.EnableNamespace(ns)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-	names := make([]string, 0)
-	for _, st := range states.States {
-		if st.Namespace == ns {
-			names = append(names, st.Name)
+		if errors.Is(err, app.ErrNamespaceNotFound) {
+			c.JSON(http.StatusNotFound, gin.H{"error": "no processes in namespace: " + ns})
+			return
 		}
-	}
-	if len(names) == 0 {
-		c.JSON(http.StatusNotFound, gin.H{"error": "no processes in namespace: " + ns})
-		return
-	}
-
-	results := make(map[string]string)
-	failures := 0
-	for _, name := range names {
-		cfg, err := api.project.GetProcessInfo(name)
-		if err != nil {
-			results[name] = err.Error()
-			failures++
-			continue
+		if len(results) > 0 {
+			c.JSON(http.StatusBadRequest, results)
+			return
 		}
-		cfg.Disabled = false
-		if err := api.project.UpdateProcess(cfg); err != nil {
-			results[name] = err.Error()
-			failures++
-		} else {
-			results[name] = "ok"
-		}
-	}
-	if failures > 0 {
-		c.JSON(http.StatusBadRequest, results)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
 	c.JSON(http.StatusOK, results)

src/app/errors.go

@@ -0,0 +1,7 @@
+package app
+
+import "errors"
+
+// ErrNamespaceNotFound indicates there are no processes in the given namespace
+var ErrNamespaceNotFound = errors.New("namespace not found")
+

src/app/project_interface.go

@@ -27,7 +27,19 @@ type IProject interface {
 	// Value in map is `ok` on success, else on error to stop specific process.
 	// Iterates all processes (best effort).
 	// If all proceses were stopped, error is nil.
-	StopProcesses(names []string) (map[string]string, error)
+    StopProcesses(names []string) (map[string]string, error)
+    // StopNamespace stops all processes in the given namespace.
+    // Returns a map of process name -> result ("ok" or error string).
+    // If namespace has no processes, returns ErrNamespaceNotFound.
+    StopNamespace(name string) (map[string]string, error)
+    // DisableNamespace disables all processes in the given namespace.
+    // Returns a map of process name -> result ("ok" or error string).
+    // If namespace has no processes, returns ErrNamespaceNotFound.
+    DisableNamespace(name string) (map[string]string, error)
+    // EnableNamespace enables all processes in the given namespace.
+    // Returns a map of process name -> result ("ok" or error string).
+    // If namespace has no processes, returns ErrNamespaceNotFound.
+    EnableNamespace(name string) (map[string]string, error)
 	StartProcess(name string) error
 	RestartProcess(name string) error
 	ScaleProcess(name string, scale int) error

src/app/project_runner.go

@@ -1140,15 +1140,15 @@ func (p *ProjectRunner) UpdateProcess(updated *types.ProcessConfig) error {
 }
 
 func (p *ProjectRunner) UpdateProcesses(processes *types.Processes) (map[string]string, error) {
-    status := make(map[string]string)
-    if processes == nil || len(*processes) == 0 {
-        return status, fmt.Errorf("no processes provided")
-    }
-
-    var errs []error
-    for _, process := range *processes {
-        if err := p.UpdateProcess(&process); err != nil {
-            status[process.ReplicaName] = err.Error()
+	status := make(map[string]string)
+	if processes == nil || len(*processes) == 0 {
+		return status, fmt.Errorf("no processes provided")
+	}
+
+	var errs []error
+	for _, process := range *processes {
+		if err := p.UpdateProcess(&process); err != nil {
+			status[process.ReplicaName] = err.Error()
 			errs = append(errs, err)
 			continue
 		}
@@ -1158,7 +1158,109 @@ func (p *ProjectRunner) UpdateProcesses(processes *types.Processes) (map[string]
 	if len(errs) == len(*processes) {
 		return nil, errors.Join(errs...)
 	}
-    return status, nil
+	return status, nil
+}
+
+// StopNamespace stops all processes in a given namespace.
+// Returns map of process name -> result ("ok" or error).
+// If namespace contains no processes, returns ErrNamespaceNotFound.
+func (p *ProjectRunner) StopNamespace(namespace string) (map[string]string, error) {
+	states, err := p.GetProcessesState()
+	if err != nil {
+		return nil, err
+	}
+
+	names := make([]string, 0)
+	for _, state := range states.States {
+		if state.Namespace == namespace {
+			names = append(names, state.Name)
+		}
+	}
+	if len(names) == 0 {
+		return nil, ErrNamespaceNotFound
+	}
+
+	return p.StopProcesses(names)
+}
+
+// DisableNamespace sets Disabled=true for all processes in the namespace.
+// Returns per-process results map and error if any failures occurred.
+func (p *ProjectRunner) DisableNamespace(namespace string) (map[string]string, error) {
+	states, err := p.GetProcessesState()
+	if err != nil {
+		return nil, err
+	}
+	names := make([]string, 0)
+	for _, st := range states.States {
+		if st.Namespace == namespace {
+			names = append(names, st.Name)
+		}
+	}
+	if len(names) == 0 {
+		return nil, ErrNamespaceNotFound
+	}
+
+	results := make(map[string]string)
+	failures := 0
+	for _, name := range names {
+		cfg, err := p.GetProcessInfo(name)
+		if err != nil {
+			results[name] = err.Error()
+			failures++
+			continue
+		}
+		cfg.Disabled = true
+		if err := p.UpdateProcess(cfg); err != nil {
+			results[name] = err.Error()
+			failures++
+		} else {
+			results[name] = "ok"
+		}
+	}
+	if failures > 0 {
+		return results, errors.New("failed to disable some processes")
+	}
+	return results, nil
+}
+
+// EnableNamespace sets Disabled=false for all processes in the namespace.
+// Returns per-process results map and error if any failures occurred.
+func (p *ProjectRunner) EnableNamespace(namespace string) (map[string]string, error) {
+	states, err := p.GetProcessesState()
+	if err != nil {
+		return nil, err
+	}
+	names := make([]string, 0)
+	for _, st := range states.States {
+		if st.Namespace == namespace {
+			names = append(names, st.Name)
+		}
+	}
+	if len(names) == 0 {
+		return nil, ErrNamespaceNotFound
+	}
+
+	results := make(map[string]string)
+	failures := 0
+	for _, name := range names {
+		cfg, err := p.GetProcessInfo(name)
+		if err != nil {
+			results[name] = err.Error()
+			failures++
+			continue
+		}
+		cfg.Disabled = false
+		if err := p.UpdateProcess(cfg); err != nil {
+			results[name] = err.Error()
+			failures++
+		} else {
+			results[name] = "ok"
+		}
+	}
+	if failures > 0 {
+		return results, errors.New("failed to enable some processes")
+	}
+	return results, nil
 }
 
 func (p *ProjectRunner) RemoveNamespace(namespace string) (map[string]string, error) {