fix(startup): bind HTTP listeners before sd_notify and improve library match logging

Split net.Listen (synchronous) from server.Serve (goroutine) so ports are
guaranteed bound before READY=1 is sent to systemd.

Replace per-target Warn "Libraries Not Found" with processor-level
aggregation: targets return ErrLibraryNotMatched sentinel, processor warns
only when NO target matched a scan (real config problem). Individual
target misses logged at Debug for traceability. Eliminates false warnings
in non-overlapping multi-target setups.

Signed-off-by: Anagh Kumar Baranwal <6824881+darthShadow@users.noreply.github.com>

Author: darthShadow

autoscan.go

@@ -57,6 +57,12 @@ func LimitReadCloser(rc io.ReadCloser) io.ReadCloser {
 }
 
 var (
+	// ErrLibraryNotMatched is returned by a target's Scan method when the
+	// scan folder does not match any of the target's known libraries.
+	// The processor uses this to distinguish "no match" (expected in
+	// non-overlapping setups) from real errors.
+	ErrLibraryNotMatched = errors.New("no matching library")
+
 	// ErrTargetUnavailable may occur when a Target goes offline
 	// or suffers from fatal errors. In this case, the processor
 	// will halt operations until the target is back online.

cmd/autoscan/main.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"net"
 	"net/http"
 	"os"
 	"os/signal"
@@ -246,30 +247,40 @@ func initProcessor(cfg config, db *sqlite.DB, procStats *stats.Stats) *processor
 	return proc
 }
 
-// startHTTPServers starts one goroutine per host address that serves the router.
-// Calls log.Fatal if any server fails to start.
+// startHTTPServers binds a listener per host address, then serves in background
+// goroutines. The function returns only after every listener has successfully
+// bound, so callers can rely on the ports being open. Calls log.Fatal on bind
+// failure.
 func startHTTPServers(cfg config, router http.Handler) {
 	for _, hostAddr := range cfg.Host {
-		go func(host string) {
-			addr := host
-			if !strings.Contains(addr, ":") {
-				addr = fmt.Sprintf("%s:%d", host, cfg.Port)
-			}
+		if !strings.Contains(hostAddr, ":") {
+			hostAddr = fmt.Sprintf("%s:%d", hostAddr, cfg.Port)
+		}
 
-			log.Info().Str("addr", addr).Msg("Server Starting")
-			server := &http.Server{
-				Addr:         addr,
-				Handler:      router,
-				ReadTimeout:  serverTimeout,
-				WriteTimeout: serverTimeout,
-			}
-			if listenErr := server.ListenAndServe(); listenErr != nil {
+		var lc net.ListenConfig
+		listener, err := lc.Listen(context.Background(), "tcp", hostAddr)
+		if err != nil {
+			log.Fatal().
+				Str("addr", hostAddr).
+				Err(err).
+				Msg("Server Bind Failed")
+		}
+
+		log.Info().Str("addr", hostAddr).Msg("Server Listening")
+		server := &http.Server{
+			Handler:      router,
+			ReadTimeout:  serverTimeout,
+			WriteTimeout: serverTimeout,
+		}
+
+		go func() {
+			if serveErr := server.Serve(listener); serveErr != nil && !errors.Is(serveErr, http.ErrServerClosed) {
 				log.Fatal().
-					Str("addr", addr).
-					Err(listenErr).
-					Msg("Server Start Failed")
+					Str("addr", hostAddr).
+					Err(serveErr).
+					Msg("Server Failed")
 			}
-		}(hostAddr)
+		}()
 	}
 }
 

processor/processor.go

@@ -2,6 +2,7 @@ package processor
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"sync"
@@ -121,20 +122,47 @@ func (*Processor) CheckAvailability(targets []autoscan.Target) error {
 }
 
 func (*Processor) callTargets(targets []autoscan.Target, scan autoscan.Scan) error {
-	ctx, cancel := context.WithTimeout(context.Background(), processorTimeout)
-	defer cancel()
-
-	g, _ := errgroup.WithContext(ctx)
+	errs := make([]error, len(targets))
+	var wg sync.WaitGroup
 
-	for _, target := range targets {
-		g.Go(func() error {
-			return target.Scan(scan)
+	for i, t := range targets {
+		wg.Go(func() {
+			errs[i] = t.Scan(scan)
 		})
 	}
 
-	if err := g.Wait(); err != nil {
-		return fmt.Errorf("call targets: %w", err)
+	wg.Wait()
+
+	var (
+		matched  int
+		skipped  int
+		firstErr error
+	)
+
+	for _, err := range errs {
+		switch {
+		case err == nil:
+			matched++
+		case errors.Is(err, autoscan.ErrLibraryNotMatched):
+			skipped++
+		default:
+			if firstErr == nil {
+				firstErr = err
+			}
+		}
+	}
+
+	if firstErr != nil {
+		return fmt.Errorf("call targets: %w", firstErr)
 	}
+
+	if matched == 0 && skipped > 0 {
+		log.Warn().
+			Str("folder", scan.Folder).
+			Int("targets_skipped", skipped).
+			Msg("No Targets Matched Scan")
+	}
+
 	return nil
 }
 

processor/processor_test.go

@@ -1,10 +1,14 @@
 package processor
 
 import (
+	"errors"
+	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 
+	"github.com/cloudbox/autoscan"
 	"github.com/cloudbox/autoscan/stats"
 )
 
@@ -42,6 +46,104 @@ func newTestProcessor(anchors []string) *Processor {
 	}
 }
 
+// mockTarget is a minimal autoscan.Target for testing callTargets.
+type mockTarget struct {
+	scanFn func(autoscan.Scan) error
+}
+
+func (m *mockTarget) Scan(scan autoscan.Scan) error {
+	return m.scanFn(scan)
+}
+
+func (*mockTarget) Available() error {
+	return nil
+}
+
+func TestCallTargets(t *testing.T) {
+	p := &Processor{}
+	scan := autoscan.Scan{Folder: "/media/movies"}
+
+	t.Run("AllMatch", func(t *testing.T) {
+		targets := []autoscan.Target{
+			&mockTarget{scanFn: func(_ autoscan.Scan) error { return nil }},
+			&mockTarget{scanFn: func(_ autoscan.Scan) error { return nil }},
+			&mockTarget{scanFn: func(_ autoscan.Scan) error { return nil }},
+		}
+		if err := p.callTargets(targets, scan); err != nil {
+			t.Errorf("expected nil error, got: %v", err)
+		}
+	})
+
+	t.Run("AllSkipped", func(t *testing.T) {
+		targets := []autoscan.Target{
+			&mockTarget{scanFn: func(_ autoscan.Scan) error {
+				return fmt.Errorf("%w: /tv", autoscan.ErrLibraryNotMatched)
+			}},
+			&mockTarget{scanFn: func(_ autoscan.Scan) error {
+				return fmt.Errorf("%w: /tv", autoscan.ErrLibraryNotMatched)
+			}},
+			&mockTarget{scanFn: func(_ autoscan.Scan) error {
+				return fmt.Errorf("%w: /tv", autoscan.ErrLibraryNotMatched)
+			}},
+		}
+		// All skipped — scan is consumed, not retried. No error returned.
+		if err := p.callTargets(targets, scan); err != nil {
+			t.Errorf("expected nil error when all targets skipped, got: %v", err)
+		}
+	})
+
+	t.Run("MixMatchAndSkip", func(t *testing.T) {
+		targets := []autoscan.Target{
+			&mockTarget{scanFn: func(_ autoscan.Scan) error { return nil }},
+			&mockTarget{scanFn: func(_ autoscan.Scan) error {
+				return fmt.Errorf("%w: /tv", autoscan.ErrLibraryNotMatched)
+			}},
+			&mockTarget{scanFn: func(_ autoscan.Scan) error { return nil }},
+		}
+		if err := p.callTargets(targets, scan); err != nil {
+			t.Errorf("expected nil error for mixed match/skip, got: %v", err)
+		}
+	})
+
+	t.Run("RealError", func(t *testing.T) {
+		targets := []autoscan.Target{
+			&mockTarget{scanFn: func(_ autoscan.Scan) error { return nil }},
+			&mockTarget{scanFn: func(_ autoscan.Scan) error {
+				return errors.New("connection refused")
+			}},
+		}
+		err := p.callTargets(targets, scan)
+		if err == nil {
+			t.Fatal("expected non-nil error, got nil")
+		}
+		if !strings.Contains(err.Error(), "connection refused") {
+			t.Errorf("expected error to contain 'connection refused', got: %v", err)
+		}
+	})
+
+	t.Run("RealErrorPlusSkip", func(t *testing.T) {
+		targets := []autoscan.Target{
+			&mockTarget{scanFn: func(_ autoscan.Scan) error {
+				return fmt.Errorf("%w: /movies", autoscan.ErrLibraryNotMatched)
+			}},
+			&mockTarget{scanFn: func(_ autoscan.Scan) error { return nil }},
+			&mockTarget{scanFn: func(_ autoscan.Scan) error {
+				return errors.New("timeout")
+			}},
+		}
+		err := p.callTargets(targets, scan)
+		if err == nil {
+			t.Fatal("expected non-nil error, got nil")
+		}
+		if !strings.Contains(err.Error(), "timeout") {
+			t.Errorf("expected error to contain 'timeout', got: %v", err)
+		}
+		if errors.Is(err, autoscan.ErrLibraryNotMatched) {
+			t.Error("returned error must not wrap ErrLibraryNotMatched")
+		}
+	})
+}
+
 func TestCheckAnchorsNoAnchors(t *testing.T) {
 	p := newTestProcessor(nil)
 
@@ -135,25 +237,3 @@ func TestCheckAnchorsStateTransitions(t *testing.T) {
 		t.Fatal("expected anchorState to be true after restore")
 	}
 }
-
-func TestCheckAnchorsDirectorySupport(t *testing.T) {
-	dir := t.TempDir()
-	anchorDir := filepath.Join(dir, "mount-check")
-	if err := os.Mkdir(anchorDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	p := newTestProcessor([]string{anchorDir})
-
-	if !p.CheckAnchors() {
-		t.Error("expected CheckAnchors to return true for directory anchor")
-	}
-
-	// Remove directory
-	if err := os.Remove(anchorDir); err != nil {
-		t.Fatal(err)
-	}
-	if p.CheckAnchors() {
-		t.Error("expected CheckAnchors to return false after directory removed")
-	}
-}

targets/emby/emby.go

@@ -72,11 +72,8 @@ func (t target) Scan(scan autoscan.Scan) error {
 
 	lib, err := t.getScanLibrary(scanFolder)
 	if err != nil {
-		t.log.Warn().
-			Err(err).
-			Msg("Libraries Not Found")
-
-		return nil
+		t.log.Debug().Str("folder", scanFolder).Msg("Library Not Matched")
+		return fmt.Errorf("%w: %s", autoscan.ErrLibraryNotMatched, scanFolder)
 	}
 
 	scanPath := scanFolder

targets/jellyfin/jellyfin.go

@@ -72,11 +72,8 @@ func (t target) Scan(scan autoscan.Scan) error {
 
 	lib, err := t.getScanLibrary(scanFolder)
 	if err != nil {
-		t.log.Warn().
-			Err(err).
-			Msg("Libraries Not Found")
-
-		return nil
+		t.log.Debug().Str("folder", scanFolder).Msg("Library Not Matched")
+		return fmt.Errorf("%w: %s", autoscan.ErrLibraryNotMatched, scanFolder)
 	}
 
 	scanPath := scanFolder

targets/plex/plex.go

@@ -82,11 +82,8 @@ func (t target) Scan(scan autoscan.Scan) error {
 
 	libs, err := t.getScanLibrary(scanFolder)
 	if err != nil {
-		t.log.Warn().
-			Err(err).
-			Msg("Libraries Not Found")
-
-		return nil
+		t.log.Debug().Str("folder", scanFolder).Msg("Library Not Matched")
+		return fmt.Errorf("%w: %s", autoscan.ErrLibraryNotMatched, scanFolder)
 	}
 
 	// send scan request