fix(cross): performance improvements

internal/qbittorrent/sync_manager_test.go

@@ -0,0 +1,195 @@
+package qbittorrent
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	qbt "github.com/autobrr/go-qbittorrent"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNormalizeHashes(t *testing.T) {
+	t.Parallel()
+
+	normalized := normalizeHashes([]string{" ABC123 ", "abc123", "Def456", "def456", ""})
+
+	require.Equal(t, []string{"abc123", "def456"}, normalized.canonical)
+	require.Equal(t, map[string]struct{}{
+		"abc123": {},
+		"def456": {},
+	}, normalized.canonicalSet)
+	require.Equal(t, "ABC123", normalized.canonicalToPreferred["abc123"])
+	require.Equal(t, []string{"ABC123", "abc123", "Def456", "def456", "DEF456"}, normalized.lookup)
+}
+
+func TestGetTorrentFilesBatch_NormalizesAndCaches(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+
+	client := &stubTorrentFilesClient{
+		torrents: []qbt.Torrent{
+			{Hash: "ABC123", Progress: 1.0},
+			{Hash: "def456", Progress: 0.5},
+		},
+		filesByHash: map[string]qbt.TorrentFiles{
+			"ABC123": {
+				{
+					Name: "cached-a.mkv",
+					Size: 1,
+				},
+			},
+			"Def456": {
+				{
+					Name: "def-file.mkv",
+					Size: 2,
+				},
+			},
+		},
+	}
+
+	fm := &stubFilesManager{
+		cached: map[string]qbt.TorrentFiles{
+			"abc123": {
+				{
+					Name: "cached-a.mkv",
+					Size: 1,
+				},
+			},
+		},
+	}
+
+	sm := &SyncManager{
+		torrentFilesClientProvider: func(context.Context, int) (torrentFilesClient, error) {
+			return client, nil
+		},
+	}
+	sm.SetFilesManager(fm)
+
+	filesByHash, err := sm.GetTorrentFilesBatch(ctx, 1, []string{"  ABC123 ", "abc123", "Def456"})
+	require.NoError(t, err)
+
+	require.Len(t, filesByHash, 2)
+	require.Contains(t, filesByHash, "abc123")
+	require.Contains(t, filesByHash, "def456")
+	require.Equal(t, "cached-a.mkv", filesByHash["abc123"][0].Name)
+	require.Equal(t, "def-file.mkv", filesByHash["def456"][0].Name)
+
+	require.ElementsMatch(t, []string{"abc123", "def456"}, fm.lastHashes)
+	require.Len(t, fm.cacheCalls, 1)
+	require.Equal(t, cacheCall{hash: "def456", progress: 0.5}, fm.cacheCalls[0])
+
+	require.Len(t, client.requestedHashes, 1)
+	require.Equal(t, []string{"ABC123", "abc123", "Def456", "def456", "DEF456"}, client.requestedHashes[0])
+	require.Equal(t, []string{"Def456"}, client.fileRequests)
+}
+
+func TestHasTorrentByAnyHash(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+
+	lookup := &stubTorrentLookup{
+		torrents: map[string]qbt.Torrent{
+			"ABC123": {Hash: "ABC123", Name: "first"},
+			"DEF456": {Hash: "zzz", InfohashV2: "def456", Name: "second"},
+		},
+	}
+
+	sm := &SyncManager{
+		torrentLookupProvider: func(context.Context, int) (torrentLookup, error) {
+			return lookup, nil
+		},
+	}
+
+	torrent, found, err := sm.HasTorrentByAnyHash(ctx, 1, []string{"  abc123 "})
+	require.NoError(t, err)
+	require.True(t, found)
+	require.NotNil(t, torrent)
+	require.Equal(t, "ABC123", torrent.Hash)
+
+	torrent, found, err = sm.HasTorrentByAnyHash(ctx, 1, []string{"def456"})
+	require.NoError(t, err)
+	require.True(t, found)
+	require.NotNil(t, torrent)
+	require.Equal(t, "zzz", torrent.Hash)
+	require.Equal(t, "second", torrent.Name)
+}
+
+type stubTorrentFilesClient struct {
+	torrents        []qbt.Torrent
+	filesByHash     map[string]qbt.TorrentFiles
+	requestedHashes [][]string
+	fileRequests    []string
+}
+
+func (c *stubTorrentFilesClient) getTorrentsByHashes(hashes []string) []qbt.Torrent {
+	copied := append([]string(nil), hashes...)
+	c.requestedHashes = append(c.requestedHashes, copied)
+	return c.torrents
+}
+
+func (c *stubTorrentFilesClient) GetFilesInformationCtx(ctx context.Context, hash string) (*qbt.TorrentFiles, error) {
+	c.fileRequests = append(c.fileRequests, hash)
+	files, ok := c.filesByHash[hash]
+	if !ok {
+		return nil, fmt.Errorf("no files for hash %s", hash)
+	}
+	copied := make(qbt.TorrentFiles, len(files))
+	copy(copied, files)
+	return &copied, nil
+}
+
+type cacheCall struct {
+	hash     string
+	progress float64
+}
+
+type stubFilesManager struct {
+	cached     map[string]qbt.TorrentFiles
+	lastHashes []string
+	cacheCalls []cacheCall
+}
+
+func (fm *stubFilesManager) GetCachedFiles(context.Context, int, string, float64) (qbt.TorrentFiles, error) {
+	return nil, nil
+}
+
+func (fm *stubFilesManager) GetCachedFilesBatch(_ context.Context, _ int, hashes []string, _ map[string]float64) (map[string]qbt.TorrentFiles, []string, error) {
+	fm.lastHashes = append([]string(nil), hashes...)
+
+	cached := make(map[string]qbt.TorrentFiles, len(hashes))
+	missing := make([]string, 0, len(hashes))
+
+	for _, hash := range hashes {
+		if files, ok := fm.cached[hash]; ok {
+			copied := make(qbt.TorrentFiles, len(files))
+			copy(copied, files)
+			cached[hash] = copied
+		} else {
+			missing = append(missing, hash)
+		}
+	}
+
+	return cached, missing, nil
+}
+
+func (fm *stubFilesManager) CacheFiles(_ context.Context, _ int, hash string, torrentProgress float64, files qbt.TorrentFiles) error {
+	fm.cacheCalls = append(fm.cacheCalls, cacheCall{hash: hash, progress: torrentProgress})
+	fm.cached[hash] = files
+	return nil
+}
+
+func (*stubFilesManager) InvalidateCache(context.Context, int, string) error {
+	return nil
+}
+
+type stubTorrentLookup struct {
+	torrents map[string]qbt.Torrent
+}
+
+func (s *stubTorrentLookup) GetTorrent(hash string) (qbt.Torrent, bool) {
+	torrent, ok := s.torrents[hash]
+	return torrent, ok
+}

internal/services/crossseed/align.go

@@ -47,6 +47,8 @@ func (s *Service) alignCrossSeedContentPaths(
 		return
 	}
 
+	canonicalHash := normalizeHash(torrentHash)
+
 	trimmedSourceName := strings.TrimSpace(sourceTorrentName)
 	trimmedMatchedName := strings.TrimSpace(matchedTorrent.Name)
 	if shouldRenameTorrentDisplay(sourceRelease, matchedRelease) && trimmedMatchedName != "" && trimmedSourceName != trimmedMatchedName {
@@ -76,8 +78,11 @@ func (s *Service) alignCrossSeedContentPaths(
 	}
 
 	sourceFiles := expectedSourceFiles
-	if currentFilesPtr, err := s.syncManager.GetTorrentFiles(ctx, instanceID, torrentHash); err == nil && currentFilesPtr != nil && len(*currentFilesPtr) > 0 {
-		sourceFiles = *currentFilesPtr
+	filesMap, err := s.syncManager.GetTorrentFilesBatch(ctx, instanceID, []string{torrentHash})
+	if err == nil {
+		if currentFiles, ok := filesMap[canonicalHash]; ok && len(currentFiles) > 0 {
+			sourceFiles = currentFiles
+		}
 	}
 
 	sourceRoot := detectCommonRoot(sourceFiles)
@@ -181,7 +186,7 @@ func (s *Service) waitForTorrentAvailability(ctx context.Context, instanceID int
 			}
 		}
 
-		torrents, err := s.syncManager.GetAllTorrents(ctx, instanceID)
+		torrents, err := s.syncManager.GetTorrents(ctx, instanceID, qbt.TorrentFilterOptions{Filter: qbt.TorrentFilterAll})
 		if err == nil {
 			for _, t := range torrents {
 				if t.Hash == hash || t.InfohashV1 == hash || t.InfohashV2 == hash {
@@ -383,7 +388,7 @@ func adjustPathForRootRename(path, oldRoot, newRoot string) string {
 	return path
 }
 
-func shouldRenameTorrentDisplay(newRelease, matchedRelease rls.Release) bool {
+func shouldRenameTorrentDisplay(newRelease, matchedRelease *rls.Release) bool {
 	// Keep episode torrents named after the episode even when pointing at season pack files
 	if newRelease.Series > 0 && newRelease.Episode > 0 &&
 		matchedRelease.Series > 0 && matchedRelease.Episode == 0 {
@@ -392,7 +397,7 @@ func shouldRenameTorrentDisplay(newRelease, matchedRelease rls.Release) bool {
 	return true
 }
 
-func shouldAlignFilesWithCandidate(newRelease, matchedRelease rls.Release) bool {
+func shouldAlignFilesWithCandidate(newRelease, matchedRelease *rls.Release) bool {
 	if newRelease.Series > 0 && newRelease.Episode > 0 &&
 		matchedRelease.Series > 0 && matchedRelease.Episode == 0 {
 		return false

internal/services/crossseed/align_test.go

@@ -139,10 +139,10 @@ func TestShouldRenameTorrentDisplay(t *testing.T) {
 	seasonPack := rls.Release{Series: 1, Episode: 0}
 	otherPack := rls.Release{Series: 2, Episode: 0}
 
-	require.False(t, shouldRenameTorrentDisplay(episode, seasonPack))
-	require.True(t, shouldRenameTorrentDisplay(seasonPack, episode))
-	require.True(t, shouldRenameTorrentDisplay(seasonPack, otherPack))
-	require.False(t, shouldRenameTorrentDisplay(episode, otherPack))
+	require.False(t, shouldRenameTorrentDisplay(&episode, &seasonPack))
+	require.True(t, shouldRenameTorrentDisplay(&seasonPack, &episode))
+	require.True(t, shouldRenameTorrentDisplay(&seasonPack, &otherPack))
+	require.False(t, shouldRenameTorrentDisplay(&episode, &otherPack))
 }
 
 func TestShouldAlignFilesWithCandidate(t *testing.T) {
@@ -152,8 +152,8 @@ func TestShouldAlignFilesWithCandidate(t *testing.T) {
 	seasonPack := rls.Release{Series: 1, Episode: 0}
 	otherEpisode := rls.Release{Series: 1, Episode: 3}
 
-	require.False(t, shouldAlignFilesWithCandidate(episode, seasonPack))
-	require.True(t, shouldAlignFilesWithCandidate(seasonPack, episode))
-	require.True(t, shouldAlignFilesWithCandidate(seasonPack, seasonPack))
-	require.True(t, shouldAlignFilesWithCandidate(episode, otherEpisode))
+	require.False(t, shouldAlignFilesWithCandidate(&episode, &seasonPack))
+	require.True(t, shouldAlignFilesWithCandidate(&seasonPack, &episode))
+	require.True(t, shouldAlignFilesWithCandidate(&seasonPack, &seasonPack))
+	require.True(t, shouldAlignFilesWithCandidate(&episode, &otherEpisode))
 }