Merge pull request #2 from clemthi/version-bump

Go version bump

Author: clemthi

.gitignore

@@ -1,3 +1,8 @@
+# GO
+
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
 # Binaries for programs and plugins
 *.exe
 *.exe~
@@ -13,3 +18,23 @@
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
+
+# Go workspace file
+go.work
+
+## VSCODE
+
+.vscode/*
+# !.vscode/settings.json
+# !.vscode/tasks.json
+# !.vscode/launch.json
+# !.vscode/extensions.json
+# !.vscode/*.code-snippets
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+

README.md

@@ -5,15 +5,15 @@ This small application allows to start multiple applications at once and if one
 ## Usage
 
 ```shell
-runsyncedapp.exe --config=myconfig.json
+runsyncedapp.exe --config=myconfig.json --verbose
 ```
 
 - `config` : path of the config file
-
+- `verbose` : show all logs
 
 ## JSON configuration
 
-The JSON configuration file looks like:
+The configuration file looks like this:
 
 ```json
 {
@@ -44,6 +44,6 @@ The parameters are the following:
 - `waitCheck`: time in second to wait after the applications starts and the verifications
 - `waitExit`: time in second to wait before the applications closures
 - `applications`: array of application to execute:
-    - `path`: full path of the application
-    - `useExistingInstance`: don't start a new instance if it's already running
-    - `killOnExit`: kill the application if it's running after another app has been killed
+  - `path`: full path of the application
+  - `useExistingInstance`: don't start a new instance if it's already running
+  - `killOnExit`: kill the application if it's running after another app has been killed

config.json

@@ -1,19 +1,19 @@
 {
-    "waitCheck": 10,
-    "waitExit": 10,
+    "waitCheck": 1,
+    "waitExit": 1,
     "applications": [
         {
-            "path": "C:\\Windows\\notepad.exe",
-            "useExistingInstance": true,
+            "path": "C:\\Windows\\System32\\dxdiag.exe",
+            "useExistingInstance": false,
             "killOnExit": true
         },
         {
-            "path": "C:\\Windows\\System32\\calc.exe",
+            "path": "C:\\Windows\\System32\\ftp.exe",
             "useExistingInstance": false,
             "killOnExit": true
         },
         {
-            "path": "C:\\Windows\\write.exe",
+            "path": "C:\\Windows\\System32\\msinfo32.exe",
             "useExistingInstance": false,
             "killOnExit": false
         }

go.mod

@@ -1,5 +1,7 @@
 module github.com/clemthi/runsyncapps
 
-go 1.18
+go 1.22
 
 require github.com/keybase/go-ps v0.0.0-20190827175125-91aafc93ba19
+
+require github.com/stretchr/testify v1.9.0 // indirect

go.sum

@@ -1,2 +1,10 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/keybase/go-ps v0.0.0-20190827175125-91aafc93ba19 h1:WjT3fLi9n8YWh/Ih8Q1LHAPsTqGddPcHqscN+PJ3i68=
 github.com/keybase/go-ps v0.0.0-20190827175125-91aafc93ba19/go.mod h1:hY+WOq6m2FpbvyrI93sMaypsttvaIL5nhVR92dTMUcQ=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

main.go

@@ -3,8 +3,8 @@ package main
 import (
 	"encoding/json"
 	"flag"
-	"io/ioutil"
-	"log"
+	"fmt"
+	"log/slog"
 	"os"
 	"os/exec"
 	"time"
@@ -31,79 +31,95 @@ type ProcessDetails struct {
 }
 
 func main() {
-	configFile := flag.String("config", "config.json", "path to a configuration file")
-	flag.Parse()
+	slog.SetLogLoggerLevel(slog.LevelInfo)
 
-	config, err := loadConfigFile(*configFile)
+	slog.Debug("Loading flags")
+	configFile := *flag.String("config", "config.json", "path to a configuration file")
+	verbose := *flag.Bool("verbose", false, "show all logs")
+
+	if verbose {
+		slog.SetLogLoggerLevel(slog.LevelDebug)
+	}
+
+	config, err := loadConfigFile(configFile)
 	if err != nil {
-		log.Fatalf("Cannot load config file %s : %s", *configFile, err)
+		exitWithMsg(fmt.Sprintf("Cannot load config file %s : %s", configFile, err))
 	}
 
-	runningProcs, err := startProcesses(config.Applications, true)
+	runningProcs, err := startProcesses(config.Applications)
 	if err != nil {
-		log.Fatalf("Error launching apps : %s", err)
+		exitWithMsg(fmt.Sprintf("Error launching apps : %s", err))
 	}
 
 	time.Sleep(time.Duration(config.WaitCheck) * time.Second)
 	checkRunningProcesses(runningProcs)
 
 	time.Sleep(time.Duration(config.WaitExit) * time.Second)
 	killProcesses(runningProcs)
-	log.Printf("Done")
+	slog.Debug("Exiting")
 }
 
-func loadConfigFile(configFile string) (ConfigFile, error) {
-	file, err := ioutil.ReadFile(configFile)
+func loadConfigFile(configFile string) (*ConfigFile, error) {
+	slog.Debug(fmt.Sprintf("Loading config file %s", configFile))
+	file, err := os.ReadFile(configFile)
 	if err != nil {
-		log.Fatalf("Error opening config %s : %s", configFile, err)
+		return nil, err
 	}
 
 	var jsonData ConfigFile
 	err = json.Unmarshal([]byte(file), &jsonData)
 
-	return jsonData, err
+	return &jsonData, err
 }
 
-func startProcesses(apps []AppConfig, checkCurrentProcesses bool) (map[int]ProcessDetails, error) {
+func startProcesses(apps []AppConfig) (map[int]ProcessDetails, error) {
 	procs := make(map[int]ProcessDetails)
 
 	runningProcs, err := ps.Processes()
 	if err != nil {
-		log.Fatalf("Error listing processed (%s)", err)
+		exitWithMsg(fmt.Sprintf("Error listing processed (%s)", err))
 	}
 
 	for _, app := range apps {
 		newProc := ProcessDetails{path: app.Path, pid: -1, killOnExit: app.KillOnExit}
 
 		if app.UseExistingInstance {
+			// check existing processes
 			currentPid, err := findPidFromPath(app.Path, runningProcs)
 			if err != nil {
-				log.Fatalf("Error checking running processes : %s", err)
+				slog.Warn(fmt.Sprintf("Error checking running processes : %s", err))
 			}
 			if currentPid != -1 {
 				newProc.pid = currentPid
-				log.Printf("Found running app %s [PID : %d]\n", newProc.path, newProc.pid)
+				slog.Info(fmt.Sprintf("Found running app %s [PID : %d]\n", newProc.path, newProc.pid))
 			}
 		}
 
+		// start app if not found in existing processes
 		if newProc.pid == -1 {
 			cmd := exec.Command(app.Path)
 			err := cmd.Start()
 			if err != nil {
 				return nil, err
 			}
 			newProc.pid = cmd.Process.Pid
-			log.Printf("Starting apps %s [PID : %d]\n", newProc.path, newProc.pid)
+			slog.Info(fmt.Sprintf("Starting apps %s [PID : %d]", newProc.path, newProc.pid))
 		}
 		procs[newProc.pid] = newProc
 	}
 
 	return procs, nil
 }
 
+func exitWithMsg(msg string) {
+	slog.Error(msg)
+	os.Exit(1)
+}
+
 func findPidFromPath(path string, procs []ps.Process) (int, error) {
 	for _, proc := range procs {
 		if procPath, _ := proc.Path(); procPath == path {
+			slog.Debug(fmt.Sprintf("Found running app %s with PID %d", path, proc.Pid()))
 			return proc.Pid(), nil
 		}
 	}
@@ -124,33 +140,49 @@ func checkRunningProcesses(procs map[int]ProcessDetails) {
 		go checkRunningProcess(pid, chanProcesses)
 	}
 	closedProcess := <-chanProcesses
-	log.Printf("Process closed %s [PID: %d]", procs[closedProcess].path, closedProcess)
+	slog.Info(fmt.Sprintf("Process closed %s [PID: %d]", procs[closedProcess].path, closedProcess))
 }
 
 func checkRunningProcess(pid int, processes chan int) {
 	process, err := os.FindProcess(pid)
 	if err != nil {
 		processes <- pid
 	}
+
+	// Wait the process to exit
+	slog.Debug(fmt.Sprintf("Waiting process [PID: %d] to exit", pid))
 	processState, err := process.Wait()
 	if err != nil {
+		slog.Warn(fmt.Sprintf("Error while waiting process [PID: %d]", pid))
 		processes <- pid
+		return
 	}
+
 	if processState.Exited() {
+		slog.Info(fmt.Sprintf("Process [PID: %d] exited with code %d", pid, processState.ExitCode()))
 		processes <- pid
+		return
 	}
+
+	// something went wrong (?), let's assume process is over
+	slog.Warn(fmt.Sprintf("Process [PID: %d] exited but : %s ", pid, processState))
+	processes <- pid
 }
 
 func killProcesses(procs map[int]ProcessDetails) {
+	slog.Info("Killing other apps")
 	for _, proc := range procs {
 		if proc.killOnExit {
+			slog.Debug(fmt.Sprintf("Killing process %s [PID: %d]", proc.path, proc.pid))
 			procKilled, err := killProcess(proc.pid)
 			if err != nil {
-				log.Printf("Error when killing process%s [PID: %d] : %s", proc.path, proc.pid, err)
+				slog.Warn(fmt.Sprintf("Error when killing process %s [PID: %d] : %s", proc.path, proc.pid, err))
 			}
 			if procKilled {
-				log.Printf("Killed process %s [PID: %d]", proc.path, proc.pid)
+				slog.Info(fmt.Sprintf("Killed process %s [PID: %d]", proc.path, proc.pid))
 			}
+		} else {
+			slog.Debug(fmt.Sprintf("Skipping process %s [PID: %d]", proc.path, proc.pid))
 		}
 	}
 }
@@ -163,7 +195,7 @@ func killProcess(pid int) (bool, error) {
 	process, _ := os.FindProcess(pid)
 	err := process.Kill()
 	if err != nil {
-		log.Printf("Cannot kill process %d", pid)
+		slog.Warn(fmt.Sprintf("Cannot kill process %d", pid))
 		return false, err
 	}
 	return true, nil