Merge feature/parallel-sync into main (v1.6.1)

Sync parallèle de toutes les virtual libraries + barres de progression inline.

Author: CCoupel

docs/CONFIGURATION.md

@@ -67,6 +67,7 @@ Cliquer **"+ Add Connector"** et remplir :
 | URL du serveur | `http://192.168.1.200:8096` ou `https://media.example.com/emby` | URL complète avec port **et chemin de base** Emby (non requis pour Plex via plex.tv) |
 | Mode d'authentification | `User Credentials` | Voir section Authentication ci-dessous |
 | Mode de métadonnées | `Remote Sync` | Voir section Metadata Source ci-dessous |
+| Bibliothèques parallèles max | `4` | Nombre de bibliothèques synchées simultanément pour ce connecteur (Phase 1 uniquement) |
 
 **Important — URL du serveur** : inclure le chemin de base si Emby est derrière un reverse proxy.
 Exemple : si Emby répond sur `https://media.example.com/emby/Items/...`, l'URL à configurer est `https://media.example.com/emby`.
@@ -103,7 +104,10 @@ Timeout proxy stream :          30 secondes
 
 ### Étape 6 : Lancer la première synchronisation
 
-Cliquer **"Synchronise Now"** pour déclencher la première sync manuellement. La barre de progression avance bibliothèque par bibliothèque.
+Cliquer **"Synchronise Now"** pour déclencher la première sync manuellement. Toutes les bibliothèques activées sont synchronisées en parallèle. L'avancement est affiché en temps réel dans l'arbre des connecteurs :
+- **Barre bleue** : Phase 1 (génération des `.strm` / `.nfo` / artwork)
+- **Barre verte** : Phase 2 (injection des métadonnées Emby post-scan)
+- Les deux barres partagent la même échelle (total d'items en Phase 1)
 
 Les dossiers virtuels Emby sont créés automatiquement par le plugin — aucune configuration manuelle dans le Dashboard Emby n'est nécessaire.
 

docs/ROADMAP.md

@@ -146,3 +146,17 @@
 - [ ] Backpropagation temps réel vers le serveur source (play/pause/stop/avancement) — issue #34
 - [ ] Détection delta / suppressions — issue #12
 - [ ] `JellyfinConnector` — issue #15
+
+---
+
+## Phase 6 — Sync parallèle & UI temps réel ✅ Terminé (v1.6.1)
+
+- [x] **Sync 100 % parallèle** : toutes les bibliothèques de tous les connecteurs synchées simultanément (`Task.WhenAll`) — issues #30 et #35
+- [x] **Phase 2 autonome** : chaque bibliothèque enchaîne Phase 1 → Phase 2 de façon indépendante, sans attendre les autres
+- [x] **`MaxParallelLibraries`** : limite configurable par connecteur (défaut : 4), appliquée via `SemaphoreSlim` sur Phase 1 uniquement (Phase 2 = polling Emby, pas de charge réseau distante)
+- [x] **`SyncState`** redesigné : `ConcurrentDictionary<string, LibrarySyncEntry>` avec champs `Volatile.Read/Write` pour la thread-safety, statuts `Pending / RunningPhase1 / RunningPhase2 / Done / Failed`
+- [x] **Barres de progression inline** : double barre (Phase 1 bleue / Phase 2 verte) sur chaque ligne de l'arbre (bibliothèque, type, connecteur), affichage via polling HTTP `/virtuallib/sync/status` toutes les 2 s
+- [x] **Barre globale** dans le header "Remote Connectors", compteur à droite
+- [x] **Barres pleine largeur** : s'étirent sur tout l'espace disponible (`flex:1`) — même dénominateur (`p1Total`) pour les deux phases, évite les sauts de progression
+- [x] **Épaisseur par niveau** : connecteur 9 px / type 6 px / bibliothèque 4 px
+- [x] **Pistes bicolores** : fond clair (20 % opacité) indique le total, remplissage foncé indique l'avancement

docs/core/SYNC.md

@@ -1,5 +1,27 @@
 # Synchronisation — SyncService & LibrarySyncJob
 
+## Orchestration parallèle (v1.6.1)
+
+Toutes les bibliothèques activées de tous les connecteurs sont synchronisées **simultanément** (`Task.WhenAll`). Chaque bibliothèque est traitée de façon autonome et indépendante.
+
+```
+SyncAll / LibrarySyncJob.Execute()
+  │
+  ├── ConnectorA :  SemaphoreSlim(MaxParallelLibraries=4)
+  │     ├── LibA1  → Phase1 ──(sémaphore relâché)──► Phase2
+  │     ├── LibA2  → Phase1 ──(sémaphore relâché)──► Phase2
+  │     └── LibA3  → Phase1 ──(sémaphore relâché)──► Phase2
+  │
+  └── ConnectorB :  SemaphoreSlim(MaxParallelLibraries=4)
+        └── LibB1  → Phase1 ──(sémaphore relâché)──► Phase2
+```
+
+- Le `SemaphoreSlim` limite la Phase 1 (appels réseau distants) mais **pas** la Phase 2 (polling Emby local).
+- `SyncState` (ConcurrentDictionary) centralise les compteurs Phase1/Phase2 de chaque bibliothèque pour le polling UI.
+- Statuts : `Pending → RunningPhase1 → RunningPhase2 → Done | Failed`
+
+---
+
 ## Algorithme en deux phases
 
 ```

src/VirtualLib/Api/ConfigController.cs

@@ -7,17 +7,19 @@
 namespace VirtualLib;
 
 /// <summary>
-/// Emby scheduled task — runs a full sync of all enabled connectors
+/// Emby scheduled task — runs a full parallel sync of all enabled connectors
 /// on the interval configured in the plugin settings.
 /// </summary>
 public sealed class LibrarySyncJob : IScheduledTask, IConfigurableScheduledTask
 {
     private readonly SyncService _syncService;
     private readonly ILibraryManager _libraryManager;
+    private readonly ILibraryMonitor _libraryMonitor;
 
-    public LibrarySyncJob(ILibraryManager libraryManager, IItemRepository itemRepository, IUserDataManager userDataManager, IUserManager userManager)
+    public LibrarySyncJob(ILibraryManager libraryManager, ILibraryMonitor libraryMonitor, IItemRepository itemRepository, IUserDataManager userDataManager, IUserManager userManager)
     {
         _libraryManager = libraryManager;
+        _libraryMonitor = libraryMonitor;
         _syncService = new SyncService(
             new ConnectorFactory(new DefaultHttpClientFactory(), NullLoggerFactory.Instance),
             new StrmGenerator(),
@@ -57,49 +59,47 @@ public async Task Execute(CancellationToken cancellationToken, IProgress<double>
         var enabledConnectors = config.Connectors.Where(c => c.Enabled).ToList();
         if (enabledConnectors.Count == 0) return;
 
-        var virtualLibRoot = config.VirtualLibraryRootPath;
-        var proxyBaseUrl   = config.ProxyBaseUrl;
+        var root     = config.VirtualLibraryRootPath;
+        var proxyUrl = config.ProxyBaseUrl;
 
-        int totalCreated = 0;
-        double step = 100.0 / enabledConnectors.Count;
-        var allPending = new List<LibraryPendingMetadata>();
-
-        for (var i = 0; i < enabledConnectors.Count; i++)
+        // Register all libraries (allows polling the config page during scheduled sync)
+        if (!SyncState.TryStart()) return; // another sync already running
+        foreach (var conn in enabledConnectors)
+        foreach (var libId in conn.LibraryIds)
         {
-            cancellationToken.ThrowIfCancellationRequested();
+            var known = conn.KnownLibraries.FirstOrDefault(l => l.Id == libId);
+            SyncState.RegisterLibrary(conn.Id, conn.DisplayName, libId,
+                known?.Name ?? libId, known?.Type ?? string.Empty);
+        }
 
-            var connectorConfig = enabledConnectors[i];
+        int totalLibs = enabledConnectors.Sum(c => c.LibraryIds.Count);
+        int doneLibs  = 0;
 
-            var syncProgress = new Progress<SyncProgress>(p =>
-            {
-                var pct = (i * step) + (step * p.Current / Math.Max(p.Total, 1));
-                progress.Report(pct);
-            });
-
-            var (result, pending) = await _syncService.SyncConnectorAsync(
-                connectorConfig,
-                virtualLibRoot,
-                proxyBaseUrl,
-                syncProgress,
-                cancellationToken);
-
-            totalCreated += result.ItemsCreated;
-            allPending.AddRange(pending);
-            progress.Report((i + 1) * step);
-        }
+        var results   = new System.Collections.Concurrent.ConcurrentBag<SyncResult>();
+        var semaphores = enabledConnectors.ToDictionary(
+            c => c.Id,
+            c => new SemaphoreSlim(Math.Max(1, c.MaxParallelLibraries)));
 
-        if (totalCreated > 0)
-        {
-            _libraryManager.QueueLibraryScan();
-            // Fire-and-forget metadata push (phase 2) for the scheduled task
-            var snapshot = allPending;
-            _ = Task.Run(async () =>
+        var syncSvc = _syncService;
+        var libMon  = _libraryMonitor;
+
+        var allTasks = enabledConnectors
+            .SelectMany(conn => conn.LibraryIds.Select(libId => Task.Run(async () =>
             {
-                foreach (var g in snapshot)
-                    await _syncService.PushMetadataAsync(g.Items, g.LibraryName, null, CancellationToken.None);
-            });
-        }
+                await SyncLibraryAutonomousAsync(conn, libId, root, proxyUrl, syncSvc, libMon,
+                    semaphores[conn.Id], results, cancellationToken);
+
+                var done = Interlocked.Increment(ref doneLibs);
+                progress.Report(done * 100.0 / Math.Max(totalLibs, 1));
+            }, cancellationToken)))
+            .ToList();
+
+        await Task.WhenAll(allTasks);
 
+        config.Connectors = Plugin.Instance?.Configuration.Connectors ?? config.Connectors;
+        Plugin.Instance?.SaveConfiguration();
+
+        SyncState.Finish(results.ToList());
         progress.Report(100);
     }
 
@@ -110,4 +110,69 @@ public async Task Execute(CancellationToken cancellationToken, IProgress<double>
     public bool IsHidden => false;
     public bool IsEnabled => true;
     public bool IsLogged => true;
+
+    // -------------------------------------------------------------------------
+    // Private — mirrors ConfigController.SyncLibraryAutonomousAsync
+    // -------------------------------------------------------------------------
+
+    private static async Task SyncLibraryAutonomousAsync(
+        ConnectorConfig conn,
+        string libraryId,
+        string root,
+        string proxyUrl,
+        SyncService syncSvc,
+        ILibraryMonitor libMon,
+        SemaphoreSlim semaphore,
+        System.Collections.Concurrent.ConcurrentBag<SyncResult> results,
+        CancellationToken ct)
+    {
+        await semaphore.WaitAsync(ct);
+        try
+        {
+            var prog1 = new Progress<SyncProgress>(p =>
+                SyncState.UpdatePhase1(conn.Id, libraryId, p.Current, p.Total));
+
+            var (result, pending) = await syncSvc.SyncLibraryAsync(
+                conn, libraryId, root, proxyUrl, prog1, ct);
+
+            results.Add(result);
+
+            var lp = pending.FirstOrDefault();
+            if (lp is not null && Directory.Exists(lp.LibraryFolderPath))
+                libMon.ReportFileSystemChanged(lp.LibraryFolderPath);
+
+            if (result.Success)
+            {
+                var total = result.ItemsCreated + result.ItemsSkipped + result.ItemsFailed;
+                SyncState.UpdatePhase1(conn.Id, libraryId, total, total);
+            }
+
+            semaphore.Release();
+
+            if (lp is not null && lp.Items.Count > 0)
+            {
+                SyncState.Phase2Start(conn.Id, libraryId, lp.Items.Count);
+                await Task.Delay(5_000, ct);
+
+                var prog2 = new Progress<SyncProgress>(p =>
+                    SyncState.UpdatePhase2(conn.Id, libraryId, p.Current, p.Total));
+
+                await syncSvc.PushMetadataAsync(lp.Items, lp.LibraryName, prog2, ct);
+            }
+
+            SyncState.MarkDone(conn.Id, libraryId);
+        }
+        catch (OperationCanceledException)
+        {
+            SyncState.MarkFailed(conn.Id, libraryId, "Cancelled");
+            try { semaphore.Release(); } catch { /* already released */ }
+            throw;
+        }
+        catch (Exception ex)
+        {
+            SyncState.MarkFailed(conn.Id, libraryId, ex.Message);
+            results.Add(SyncResult.Failure(conn.DisplayName, ex.Message, TimeSpan.Zero));
+            try { semaphore.Release(); } catch { /* already released */ }
+        }
+    }
 }