feat: Ability to view all logs with prefix when processes table header is selected

src/api/pc_api.go

@@ -250,6 +250,25 @@ func (api *PcApi) RestartProcess(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{"name": name})
 }
 
+// @Schemes
+// @Id				RestartAllProcesses
+// @Description	Restarts all processes
+// @Tags			Process
+// @Summary		Restart all processes
+// @Produce		json
+// @Success		200	{object}	api.StatusResponse	"Restart All Status"
+// @Failure		400	{object}	map[string]string
+// @Router			/processes/restart [post]
+func (api *PcApi) RestartAllProcesses(c *gin.Context) {
+	err := api.project.RestartAllProcesses()
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"status": "restarted"})
+}
+
 // @Schemes
 // @Id				ScaleProcess
 // @Description	Scale a process

src/api/routes.go

@@ -36,6 +36,7 @@ func InitRoutes(useLogger bool, handler *PcApi) *gin.Engine {
 	r.PATCH("/processes/stop", handler.StopProcesses)
 	r.POST("/process/start/:name", handler.StartProcess)
 	r.POST("/process/restart/:name", handler.RestartProcess)
+	r.POST("/processes/restart", handler.RestartAllProcesses)
 	r.POST("/project/stop", handler.ShutDownProject)
 	r.POST("/project", handler.UpdateProject)
 	r.POST("/project/configuration", handler.ReloadProject)

src/app/project_interface.go

@@ -28,6 +28,7 @@ type IProject interface {
 	StopProcesses(names []string) (map[string]string, error)
 	StartProcess(name string) error
 	RestartProcess(name string) error
+	RestartAllProcesses() error
 	ScaleProcess(name string, scale int) error
 	GetProcessPorts(name string) (*types.ProcessPorts, error)
 	SetProcessPassword(name string, password string) error

src/app/project_runner.go

@@ -66,6 +66,8 @@ type ProjectRunner struct {
 	procCompleteChannel  chan int
 	processTree          *ProcessTree
 	processScheduler     *scheduler.Scheduler
+	isRestartingAll      bool
+	restartAllMutex      sync.Mutex
 }
 
 // RestartCall represents an in-flight restart operation
@@ -161,6 +163,14 @@ func (p *ProjectRunner) Run() error {
 		case runProcCount := <-p.procCompleteChannel:
 			log.Debug().Msgf("Remaining processes: %d", runProcCount)
 			if runProcCount == 0 {
+				// Check if a restart-all operation is in progress
+				p.restartAllMutex.Lock()
+				isRestarting := p.isRestartingAll
+				p.restartAllMutex.Unlock()
+				if isRestarting {
+					log.Debug().Msg("Restart all in progress, not exiting")
+					continue
+				}
 				if p.processScheduler == nil || len(p.processScheduler.GetScheduledProcesses()) == 0 {
 					log.Info().Msg("Project completed")
 					p.exitCodeMutex.Lock()
@@ -561,6 +571,106 @@ func (p *ProjectRunner) doRestart(name string) error {
 	return nil
 }
 
+func (p *ProjectRunner) RestartAllProcesses() error {
+	log.Info().Msg("Restarting all processes")
+
+	// Set flag to prevent main loop from exiting when process count reaches 0
+	p.restartAllMutex.Lock()
+	p.isRestartingAll = true
+	p.restartAllMutex.Unlock()
+
+	// Build shutdown order
+	p.runProcMutex.Lock()
+	shutdownOrder := []*Process{}
+	if p.isOrderedShutdown {
+		err := p.project.WithProcesses([]string{}, func(process types.ProcessConfig) error {
+			if runningProc, ok := p.runningProcesses[process.ReplicaName]; ok {
+				shutdownOrder = append(shutdownOrder, runningProc)
+			}
+			return nil
+		})
+		if err != nil {
+			log.Error().Msgf("Failed to build project run order: %s", err.Error())
+		}
+		slices.Reverse(shutdownOrder)
+	} else {
+		for _, proc := range p.runningProcesses {
+			shutdownOrder = append(shutdownOrder, proc)
+		}
+	}
+	p.runProcMutex.Unlock()
+
+	var nameOrder []string
+	for _, v := range shutdownOrder {
+		nameOrder = append(nameOrder, v.getName())
+	}
+	log.Debug().Msgf("Stopping %d processes for restart. Order: %q", len(shutdownOrder), nameOrder)
+
+	// Prepare all processes for shutdown (prevents auto-restart)
+	for _, proc := range shutdownOrder {
+		proc.prepareForShutDown()
+	}
+
+	// Stop all processes
+	p.shutDownAndWait(shutdownOrder)
+
+	// Clear done processes map
+	p.doneProcMutex.Lock()
+	p.doneProcesses = make(map[string]*Process)
+	p.doneProcMutex.Unlock()
+
+	// Reset process states to pending
+	p.statesMutex.Lock()
+	for name, state := range p.processStates {
+		state.Status = types.ProcessStatePending
+		state.Pid = 0
+		state.ExitCode = 0
+		state.IsRunning = false
+		p.processStates[name] = state
+	}
+	p.statesMutex.Unlock()
+
+	// Build run order (same as initial Run())
+	runOrder := []types.ProcessConfig{}
+	err := p.project.WithProcesses([]string{}, func(process types.ProcessConfig) error {
+		if process.IsDeferred() {
+			return nil
+		}
+		runOrder = append(runOrder, process)
+		return nil
+	})
+	if err != nil {
+		// Clear the restart flag on error
+		p.restartAllMutex.Lock()
+		p.isRestartingAll = false
+		p.restartAllMutex.Unlock()
+		return fmt.Errorf("failed to build project run order: %w", err)
+	}
+
+	var startOrder []string
+	for _, v := range runOrder {
+		startOrder = append(startOrder, v.ReplicaName)
+	}
+	log.Debug().Msgf("Starting %d processes. Order: %q", len(runOrder), startOrder)
+
+	// Start all processes
+	for _, proc := range runOrder {
+		if proc.Schedule != nil && proc.Schedule.IsScheduled() {
+			continue
+		}
+		newConf := proc
+		p.runProcess(&newConf)
+	}
+
+	// Clear the restart flag now that new processes are started
+	p.restartAllMutex.Lock()
+	p.isRestartingAll = false
+	p.restartAllMutex.Unlock()
+
+	log.Info().Msg("All processes restarted")
+	return nil
+}
+
 func (p *ProjectRunner) GetProcessInfo(name string) (*types.ProcessConfig, error) {
 	p.runProcMutex.Lock()
 	defer p.runProcMutex.Unlock()

src/client/client.go

@@ -132,6 +132,10 @@ func (p *PcClient) RestartProcess(name string) error {
 	return p.restartProcess(name)
 }
 
+func (p *PcClient) RestartAllProcesses() error {
+	return p.restartAllProcesses()
+}
+
 func (p *PcClient) ScaleProcess(name string, scale int) error {
 	return p.scaleProcess(name, scale)
 }

src/client/restart.go

@@ -4,8 +4,9 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/rs/zerolog/log"
 	"net/http"
+
+	"github.com/rs/zerolog/log"
 )
 
 func (p *PcClient) restartProcess(name string) error {
@@ -25,3 +26,21 @@ func (p *PcClient) restartProcess(name string) error {
 	}
 	return errors.New(respErr.Error)
 }
+
+func (p *PcClient) restartAllProcesses() error {
+	url := fmt.Sprintf("http://%s/processes/restart", p.address)
+	resp, err := p.client.Post(url, "application/json", nil)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode == http.StatusOK {
+		return nil
+	}
+	var respErr pcError
+	if err = json.NewDecoder(resp.Body).Decode(&respErr); err != nil {
+		log.Error().Msgf("failed to decode restart all processes response: %v", err)
+		return err
+	}
+	return errors.New(respErr.Error)
+}

src/tui/actions.go

@@ -25,6 +25,7 @@ const (
 	ActionProcessInfo      = ActionName("process_info")
 	ActionProcessStop      = ActionName("process_stop")
 	ActionProcessRestart   = ActionName("process_restart")
+	ActionProcessRestartAll = ActionName("process_restart_all")
 	ActionProcessScreen    = ActionName("process_screen")
 	ActionQuit             = ActionName("quit")
 	ActionLogFind          = ActionName("find")
@@ -57,6 +58,7 @@ var defaultShortcuts = map[ActionName]tcell.Key{
 	ActionProcessStart:     tcell.KeyF7,
 	ActionProcessStop:      tcell.KeyF9,
 	ActionProcessRestart:   tcell.KeyCtrlR,
+	ActionProcessRestartAll: tcell.KeyCtrlU,
 	ActionProcessScreen:    tcell.KeyF8,
 	ActionQuit:             tcell.KeyF10,
 	ActionLogFind:          tcell.KeyCtrlF,
@@ -109,6 +111,7 @@ var procActionsOrder = []ActionName{
 	ActionProcessScreen,
 	ActionProcessStop,
 	ActionProcessRestart,
+	ActionProcessRestartAll,
 	ActionEditProcess,
 	ActionReloadConfig,
 	ActionNsFilter,
@@ -342,6 +345,9 @@ func newShortCuts() *ShortCuts {
 			ActionProcessRestart: {
 				Description: "Restart",
 			},
+			ActionProcessRestartAll: {
+				Description: "Restart All",
+			},
 			ActionQuit: {
 				Description: "Quit",
 			},

src/tui/all-logs-observer.go

@@ -0,0 +1,73 @@
+package tui
+
+import (
+	"fmt"
+	"hash/fnv"
+	"math"
+
+	"github.com/f1bonacc1/process-compose/src/pclog"
+)
+
+// tviewColors is a list of tview color names for process name prefixes.
+var tviewColors = []string{
+	"red",
+	"green",
+	"yellow",
+	"blue",
+	"magenta",
+	"cyan",
+	"orange",
+	"pink",
+	"lime",
+	"aqua",
+	"violet",
+	"gold",
+}
+
+// getProcessColor returns a tview color name for the given process name.
+func getProcessColor(name string) string {
+	hash := fnv.New32a()
+	hash.Write([]byte(name))
+	return tviewColors[int(hash.Sum32())%len(tviewColors)]
+}
+
+// AllLogsObserver wraps a LogView and prefixes log lines with a colored process name.
+// It implements pclog.LogObserver interface.
+type AllLogsObserver struct {
+	processName string
+	logView     *LogView
+	color       string
+	uniqueID    string
+}
+
+// NewAllLogsObserver creates a new AllLogsObserver for the given process.
+func NewAllLogsObserver(processName string, logView *LogView) *AllLogsObserver {
+	return &AllLogsObserver{
+		processName: processName,
+		logView:     logView,
+		color:       getProcessColor(processName),
+		uniqueID:    pclog.GenerateUniqueID(10),
+	}
+}
+
+// WriteString writes a log line prefixed with the colored process name.
+func (o *AllLogsObserver) WriteString(line string) (n int, err error) {
+	return o.logView.WriteStringWithProcess(line, o.processName, o.color)
+}
+
+// SetLines sets multiple log lines, each prefixed with the colored process name.
+func (o *AllLogsObserver) SetLines(lines []string) {
+	for _, line := range lines {
+		_, _ = o.WriteString(line)
+	}
+}
+
+// GetTailLength returns the tail length for log subscription.
+func (o *AllLogsObserver) GetTailLength() int {
+	return math.MaxInt
+}
+
+// GetUniqueID returns the unique identifier for this observer.
+func (o *AllLogsObserver) GetUniqueID() string {
+	return fmt.Sprintf("all-logs-%s-%s", o.processName, o.uniqueID)
+}