fix: ensure monitors work

compose.yaml

@@ -15,8 +15,7 @@ services:
     security_opt:
       - apparmor:unconfined
     volumes:
-      - ./config.yaml:/data/config.yaml
-      - ./rclone.conf:/data/rclone.conf
+      - ./data:/data
       - ./local-dev/mnt/rclone:/mnt/rclone:shared
       - ./local-dev/caches/rclone:/caches/rclone
     environment:

config.yaml → data/config.yaml

@@ -4,8 +4,7 @@ mounts:
   - backendName: "AllDebrid"
     # This is the path to the mountpoint on the host
     mountPoint: "/mnt/rclone/alldebrid"
-    # These will be fully converted to vfsOpt and mountOpt payloads for the rclone mount command through RC. You can use your regular rclone env vars.
-    # They override the shared options in the environment section of the compose / running container for this specific mount.
+    # These override the shared options in the environment section of the compose / running container for this specific mount.
     environment:
       RCLONE_BWLIMIT: off
       RCLONE_READ_ONLY: true

src/internal/mount_manager/helpers.go

@@ -76,3 +76,17 @@ func removeStaleMounts(conf *config.Config, logger zerolog.Logger) {
 		}
 	}
 }
+
+func ensureExists(mountPoint string, logger zerolog.Logger) {
+	if _, err := os.Stat(mountPoint); os.IsNotExist(err) {
+		logger.Info().Str(constants.LogMountPoint, mountPoint).Msg("Creating mount point...")
+		err := os.MkdirAll(mountPoint, 0777)
+		if err != nil {
+			logger.Error().Err(err).Str(constants.LogMountPoint, mountPoint).
+				Msg("Failed to create mount point")
+		} else {
+			logger.Info().Str(constants.LogMountPoint, mountPoint).
+				Msg("Mount point created successfully.")
+		}
+	}
+}

src/internal/mount_manager/monitor.go

@@ -22,11 +22,16 @@ func MonitorMountProcesses(logger zerolog.Logger) {
 	shouldMonitorProcesses = true
 
 	for {
+		logger.Debug().Msg("Checking mount processes...")
 		if !shouldMonitorProcesses {
 			logger.Info().Msg("Stopping rclone mount process monitor")
 			break
 		}
 		tracker.Range(func(key, value interface{}) bool {
+			if !shouldMonitorProcesses {
+				return false
+			}
+
 			mountProcess := value.(*MountProcess)
 
 			if time.Since(mountProcess.StartedAt) < mountProcess.GracePeriod {
@@ -38,14 +43,26 @@ func MonitorMountProcesses(logger zerolog.Logger) {
 				logger.Warn().Str(constants.LogBackend, mountProcess.BackendName).
 					Msgf("Process (PID: %d) died. Restarting...", mountProcess.PID)
 
+				if !shouldMonitorProcesses {
+					return false
+				}
+
 				UnmountEndpoint(mountProcess, logger)
 
-				newServe := &MountProcess{
+				if !shouldMonitorProcesses {
+					return false
+				}
+
+				newMount := &MountProcess{
 					MountPoint:    mountProcess.MountPoint,
 					RcloneProcess: mountProcess.RcloneProcess,
 				}
 
-				newProcess := StartMountWithRetries(newServe, logger)
+				newProcess := StartMountWithRetries(newMount, logger)
+
+				if !shouldMonitorProcesses {
+					return false
+				}
 
 				if newProcess != nil {
 					tracker.Track(newProcess.BackendName, newProcess)
@@ -56,6 +73,8 @@ func MonitorMountProcesses(logger zerolog.Logger) {
 						Msg("Failed to restart mount process")
 				}
 			}
+
+			logger.Debug().Str("MountPoint", mountProcess.MountPoint).Msg("Mount is mounted fine. Nothing to do.")
 			return true
 		})
 		time.Sleep(10 * time.Second)

src/internal/mount_manager/mount.go

@@ -34,6 +34,7 @@ func InitializeMountEndpoints(conf *config.Config, logger zerolog.Logger, proces
 func StartMountWithRetries(instance *MountProcess, logger zerolog.Logger) *MountProcess {
 	retries := 0
 	for retries < 3 {
+		ensureExists(instance.MountPoint, logger)
 		cmd := createMountCommand(instance)
 		instance.Command = cmd
 		err := cmd.Start()
@@ -46,6 +47,18 @@ func StartMountWithRetries(instance *MountProcess, logger zerolog.Logger) *Mount
 			instance.StartedAt = time.Now()
 			instance.GracePeriod = 10 * time.Second
 			tracker.Track(instance.BackendName, instance)
+			go func() {
+				err := cmd.Wait()
+				if err != nil {
+					logger.Warn().AnErr(constants.LogError, err).
+						Str(constants.LogBackend, instance.BackendName).
+						Msg("Mount process exited with error.")
+				} else {
+					logger.Info().
+						Str(constants.LogBackend, instance.BackendName).
+						Msg("Mount process exited normally.")
+				}
+			}()
 			return instance
 		}
 		logger.Warn().AnErr(constants.LogError, err).Msgf("Mount failed. Retrying %d/3...", retries+1)
@@ -58,6 +71,7 @@ func StartMountWithRetries(instance *MountProcess, logger zerolog.Logger) *Mount
 
 func StopMount(instance *MountProcess, logger zerolog.Logger) {
 	logger.Info().Str(constants.LogBackend, instance.BackendName).Msg("Stopping mount process...")
+	UnmountEndpoint(instance, logger)
 	if err := instance.Command.Process.Kill(); err == nil {
 		tracker.Untrack(instance.BackendName)
 		logger.Info().Int(constants.LogPid, instance.PID).Str(constants.LogBackend, instance.BackendName).Msg("Mount process stopped")
@@ -67,6 +81,7 @@ func StopMount(instance *MountProcess, logger zerolog.Logger) {
 }
 
 func Cleanup(config *config.Config, logger zerolog.Logger) {
+	shouldMonitorProcesses = false
 	logger.Info().Msg("Cleaning up all rclone mount processes")
 	tracker.Range(func(key, value interface{}) bool {
 		instance := value.(*MountProcess)
@@ -82,8 +97,8 @@ func ReconcileMounts(conf *config.Config, logger zerolog.Logger, processLock *sy
 
 	logger.Info().Msg("Reconciling mounts...")
 
-	setupMountsFromConfig(conf, logger)
 	removeStaleMounts(conf, logger)
+	setupMountsFromConfig(conf, logger)
 }
 
 func UnmountEndpoint(mount *MountProcess, logger zerolog.Logger) {

src/internal/serve_manager/monitor.go

@@ -22,13 +22,18 @@ func MonitorServeProcesses(logger zerolog.Logger) {
 	shouldMonitorProcesses = true
 
 	for {
+		logger.Debug().Msg("Checking serve processes...")
 		if !shouldMonitorProcesses {
 			logger.Info().Msg("Stopping rclone serve process monitor")
 			break
 		}
 		tracker.Range(func(key, value interface{}) bool {
 			serveProcess := value.(*ServeProcess)
 
+			if !shouldMonitorProcesses {
+				return false
+			}
+
 			if time.Since(serveProcess.StartedAt) < serveProcess.GracePeriod {
 				logger.Debug().Int(constants.LogPid, serveProcess.PID).Msg("Skipping process check (within grace period)")
 				return true
@@ -38,6 +43,10 @@ func MonitorServeProcesses(logger zerolog.Logger) {
 				logger.Warn().Str(constants.LogBackend, serveProcess.BackendName).
 					Msgf("Process (PID: %d) died. Restarting...", serveProcess.PID)
 
+				if !shouldMonitorProcesses {
+					return false
+				}
+
 				newServe := &ServeProcess{
 					Protocol:      serveProcess.Protocol,
 					Addr:          serveProcess.Addr,
@@ -46,6 +55,10 @@ func MonitorServeProcesses(logger zerolog.Logger) {
 
 				newProcess := StartServeWithRetries(newServe, logger)
 
+				if !shouldMonitorProcesses {
+					return false
+				}
+
 				if newProcess != nil {
 					tracker.Track(newProcess.BackendName, newProcess)
 					logger.Info().Str(constants.LogBackend, serveProcess.BackendName).
@@ -55,6 +68,7 @@ func MonitorServeProcesses(logger zerolog.Logger) {
 						Msg("Failed to restart serve process")
 				}
 			}
+			logger.Debug().Str("Backend", serveProcess.BackendName).Msg("Serve is fine. Nothing to do.")
 			return true
 		})
 		time.Sleep(10 * time.Second)

src/internal/serve_manager/serve.go

@@ -48,6 +48,18 @@ func StartServeWithRetries(instance *ServeProcess, logger zerolog.Logger) *Serve
 			instance.StartedAt = time.Now()
 			instance.GracePeriod = 10 * time.Second
 			tracker.Track(instance.BackendName, instance)
+			go func() {
+				err := cmd.Wait()
+				if err != nil {
+					logger.Warn().AnErr(constants.LogError, err).
+						Str(constants.LogBackend, instance.BackendName).
+						Msg("Serve process exited with error.")
+				} else {
+					logger.Info().
+						Str(constants.LogBackend, instance.BackendName).
+						Msg("Serve process exited normally.")
+				}
+			}()
 			return instance
 		}
 		logger.Warn().AnErr(constants.LogError, err).Msgf("Serve failed. Retrying %d/3...", retries+1)
@@ -69,6 +81,7 @@ func StopServe(instance *ServeProcess, logger zerolog.Logger) {
 }
 
 func Cleanup(logger zerolog.Logger) {
+	shouldMonitorProcesses = false
 	logger.Info().Msg("Cleaning up all rclone serve processes")
 	tracker.Range(func(key, value interface{}) bool {
 		instance := value.(*ServeProcess)