From 2e1c67f531804c55cd123adf5d4162813f8f5aff Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Wed, 4 Nov 2026 15:05:09 +0100 Subject: [PATCH] feat(workspace): lay the phase 5c foundation Phase 5c (owner review 2, R8) is built by six packages in parallel. This commit settles everything they share, so each one touches its own files: - job kinds WorkspaceRender (21), WorkspaceSend (22) and WorkspaceMove (23) with their wire names, default priorities, notices and parameter records; their handlers are registered as skeletons that throw until their package lands - WorkspaceJobOptions and a new CreateHandlers overload; the earlier ones stay and default the options - originals in the media index (an index of phase 5b reads as proxies only), their file names, and the exports/renders.json ledger of local renders, written atomically - the optional project and version of an uploaded render - the workspace settings (size limit, default media, version on render, clean-up age, project to open) and when each project was opened, which Reset and Import keep and Export leaves out - WorkspaceHost split into partial files, with stubs for usage, trash and the folder move, removal hooks for unsent renders and last originals, and a guard that holds work while the workspace moves - every new string of the phase in English and Italian, with tooltips Co-Authored-By: Claude Opus 5.5 --- i18n/en/Archive.resx | 10 + i18n/en/Editor.resx | 32 +++ i18n/en/Errors.resx | 24 ++ i18n/en/Jobs.resx | 19 ++ i18n/en/Server.resx | 2 + i18n/en/Settings.resx | 50 +++++ i18n/en/Tooltips.resx | 54 +++++ i18n/it/Archive.it.resx | 10 + i18n/it/Editor.it.resx | 32 +++ i18n/it/Errors.it.resx | 24 ++ i18n/it/Jobs.it.resx | 19 ++ i18n/it/Server.it.resx | 2 + i18n/it/Settings.it.resx | 50 +++++ i18n/it/Tooltips.it.resx | 54 +++++ src/Chronos.App/Infrastructure/AppServices.cs | 18 +- src/Chronos.App/Infrastructure/AppSettings.cs | 106 +++++++++ src/Chronos.App/Jobs/JobNotices.cs | 3 +- src/Chronos.App/Jobs/JobText.cs | 2 +- src/Chronos.App/Sections/SettingsViewModel.cs | 43 +--- .../Workspace/WorkspaceFolderChange.cs | 25 +++ .../Workspace/WorkspaceHost.Cleanup.cs | 102 +++++++++ .../Workspace/WorkspaceHost.Media.cs | 25 +++ .../Workspace/WorkspaceHost.Move.cs | 76 +++++++ .../Workspace/WorkspaceHost.Render.cs | 9 + src/Chronos.App/Workspace/WorkspaceHost.cs | 74 ++++-- src/Chronos.Core/Model/Enums.cs | 18 ++ src/Chronos.Data/Jobs/JobPriorityQueue.cs | 8 +- src/Chronos.Data/Sync/SyncTransfers.cs | 6 +- .../Workspaces/WorkspaceCopyJobHandler.cs | 54 ----- src/Chronos.Data/Workspaces/WorkspaceJobs.cs | 183 +++++++++++++++ src/Chronos.Data/Workspaces/WorkspaceMedia.cs | 43 +++- .../Workspaces/WorkspaceMoveJobHandler.cs | 23 ++ .../Workspaces/WorkspaceRenderJobHandler.cs | 24 ++ .../Workspaces/WorkspaceRenders.cs | 136 +++++++++++ .../Workspaces/WorkspaceSendJobHandler.cs | 25 +++ src/Chronos.Data/Workspaces/WorkspaceStore.cs | 76 ++++++- src/Chronos.Protocol/Uploads.cs | 8 +- .../Chronos.App.Tests/Jobs/JobNoticesTests.cs | 3 + .../Workspace/WorkspaceHostTests.cs | 96 ++++++++ .../Jobs/JobPriorityQueueTests.cs | 24 ++ tests/Chronos.Data.Tests/Jobs/JobWireTests.cs | 31 +++ .../Workspaces/WorkspaceFoundationTests.cs | 211 ++++++++++++++++++ .../Storage/UploadTests.cs | 19 ++ 43 files changed, 1725 insertions(+), 128 deletions(-) create mode 100644 src/Chronos.App/Workspace/WorkspaceHost.Cleanup.cs create mode 100644 src/Chronos.App/Workspace/WorkspaceHost.Media.cs create mode 100644 src/Chronos.App/Workspace/WorkspaceHost.Move.cs create mode 100644 src/Chronos.App/Workspace/WorkspaceHost.Render.cs create mode 100644 src/Chronos.Data/Workspaces/WorkspaceJobs.cs create mode 100644 src/Chronos.Data/Workspaces/WorkspaceMoveJobHandler.cs create mode 100644 src/Chronos.Data/Workspaces/WorkspaceRenderJobHandler.cs create mode 100644 src/Chronos.Data/Workspaces/WorkspaceRenders.cs create mode 100644 src/Chronos.Data/Workspaces/WorkspaceSendJobHandler.cs create mode 100644 tests/Chronos.Data.Tests/Jobs/JobWireTests.cs create mode 100644 tests/Chronos.Data.Tests/Workspaces/WorkspaceFoundationTests.cs diff --git a/i18n/en/Archive.resx b/i18n/en/Archive.resx index fa269f93..3c37491a 100644 --- a/i18n/en/Archive.resx +++ b/i18n/en/Archive.resx @@ -433,4 +433,14 @@ Health View Overview + {0}: originals copied: {1}, unchanged: {2}, without one: {3}long: job log line; {0} sequence; {1} originals copied; {2} already in the workspace; {3} frames whose original the home lacks + {0}: originals downloaded: {1}, unchanged: {2}, without one: {3}long: job log line; {0} sequence; {1} originals downloaded; {2} already in the workspace; {3} frames whose original the server did not give + {0}: frame {1} has no original at its home; its proxy stayslong: job log line; {0} sequence; {1} frame file name + {0}: originals the home no longer holds, kept in the trash: {1}long: job log line; {0} project name; {1} a count + {0}: renders sent: {1}, already there: {2}long: job log line; {0} project name; {1} renders sent; {2} the home held already + {0}: version {1} sent first, for its renderlong: job log line; {0} project name; {1} version number + Held while the connection is meteredlong: job log line + Workspace moved to {0}: projects: {1}, files: {2}long: job log line; {0} target folder; {1} and {2} counts + Move resumed from its journal: {0}long: job log line; {0} the journal file + Moved: {0}long: job log line; {0} project name diff --git a/i18n/en/Editor.resx b/i18n/en/Editor.resx index 724ff1df..350a4e3f 100644 --- a/i18n/en/Editor.resx +++ b/i18n/en/Editor.resx @@ -447,4 +447,36 @@ Undo Update media Updating media + Originals: {0}long; {0} a size, "1.2 GB" + Copy originals… + Proxies only… + Proxies only for {0}{0} project name + The originals copied to this PC are deleted once the library is checked to hold each one; renders then run where the originals are.long + The originals downloaded to this PC are deleted once the server is checked to hold each one; renders then run on the server.long + Originals: {0}long; {0} a count + Size: {0}long; {0} a size, "1.2 GB" + Kept in trash: {0}long; {0} a count + Delete originals + Copying originals + Originals copied + Originals removed + Originals not removed + Without original: {0}long; {0} a count of frames + Proxies + Originals + Open which project? + {0} has several projects in the workspace: choose the one to open.long; {0} sequence title + Render queued on this PC + On this PC + Sent home + {0} is in the library{0} render file name + {0} is on the server{0} render file name + Not sent + Render not sent + Send again + Sending render + Renderthe note of the version Version on render saves before a render + Version {0} saved for render{0} version number + Renders not sent + Last originals diff --git a/i18n/en/Errors.resx b/i18n/en/Errors.resx index fcc5c329..5eec3ce5 100644 --- a/i18n/en/Errors.resx +++ b/i18n/en/Errors.resx @@ -90,4 +90,28 @@ Some work is not on the server yet: send it first, or discard it. This version is larger than the {0} MB a version can be, so the library cannot store it; your work stays in the workspace.{0} megabytes This version is larger than the {0} MB a version can be, so the server cannot store it; your work stays in the workspace.{0} megabytes + This workspace job has no valid parameters. + The workspace holds no originals of this project: Copy originals… copies them from the library. + The workspace holds no originals of this project: Copy originals… downloads them from the server. + The original {0} did not match its SHA-256 after it was copied; it was not kept. + The library cannot be reached to check the originals against it; nothing was removed. + The server cannot be reached to check the originals against it; nothing was removed. + Save your changes as a version and wait for this project's jobs to end before changing its media. + Frames without an original in the workspace: {0}. Copy originals… copies them, then render again. + The version to render is not in the workspace: sync the project, then render again. + The project to render is no longer in the workspace. + {0} changed after it was rendered: it was not sent, and stays in the workspace. + The version this render was made from could not be sent first; the render waits in the workspace. + Renders not sent: {0} of {1}; the job log says why. + {0} is no longer in the workspace's exports; it cannot be sent. + Some renders made here are not in the library yet: send them first, or discard them. + Some renders made here are not on the server yet: send them first, or discard them. + The workspace's trash changed after it was listed; nothing was erased: look at it again. + The workspace folder is being moved; try again once the move ends. + {0} already holds a workspace or a project of this one: choose another folder. + {0} is the workspace folder or lies inside it: choose a folder elsewhere. + A workspace job is queued or running: move the folder once it ends. + The workspace changed after its plan was shown; nothing was moved: plan the move again. + {0} did not match its source after it was copied; the workspace stays where it was. + The target drive needs {0} GB more for the workspace. diff --git a/i18n/en/Jobs.resx b/i18n/en/Jobs.resx index f44956db..34f848d9 100644 --- a/i18n/en/Jobs.resx +++ b/i18n/en/Jobs.resx @@ -187,4 +187,23 @@ {0} → {1}invariant; {0} sequence title; {1} export preset {0} ← {1}invariant; right-to-left languages: the arrow points from the sequence to the preset this PC + Local render + Send render + Move workspace + Workspace clean-up + Workspace media + Workspace trash + Workspace: projects cleaned: {0}, freed: {1}, kept: {2}long: job log line; {0} a count; {1} a size; {2} a count of projects kept, each logged with why + Workspace: {0} used, nothing to cleanlong: job log line; {0} a size + Workspace: {0} kept: {1}long: job log line; {0} project name; {1} a reason, Jobs.Log.WorkspaceSkip.* + Workspace trash: items: {0}, size: {1}; nothing was deletedlong: job log line + Workspace not cleaned: its folder cannot be readlong: job log line + open in Edit + not in step with its home + its home is out of reach + a job is using it + renders not sent + it cannot be read + no media to remove + just copied diff --git a/i18n/en/Server.resx b/i18n/en/Server.resx index 403b4429..9fc8007c 100644 --- a/i18n/en/Server.resx +++ b/i18n/en/Server.resx @@ -256,4 +256,6 @@ {0} uses a certificate Chronos does not know yet. Compare the fingerprint with the one in the server's admin panel before you trust it.long Trust this server? v{0} + The project or version named with this render is not one of this sequence's.long + Pause metered transfers diff --git a/i18n/en/Settings.resx b/i18n/en/Settings.resx index dbc94927..62920c2b 100644 --- a/i18n/en/Settings.resx +++ b/i18n/en/Settings.resx @@ -212,4 +212,54 @@ Use folder {0} version {0} versions + Empty the workspace's trash? + What these entries kept, removed local copies and originals set aside among them, is erased for good; this cannot be undone.long + Entries: {0}long; {0} a count + Size: {0}long; {0} a size, "1.2 GB" + {0} · {1} · {2}invariant; {0} entry name; {1} its size; {2} when it was put in the trash + Type the number of entries, {0}, to confirmlong; {0} a count + Erase for good + Workspace trash emptied + Trash not emptied + {0} used{0} a size, "12.4 GB" + Measuring… + Move… + Size limit + No limit + Default media + Proxies + Originals + Version on render + Save before rendering + Clean after + Never + {0} day + {0} days + Open project + Last used + Main + Ask + Trash + {0} item, {1}{1} a size, "1.2 GB" + {0} items, {1}{1} a size, "1.2 GB" + Nothing in trash + Empty… + Choose where to move the workspacelong: folder picker title + Move the workspace? + The projects in {0} move to {1}, each file checked before its source is removed. Edit waits until the move ends.long; {0} the folder in use; {1} the folder chosen + Projects: {0}long; {0} a count + Files: {0}long; {0} a count + Size: {0}long; {0} a size, "1.2 GB" + Free at target: {0}long; {0} a size, "1.2 GB" + Same drive: folders renamedlong + Other drive: files copied and checkedlong + Not sent yet: {0}long; {0} a count of projects + Move + Move not possible + Moving the workspace + Workspace moved + Workspace not moved + Move not finished + A move of the workspace to {0} stopped before it ended; its projects are still in {1}.long; {0} the target folder; {1} the folder in use + Resume diff --git a/i18n/en/Tooltips.resx b/i18n/en/Tooltips.resx index e7c68d6a..a0dfe097 100644 --- a/i18n/en/Tooltips.resx +++ b/i18n/en/Tooltips.resx @@ -937,4 +937,58 @@ Maximize Minimize Restore + What the copy of the originals writes into the workspace besides the proxies, as reckoned before it starts + Copy the proxies and the originals: renders then run on this PC, from the workspace; it takes the most space + Download the server's proxies and originals: renders then run on this PC, from the workspace; it takes the most space + The drive of the workspace folder lacks room for the originals and the 0.5 GB the copy keeps free: copy the proxies, or free some space + Copy this project's originals from the library into the workspace, to render on this PC + Download this project's originals from the server into the workspace, to render on this PC + Free this PC's space: delete the originals copied to the workspace once the library is checked to hold each one; the proxies stay + Free this PC's space: delete the originals downloaded to the workspace once the server is checked to hold each one; the proxies stay + Save your changes as a version and wait for this project's jobs to end first + Originals the library no longer holds as they are here: they go to the workspace's trash, not deleted + Originals the server no longer holds as they are here: they go to the workspace's trash, not deleted + Delete the originals listed from the workspace; the proxies and the project stay + Keep the originals in the workspace + The library had no original of these frames: they stay proxies here, and a local render waits until they are copied + The server had no original of these frames (or your account cannot read them): they stay proxies here + The workspace holds the proxies of this project: renders run where the originals are + The workspace holds the proxies and the originals of this project: renders run on this PC + Open this project of the sequence; Settings › Workspace › Open project says whether Edit asks + Rendered on this PC from the workspace's originals; the file is in the project's exports folder + Rendered on this PC, not in the library yet: it is sent with the next send; the file stays in the workspace + Rendered on this PC, not on the server yet: it is sent with the next send; the file stays in the workspace + Send the renders made here that the library does not have yet + Send the renders made here that the server does not have yet + Pause uploads and downloads with the server, workspace copies and renders sent among them, while Windows reports this connection as metered + Removes the media of workspace projects in step with their home: unopened past Clean after, or the oldest past Size limit + Lists what the workspace's trash holds; nothing is deleted + Renders made on this PC that the library does not have yet: Send first sends them, Discard keeps them in the workspace's trash + Renders made on this PC that the server does not have yet: Send first sends them, Discard keeps them in the workspace's trash + Originals the library no longer holds as they are here: they go to the workspace's trash, not deleted + Originals the server no longer holds as they are here: they go to the workspace's trash, not deleted + Erase every entry listed from the workspace's trash, for good; type their number above first + Keep the workspace's trash as it is + What the workspace folder takes on its drive, its trash included + The workspace's folder (a fast disk is best); Change uses another one, Move takes the projects along + Move the workspace folder with its projects to another folder, after a plan; each file is checked before its source goes + Past this size, the media of the projects used longest ago are removed once they are in step with their home; their versions stay + The workspace grows as needed; only Clean after removes media + What Open in workspace copies unless you choose otherwise there + Copy the proxies: light and fast to edit; renders run where the originals are + Copy the originals too, to render on this PC; it takes the most space + A render first saves your changes as a version (sent at once when Sync is on), so the render names the version it shows + Remove the media of projects not opened for this long, once they are in step with their home; opening one copies them again + Media stay until you remove them, or Size limit does + Which project Edit opens for a sequence with several in the workspace + The project you opened last for the sequence + The sequence's Main project, which holds its own settings + List the sequence's projects each time + What removed local copies and the clean-up kept aside; only Empty… erases it + Erase the workspace's trash for good, after a list of what it holds and a typed confirmation + The workspace's trash is empty + Projects with versions, changes or renders not at their home: they move with the rest, nothing is lost + Queue the move: the projects are moved or copied and checked, then Edit uses the new folder + Keep the workspace where it is + Queue the move again: it takes up from its journal, nothing is copied twice diff --git a/i18n/it/Archive.it.resx b/i18n/it/Archive.it.resx index c74b3721..4c9d6081 100644 --- a/i18n/it/Archive.it.resx +++ b/i18n/it/Archive.it.resx @@ -425,4 +425,14 @@ Stato Vista Panoramica + {0}: originali copiati: {1}, invariati: {2}, assenti: {3} + {0}: originali scaricati: {1}, invariati: {2}, assenti: {3} + {0}: il fotogramma {1} non ha l'originale all'origine; resta il suo proxy + {0}: originali che l'origine non ha più, tenuti nel cestino: {1} + {0}: render inviati: {1}, già presenti: {2} + {0}: versione {1} inviata prima, per il suo render + In attesa finché la connessione è a consumo + Spazio di lavoro spostato in {0}: progetti: {1}, file: {2} + Spostamento ripreso dal suo registro: {0} + Spostato: {0} diff --git a/i18n/it/Editor.it.resx b/i18n/it/Editor.it.resx index fe381624..e4d92e72 100644 --- a/i18n/it/Editor.it.resx +++ b/i18n/it/Editor.it.resx @@ -422,4 +422,36 @@ Annulla Aggiorna media Aggiornamento media + Originali: {0} + Copia originali… + Solo proxy… + Solo proxy per {0} + Gli originali copiati su questo PC vengono eliminati dopo aver verificato che la libreria li abbia tutti; i render avvengono poi dove sono gli originali. + Gli originali scaricati su questo PC vengono eliminati dopo aver verificato che il server li abbia tutti; i render avvengono poi sul server. + Originali: {0} + Dimensione: {0} + Tenuti nel cestino: {0} + Elimina originali + Copia degli originali + Originali copiati + Originali rimossi + Originali non rimossi + Senza originale: {0} + Proxy + Originali + Quale progetto aprire? + {0} ha più progetti nello spazio di lavoro: scegli quello da aprire. + Render in coda su questo PC + Su questo PC + Render inviato + {0} è nella libreria + {0} è sul server + Non inviato + Render non inviato + Invia di nuovo + Invio del render + Render + Versione {0} salvata per il render + Render non inviati + Ultimi originali diff --git a/i18n/it/Errors.it.resx b/i18n/it/Errors.it.resx index a6b9e20d..290ef057 100644 --- a/i18n/it/Errors.it.resx +++ b/i18n/it/Errors.it.resx @@ -90,4 +90,28 @@ Parte del lavoro non è ancora sul server: prima inviala oppure scartala. Questa versione supera i {0} MB che una versione può occupare, quindi la libreria non può conservarla; il tuo lavoro resta nello spazio di lavoro. Questa versione supera i {0} MB che una versione può occupare, quindi il server non può conservarla; il tuo lavoro resta nello spazio di lavoro. + Questa attività dello spazio di lavoro non ha parametri validi. + Lo spazio di lavoro non ha gli originali di questo progetto: Copia originali… li copia dalla libreria. + Lo spazio di lavoro non ha gli originali di questo progetto: Copia originali… li scarica dal server. + L'originale {0} non corrispondeva al suo SHA-256 dopo la copia; non è stato tenuto. + Non si raggiunge la libreria per verificare gli originali; non è stato rimosso nulla. + Non si raggiunge il server per verificare gli originali; non è stato rimosso nulla. + Salva le modifiche come versione e attendi la fine delle attività di questo progetto prima di cambiarne i media. + Fotogrammi senza originale nello spazio di lavoro: {0}. Copia originali… li copia, poi renderizza di nuovo. + La versione da renderizzare non è nello spazio di lavoro: sincronizza il progetto, poi renderizza di nuovo. + Il progetto da renderizzare non è più nello spazio di lavoro. + {0} è cambiato dopo il render: non è stato inviato e resta nello spazio di lavoro. + Non è stato possibile inviare prima la versione da cui è stato fatto questo render; il render attende nello spazio di lavoro. + Render non inviati: {0} di {1}; il log dell'attività dice perché. + {0} non è più negli export dello spazio di lavoro; non si può inviare. + Alcuni render fatti qui non sono ancora nella libreria: prima inviali oppure scartali. + Alcuni render fatti qui non sono ancora sul server: prima inviali oppure scartali. + Il cestino dello spazio di lavoro è cambiato dopo l'elenco; non è stato eliminato nulla: guardalo di nuovo. + La cartella dello spazio di lavoro è in spostamento; riprova a spostamento finito. + {0} contiene già uno spazio di lavoro o un progetto di questo: scegli un'altra cartella. + {0} è la cartella dello spazio di lavoro o si trova al suo interno: scegli una cartella altrove. + Un'attività dello spazio di lavoro è in coda o in corso: sposta la cartella quando finisce. + Lo spazio di lavoro è cambiato dopo che il piano è stato mostrato; non è stato spostato nulla: pianifica di nuovo. + {0} non corrispondeva alla sua origine dopo la copia; lo spazio di lavoro resta dov'era. + Al disco di destinazione servono altri {0} GB per lo spazio di lavoro. diff --git a/i18n/it/Jobs.it.resx b/i18n/it/Jobs.it.resx index 151e2e1b..7f65977e 100644 --- a/i18n/it/Jobs.it.resx +++ b/i18n/it/Jobs.it.resx @@ -185,4 +185,23 @@ Coda Pianificate questo PC + Rendering locale + Invio rendering + Sposta spazio di lavoro + Pulizia spazio di lavoro + Media spazio di lavoro + Cestino spazio di lavoro + Spazio di lavoro: progetti puliti: {0}, liberati: {1}, tenuti: {2} + Spazio di lavoro: {0} usati, niente da pulire + Spazio di lavoro: {0} tenuto: {1} + Cestino dello spazio di lavoro: elementi: {0}, dimensione: {1}; non è stato eliminato nulla + Spazio di lavoro non pulito: la sua cartella non è leggibile + aperto in Modifica + non allineato con l'origine + origine non raggiungibile + un'attività lo sta usando + render non inviati + non leggibile + nessun media da rimuovere + appena copiato diff --git a/i18n/it/Server.it.resx b/i18n/it/Server.it.resx index d4df3552..5cfccb71 100644 --- a/i18n/it/Server.it.resx +++ b/i18n/it/Server.it.resx @@ -253,4 +253,6 @@ {0} usa un certificato che Chronos non conosce ancora. Confronta l'impronta con quella del pannello di amministrazione del server prima di considerarlo attendibile. Ti fidi di questo server? v{0} + Il progetto o la versione indicati con questo render non sono di questa sequenza. + Pausa trasferimenti a consumo diff --git a/i18n/it/Settings.it.resx b/i18n/it/Settings.it.resx index 3a98ada2..ad86bc87 100644 --- a/i18n/it/Settings.it.resx +++ b/i18n/it/Settings.it.resx @@ -209,4 +209,54 @@ Usa cartella {0} versione {0} versioni + Svuotare il cestino? + Ciò che queste voci tenevano, comprese copie locali rimosse e originali messi da parte, viene eliminato per sempre; non si può annullare. + Voci: {0} + Dimensione: {0} + {0} · {1} · {2} + Scrivi il numero di voci, {0}, per confermare + Elimina per sempre + Cestino svuotato + Cestino non svuotato + {0} usati + Misura in corso… + Sposta… + Limite dimensione + Nessun limite + Media predefiniti + Proxy + Originali + Versione al render + Salva prima del render + Pulisci dopo + Mai + {0} giorno + {0} giorni + Apri progetto + Ultimo usato + Principale + Chiedi + Cestino + {0} elemento, {1} + {0} elementi, {1} + Cestino vuoto + Svuota… + Scegli dove spostare lo spazio di lavoro + Spostare lo spazio di lavoro? + I progetti in {0} vanno in {1}, ogni file verificato prima di rimuoverne l'origine. Modifica attende la fine dello spostamento. + Progetti: {0} + File: {0} + Dimensione: {0} + Libero alla meta: {0} + Stesso disco: cartelle rinominate + Altro disco: file copiati e verificati + Non ancora inviati: {0} + Sposta + Spostamento non possibile + Spostamento in corso + Spazio di lavoro spostato + Spazio di lavoro non spostato + Spostamento non finito + Uno spostamento dello spazio di lavoro in {0} si è fermato prima della fine; i progetti sono ancora in {1}. + Riprendi diff --git a/i18n/it/Tooltips.it.resx b/i18n/it/Tooltips.it.resx index 9c5f333c..5382f4e7 100644 --- a/i18n/it/Tooltips.it.resx +++ b/i18n/it/Tooltips.it.resx @@ -935,4 +935,58 @@ Ingrandisci Riduci a icona Ripristina + Quanto scrive nello spazio di lavoro la copia degli originali oltre ai proxy, stimato prima che inizi + Copia i proxy e gli originali: i render avvengono poi su questo PC, dallo spazio di lavoro; occupa più spazio + Scarica i proxy e gli originali del server: i render avvengono poi su questo PC, dallo spazio di lavoro; occupa più spazio + Al disco della cartella dello spazio di lavoro manca spazio per gli originali e per gli 0,5 GB che la copia lascia liberi: copia i proxy o libera spazio + Copia gli originali di questo progetto dalla libreria nello spazio di lavoro, per renderizzare su questo PC + Scarica gli originali di questo progetto dal server nello spazio di lavoro, per renderizzare su questo PC + Libera spazio su questo PC: elimina gli originali copiati nello spazio di lavoro dopo aver verificato che la libreria li abbia tutti; i proxy restano + Libera spazio su questo PC: elimina gli originali scaricati nello spazio di lavoro dopo aver verificato che il server li abbia tutti; i proxy restano + Prima salva le modifiche come versione e attendi la fine delle attività di questo progetto + Originali che la libreria non ha più come sono qui: vanno nel cestino dello spazio di lavoro, non vengono eliminati + Originali che il server non ha più come sono qui: vanno nel cestino dello spazio di lavoro, non vengono eliminati + Elimina dallo spazio di lavoro gli originali elencati; i proxy e il progetto restano + Tieni gli originali nello spazio di lavoro + La libreria non aveva l'originale di questi fotogrammi: qui restano proxy, e un render locale attende finché non vengono copiati + Il server non aveva l'originale di questi fotogrammi (o il tuo account non può leggerli): qui restano proxy + Lo spazio di lavoro contiene i proxy di questo progetto: i render avvengono dove sono gli originali + Lo spazio di lavoro contiene i proxy e gli originali di questo progetto: i render avvengono su questo PC + Apri questo progetto della sequenza; Impostazioni › Spazio di lavoro › Apri progetto dice se Modifica lo chiede + Renderizzato su questo PC dagli originali dello spazio di lavoro; il file è nella cartella exports del progetto + Renderizzato su questo PC, non ancora nella libreria: viene inviato col prossimo invio; il file resta nello spazio di lavoro + Renderizzato su questo PC, non ancora sul server: viene inviato col prossimo invio; il file resta nello spazio di lavoro + Invia i render fatti qui che la libreria non ha ancora + Invia i render fatti qui che il server non ha ancora + Mette in pausa caricamenti e download col server, comprese copie dello spazio di lavoro e render inviati, mentre Windows segnala la connessione a consumo + Rimuove i media dei progetti allineati con la loro origine: non aperti oltre Pulisci dopo, o i più vecchi oltre Limite dimensione + Elenca cosa contiene il cestino dello spazio di lavoro; non elimina niente + Render fatti su questo PC che la libreria non ha ancora: Prima invia li invia, Scarta li tiene nel cestino dello spazio di lavoro + Render fatti su questo PC che il server non ha ancora: Prima invia li invia, Scarta li tiene nel cestino dello spazio di lavoro + Originali che la libreria non ha più come sono qui: vanno nel cestino dello spazio di lavoro, non vengono eliminati + Originali che il server non ha più come sono qui: vanno nel cestino dello spazio di lavoro, non vengono eliminati + Elimina per sempre ogni voce elencata dal cestino dello spazio di lavoro; prima scrivi il loro numero qui sopra + Lascia il cestino dello spazio di lavoro com'è + Quanto occupa la cartella dello spazio di lavoro sul suo disco, cestino compreso + La cartella dello spazio di lavoro (meglio un disco veloce); Cambia ne usa un'altra, Sposta porta con sé i progetti + Sposta la cartella dello spazio di lavoro con i suoi progetti in un'altra cartella, dopo un piano; ogni file è verificato prima di rimuovere l'origine + Oltre questa dimensione, i media dei progetti usati meno di recente vengono rimossi quando sono allineati con la loro origine; le versioni restano + Lo spazio di lavoro cresce quanto serve; solo Pulisci dopo rimuove i media + Cosa copia Apri nello spazio di lavoro, se lì non scegli altro + Copia i proxy: leggeri e veloci da modificare; i render avvengono dove sono gli originali + Copia anche gli originali, per renderizzare su questo PC; occupa più spazio + Un render salva prima le modifiche come versione (inviata subito con la sincronizzazione attiva), così il render indica la versione che mostra + Rimuove i media dei progetti non aperti da tanto, quando sono allineati con la loro origine; aprirne uno li ricopia + I media restano finché non li rimuovi tu o Limite dimensione + Quale progetto apre Modifica per una sequenza con più progetti nello spazio di lavoro + Il progetto che hai aperto per ultimo per la sequenza + Il progetto Principale della sequenza, che ne tiene le impostazioni + Elenca ogni volta i progetti della sequenza + Ciò che le copie locali rimosse e la pulizia hanno messo da parte; solo Svuota… lo elimina + Svuota per sempre il cestino dello spazio di lavoro, dopo un elenco di ciò che contiene e una conferma scritta + Il cestino dello spazio di lavoro è vuoto + Progetti con versioni, modifiche o render non ancora all'origine: si spostano col resto, non si perde nulla + Mette in coda lo spostamento: i progetti vengono spostati o copiati e verificati, poi Modifica usa la nuova cartella + Lascia lo spazio di lavoro dov'è + Rimette in coda lo spostamento: riparte dal suo registro, niente viene copiato due volte diff --git a/src/Chronos.App/Infrastructure/AppServices.cs b/src/Chronos.App/Infrastructure/AppServices.cs index 03c1c323..b60cbaea 100644 --- a/src/Chronos.App/Infrastructure/AppServices.cs +++ b/src/Chronos.App/Infrastructure/AppServices.cs @@ -178,15 +178,27 @@ public sealed class AppServices : IAsyncDisposable typeof(AppServices).Assembly.GetCustomAttribute()?.InformationalVersion ?? "0.0.0"; /// The job handlers of this PC's engine — the single registration list; a kind without a handler stays - /// queued (it is never claimed here). The workspace copy is the desktop's alone: it writes into this PC's workspace, from - /// this PC's archive or, through the signed-in session, from a server. + /// queued (it is never claimed here). The workspace's jobs are the desktop's alone: they write into this PC's workspace + /// (a copy from this PC's archive or, through the signed-in session, from a server; a local render with this PC's + /// encoders; the sending of its renders home; the move of its folder, which Settings › Workspace then names). public static IReadOnlyList CreateJobHandlers(AppServices services) => [ .. services.Archives?.CreateJobHandlers() ?? [], .. services.Processing?.CreateJobHandlers() ?? [], .. services.Sync.Service?.CreateJobHandlers(services.Sync) ?? [], - .. services.Database is { } db && services.Archives is { } archives ? WorkspaceJobs.CreateHandlers(db, archives, services.Sync) : [], + .. services.Database is { } db && services.Archives is { } archives + ? WorkspaceJobs.CreateHandlers(db, archives, services.Sync, WorkspaceOptions(services, archives)) + : [], ]; + /// + /// The workspace jobs' share of the desktop (phase 5c): its processing options for local renders, the metered hold of + /// Settings › Server over transfers with a server, and the workspace that follows a moved folder. + /// + private static WorkspaceJobOptions WorkspaceOptions(AppServices services, ArchiveService archives) => + new(services.Processing?.Options ?? WorkspaceJobOptions.For(archives).Processing, + () => services.Settings.PauseUploadsOnMetered && MeteredNetwork.IsMetered(), + services.Workspace.MovedAsync); + /// /// Queues a scan of unless one is already waiting or running; the sequences it indexes get /// a background deep analysis when Settings › Analysis asks for it. diff --git a/src/Chronos.App/Infrastructure/AppSettings.cs b/src/Chronos.App/Infrastructure/AppSettings.cs index 5e425a03..a2e2e6ac 100644 --- a/src/Chronos.App/Infrastructure/AppSettings.cs +++ b/src/Chronos.App/Infrastructure/AppSettings.cs @@ -7,6 +7,7 @@ using Chronos.Core.Diagnostics; using Chronos.Core.Import; using Chronos.Core.IO; using Chronos.Core.Naming; +using Chronos.Core.Project; using Chronos.Data.Archiving; using Chronos.Data.Repositories; using Chronos.Ui.Theming; @@ -39,6 +40,21 @@ public enum HardwarePreference HardwareForPreviews, } +/// +/// Which project Edit opens for a sequence that has several in the workspace (Settings › Workspace › Open project, phase 5c). +/// +public enum WorkspaceOpenPolicy +{ + /// The project opened last for the sequence (), else the one saved last. + LastUsed, + + /// The sequence's Main project. + Main, + + /// Ask each time, listing the sequence's projects. + Ask, +} + /// A server certificate the user trusted on first use (BRIEF §12.7). public sealed class TrustedCertificate { @@ -58,6 +74,8 @@ public sealed class AppSettings public const int DefaultCacheLimitGb = 20; public const int DefaultScanIntervalMinutes = 10; public const int DefaultWorkspaceKeptVersions = 20; + public const int DefaultWorkspaceSizeLimitGb = 100; + public const int DefaultWorkspaceCleanAfterDays = 30; /// 2⁻⁴ of white: the deep analysis' night threshold (a mean log2 luminance of −4). public const double DefaultNightBrightnessPercent = 6.25; @@ -169,6 +187,36 @@ public sealed class AppSettings /// The workspace project opened last for each sequence (sequence id → project id); Edit opens it again. public Dictionary WorkspaceRecent { get; set; } = []; + /// + /// Phase 5c: past this size (GB of 2³⁰ bytes) the workspace's clean-up removes the media of the projects used longest ago + /// that are in step with their home (never one open, with jobs, or with renders not sent); 0 = no limit. + /// + public int WorkspaceSizeLimitGb { get; set; } = DefaultWorkspaceSizeLimitGb; + + /// + /// What "Open in workspace" copies unless chosen otherwise: or + /// (the proxies plus the originals, to render on this PC). + /// + public string WorkspaceDefaultMedia { get; set; } = BundleMedia.Proxies; + + /// A render of a project with changes not saved as a version saves one first (and sends it when Sync automatically is on). + public bool WorkspaceVersionOnRender { get; set; } = true; + + /// + /// The workspace's clean-up removes the media of a project not opened for this many days, once it is in step with its + /// home; 0 = never. + /// + public int WorkspaceCleanAfterDays { get; set; } = DefaultWorkspaceCleanAfterDays; + + /// Which project Edit opens for a sequence with several in the workspace. + public WorkspaceOpenPolicy WorkspaceOpenProject { get; set; } = WorkspaceOpenPolicy.LastUsed; + + /// + /// When each workspace project was last opened in Edit (project id → time), which the clean-up goes by (else the time + /// its working state was saved). This PC's, like . + /// + public Dictionary WorkspaceOpened { get; set; } = []; + // ---- Server ---- public string? ServerUrl { get; set; } public string? ServerUsername { get; set; } @@ -285,6 +333,64 @@ public sealed class AppSettings /// A deep copy (JSON round trip), used for import and reset. public AppSettings Clone() => Parse(ToJson()) ?? new AppSettings(); + + /// + /// Settings › Advanced › Reset: every default, but the values that are this PC's or this user's state rather than + /// preferences: the archive and the session, the window and its rail, the sequence edited last, the first-run flag, the + /// jobs cleared, and the workspace (its folder, moved only by its own operation, the projects opened last and when). + /// + public AppSettings ResetKeepingState() => new() + { + LastArchivePath = LastArchivePath, + ServerUrl = ServerUrl, + ServerUsername = ServerUsername, + ProtectedToken = ProtectedToken, + TrustedCertificates = TrustedCertificates, + RecentServers = RecentServers, + Window = Window, + RailCollapsed = RailCollapsed, + LastEditedSequence = LastEditedSequence, + FirstRunCompleted = FirstRunCompleted, + JobsClearedAt = JobsClearedAt, + WorkspaceFolder = WorkspaceFolder, + WorkspaceRecent = WorkspaceRecent, + WorkspaceOpened = WorkspaceOpened, + }; + + /// + /// Settings › Export: a copy without secrets and machine-bound values (the session, the window, the workspace's folder and + /// what it remembers of its projects: another PC's ids mean nothing there). + /// + public AppSettings ForExport() + { + var copy = Clone(); + copy.ProtectedToken = null; + copy.Window = null; + copy.WorkspaceFolder = null; + copy.WorkspaceRecent = []; + copy.WorkspaceOpened = []; + return copy; + } + + /// + /// Settings › Import: with this PC's own values taken from these settings: the session, the + /// window and its rail, the sequence edited last, the first-run flag, and the workspace (its folder, the projects opened + /// last and when). Changes and returns . + /// + public AppSettings KeepLocalIn(AppSettings imported) + { + ArgumentNullException.ThrowIfNull(imported); + imported.ProtectedToken = ProtectedToken; + imported.ServerUrl = ServerUrl; + imported.Window = Window; + imported.RailCollapsed = RailCollapsed; + imported.LastEditedSequence = LastEditedSequence; + imported.FirstRunCompleted = FirstRunCompleted; + imported.WorkspaceFolder = WorkspaceFolder; + imported.WorkspaceRecent = WorkspaceRecent; + imported.WorkspaceOpened = WorkspaceOpened; + return imported; + } } [JsonSourceGenerationOptions(WriteIndented = true, UseStringEnumConverter = true)] diff --git a/src/Chronos.App/Jobs/JobNotices.cs b/src/Chronos.App/Jobs/JobNotices.cs index 004a2d68..62a02834 100644 --- a/src/Chronos.App/Jobs/JobNotices.cs +++ b/src/Chronos.App/Jobs/JobNotices.cs @@ -40,7 +40,8 @@ public static class JobNotices private static bool Announces(JobKind kind) => kind is JobKind.Render or JobKind.DeepAnalyse or JobKind.Verify or JobKind.Rebuild or JobKind.Maintenance or JobKind.UploadCommit - or JobKind.Move or JobKind.Adopt or JobKind.EmptyTrash or JobKind.Convert; + or JobKind.Move or JobKind.Adopt or JobKind.EmptyTrash or JobKind.Convert or JobKind.WorkspaceRender or JobKind.WorkspaceSend + or JobKind.WorkspaceMove; /// /// Work that keeps the index and its previews current: the next run repeats it, the Archive screen shows what is missing. diff --git a/src/Chronos.App/Jobs/JobText.cs b/src/Chronos.App/Jobs/JobText.cs index 95ddbe5b..d748456b 100644 --- a/src/Chronos.App/Jobs/JobText.cs +++ b/src/Chronos.App/Jobs/JobText.cs @@ -12,7 +12,7 @@ public static class JobText /// True for jobs whose items are frames, so their speed reads in fps. public static bool CountsFrames(JobKind kind) => - kind is JobKind.Render or JobKind.Proxies or JobKind.Thumbs or JobKind.DeepAnalyse; + kind is JobKind.Render or JobKind.Proxies or JobKind.Thumbs or JobKind.DeepAnalyse or JobKind.WorkspaceRender; /// True for jobs whose progress counts bytes (hash verification, card import). public static bool CountsBytes(JobKind kind) => kind is JobKind.Verify or JobKind.Import; diff --git a/src/Chronos.App/Sections/SettingsViewModel.cs b/src/Chronos.App/Sections/SettingsViewModel.cs index 83ccf08c..065a9dab 100644 --- a/src/Chronos.App/Sections/SettingsViewModel.cs +++ b/src/Chronos.App/Sections/SettingsViewModel.cs @@ -1207,7 +1207,8 @@ public sealed class SettingsViewModel : SectionViewModel [ JobKind.Render, JobKind.Import, JobKind.Download, JobKind.UploadCommit, JobKind.Scan, JobKind.Rebuild, JobKind.Verify, JobKind.LightAnalyse, JobKind.DeepAnalyse, JobKind.Thumbs, JobKind.Proxies, JobKind.Maintenance, JobKind.Duplicates, JobKind.Orphans, JobKind.Adopt, JobKind.Move, - JobKind.Backup, JobKind.Cleanup, JobKind.EmptyTrash, JobKind.Convert, JobKind.WorkspaceCopy, + JobKind.Backup, JobKind.Cleanup, JobKind.EmptyTrash, JobKind.Convert, JobKind.WorkspaceCopy, JobKind.WorkspaceRender, JobKind.WorkspaceSend, + JobKind.WorkspaceMove, ]; /// Stores for , keeping only the levels that differ from the defaults. @@ -1632,23 +1633,8 @@ public sealed class SettingsViewModel : SectionViewModel IsDestructive = true, }); if (!confirmed) return; - var defaults = new AppSettings - { - LastArchivePath = _s.LastArchivePath, - ServerUrl = _s.ServerUrl, - ServerUsername = _s.ServerUsername, - ProtectedToken = _s.ProtectedToken, - TrustedCertificates = _s.TrustedCertificates, - RecentServers = _s.RecentServers, - Window = _s.Window, - RailCollapsed = _s.RailCollapsed, - LastEditedSequence = _s.LastEditedSequence, - FirstRunCompleted = _s.FirstRunCompleted, - JobsClearedAt = _s.JobsClearedAt, - // The workspace holds this PC's work: its folder stays where it is (moving it is its own operation). - WorkspaceFolder = _s.WorkspaceFolder, - WorkspaceRecent = _s.WorkspaceRecent, - }; + // The workspace holds this PC's work: its folder stays where it is (moving it is its own operation). + var defaults = _s.ResetKeepingState(); // Start with Windows lives in the registry, not in the settings file: its default is off. Startup.SetEnabled(false); ApplyAll(defaults); @@ -1690,12 +1676,8 @@ public sealed class SettingsViewModel : SectionViewModel { var folder = Shell.Services.Dialogs.PickFolder(Loc.L("Settings.Export.Title")); if (folder is null) return; - var copy = _s.Clone(); // Secrets and machine-bound values stay on this PC. - copy.ProtectedToken = null; - copy.Window = null; - copy.WorkspaceFolder = null; - copy.WorkspaceRecent = []; + var copy = _s.ForExport(); var path = Path.Combine(folder, $"Chronos settings {DateTime.Now.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture)}.json"); await Task.Run(() => AtomicFile.WriteAllText(path, copy.ToJson())); Shell.Notify(Loc.L("Settings.Export.Done"), Path.GetFileName(path), Loc.L("Library.Export.Show"), Loc.L("Tooltips.Library.ShowExport"), () => ShellActions.Reveal(path)); @@ -1720,18 +1702,9 @@ public sealed class SettingsViewModel : SectionViewModel Shell.Notify(Loc.L("Errors.Settings.Import"), isError: true); return; } - // Everything but the session, the window and its rail, the sequence edited last (another PC's ids mean nothing here) - // and the first-run flag. - imported.ProtectedToken = _s.ProtectedToken; - imported.ServerUrl = _s.ServerUrl; - imported.Window = _s.Window; - imported.RailCollapsed = _s.RailCollapsed; - imported.LastEditedSequence = _s.LastEditedSequence; - imported.FirstRunCompleted = _s.FirstRunCompleted; - // The workspace is this PC's: its folder and the projects opened last stay. - imported.WorkspaceFolder = _s.WorkspaceFolder; - imported.WorkspaceRecent = _s.WorkspaceRecent; - ApplyAll(imported); + // Everything but the session, the window and its rail, the sequence edited last (another PC's ids mean nothing here), + // the first-run flag and the workspace, which is this PC's (its folder, the projects opened last and when). + ApplyAll(_s.KeepLocalIn(imported)); // Settings of a PC never rewrite the shared archive.json: the imported templates and sizes are the defaults of new // archives, and the rows show the own settings of the archive at the (possibly imported) archive folder. _retarget = RetargetArchiveAsync(); diff --git a/src/Chronos.App/Workspace/WorkspaceFolderChange.cs b/src/Chronos.App/Workspace/WorkspaceFolderChange.cs index 36d94f64..81c744a3 100644 --- a/src/Chronos.App/Workspace/WorkspaceFolderChange.cs +++ b/src/Chronos.App/Workspace/WorkspaceFolderChange.cs @@ -66,6 +66,31 @@ public static class WorkspaceFolderChange } } + /// + /// Settings › Workspace › Move… (phase 5c): the shell's flow over , + /// with its folder picker, confirmation, editor and toasts. True when the move was queued. + /// + public static Task MoveAsync(ShellViewModel shell) + { + ArgumentNullException.ThrowIfNull(shell); + throw new NotImplementedException("Moving the workspace folder comes with phase 5c (P6)."); + } + + /// + /// Picks the folder the workspace moves to through , shows its plan + /// () and asks for the user's word, lets close a + /// workspace project open in the editor (false keeps everything as it is), then queues the move + /// (). hears why it was refused. True when it was queued. + /// + public static Task MoveAsync(WorkspaceHost host, IAppDialogs dialogs, Func> closeProject, Action failed) + { + ArgumentNullException.ThrowIfNull(host); + ArgumentNullException.ThrowIfNull(dialogs); + ArgumentNullException.ThrowIfNull(closeProject); + ArgumentNullException.ThrowIfNull(failed); + throw new NotImplementedException("Moving the workspace folder comes with phase 5c (P6)."); + } + /// The plan as a confirmation: where Edit's projects come from now, and what stays where it is. public static ConfirmRequest Request(WorkspaceFolderPlan plan) { diff --git a/src/Chronos.App/Workspace/WorkspaceHost.Cleanup.cs b/src/Chronos.App/Workspace/WorkspaceHost.Cleanup.cs new file mode 100644 index 00000000..2a1e1f88 --- /dev/null +++ b/src/Chronos.App/Workspace/WorkspaceHost.Cleanup.cs @@ -0,0 +1,102 @@ +using System.IO; +using Chronos.Core.Project; +using Chronos.Data.Workspaces; + +namespace Chronos.App.Workspace; + +/// +/// What the workspace takes of its drive (Settings › Workspace, phase 5c): the projects' media (proxies and originals, which +/// the clean-up and the size limit may remove), the whole folder, and its trash (). +/// +/// The bytes of every project's media/ folder. +/// The bytes of the whole workspace folder, its trash included. +/// The bytes of the workspace's trash. +/// The entries of the workspace's trash (one per copy removed or originals set aside). +public sealed record WorkspaceUsage(long MediaBytes, long TotalBytes, long TrashBytes, int TrashItems) +{ + /// A workspace that holds nothing. + public static WorkspaceUsage None { get; } = new(0, 0, 0, 0); +} + +/// One entry of the workspace's trash as Empty… lists it: its folder name, size, files and when it was put there. +public sealed record WorkspaceTrashItem(string Name, long Bytes, int Files, DateTimeOffset Trashed); + +/// +/// The plan of Settings › Workspace › Trash › Empty… (phase 5c): every entry of the workspace's trash and their bytes, and a +/// fingerprint over their names, sizes and times. Emptying erases exactly these entries, and only while the fingerprint +/// still matches (the user types the number of entries to confirm); schedules and the size limit never empty the trash. +/// +public sealed record WorkspaceTrashPlan(string Folder, IReadOnlyList Items, long Bytes, string Fingerprint) +{ + /// Nothing to erase: Empty… is disabled. + public bool IsEmpty => Items.Count == 0; +} + +/// What emptying the workspace's trash erased. +public sealed record WorkspaceTrashResult(int Items, long Bytes); + +/// +/// The workspace's clean-up side (phase 5c, P4): its usage, the plan and emptying of its trash, and what a local copy's removal +/// keeps of renders not sent and originals the home lost. Stubs until the clean-up lands: usage and the trash read as empty, +/// and a removal finds nothing more to keep. +/// +public sealed partial class WorkspaceHost +{ + /// What the workspace takes of its drive (), measured off the UI thread. + public Task UsageAsync(CancellationToken cancellationToken = default) + { + cancellationToken.ThrowIfCancellationRequested(); + return Task.FromResult(WorkspaceUsage.None); + } + + /// The plan of emptying the workspace's trash (); nothing is erased. + public Task PlanTrashAsync(CancellationToken cancellationToken = default) + { + cancellationToken.ThrowIfCancellationRequested(); + return Task.FromResult(new WorkspaceTrashPlan(Path.Combine(Root, TrashFolder), [], 0, string.Empty)); + } + + /// + /// Erases the entries of from the workspace's trash for good, after the user typed their number; + /// refused when the trash changed since the plan (Errors.Workspace.TrashChanged). + /// + /// The trash changed since the plan; nothing was erased. + public Task EmptyTrashAsync(WorkspaceTrashPlan plan, CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(plan); + throw new NotImplementedException("Emptying the workspace's trash comes with phase 5c (P4)."); + } + + /// + /// What a local copy's removal plan counts besides its versions (, + /// ): renders of its ledger not sent, and originals the home no longer holds. + /// + private Task<(int UnsentRenders, int LastOriginals)> RemovalMediaAsync(WorkspaceProject project, CancellationToken cancellationToken) + { + ArgumentNullException.ThrowIfNull(project); + cancellationToken.ThrowIfCancellationRequested(); + return Task.FromResult((0, 0)); + } + + /// A removal without Discard is refused while the project's ledger holds renders not sent (Send first sends them). + /// Renders wait to be sent. + private Task EnsureRendersSentAsync(WorkspaceProject project, BundleWorkspace workspace, CancellationToken cancellationToken) + { + ArgumentNullException.ThrowIfNull(project); + ArgumentNullException.ThrowIfNull(workspace); + cancellationToken.ThrowIfCancellationRequested(); + return Task.CompletedTask; + } + + /// + /// Before a removed copy's media are deleted, under the project's lease: the originals the home no longer holds with the + /// same SHA-256 moved into (the copy's trash entry), never deleted. + /// + private Task KeepLastOriginalsAsync(WorkspaceProject project, string aside, CancellationToken cancellationToken) + { + ArgumentNullException.ThrowIfNull(project); + ArgumentException.ThrowIfNullOrEmpty(aside); + cancellationToken.ThrowIfCancellationRequested(); + return Task.CompletedTask; + } +} diff --git a/src/Chronos.App/Workspace/WorkspaceHost.Media.cs b/src/Chronos.App/Workspace/WorkspaceHost.Media.cs new file mode 100644 index 00000000..d3ba872d --- /dev/null +++ b/src/Chronos.App/Workspace/WorkspaceHost.Media.cs @@ -0,0 +1,25 @@ +using Chronos.Core.Localization; +using Chronos.Data.Workspaces; + +namespace Chronos.App.Workspace; + +/// +/// The workspace's media (phase 5c, P1): what a copy writes (proxies, and the originals besides), copying the originals of a +/// project, and going back to proxies only. +/// +public sealed partial class WorkspaceHost +{ + /// The bytes the first copy of a sequence's media writes into the workspace, and the free bytes of the workspace's drive. + /// The index or the archive engine is not open. + public Task CopyFactsAsync(Guid sequenceId, CancellationToken cancellationToken = default) + { + var db = _db() ?? throw new WorkspaceException(Loc.L("Editor.Error.NoEngine")); + var archives = _archives() ?? throw new WorkspaceException(Loc.L("Editor.Error.NoEngine")); + var root = Root; + return Task.Run(async () => + { + var (bytes, free) = await WorkspaceJobs.CopyFactsAsync(db, archives, sequenceId, root, cancellationToken).ConfigureAwait(false); + return new WorkspaceCopyFacts(bytes, free); + }, cancellationToken); + } +} diff --git a/src/Chronos.App/Workspace/WorkspaceHost.Move.cs b/src/Chronos.App/Workspace/WorkspaceHost.Move.cs new file mode 100644 index 00000000..9d70dfc6 --- /dev/null +++ b/src/Chronos.App/Workspace/WorkspaceHost.Move.cs @@ -0,0 +1,76 @@ +using Chronos.Core.Localization; +using Chronos.Core.Model; + +namespace Chronos.App.Workspace; + +/// A project of the workspace as the plan of a move lists it: its size, and work not at its home yet (a warning, never a refusal). +/// Versions or renders wait to be sent to its home. +/// Changes not saved as a version. +public sealed record WorkspaceMoveProject(Guid ProjectId, string Name, int Files, long Bytes, bool Unsent, bool Modified); + +/// +/// The plan of Settings › Workspace › Move… (phase 5c): the workspace folder moved with its projects to +/// : the projects and their bytes, the free bytes at the target, whether both lie on one volume (folders +/// renamed) or not (files copied and hash-verified), why it is refused (null when it can go), and a fingerprint of what +/// the plan read, which the move job checks again. +/// +/// The free bytes of the target's drive; null when they cannot be measured. +/// +/// Why the move cannot go, one localized sentence: the target is the folder itself or inside it +/// (Errors.Workspace.MoveSameFolder), already holds a workspace or a project of the same id +/// (Errors.Workspace.MoveTargetNotEmpty), lacks the room (Errors.Workspace.DiskFull), or a workspace job is +/// pending or running (Errors.Workspace.JobsRunning); null when it can go. +/// +public sealed record WorkspaceMovePlan(string From, string To, IReadOnlyList Projects, int Files, long Bytes, long? Free, bool SameVolume, + string? Refusal, string Fingerprint) +{ + /// Nothing refuses the move. + public bool CanMove => Refusal is null; + + /// Projects with work not at their home: the move keeps it, the plan says so. + public int Warnings => Projects.Count(p => p.Unsent || p.Modified); +} + +/// +/// Moving the workspace folder with its projects (phase 5c, P6): the plan, the that +/// carries it out, and the workspace that follows the folder once every file is verified there. While a move is queued or +/// running the workspace is refused for syncs, saves and opens (). Stubs until the move lands. +/// +public sealed partial class WorkspaceHost +{ + /// A move of the workspace folder is queued or running: syncs, saves and opens wait for it. + public bool IsMoving => false; + + /// The plan of moving the workspace folder to (); nothing is written. + public Task PlanMoveAsync(string to, CancellationToken cancellationToken = default) + { + ArgumentException.ThrowIfNullOrWhiteSpace(to); + throw new NotImplementedException("Moving the workspace folder comes with phase 5c (P6)."); + } + + /// Queues the of a plan the user confirmed. + /// The plan refuses the move. + public Task QueueMoveAsync(WorkspaceMovePlan plan, CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(plan); + throw new NotImplementedException("Moving the workspace folder comes with phase 5c (P6)."); + } + + /// + /// Told by the move job once every file of the workspace is verified at + /// (WorkspaceJobOptions.Moved): Settings › Workspace names the new folder and the workspace opens there. + /// + public Task MovedAsync(string from, string to) + { + ArgumentException.ThrowIfNullOrWhiteSpace(from); + ArgumentException.ThrowIfNullOrWhiteSpace(to); + throw new NotImplementedException("Moving the workspace folder comes with phase 5c (P6)."); + } + + /// Refuses an operation that writes into the workspace while its folder is being moved. + /// A move is queued or running (Errors.Workspace.Moving). + private void EnsureNotMoving() + { + if (IsMoving) throw new WorkspaceException(Loc.L("Errors.Workspace.Moving")); + } +} diff --git a/src/Chronos.App/Workspace/WorkspaceHost.Render.cs b/src/Chronos.App/Workspace/WorkspaceHost.Render.cs new file mode 100644 index 00000000..758047ae --- /dev/null +++ b/src/Chronos.App/Workspace/WorkspaceHost.Render.cs @@ -0,0 +1,9 @@ +namespace Chronos.App.Workspace; + +/// +/// The workspace's local renders (phase 5c, P2): rendering a project from the originals it holds on this PC, and sending its +/// renders home. +/// +public sealed partial class WorkspaceHost +{ +} diff --git a/src/Chronos.App/Workspace/WorkspaceHost.cs b/src/Chronos.App/Workspace/WorkspaceHost.cs index f45ffae6..61d5a5a5 100644 --- a/src/Chronos.App/Workspace/WorkspaceHost.cs +++ b/src/Chronos.App/Workspace/WorkspaceHost.cs @@ -70,8 +70,17 @@ public sealed record WorkspaceFolderPlan(string Current, string Folder, int Proj } /// What "Open in workspace" shows of the copy it queues: its bytes (as the copy reckons them) and the free bytes of the workspace's drive. -public sealed record WorkspaceCopyFacts(long Bytes, long? Free) +/// What the copy of the proxies writes. +/// What the copy of the originals writes besides (phase 5c); null when not known. +public sealed record WorkspaceCopyFacts(long Bytes, long? Free, long? OriginalsBytes = null) { + /// + /// The drive lacks room for the copy of (: the proxies and the + /// originals) and the reserve the copy keeps free. + /// + public bool TooLittleSpaceFor(string media) => + Free is { } free && free < Bytes + (media == BundleMedia.Originals ? OriginalsBytes ?? 0 : 0) + WorkspaceJobs.CopySpaceReserve; + /// The drive lacks the copy and the reserve the copy keeps: it would stop saying so. public bool TooLittleSpace => Free is { } free && free < Bytes + WorkspaceJobs.CopySpaceReserve; } @@ -113,8 +122,20 @@ public sealed record WorkspaceRemovalPlan(Guid ProjectId, string Name, int Files /// public string? KnownName { get; init; } + /// + /// Local renders not at the home yet (phase 5c, the project's ledger): Send first sends them, Discard keeps them in the + /// workspace's trash with the rest of the work not sent. + /// + public int UnsentRenders { get; init; } + + /// + /// Originals the workspace holds that the home no longer holds with the same SHA-256 (phase 5c): they go to the + /// workspace's trash, never deleted, when the copy is removed. + /// + public int LastOriginals { get; init; } + /// Everything the copy holds is at the home: it can go without discarding anything. - public bool IsSafe => Unsent == 0 && !Modified && !Conflict && !Damaged; + public bool IsSafe => Unsent == 0 && UnsentRenders == 0 && !Modified && !Conflict && !Damaged; } /// @@ -129,7 +150,7 @@ public sealed record WorkspaceRemovalPlan(Guid ProjectId, string Name, int Files /// Workspace › Kept versions only after the home returned each, a page of its history at a time. A capture (sample data, no /// engine) has no workspace: Edit opens the library there. /// -public sealed class WorkspaceHost +public sealed partial class WorkspaceHost { /// Where discarded work of removed local copies is kept (the store lists only folders named by a project id). public const string TrashFolder = ".trash"; @@ -358,20 +379,6 @@ public sealed class WorkspaceHost Log.Info("workspace", $"The workspace folder is now {plan.Folder} ({plan.ProjectsLeft} project(s) stay in {plan.Current})"); } - /// The bytes the first copy of a sequence's media writes into the workspace, and the free bytes of the workspace's drive. - /// The index or the archive engine is not open. - public Task CopyFactsAsync(Guid sequenceId, CancellationToken cancellationToken = default) - { - var db = _db() ?? throw new WorkspaceException(Loc.L("Editor.Error.NoEngine")); - var archives = _archives() ?? throw new WorkspaceException(Loc.L("Editor.Error.NoEngine")); - var root = Root; - return Task.Run(async () => - { - var (bytes, free) = await WorkspaceJobs.CopyFactsAsync(db, archives, sequenceId, root, cancellationToken).ConfigureAwait(false); - return new WorkspaceCopyFacts(bytes, free); - }, cancellationToken); - } - /// The project of opened last here, else the one saved last; null when the workspace has none. public async Task LastUsedAsync(Guid sequenceId, CancellationToken cancellationToken = default) { @@ -388,6 +395,16 @@ public sealed class WorkspaceHost _savePreferences(); } + /// + /// Records that Edit opened at (now when null): the clean-up's Clean + /// after goes by it (phase 5c, ). Call it on the UI thread, which writes the settings. + /// + public void RecordOpened(Guid projectId, DateTimeOffset? at = null) + { + _settings.WorkspaceOpened[projectId] = at ?? DateTimeOffset.UtcNow; + _savePreferences(); + } + /// The home's live projects of a sequence, Main first (made from the sequence's settings when it has none yet). public Task> HomeProjectsAsync(Guid sequenceId, CancellationToken cancellationToken = default) => HomeProjectsAsync(ArchiveHome(sequenceId), cancellationToken); @@ -426,6 +443,7 @@ public sealed class WorkspaceHost var sequenceId = home.SequenceId; var checkout = await Task.Run(async () => { + EnsureNotMoving(); // Refused before anything is written: the copy job would refuse such a folder after the checkout filled it. if (await InsideALibraryAsync(cancellationToken).ConfigureAwait(false)) throw new WorkspaceException(Loc.L("Errors.Workspace.InsideLibraryEdit", Root)) { FolderRefused = true }; @@ -461,6 +479,7 @@ public sealed class WorkspaceHost /// public Task QueueCopyAsync(Guid projectId, CancellationToken cancellationToken = default) => Task.Run(async () => { + EnsureNotMoving(); var bundle = Existing(projectId).ReadBundle(); return await QueueCopyCoreAsync(bundle.Workspace!.Home, projectId, bundle.Workspace.Media.Kind, bundle.Sequence.Title ?? string.Empty, cancellationToken) .ConfigureAwait(false); @@ -516,6 +535,7 @@ public sealed class WorkspaceHost { var version = await Task.Run(async () => { + EnsureNotMoving(); EnsureWritable(await Sync.StatusAsync(projectId, null, cancellationToken).ConfigureAwait(false)); return await Sync.CommitAsync(projectId, note, null, cancellationToken).ConfigureAwait(false); }, cancellationToken).ConfigureAwait(false); @@ -538,6 +558,7 @@ public sealed class WorkspaceHost /// The working state as a new local version without a note and without sending it; null when nothing changed. public Task CommitAsync(Guid projectId, CancellationToken cancellationToken = default) => Task.Run(async () => { + EnsureNotMoving(); EnsureWritable(await Sync.StatusAsync(projectId, null, cancellationToken).ConfigureAwait(false)); return await Sync.CommitAsync(projectId, null, null, cancellationToken).ConfigureAwait(false); }, cancellationToken); @@ -551,6 +572,7 @@ public sealed class WorkspaceHost /// The home refused a version for good. public Task SyncAsync(Guid projectId, CancellationToken cancellationToken = default) => Task.Run(async () => { + EnsureNotMoving(); var home = HomeOfProject(projectId); var pulled = await Sync.PullAsync(projectId, home, cancellationToken).ConfigureAwait(false); // Deleted at the library: nothing to send, nothing to prune; the copy stays as it is. @@ -570,6 +592,7 @@ public sealed class WorkspaceHost public Task ResolveAsync(Guid projectId, ConflictChoice choice, IReadOnlySet? takeServer = null, WorkspaceConflict? shown = null, CancellationToken cancellationToken = default) => Task.Run(async () => { + EnsureNotMoving(); var home = HomeOfProject(projectId); WorkspaceSyncResult resolved; if (choice == ConflictChoice.SaveBoth) @@ -619,6 +642,7 @@ public sealed class WorkspaceHost /// public Task RestoreAsync(Guid projectId, Guid versionId, CancellationToken cancellationToken = default) => Task.Run(async () => { + EnsureNotMoving(); var status = await Sync.StatusAsync(projectId, null, cancellationToken).ConfigureAwait(false); if (status.ReadOnly) throw new WorkspaceException(Loc.L("Errors.Workspace.ReadOnly")); if (status.MediaRemoved) throw new WorkspaceException(Loc.L("Errors.Workspace.MediaMissing")); @@ -766,8 +790,9 @@ public sealed class WorkspaceHost // A conflict recorded counts as work not at the home, also once the library no longer has the project (Gone asks none); // one a settling replay took past its commit point is over, as the status reads it. var conflict = status.Conflict is not null || project.OpenConflict() is not null; + var (unsentRenders, lastOriginals) = await RemovalMediaAsync(project, cancellationToken).ConfigureAwait(false); return new WorkspaceRemovalPlan(projectId, name, files, bytes, status.Ahead + status.Damaged, status.Modified, conflict, status.Offline, - status.State == WorkspaceState.Gone); + status.State == WorkspaceState.Gone) { UnsentRenders = unsentRenders, LastOriginals = lastOriginals }; }, cancellationToken); /// @@ -802,6 +827,7 @@ public sealed class WorkspaceHost // A version saved here that cannot be read may be one the home never had: only discarding keeps it aside. if (status.Ahead > 0 || status.Damaged > 0 || (status.Modified && !status.ReadOnly) || status.Conflict is not null) throw new WorkspaceException(Unsent(workspace.Home)); + await EnsureRendersSentAsync(project, workspace, cancellationToken).ConfigureAwait(false); await VerifyHomeAsync(projectId, workspace, cancellationToken).ConfigureAwait(false); } await RemoveFolderAsync(project, cancellationToken).ConfigureAwait(false); @@ -950,6 +976,8 @@ public sealed class WorkspaceHost } throw; } + // Originals the home no longer holds go aside with the rest; only what the home can make again is deleted. + await KeepLastOriginalsAsync(project, aside, cancellationToken).ConfigureAwait(false); if (Directory.Exists(project.MediaDirectory)) Directory.Delete(project.MediaDirectory, recursive: true); void Move(string from, string to) @@ -1007,9 +1035,13 @@ public sealed class WorkspaceHost private void Forget(Guid sequenceId, Guid projectId) { - if (!_settings.WorkspaceRecent.TryGetValue(sequenceId, out var known) || known != projectId) return; - _settings.WorkspaceRecent.Remove(sequenceId); - _savePreferences(); + var changed = _settings.WorkspaceOpened.Remove(projectId); + if (_settings.WorkspaceRecent.TryGetValue(sequenceId, out var known) && known == projectId) + { + _settings.WorkspaceRecent.Remove(sequenceId); + changed = true; + } + if (changed) _savePreferences(); } /// diff --git a/src/Chronos.Core/Model/Enums.cs b/src/Chronos.Core/Model/Enums.cs index 54612451..b139f4b7 100644 --- a/src/Chronos.Core/Model/Enums.cs +++ b/src/Chronos.Core/Model/Enums.cs @@ -105,6 +105,24 @@ public enum JobKind /// and resumable (owner review 2, R8); stored as 20. /// WorkspaceCopy = 20, + + /// + /// Renders a workspace project from the originals the workspace holds, on this PC, into the project's exports/ + /// with a ledger entry per output (owner review 2, R8, phase 5c); stored as 21. + /// + WorkspaceRender = 21, + + /// + /// Sends a workspace project's local renders home (this PC's archive or its server) with their project and version, + /// each hash-checked and idempotent by render id (owner review 2, R8, phase 5c); stored as 22. + /// + WorkspaceSend = 22, + + /// + /// Moves the workspace folder with its projects to another folder, journaled and hash-verified across volumes, the + /// source kept until every file is verified (owner review 2, R8, phase 5c); stored as 23. + /// + WorkspaceMove = 23, } /// Why a photo left a sequence (its tombstone, owner review 2, R6); stored as a number. diff --git a/src/Chronos.Data/Jobs/JobPriorityQueue.cs b/src/Chronos.Data/Jobs/JobPriorityQueue.cs index fca96fd0..71b6d396 100644 --- a/src/Chronos.Data/Jobs/JobPriorityQueue.cs +++ b/src/Chronos.Data/Jobs/JobPriorityQueue.cs @@ -23,8 +23,9 @@ public sealed record JobPriorityQueue { /// /// The levels a kind has unless the user changed it: renders, imports and downloads first, and the copy of a project's - /// media into the workspace, which Edit waits for (owner review 2, R8); the long passes that resume anywhere, and the - /// housekeeping of the schedules (backups, clean-ups), last. + /// media into the workspace, which Edit waits for (owner review 2, R8), a workspace's local render and the move of the + /// workspace folder, which Edit is held for (phase 5c); a local render's sending home at the normal level; the long + /// passes that resume anywhere, and the housekeeping of the schedules (backups, clean-ups), last. /// public static IReadOnlyDictionary DefaultLevels { get; } = new Dictionary { @@ -32,6 +33,9 @@ public sealed record JobPriorityQueue [JobKind.Import] = JobKindPriority.High, [JobKind.Download] = JobKindPriority.High, [JobKind.WorkspaceCopy] = JobKindPriority.High, + [JobKind.WorkspaceRender] = JobKindPriority.High, + [JobKind.WorkspaceSend] = JobKindPriority.Normal, + [JobKind.WorkspaceMove] = JobKindPriority.High, [JobKind.Verify] = JobKindPriority.Low, [JobKind.Proxies] = JobKindPriority.Low, [JobKind.Backup] = JobKindPriority.Low, diff --git a/src/Chronos.Data/Sync/SyncTransfers.cs b/src/Chronos.Data/Sync/SyncTransfers.cs index 6110d096..a8a816f6 100644 --- a/src/Chronos.Data/Sync/SyncTransfers.cs +++ b/src/Chronos.Data/Sync/SyncTransfers.cs @@ -558,14 +558,14 @@ internal sealed class SyncTransfers(SyncService sync) } } - private static string? SafeFileName(string? name) + internal static string? SafeFileName(string? name) { var file = Path.GetFileName(name?.Trim()); return string.IsNullOrEmpty(file) || file.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0 || file is "." or ".." ? null : file; } /// "name.mp4", else "name (2).mp4", … — an existing export is never replaced. - private static string Unique(string folder, string fileName) + internal static string Unique(string folder, string fileName) { var candidate = Path.Combine(folder, fileName); var stem = Path.GetFileNameWithoutExtension(fileName); @@ -693,7 +693,7 @@ internal sealed class SyncTransfers(SyncService sync) /// manifest's SHA-256 (two attempts). A part as long as the file (a job stopped while hashing it) is only hashed again; /// a part the server can no longer resume (416) starts over. /// - private static async Task<(string Path, string Sha256)> FetchOriginalAsync(ISyncRemote remote, ManifestFrame frame, string staging, + internal static async Task<(string Path, string Sha256)> FetchOriginalAsync(ISyncRemote remote, ManifestFrame frame, string staging, CancellationToken cancellationToken) { if (frame.Sha256.Length == 0) return await FetchUnhashedAsync(remote, frame, staging, cancellationToken).ConfigureAwait(false); diff --git a/src/Chronos.Data/Workspaces/WorkspaceCopyJobHandler.cs b/src/Chronos.Data/Workspaces/WorkspaceCopyJobHandler.cs index 1cf3f769..d788b35a 100644 --- a/src/Chronos.Data/Workspaces/WorkspaceCopyJobHandler.cs +++ b/src/Chronos.Data/Workspaces/WorkspaceCopyJobHandler.cs @@ -19,60 +19,6 @@ using SequenceManifest = Chronos.Protocol.SequenceManifest; namespace Chronos.Data.Workspaces; -/// Builds the jobs of the workspace (owner review 2, R8), and their handlers for the desktop's engine. -public static class WorkspaceJobs -{ - /// - /// : the media of workspace project (checked out first, - /// ) copied from its home, the sequence of this PC's archive. - /// - public static ArchiveJobRequest Copy(Sequence sequence, string workspaceRoot, Guid projectId, string media = BundleMedia.Proxies) - { - ArgumentNullException.ThrowIfNull(sequence); - ArgumentException.ThrowIfNullOrWhiteSpace(workspaceRoot); - return new ArchiveJobRequest(JobKind.WorkspaceCopy, [sequence.Id], sequence.DisplayTitle, - JsonSerializer.Serialize(new WorkspaceCopyParameters(workspaceRoot, projectId, media), WorkspaceJson.Default.WorkspaceCopyParameters), JobPriority.User); - } - - /// - /// of a project whose home is a server (phase 5b): the media of workspace project - /// (checked out first) downloaded from sequence of - /// (), into the workspace alone. The job's target is the - /// server's sequence, as for a sync download. - /// - public static ArchiveJobRequest CopyFromServer(Guid sequenceId, string title, string server, string workspaceRoot, Guid projectId, string media = BundleMedia.Proxies) - { - ArgumentException.ThrowIfNullOrWhiteSpace(server); - ArgumentException.ThrowIfNullOrWhiteSpace(workspaceRoot); - return new ArchiveJobRequest(JobKind.WorkspaceCopy, [sequenceId], title, - JsonSerializer.Serialize(new WorkspaceCopyParameters(workspaceRoot, projectId, media, server), WorkspaceJson.Default.WorkspaceCopyParameters), JobPriority.User); - } - - /// - /// The handlers of the workspace's jobs for a desktop's engine (never a server's: the job writes into a folder its - /// parameters name); copies from a server fail without a connection to it. - /// - public static IReadOnlyList CreateHandlers(ChronosDatabase db, ArchiveService archives) => CreateHandlers(db, archives, null); - - /// The connection a copy from a server's sequence downloads through (the desktop's signed-in session). - public static IReadOnlyList CreateHandlers(ChronosDatabase db, ArchiveService archives, ISyncConnector? servers) => - [new WorkspaceCopyJobHandler(db, archives, servers)]; - - /// - /// What a first copy of a sequence's proxies writes into a workspace, as the copy reckons it before it starts (the - /// archive's proxies' sizes, an estimate for those it makes), and the free bytes on 's - /// drive (null when it cannot be measured): "Open in workspace" shows both. The copy keeps - /// free besides. - /// - /// The index has no such sequence or archive. - public static Task<(long Bytes, long? Free)> CopyFactsAsync(ChronosDatabase db, ArchiveService archives, Guid sequenceId, string workspaceRoot, - CancellationToken cancellationToken = default) => - new WorkspaceCopyJobHandler(db, archives).FactsAsync(sequenceId, workspaceRoot, cancellationToken); - - /// Bytes the copy leaves free on the workspace's drive besides what it copies. - public static long CopySpaceReserve => WorkspaceCopyJobHandler.SpaceReserve; -} - /// /// for a sequence of this PC's archive (owner review 2, R8): its proxies into the /// workspace project's media/proxies/<frame id>.jpg, the archive's own when current, else made here from the diff --git a/src/Chronos.Data/Workspaces/WorkspaceJobs.cs b/src/Chronos.Data/Workspaces/WorkspaceJobs.cs new file mode 100644 index 00000000..b3435793 --- /dev/null +++ b/src/Chronos.Data/Workspaces/WorkspaceJobs.cs @@ -0,0 +1,183 @@ +using System.Text.Json; +using Chronos.Core.Model; +using Chronos.Core.Project; +using Chronos.Data.Archiving; +using Chronos.Data.Archiving.Jobs; +using Chronos.Data.Jobs; +using Chronos.Data.Processing; +using Chronos.Data.Sync; + +namespace Chronos.Data.Workspaces; + +/// +/// What the workspace's job handlers take from the desktop besides the index and the archive engine (phase 5c). +/// +/// +/// Decoders, encoders and tuning of a local render (): the desktop's +/// . +/// +/// +/// True while transfers with a server are held (Settings › Server › Pause metered transfers on a metered connection): a +/// or naming a server is not started then. Never +/// holds a copy from or a send to this PC's archive. +/// +/// +/// Told once a verified every file at its target (from, to): the desktop names the new +/// folder in Settings › Workspace and refreshes the workspace; null where nothing follows the folder. +/// +public sealed record WorkspaceJobOptions(ProcessingOptions Processing, Func HoldTransfers, Func? Moved = null) +{ + /// The options of an engine without a processing service of its own: the archive engine's decoders, nothing held, no move followed. + public static WorkspaceJobOptions For(ArchiveService archives) + { + ArgumentNullException.ThrowIfNull(archives); + return new WorkspaceJobOptions(new ProcessingOptions { Archive = new ArchiveServiceOptions { Decoder = archives.Decoder } }, () => false); + } +} + +/// Builds the jobs of the workspace (owner review 2, R8), and their handlers for the desktop's engine. +public static class WorkspaceJobs +{ + /// + /// : the media of workspace project (checked out first, + /// ) copied from its home, the sequence of this PC's archive. + /// + public static ArchiveJobRequest Copy(Sequence sequence, string workspaceRoot, Guid projectId, string media = BundleMedia.Proxies) + { + ArgumentNullException.ThrowIfNull(sequence); + ArgumentException.ThrowIfNullOrWhiteSpace(workspaceRoot); + return new ArchiveJobRequest(JobKind.WorkspaceCopy, [sequence.Id], sequence.DisplayTitle, + JsonSerializer.Serialize(new WorkspaceCopyParameters(workspaceRoot, projectId, media), WorkspaceJson.Default.WorkspaceCopyParameters), JobPriority.User); + } + + /// + /// of a project whose home is a server (phase 5b): the media of workspace project + /// (checked out first) downloaded from sequence of + /// (), into the workspace alone. The job's target is the + /// server's sequence, as for a sync download. + /// + public static ArchiveJobRequest CopyFromServer(Guid sequenceId, string title, string server, string workspaceRoot, Guid projectId, string media = BundleMedia.Proxies) + { + ArgumentException.ThrowIfNullOrWhiteSpace(server); + ArgumentException.ThrowIfNullOrWhiteSpace(workspaceRoot); + return new ArchiveJobRequest(JobKind.WorkspaceCopy, [sequenceId], title, + JsonSerializer.Serialize(new WorkspaceCopyParameters(workspaceRoot, projectId, media, server), WorkspaceJson.Default.WorkspaceCopyParameters), JobPriority.User); + } + + /// + /// (phase 5c): workspace project rendered on this PC from + /// the originals its media hold, into its exports/, as says (Protocol + /// RenderJobParameters with the portable settings: what writes for a render), each + /// output recorded with in the project's ledger and sent home after. The target is the + /// home's sequence (this PC's archive, or 's, ), so the + /// editor follows it as it follows a render of that sequence. + /// + public static ArchiveJobRequest Render(Guid sequenceId, string title, string workspaceRoot, Guid projectId, Guid? projectVersionId, string renderJson, + string? server = null) + { + ArgumentException.ThrowIfNullOrWhiteSpace(workspaceRoot); + ArgumentException.ThrowIfNullOrWhiteSpace(renderJson); + return new ArchiveJobRequest(JobKind.WorkspaceRender, [sequenceId], title, + JsonSerializer.Serialize(new WorkspaceRenderParameters(workspaceRoot, projectId, projectVersionId, renderJson, server), + WorkspaceJson.Default.WorkspaceRenderParameters), JobPriority.User); + } + + /// + /// (phase 5c): the local renders of workspace project + /// (every unsent one of its ledger when empty) sent to its home, the sequence of this PC's + /// archive or of (), with their project and version. + /// + public static ArchiveJobRequest Send(Guid sequenceId, string title, string workspaceRoot, Guid projectId, IReadOnlyList renderIds, string? server = null, + JobPriority priority = JobPriority.User) + { + ArgumentException.ThrowIfNullOrWhiteSpace(workspaceRoot); + ArgumentNullException.ThrowIfNull(renderIds); + return new ArchiveJobRequest(JobKind.WorkspaceSend, [sequenceId], title, + JsonSerializer.Serialize(new WorkspaceSendParameters(workspaceRoot, projectId, [.. renderIds], server), WorkspaceJson.Default.WorkspaceSendParameters), + priority); + } + + /// + /// (phase 5c): the workspace folder moved with its projects to + /// , as the plan of fingerprint the user confirmed showed it. The + /// job has no target; its label is the folder it moves to. + /// + public static ArchiveJobRequest Move(string from, string to, string planFingerprint) + { + ArgumentException.ThrowIfNullOrWhiteSpace(from); + ArgumentException.ThrowIfNullOrWhiteSpace(to); + ArgumentException.ThrowIfNullOrWhiteSpace(planFingerprint); + return new ArchiveJobRequest(JobKind.WorkspaceMove, [], to, + JsonSerializer.Serialize(new WorkspaceMoveParameters(from, to, planFingerprint), WorkspaceJson.Default.WorkspaceMoveParameters), JobPriority.User); + } + + /// The parameters of a job; null when it has none that read. + public static WorkspaceRenderParameters? RenderParameters(Job job) => Read(job, JobKind.WorkspaceRender, WorkspaceJson.Default.WorkspaceRenderParameters); + + /// The parameters of a job; null when it has none that read. + public static WorkspaceSendParameters? SendParameters(Job job) => Read(job, JobKind.WorkspaceSend, WorkspaceJson.Default.WorkspaceSendParameters); + + /// The parameters of a job; null when it has none that read. + public static WorkspaceMoveParameters? MoveParameters(Job job) => Read(job, JobKind.WorkspaceMove, WorkspaceJson.Default.WorkspaceMoveParameters); + + /// The parameters of a job; null when it has none that read. + public static WorkspaceCopyParameters? CopyParameters(Job job) => Read(job, JobKind.WorkspaceCopy, WorkspaceJson.Default.WorkspaceCopyParameters); + + /// + /// The handlers of the workspace's jobs for a desktop's engine (never a server's: the job writes into a folder its + /// parameters name); copies from a server fail without a connection to it. + /// + public static IReadOnlyList CreateHandlers(ChronosDatabase db, ArchiveService archives) => CreateHandlers(db, archives, null); + + /// The connection a copy from a server's sequence downloads through (the desktop's signed-in session). + public static IReadOnlyList CreateHandlers(ChronosDatabase db, ArchiveService archives, ISyncConnector? servers) => + CreateHandlers(db, archives, servers, WorkspaceJobOptions.For(archives)); + + /// + /// The handlers of every workspace job (phase 5c): the copy of a project's media, its local render, the sending of its + /// renders home and the move of the workspace folder. + /// + /// The connection a copy from, or a send to, a server's sequence goes through (the desktop's signed-in session). + /// The desktop's processing options, its hold on transfers and what follows a moved folder. + public static IReadOnlyList CreateHandlers(ChronosDatabase db, ArchiveService archives, ISyncConnector? servers, WorkspaceJobOptions options) + { + ArgumentNullException.ThrowIfNull(db); + ArgumentNullException.ThrowIfNull(archives); + ArgumentNullException.ThrowIfNull(options); + return + [ + new WorkspaceCopyJobHandler(db, archives, servers), + new WorkspaceRenderJobHandler(db, archives, options), + new WorkspaceSendJobHandler(db, archives, servers, options), + new WorkspaceMoveJobHandler(db, options), + ]; + } + + /// + /// What a first copy of a sequence's proxies writes into a workspace, as the copy reckons it before it starts (the + /// archive's proxies' sizes, an estimate for those it makes), and the free bytes on 's + /// drive (null when it cannot be measured): "Open in workspace" shows both. The copy keeps + /// free besides. + /// + /// The index has no such sequence or archive. + public static Task<(long Bytes, long? Free)> CopyFactsAsync(ChronosDatabase db, ArchiveService archives, Guid sequenceId, string workspaceRoot, + CancellationToken cancellationToken = default) => + new WorkspaceCopyJobHandler(db, archives).FactsAsync(sequenceId, workspaceRoot, cancellationToken); + + /// Bytes the copy leaves free on the workspace's drive besides what it copies. + public static long CopySpaceReserve => WorkspaceCopyJobHandler.SpaceReserve; + + private static T? Read(Job job, JobKind kind, System.Text.Json.Serialization.Metadata.JsonTypeInfo info) where T : class + { + ArgumentNullException.ThrowIfNull(job); + if (job.Kind != kind || job.ParametersJson is not { Length: > 0 } json) return null; + try + { + return JsonSerializer.Deserialize(json, info); + } + catch (JsonException) + { + return null; + } + } +} diff --git a/src/Chronos.Data/Workspaces/WorkspaceMedia.cs b/src/Chronos.Data/Workspaces/WorkspaceMedia.cs index e87d2b49..59079d8e 100644 --- a/src/Chronos.Data/Workspaces/WorkspaceMedia.cs +++ b/src/Chronos.Data/Workspaces/WorkspaceMedia.cs @@ -17,6 +17,13 @@ namespace Chronos.Data.Workspaces; /// What the file is when a server sent it (phase 5b): proxy, or thumb, a thumbnail standing in while the server /// had no proxy of the frame, which a later copy replaces once it has one; null for a proxy (copies from this PC's archive). /// +/// +/// The frame's original the workspace holds, relative to the media folder (: +/// "originals/<frame id>-<sha8><ext>", phase 5c), in media of kind ; null +/// when it holds none (proxies only, or the home had no original of the frame: the proxy stands in for editing). +/// +/// The original's SHA-256 as copied and checked (lower case); null with . +/// The original's size as copied; 0 with no original. public sealed record WorkspaceFrame( Guid Id, int Index, @@ -46,7 +53,10 @@ public sealed record WorkspaceFrame( string? File, string? FileSha256, long FileBytes, - string? FileKind = null) + string? FileKind = null, + string? Original = null, + string? OriginalSha256 = null, + long OriginalBytes = 0) { /// The record of a home's frame, with the file the workspace holds for it (: what a server sent). public static WorkspaceFrame Of(Frame frame, string? file, string? fileSha256, long fileBytes, string? fileKind = null) @@ -62,6 +72,24 @@ public sealed record WorkspaceFrame( [JsonIgnore] public bool IsStandIn => FileKind == Sync.ProxyCache.Thumb; + /// The workspace holds the frame's original (media of kind ). + [JsonIgnore] + public bool HasOriginal => Original is not null; + + /// + /// The frame as a render from the workspace's originals reads it (phase 5c): its file is , and + /// it is flagged missing while the workspace holds no original for it (a render refuses such media first). + /// + public Frame ToOriginalFrame(Guid sequenceId) + { + var frame = ToFrame(sequenceId); + return frame with + { + RelativePath = Original ?? FileName, + Flags = Original is null ? Flags | FrameFlags.Missing : Flags, + }; + } + /// The frame as the processing engine reads it; flagged missing while the workspace holds no file for it. public Frame ToFrame(Guid sequenceId) => new() { @@ -97,8 +125,10 @@ public sealed record WorkspaceFrame( /// /// What a workspace project holds of its sequence's photos (media/media.json, owner review 2, R8): the kind -/// (; originals in phase 5c), the sequence and its frames version at the home when they -/// were copied, and every frame in index order. Written last by a copy, so a copy cut short leaves the previous index. +/// (, or from phase 5c : the proxies plus each frame's +/// original, ), the sequence and its frames version at the home when they were +/// copied, and every frame in index order. Written last by a copy, so a copy cut short leaves the previous index. An index +/// of phase 5b has no original fields: it reads as proxies only. /// /// The encodings of the sequence's photos a conversion joined at the home (R7, its tombstones of reason /// "replaced") when the media were copied: a version parked on a photo before its file was converted still finds its frame. @@ -115,6 +145,13 @@ public sealed record WorkspaceMedia(string Format, int FormatVersion, string Kin /// The frames held, as the processing engine reads them. public IReadOnlyList ToFrames() => [.. Frames.Select(f => f.ToFrame(SequenceId))]; + /// The frames over the originals the workspace holds (), as a local render reads them. + public IReadOnlyList ToOriginalFrames() => [.. Frames.Select(f => f.ToOriginalFrame(SequenceId))]; + + /// Media of kind : the proxies plus the originals the frames name. + [JsonIgnore] + public bool HoldsOriginals => Kind == BundleMedia.Originals; + /// /// These media with their photos named as names them now (owner review 2, R8): a frame copied /// before the home hashed its photo (a folder adopted, verified since) takes the SHA-256 the home's frame of that id has diff --git a/src/Chronos.Data/Workspaces/WorkspaceMoveJobHandler.cs b/src/Chronos.Data/Workspaces/WorkspaceMoveJobHandler.cs new file mode 100644 index 00000000..6df7803b --- /dev/null +++ b/src/Chronos.Data/Workspaces/WorkspaceMoveJobHandler.cs @@ -0,0 +1,23 @@ +using Chronos.Core.Model; +using Chronos.Data.Jobs; + +namespace Chronos.Data.Workspaces; + +/// +/// (phase 5c, ): the workspace folder moved with its +/// projects, after the plan the user confirmed (its fingerprint checked again): journaled in <from>/.move.json, +/// moved per project on one volume, copied and hash-verified on both sides across volumes, a project's source deleted only +/// once every file of it is verified, resumable from the journal; at the end is told. +/// On failure the source stays the workspace and unverified partial copies are removed. +/// +internal sealed class WorkspaceMoveJobHandler(ChronosDatabase db, WorkspaceJobOptions options) : IJobHandler +{ + public JobKind Kind => JobKind.WorkspaceMove; + + public Task RunAsync(JobContext context) + { + ArgumentNullException.ThrowIfNull(context); + _ = (db, options); + throw new NotImplementedException("Moving the workspace folder comes with phase 5c (P6)."); + } +} diff --git a/src/Chronos.Data/Workspaces/WorkspaceRenderJobHandler.cs b/src/Chronos.Data/Workspaces/WorkspaceRenderJobHandler.cs new file mode 100644 index 00000000..f37c4e52 --- /dev/null +++ b/src/Chronos.Data/Workspaces/WorkspaceRenderJobHandler.cs @@ -0,0 +1,24 @@ +using Chronos.Core.Model; +using Chronos.Data.Archiving; +using Chronos.Data.Jobs; + +namespace Chronos.Data.Workspaces; + +/// +/// (phase 5c, ): a workspace project rendered on this +/// PC from the originals its media hold, as renders an archive's sequence, +/// into the project's exports/ (each output written as .part, then renamed), each output hashed and recorded in +/// the project's ledger (, its id RenderJobHandler.RenderId(jobId, index)), then a +/// queued with the new ids. Media without an original for every placed frame are refused. +/// +internal sealed class WorkspaceRenderJobHandler(ChronosDatabase db, ArchiveService archives, WorkspaceJobOptions options) : IJobHandler +{ + public JobKind Kind => JobKind.WorkspaceRender; + + public Task RunAsync(JobContext context) + { + ArgumentNullException.ThrowIfNull(context); + _ = (db, archives, options); + throw new NotImplementedException("Local renders of a workspace project come with phase 5c (P2)."); + } +} diff --git a/src/Chronos.Data/Workspaces/WorkspaceRenders.cs b/src/Chronos.Data/Workspaces/WorkspaceRenders.cs new file mode 100644 index 00000000..88d0dc5e --- /dev/null +++ b/src/Chronos.Data/Workspaces/WorkspaceRenders.cs @@ -0,0 +1,136 @@ +using System.Text.Json; +using System.Text.Json.Serialization; +using Chronos.Core.IO; +using Chronos.Core.Model; + +namespace Chronos.Data.Workspaces; + +/// +/// One local render of a workspace project (phase 5c), as its ledger () records it: the output +/// a wrote into the project's exports/, its SHA-256 and size as written, what it +/// is (preset, codec, size, rate, length), the project and version it was rendered from, and whether it went home +/// (). The file stays in exports/ after it is sent, until a clean-up removes it. +/// +/// +/// The render's id, the same at the home once sent (RenderJobHandler.RenderId(jobId, index)): a send repeated after a +/// cut finds the home holding it already, and nothing is filed twice. +/// +/// The job that wrote it. +/// The output, relative to the project's exports/ folder (forward slashes; ). +/// The output's SHA-256 (lower case) as it was written: a send hashes the file again and refuses another. +/// The output's size in bytes. +/// The project version rendered; null for a working state no version names. +/// The content hash of the portable settings rendered (ProjectContent); null when not known. +/// When the output was finished. +/// , or (a later Chronos may write others: read as pending). +/// When the home took it; null until then. +/// Why the last send failed (one localized sentence); null otherwise. +public sealed record WorkspaceRenderEntry( + Guid RenderId, + Guid JobId, + string File, + string Sha256, + long Size, + string PresetName, + string? Codec, + int Width, + int Height, + double Fps, + double DurationSeconds, + Guid ProjectId, + Guid? ProjectVersionId, + string? SettingsHash, + DateTimeOffset Rendered, + string State = WorkspaceRenderEntry.Pending, + DateTimeOffset? Sent = null, + string? Error = null) +{ + /// Written, not at the home yet. + public const string Pending = "pending"; + + /// The home holds it (a render row of the home's sequence with this id). + public const string SentState = "sent"; + + /// The last send failed ( says why); sent again by the next send. + public const string Failed = "failed"; + + /// The home holds this render. + [JsonIgnore] + public bool IsSent => State == SentState; + + /// Not at the home yet: pending, failed, or a state this Chronos does not know. A clean-up never removes its file. + [JsonIgnore] + public bool IsUnsent => !IsSent; + + /// This entry as taken by the home at . + public WorkspaceRenderEntry AsSent(DateTimeOffset at) => this with { State = SentState, Sent = at, Error = null }; + + /// This entry after a send that failed for ; it stays to be sent again. + public WorkspaceRenderEntry AsFailed(string error) => this with { State = Failed, Error = error }; +} + +/// +/// The ledger of a workspace project's local renders (exports/renders.json, phase 5c): every output a +/// finished, oldest first, one entry per render id. Read whole and written whole and +/// atomically (temporary file, flush, rename), always under the project's lease; a missing ledger is an empty one. +/// +public sealed record WorkspaceRenders(string Format, int FormatVersion, IReadOnlyList Entries) +{ + public const string FormatName = "chronos-workspace-renders"; + public const int CurrentFormatVersion = 1; + + /// A ledger without entries. + public static WorkspaceRenders Empty { get; } = new(FormatName, CurrentFormatVersion, []); + + /// The entries not at the home yet (), oldest first. + [JsonIgnore] + public IReadOnlyList Unsent => [.. Entries.Where(e => e.IsUnsent)]; + + /// The entry of ; null when the ledger has none. + public WorkspaceRenderEntry? Find(Guid renderId) => Entries.FirstOrDefault(e => e.RenderId == renderId); + + /// This ledger with in place of the entry of its render id, or appended when it has none. + public WorkspaceRenders With(WorkspaceRenderEntry entry) + { + ArgumentNullException.ThrowIfNull(entry); + var entries = Entries.ToList(); + var at = entries.FindIndex(e => e.RenderId == entry.RenderId); + if (at >= 0) entries[at] = entry; + else entries.Add(entry); + return this with { Entries = entries }; + } + + /// This ledger without the entry of (a sent file a clean-up removed, a discarded render). + public WorkspaceRenders Without(Guid renderId) => Entries.Any(e => e.RenderId == renderId) ? this with { Entries = [.. Entries.Where(e => e.RenderId != renderId)] } : this; + + /// The ledger at ; when there is none. + /// The file is no ledger, is damaged, or a newer Chronos wrote it. + /// The file cannot be read. + public static WorkspaceRenders Read(string path) + { + ArgumentException.ThrowIfNullOrEmpty(path); + if (!System.IO.File.Exists(path)) return Empty; + WorkspaceRenders? renders; + try + { + renders = JsonSerializer.Deserialize(AtomicFile.ReadAllText(path), WorkspaceJson.Default.WorkspaceRenders); + } + catch (JsonException ex) + { + throw new InvalidDataException($"{path} cannot be read.", ex); + } + if (renders is null || renders.Format != FormatName || renders.Entries is null) throw new InvalidDataException($"{path} is not a renders ledger."); + if (renders.FormatVersion > CurrentFormatVersion) throw new InvalidDataException($"{path} is newer than this Chronos."); + return renders; + } + + /// Writes to whole and atomically, making its folder when needed. + /// The file cannot be written; the ledger there stays as it was. + public static void Write(string path, WorkspaceRenders renders) + { + ArgumentException.ThrowIfNullOrEmpty(path); + ArgumentNullException.ThrowIfNull(renders); + if (Path.GetDirectoryName(Path.GetFullPath(path)) is { Length: > 0 } folder) Directory.CreateDirectory(folder); + AtomicFile.WriteAllText(path, JsonSerializer.Serialize(renders with { Format = FormatName, FormatVersion = CurrentFormatVersion }, WorkspaceJson.Default.WorkspaceRenders)); + } +} diff --git a/src/Chronos.Data/Workspaces/WorkspaceSendJobHandler.cs b/src/Chronos.Data/Workspaces/WorkspaceSendJobHandler.cs new file mode 100644 index 00000000..2434dca6 --- /dev/null +++ b/src/Chronos.Data/Workspaces/WorkspaceSendJobHandler.cs @@ -0,0 +1,25 @@ +using Chronos.Core.Model; +using Chronos.Data.Archiving; +using Chronos.Data.Jobs; +using Chronos.Data.Sync; + +namespace Chronos.Data.Workspaces; + +/// +/// (phase 5c, ): the local renders of a workspace project +/// sent home with their project and version, per unsent ledger entry: the file hashed again (another is refused and stays), +/// the version it names pushed first when the home lacks it, then filed in this PC's archive (as the sync files a server's +/// exports) or uploaded to its server (RenderUploadRequest with ProjectId and ProjectVersionId), and the +/// entry marked sent. Idempotent by render id: a send repeated after a cut finds the home holding it already. +/// +internal sealed class WorkspaceSendJobHandler(ChronosDatabase db, ArchiveService archives, ISyncConnector? servers, WorkspaceJobOptions options) : IJobHandler +{ + public JobKind Kind => JobKind.WorkspaceSend; + + public Task RunAsync(JobContext context) + { + ArgumentNullException.ThrowIfNull(context); + _ = (db, archives, servers, options); + throw new NotImplementedException("Sending a workspace project's renders home comes with phase 5c (P3)."); + } +} diff --git a/src/Chronos.Data/Workspaces/WorkspaceStore.cs b/src/Chronos.Data/Workspaces/WorkspaceStore.cs index 03d455a5..78df8d9f 100644 --- a/src/Chronos.Data/Workspaces/WorkspaceStore.cs +++ b/src/Chronos.Data/Workspaces/WorkspaceStore.cs @@ -91,17 +91,48 @@ public sealed record WorkspaceConflict(Guid TheirsVersionId, int TheirsNumber, G /// /// Parameters of a job: target = the home's sequence; the workspace folder, the -/// project whose media to copy and what to copy (; originals in phase 5c). +/// project whose media to copy and what to copy (, or : +/// the proxies plus the originals, phase 5c). /// /// The server the home's sequence is on (, phase 5b); null for a sequence of this PC's archive. public sealed record WorkspaceCopyParameters(string WorkspaceRoot, Guid ProjectId, string Media, string? Server = null); +/// +/// Parameters of a job (phase 5c): target = the home's sequence; the workspace folder, +/// the project rendered from the originals its media hold, the version rendered (null: the head version the workspace +/// holds), and the render's export settings as Protocol RenderJobParameters JSON (portable settings, preset, +/// overrides, batch), as writes them for a render. +/// +/// The version rendered and recorded with each output; null renders the head version the workspace holds. +/// Protocol RenderJobParameters as JSON. +/// The server the home's sequence is on (); null for a sequence of this PC's archive. +public sealed record WorkspaceRenderParameters(string WorkspaceRoot, Guid ProjectId, Guid? ProjectVersionId, string RenderJson, string? Server = null); + +/// +/// Parameters of a job (phase 5c): target = the home's sequence; the workspace folder, +/// the project, and the ledger entries () whose files go home. +/// +/// The renders sent; empty sends every pending entry of the project's ledger. +/// The server the home's sequence is on (); null for a sequence of this PC's archive. +public sealed record WorkspaceSendParameters(string WorkspaceRoot, Guid ProjectId, IReadOnlyList RenderIds, string? Server = null); + +/// +/// Parameters of a job (phase 5c): no target; the workspace folder moved +/// (), the folder it goes to, and the fingerprint of the plan the user confirmed (the job refuses a +/// workspace that changed since). +/// +public sealed record WorkspaceMoveParameters(string From, string To, string PlanFingerprint); + [JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase, DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull, UseStringEnumConverter = true, WriteIndented = true)] [JsonSerializable(typeof(WorkspaceManifest))] [JsonSerializable(typeof(WorkspaceMedia))] [JsonSerializable(typeof(WorkspaceSyncState))] [JsonSerializable(typeof(WorkspaceCopyParameters))] +[JsonSerializable(typeof(WorkspaceRenderParameters))] +[JsonSerializable(typeof(WorkspaceSendParameters))] +[JsonSerializable(typeof(WorkspaceMoveParameters))] +[JsonSerializable(typeof(WorkspaceRenders))] internal sealed partial class WorkspaceJson : JsonSerializerContext; /// @@ -309,9 +340,11 @@ public sealed class WorkspaceStore /// /// One project in the workspace (owner review 2, R8): <root>/<project id>/ with /// project.chronos (the working state: a project file of format 2, its settings placed on the media's frames), -/// media/media.json with media/proxies/<frame id>.jpg (originals later) and media/analysis.json -/// (the home's deep report), versions/<number>-<id>.json (commits not pushed yet, and the versions pulled), -/// sync.json, exports/ and the lease .lock.lease that one writer at a time holds. +/// media/media.json with media/proxies/<frame id>.jpg, media/originals/<frame id>-<sha8><ext> +/// (media of kind originals, phase 5c) and media/analysis.json (the home's deep report), +/// versions/<number>-<id>.json (commits not pushed yet, and the versions pulled), sync.json, +/// exports/ with the local renders and their ledger exports/renders.json (phase 5c), and the lease +/// .lock.lease that one writer at a time holds. /// public sealed class WorkspaceProject { @@ -324,6 +357,12 @@ public sealed class WorkspaceProject public const string ExportsFolder = "exports"; public const string SyncFile = "sync.json"; + /// The name of the ledger of the project's local renders () in . + public const string RendersFileName = "renders.json"; + + /// The ledger of the project's local renders (phase 5c), relative to . + public const string RendersFile = ExportsFolder + "/" + RendersFileName; + /// /// Old local commits replaced by their replay on top of the home's head, files the home's copy replaced, and the working /// states a take of the server's values replaced: kept up to a month, the newest 20 at most (). @@ -365,6 +404,9 @@ public sealed class WorkspaceProject public string ExportsDirectory => Path.Combine(Folder, ExportsFolder); public string SyncPath => Path.Combine(Folder, SyncFile); + /// The ledger of the project's local renders (, phase 5c). + public string RendersPath => Path.Combine(ExportsDirectory, RendersFileName); + public bool Exists => File.Exists(BundlePath); /// The file a frame's proxy is copied to, relative to . @@ -380,9 +422,35 @@ public sealed class WorkspaceProject return ProxiesFolder + "/" + frameId.ToString("N") + "-" + sha256[..Math.Min(16, sha256.Length)].ToLowerInvariant() + ".jpg"; } + /// + /// The file a frame's original is copied to, relative to (phase 5c): + /// originals/<frame id>-<sha8><ext>. The first 8 hex digits of its SHA-256 tell two encodings of one + /// frame apart (a conversion since: the editor keeps the one it reads until the copy commits), and the original's own + /// extension is kept, lower case, since decoders go by it. + /// + /// The original's extension, with or without its dot (".CR3", "dng", or the file name's ); empty or null for none. + public static string OriginalName(Guid frameId, string sha256, string? extension) + { + ArgumentException.ThrowIfNullOrEmpty(sha256); + var ext = (extension ?? string.Empty).Trim().TrimStart('.').ToLowerInvariant(); + if (ext.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0 || ext.Contains('/') || ext.Contains('\\')) ext = string.Empty; + return OriginalsFolder + "/" + frameId.ToString("N") + "-" + sha256[..Math.Min(8, sha256.Length)].ToLowerInvariant() + (ext.Length > 0 ? "." + ext : string.Empty); + } + + /// The ledger of the project's local renders; empty while it has none (). + /// The ledger is damaged or newer. + /// The ledger cannot be read. + public WorkspaceRenders ReadRenders() => WorkspaceRenders.Read(RendersPath); + + /// Writes the ledger of the project's local renders whole and atomically (); the caller holds the project's lease. + public void WriteRenders(WorkspaceRenders renders) => WorkspaceRenders.Write(RendersPath, renders); + /// The absolute path of a file named relative to . public string MediaFile(string relative) => LongPath.FromPortableRelative(MediaDirectory, relative); + /// The absolute path of a local render named relative to (). + public string ExportFile(string relative) => LongPath.FromPortableRelative(ExportsDirectory, relative); + /// Holds the project for one writer (this program's sync, a copy job) until disposed. /// Another writer kept it for longer than . public async Task LockAsync(TimeSpan wait, CancellationToken cancellationToken = default) diff --git a/src/Chronos.Protocol/Uploads.cs b/src/Chronos.Protocol/Uploads.cs index b0a2108d..14875b6a 100644 --- a/src/Chronos.Protocol/Uploads.cs +++ b/src/Chronos.Protocol/Uploads.cs @@ -46,6 +46,10 @@ public sealed record CardImportReport(Guid ImportId, string Card, string State, /// and files the render under the sequence's exports. A completion that cannot file it for now answers 503 /// sequence_busy, archive_offline or folder_moved (another index moved the sequence's folder; the /// server's next scan finds it) and keeps the upload, to be completed again. +/// A render a workspace made on a client (phase 5c) names the project and version it was rendered from +/// (, ): the server records them with the render once it checked that +/// the project is the sequence's and the version the project's (422 project_mismatch otherwise). Both are optional +/// and appended: a request of an earlier client has neither, and an earlier server ignores them. /// public sealed record RenderUploadRequest( Guid RenderId, @@ -58,4 +62,6 @@ public sealed record RenderUploadRequest( int Height, double Fps, double DurationSeconds, - string? ProducedBy); + string? ProducedBy, + Guid? ProjectId = null, + Guid? ProjectVersionId = null); diff --git a/tests/Chronos.App.Tests/Jobs/JobNoticesTests.cs b/tests/Chronos.App.Tests/Jobs/JobNoticesTests.cs index 8d755a06..3e25a2ca 100644 --- a/tests/Chronos.App.Tests/Jobs/JobNoticesTests.cs +++ b/tests/Chronos.App.Tests/Jobs/JobNoticesTests.cs @@ -17,6 +17,9 @@ public sealed class JobNoticesTests [Case(JobKind.Move)] [Case(JobKind.Adopt)] [Case(JobKind.Convert)] + [Case(JobKind.WorkspaceRender)] + [Case(JobKind.WorkspaceSend)] + [Case(JobKind.WorkspaceMove)] public void ALongOperationThatEndsSaysSo(JobKind kind) { Assert.Equal(JobNotice.Done, JobNotices.For(JobState.Running, Job(kind, JobState.Done))); diff --git a/tests/Chronos.App.Tests/Workspace/WorkspaceHostTests.cs b/tests/Chronos.App.Tests/Workspace/WorkspaceHostTests.cs index 65cd8195..e438e123 100644 --- a/tests/Chronos.App.Tests/Workspace/WorkspaceHostTests.cs +++ b/tests/Chronos.App.Tests/Workspace/WorkspaceHostTests.cs @@ -75,6 +75,102 @@ public sealed class WorkspaceHostTests(TestContext context) Assert.Empty(older.WorkspaceRecent); } + [Test] + public void ThePhase5cWorkspaceSettingsHaveTheirDefaultsAndSurviveTheSettingsFile() + { + var fresh = new AppSettings(); + Assert.Equal((100, BundleMedia.Proxies, true, 30, WorkspaceOpenPolicy.LastUsed), + (fresh.WorkspaceSizeLimitGb, fresh.WorkspaceDefaultMedia, fresh.WorkspaceVersionOnRender, fresh.WorkspaceCleanAfterDays, fresh.WorkspaceOpenProject)); + Assert.Empty(fresh.WorkspaceOpened); + + // A settings file of phase 5b gets them too. + var older = AppSettings.Parse("""{ "Theme": "Light", "WorkspaceKeptVersions": 50 }""")!; + Assert.Equal((100, BundleMedia.Proxies, true, 30, WorkspaceOpenPolicy.LastUsed, 50), + (older.WorkspaceSizeLimitGb, older.WorkspaceDefaultMedia, older.WorkspaceVersionOnRender, older.WorkspaceCleanAfterDays, older.WorkspaceOpenProject, + older.WorkspaceKeptVersions)); + Assert.Empty(older.WorkspaceOpened); + + var project = Guid.CreateVersion7(); + var at = new DateTimeOffset(2026, 11, 4, 9, 30, 0, TimeSpan.FromHours(1)); + var settings = new AppSettings + { + WorkspaceSizeLimitGb = 0, + WorkspaceDefaultMedia = BundleMedia.Originals, + WorkspaceVersionOnRender = false, + WorkspaceCleanAfterDays = 0, + WorkspaceOpenProject = WorkspaceOpenPolicy.Ask, + }; + settings.WorkspaceOpened[project] = at; + var copy = AppSettings.Parse(settings.ToJson())!; + Assert.Equal((0, BundleMedia.Originals, false, 0, WorkspaceOpenPolicy.Ask), + (copy.WorkspaceSizeLimitGb, copy.WorkspaceDefaultMedia, copy.WorkspaceVersionOnRender, copy.WorkspaceCleanAfterDays, copy.WorkspaceOpenProject)); + Assert.Equal(at, copy.WorkspaceOpened[project]); + Assert.Contains("\"Ask\"", settings.ToJson()); + } + + [Test] + public void WhenEachProjectWasOpenedStaysOnThisPc() + { + var project = Guid.CreateVersion7(); + var sequence = Guid.CreateVersion7(); + var at = new DateTimeOffset(2026, 11, 4, 9, 30, 0, TimeSpan.Zero); + var mine = new AppSettings { WorkspaceFolder = @"D:\Fast\Workspace", WorkspaceSizeLimitGb = 250, WorkspaceOpenProject = WorkspaceOpenPolicy.Main }; + mine.WorkspaceRecent[sequence] = project; + mine.WorkspaceOpened[project] = at; + + // Reset puts the preferences back and keeps what this PC knows of its projects. + var reset = mine.ResetKeepingState(); + Assert.Equal((AppSettings.DefaultWorkspaceSizeLimitGb, WorkspaceOpenPolicy.LastUsed), (reset.WorkspaceSizeLimitGb, reset.WorkspaceOpenProject)); + Assert.Equal((@"D:\Fast\Workspace", project, at), (reset.WorkspaceFolder, reset.WorkspaceRecent[sequence], reset.WorkspaceOpened[project])); + + // Export carries the preferences, not this PC's projects. + var exported = AppSettings.Parse(mine.ForExport().ToJson())!; + Assert.Equal((250, WorkspaceOpenPolicy.Main, (string?)null), (exported.WorkspaceSizeLimitGb, exported.WorkspaceOpenProject, exported.WorkspaceFolder)); + Assert.Empty(exported.WorkspaceOpened); + Assert.Empty(exported.WorkspaceRecent); + Assert.Equal(at, mine.WorkspaceOpened[project]); + + // Import takes another PC's preferences and keeps this PC's projects. + var theirs = new AppSettings { WorkspaceSizeLimitGb = 40, WorkspaceFolder = @"E:\Elsewhere" }; + theirs.WorkspaceOpened[Guid.CreateVersion7()] = at.AddDays(-3); + var imported = mine.KeepLocalIn(AppSettings.Parse(theirs.ToJson())!); + Assert.Equal((40, @"D:\Fast\Workspace"), (imported.WorkspaceSizeLimitGb, imported.WorkspaceFolder)); + Assert.Equal(at, imported.WorkspaceOpened.Values.Single()); + Assert.Count(1, imported.WorkspaceOpened); + } + + [Test] + public void OpeningAProjectRecordsWhenAndSavesIt() + { + var local = context.CreateTempDirectory("local"); + var installed = AppEnvironment.From(AppPaths.Resolve(context.CreateTempDirectory("app"), local, [])); + var settings = new AppSettings(); + var saves = 0; + var host = new WorkspaceHost(installed, settings, () => saves++, () => null, () => null, () => null); + var project = Guid.CreateVersion7(); + var at = new DateTimeOffset(2026, 11, 4, 10, 0, 0, TimeSpan.Zero); + host.RecordOpened(project, at); + Assert.Equal((at, 1), (settings.WorkspaceOpened[project], saves)); + host.RecordOpened(project); + Assert.True(settings.WorkspaceOpened[project] > at, "opened again later"); + Assert.Equal(2, saves); + Assert.False(host.IsMoving); + } + + [Test] + public void AProjectWithRendersNotSentIsNotSafeToRemoveAndOriginalsNeedTheirRoom() + { + var plan = new WorkspaceRemovalPlan(Guid.CreateVersion7(), "Main", 12, 1_000, 0, false, false, false); + Assert.True(plan.IsSafe); + Assert.False((plan with { UnsentRenders = 1 }).IsSafe); + Assert.True((plan with { LastOriginals = 3 }).IsSafe, "the last originals go to the trash, never deleted"); + + var facts = new WorkspaceCopyFacts(1_000, 1_000 + WorkspaceJobs.CopySpaceReserve + 500, 2_000); + Assert.False(facts.TooLittleSpaceFor(BundleMedia.Proxies)); + Assert.True(facts.TooLittleSpaceFor(BundleMedia.Originals)); + Assert.False((facts with { Free = null }).TooLittleSpaceFor(BundleMedia.Originals), "a drive whose room is unknown is tried"); + } + [Test] public void SettingsWorkspaceRowsStoreEachChoiceAtOnce() { diff --git a/tests/Chronos.Data.Tests/Jobs/JobPriorityQueueTests.cs b/tests/Chronos.Data.Tests/Jobs/JobPriorityQueueTests.cs index 9f87aa39..e090f2d6 100644 --- a/tests/Chronos.Data.Tests/Jobs/JobPriorityQueueTests.cs +++ b/tests/Chronos.Data.Tests/Jobs/JobPriorityQueueTests.cs @@ -30,6 +30,30 @@ public sealed class JobPriorityQueueTests Assert.Equal(JobKindPriority.Low, (queue with { Levels = new Dictionary { [JobKind.Render] = JobKindPriority.Low } }).LevelOf(JobKind.Render)); } + [Test] + public void ALocalRenderAndAWorkspaceMoveGoFirstAndSendingARenderHomeWaitsItsTurn() + { + var queue = new JobPriorityQueue(); + // The user waits on a local render as on a render, and Edit is held while the workspace moves. + Assert.Equal(JobKindPriority.High, queue.LevelOf(JobKind.WorkspaceRender)); + Assert.Equal(JobKindPriority.High, queue.LevelOf(JobKind.WorkspaceMove)); + Assert.Equal(JobKindPriority.Normal, queue.LevelOf(JobKind.WorkspaceSend)); + var on = queue with { Enabled = true }; + Assert.True(on.Interrupts(JobKind.WorkspaceRender, JobKind.WorkspaceSend)); + Assert.False(on.Interrupts(JobKind.WorkspaceSend, JobKind.Scan)); + // The defaults are no change: settings store none of them, and read back as they are. + var defaults = new Dictionary + { + [JobKind.WorkspaceRender] = JobKindPriority.High, + [JobKind.WorkspaceSend] = JobKindPriority.Normal, + [JobKind.WorkspaceMove] = JobKindPriority.High, + }; + Assert.Empty(JobPriorityQueue.Changed(defaults)); + var changed = JobPriorityQueue.Changed(new Dictionary { [JobKind.WorkspaceSend] = JobKindPriority.Low }); + Assert.Equal("low", changed["workspace-send"]); + Assert.Equal(JobKindPriority.Low, JobPriorityQueue.From(true, changed).LevelOf(JobKind.WorkspaceSend)); + } + [Test] public void OnlyAHigherLevelInterruptsAndOnlyWhileTheQueueIsOn() { diff --git a/tests/Chronos.Data.Tests/Jobs/JobWireTests.cs b/tests/Chronos.Data.Tests/Jobs/JobWireTests.cs new file mode 100644 index 00000000..b4262c31 --- /dev/null +++ b/tests/Chronos.Data.Tests/Jobs/JobWireTests.cs @@ -0,0 +1,31 @@ +using Chronos.Core.Model; +using Chronos.Data.Jobs; +using Chronos.Testing; + +namespace Chronos.Data.Tests.Jobs; + +/// The names the jobs' kinds carry on the wire and in settings (BRIEF §14.6): stable once shipped. +[Category("jobs")] +public sealed class JobWireTests +{ + [Theory] + [Case(JobKind.WorkspaceCopy, 20, "workspace-copy")] + [Case(JobKind.WorkspaceRender, 21, "workspace-render")] + [Case(JobKind.WorkspaceSend, 22, "workspace-send")] + [Case(JobKind.WorkspaceMove, 23, "workspace-move")] + public void TheWorkspaceJobsKeepTheirValueAndName(JobKind kind, int value, string name) + { + Assert.Equal(value, (int)kind); + Assert.Equal(name, JobWire.Kind(kind)); + Assert.True(JobWire.TryParseKind(name, out var parsed), name); + Assert.Equal(kind, parsed); + } + + [Test] + public void EveryKindHasItsOwnName() + { + var names = Enum.GetValues().Select(JobWire.Kind).ToList(); + Assert.Equal(names.Count, names.Distinct(StringComparer.Ordinal).Count()); + Assert.False(JobWire.TryParseKind("workspace-teleport", out _)); + } +} diff --git a/tests/Chronos.Data.Tests/Workspaces/WorkspaceFoundationTests.cs b/tests/Chronos.Data.Tests/Workspaces/WorkspaceFoundationTests.cs new file mode 100644 index 00000000..ec9907f2 --- /dev/null +++ b/tests/Chronos.Data.Tests/Workspaces/WorkspaceFoundationTests.cs @@ -0,0 +1,211 @@ +using System.Text.Json.Nodes; +using Chronos.Core.Model; +using Chronos.Core.Project; +using Chronos.Data.Archiving.Jobs; +using Chronos.Data.Jobs; +using Chronos.Data.Tests.Archiving; +using Chronos.Data.Tests.Infrastructure; +using Chronos.Data.Workspaces; +using Chronos.Testing; + +namespace Chronos.Data.Tests.Workspaces; + +/// +/// The shared types of phase 5c (owner review 2, R8): originals in the media index, the ledger of local renders, the names +/// of the workspace's files, and the jobs of the workspace with their parameters. +/// +[Category("workspace")] +public sealed class WorkspaceFoundationTests(TestContext context) +{ + private static readonly DateTimeOffset T0 = new(2026, 11, 4, 9, 0, 0, TimeSpan.Zero); + + private static WorkspaceMedia Media(Guid sequenceId, string kind, params WorkspaceFrame[] frames) => + new(WorkspaceMedia.FormatName, WorkspaceMedia.CurrentFormatVersion, kind, sequenceId, 3, frames, T0); + + private static WorkspaceFrame Frame(Guid sequenceId, int index) => + WorkspaceFrame.Of(TestData.Frame(sequenceId, index), $"proxies/{Guid.NewGuid():N}.jpg", new string('a', 64), 1_500_000); + + [Test] + public void AMediaIndexOfPhase5bReadsAsProxiesWithoutOriginals() + { + var store = new WorkspaceStore(Path.Combine(context.CreateTempDirectory("ws"), "workspace")); + var project = store.Project(Guid.CreateVersion7()); + var sequenceId = Guid.CreateVersion7(); + project.WriteMedia(Media(sequenceId, BundleMedia.Proxies, Frame(sequenceId, 0), Frame(sequenceId, 1))); + + // As phase 5b wrote it: no original fields at all. + var json = JsonNode.Parse(File.ReadAllText(project.MediaIndexPath))!.AsObject(); + foreach (var frame in json["frames"]!.AsArray()) + { + var fields = frame!.AsObject(); + foreach (var name in new[] { "original", "originalSha256", "originalBytes" }) fields.Remove(name); + } + File.WriteAllText(project.MediaIndexPath, json.ToJsonString()); + Assert.False(File.ReadAllText(project.MediaIndexPath).Contains("\"original\"", StringComparison.Ordinal), "no original field is left"); + + var media = Assert.NotNull(project.ReadMedia()); + Assert.Equal(BundleMedia.Proxies, media.Kind); + Assert.False(media.HoldsOriginals); + foreach (var frame in media.Frames) + { + Assert.Equal(((string?)null, (string?)null, 0L, false), (frame.Original, frame.OriginalSha256, frame.OriginalBytes, frame.HasOriginal)); + // A render from originals finds none: every frame is missing there, while the editor reads its proxy. + Assert.True(frame.ToOriginalFrame(sequenceId).Flags.HasFlag(FrameFlags.Missing)); + Assert.False(frame.ToFrame(sequenceId).Flags.HasFlag(FrameFlags.Missing)); + } + } + + [Test] + public void OriginalsInTheMediaIndexAreReadBackAndRenderedFrom() + { + var store = new WorkspaceStore(Path.Combine(context.CreateTempDirectory("ws"), "workspace")); + var project = store.Project(Guid.CreateVersion7()); + var sequenceId = Guid.CreateVersion7(); + var held = Frame(sequenceId, 0); + var sha = new string('c', 64); + var original = WorkspaceProject.OriginalName(held.Id, sha, Path.GetExtension(held.FileName)); + held = held with { Original = original, OriginalSha256 = sha, OriginalBytes = held.Size }; + var proxied = Frame(sequenceId, 1); + project.WriteMedia(Media(sequenceId, BundleMedia.Originals, held, proxied)); + + var media = Assert.NotNull(project.ReadMedia()); + Assert.True(media.HoldsOriginals); + Assert.Equal((original, sha, held.Size), (media.Frames[0].Original, media.Frames[0].OriginalSha256, media.Frames[0].OriginalBytes)); + var frames = media.ToOriginalFrames(); + Assert.Equal(original, frames[0].RelativePath); + Assert.False(frames[0].Flags.HasFlag(FrameFlags.Missing)); + // A frame whose original the home lacked stays a proxy for the editor and is missing for a local render. + Assert.True(frames[1].Flags.HasFlag(FrameFlags.Missing)); + Assert.Equal(proxied.File, media.ToFrames()[1].RelativePath); + Assert.Equal(Path.Combine(project.OriginalsDirectory, Path.GetFileName(original)), project.MediaFile(original)); + } + + [Test] + public void OriginalsKeepTheirExtensionAndAShortHashInTheirName() + { + var id = Guid.Parse("0192a4c1-7b3e-7cc0-8a51-2f9d0e6b1a01"); + var sha = "ABCDEF0123456789" + new string('0', 48); + Assert.Equal("originals/0192a4c17b3e7cc08a512f9d0e6b1a01-abcdef01.cr3", WorkspaceProject.OriginalName(id, sha, ".CR3")); + Assert.Equal("originals/0192a4c17b3e7cc08a512f9d0e6b1a01-abcdef01.dng", WorkspaceProject.OriginalName(id, sha, "dng")); + Assert.Equal("originals/0192a4c17b3e7cc08a512f9d0e6b1a01-abcdef01", WorkspaceProject.OriginalName(id, sha, null)); + Assert.Equal("originals/0192a4c17b3e7cc08a512f9d0e6b1a01-abcdef01", WorkspaceProject.OriginalName(id, sha, "a/b")); + Assert.Throws(() => WorkspaceProject.OriginalName(id, string.Empty, ".jpg")); + + var store = new WorkspaceStore(Path.Combine(context.CreateTempDirectory("ws"), "workspace")); + var project = store.Project(id); + Assert.Equal("exports/renders.json", WorkspaceProject.RendersFile); + Assert.Equal(Path.Combine(project.Folder, "exports", "renders.json"), project.RendersPath); + Assert.Equal(Path.Combine(project.ExportsDirectory, "Roof 4K.mp4"), project.ExportFile("Roof 4K.mp4")); + } + + private static WorkspaceRenderEntry Entry(Guid projectId, string file) => + new(Guid.CreateVersion7(), Guid.CreateVersion7(), file, new string('b', 64), 12_345, "4K HEVC", "hevc", 3840, 2160, 30, 10, projectId, + Guid.CreateVersion7(), "hash", T0); + + [Test] + public void TheLedgerOfLocalRendersIsWrittenWholeAndReadBack() + { + var store = new WorkspaceStore(Path.Combine(context.CreateTempDirectory("ws"), "workspace")); + var project = store.Project(Guid.CreateVersion7()); + // No ledger yet: no renders. + Assert.Empty(project.ReadRenders().Entries); + Assert.Same(WorkspaceRenders.Empty, project.ReadRenders()); + + var first = Entry(project.ProjectId, "Roof 4K.mp4"); + var second = Entry(project.ProjectId, "Roof 1080p.mp4") with { ProjectVersionId = null, SettingsHash = null }; + var ledger = WorkspaceRenders.Empty.With(first).With(second); + project.WriteRenders(ledger); + Assert.FileExists(project.RendersPath); + Assert.Empty(Directory.GetFiles(project.ExportsDirectory, "*.tmp")); + + var read = project.ReadRenders(); + Assert.Equal((WorkspaceRenders.FormatName, 1, 2), (read.Format, read.FormatVersion, read.Entries.Count)); + Assert.Equal(first, read.Entries[0]); + Assert.Equal(second, read.Entries[1]); + Assert.Equal(WorkspaceRenderEntry.Pending, read.Entries[0].State); + Assert.Count(2, read.Unsent); + Assert.Contains("\"state\": \"pending\"", File.ReadAllText(project.RendersPath)); + + // One entry per render id: a send that went home replaces it, a second time changes nothing. + var sent = read.With(first.AsSent(T0.AddMinutes(5))); + Assert.Count(2, sent.Entries); + Assert.True(Assert.NotNull(sent.Find(first.RenderId)).IsSent); + Assert.True(sent.Entries.SequenceEqual(sent.With(first.AsSent(T0.AddMinutes(5))).Entries), "the same send twice changes nothing"); + Assert.True(sent.Unsent.Select(e => e.RenderId).SequenceEqual([second.RenderId]), "only the render not sent is unsent"); + var failed = sent.With(second.AsFailed("The library cannot be reached now.")); + Assert.Equal((WorkspaceRenderEntry.Failed, "The library cannot be reached now."), (failed.Find(second.RenderId)!.State, failed.Find(second.RenderId)!.Error)); + Assert.True(failed.Find(second.RenderId)!.IsUnsent, "a failed send is sent again"); + Assert.Count(1, failed.Without(first.RenderId).Entries); + Assert.Null(failed.Find(Guid.NewGuid())); + + project.WriteRenders(failed); + Assert.True(failed.Entries.SequenceEqual(project.ReadRenders().Entries), "the ledger reads back as written"); + } + + [Test] + public void ALedgerDamagedOrOfANewerChronosIsRefused() + { + var store = new WorkspaceStore(Path.Combine(context.CreateTempDirectory("ws"), "workspace")); + var project = store.Project(Guid.CreateVersion7()); + Directory.CreateDirectory(project.ExportsDirectory); + File.WriteAllText(project.RendersPath, "{ \"format\": \"chronos-workspace-renders\", \"formatVersion\": 1, \"entries\": [ { \"renderId\": "); + Assert.Throws(() => project.ReadRenders()); + File.WriteAllText(project.RendersPath, """{ "format": "something-else", "formatVersion": 1, "entries": [] }"""); + Assert.Throws(() => project.ReadRenders()); + File.WriteAllText(project.RendersPath, """{ "format": "chronos-workspace-renders", "formatVersion": 2, "entries": [] }"""); + Assert.Throws(() => project.ReadRenders()); + // A state a later Chronos wrote counts as not sent: its file is never cleaned up. + var entry = Entry(project.ProjectId, "Roof.mp4") with { State = "queued-elsewhere" }; + project.WriteRenders(WorkspaceRenders.Empty.With(entry)); + Assert.True(project.ReadRenders().Entries.Single().IsUnsent); + } + + [Test] + public void TheWorkspaceJobsCarryTheirParameters() + { + var sequenceId = Guid.CreateVersion7(); + var projectId = Guid.CreateVersion7(); + var versionId = Guid.CreateVersion7(); + var root = Path.Combine(context.CreateTempDirectory("ws"), "workspace"); + + var render = WorkspaceJobs.Render(sequenceId, "Roof", root, projectId, versionId, """{ "presetName": "4K HEVC" }""", "https://studio:8443"); + Assert.Equal((JobKind.WorkspaceRender, "Roof", JobPriority.User), (render.Kind, render.Label, render.Priority)); + Assert.True(render.Targets.SequenceEqual([sequenceId]), "the render targets its sequence"); + var rendered = Assert.NotNull(WorkspaceJobs.RenderParameters(Job(render))); + Assert.Equal(new WorkspaceRenderParameters(root, projectId, versionId, """{ "presetName": "4K HEVC" }""", "https://studio:8443"), rendered); + + var ids = new[] { Guid.CreateVersion7(), Guid.CreateVersion7() }; + var send = WorkspaceJobs.Send(sequenceId, "Roof", root, projectId, ids); + Assert.Equal((JobKind.WorkspaceSend, JobPriority.User), (send.Kind, send.Priority)); + var sending = Assert.NotNull(WorkspaceJobs.SendParameters(Job(send))); + Assert.Equal((root, projectId, (string?)null), (sending.WorkspaceRoot, sending.ProjectId, sending.Server)); + Assert.True(sending.RenderIds.SequenceEqual(ids), "the send names its renders"); + + var target = Path.Combine(context.CreateTempDirectory("fast"), "workspace"); + var move = WorkspaceJobs.Move(root, target, "fingerprint"); + Assert.Equal((JobKind.WorkspaceMove, target, 0), (move.Kind, move.Label, move.Targets.Count)); + Assert.Equal(new WorkspaceMoveParameters(root, target, "fingerprint"), WorkspaceJobs.MoveParameters(Job(move))); + + // Parameters of another kind, or none that read, are none. + Assert.Null(WorkspaceJobs.RenderParameters(Job(send))); + Assert.Null(WorkspaceJobs.MoveParameters(Job(move) with { ParametersJson = "{" })); + Assert.Equal(BundleMedia.Originals, WorkspaceJobs.CopyParameters(Job(WorkspaceJobs.CopyFromServer(sequenceId, "Roof", "https://studio:8443", root, + projectId, BundleMedia.Originals)))!.Media); + Assert.Throws(() => WorkspaceJobs.Move(root, target, " ")); + + static Job Job(ArchiveJobRequest request) => TestData.Job(request.Kind) with { TargetIds = request.Targets, ParametersJson = request.ParametersJson }; + } + + [Test] + public async Task TheWorkspaceRegistersAHandlerForEachOfItsJobs() + { + await using var archive = await ArchiveFixture.CreateAsync(context); + var kinds = new[] { JobKind.WorkspaceCopy, JobKind.WorkspaceRender, JobKind.WorkspaceSend, JobKind.WorkspaceMove }; + var handlers = WorkspaceJobs.CreateHandlers(archive.Db, archive.Service, null, WorkspaceJobOptionsFor()); + Assert.True(handlers.Select(h => h.Kind).SequenceEqual(kinds), string.Join(", ", handlers.Select(h => h.Kind))); + // The overloads of phase 5b register them all too. + Assert.True(WorkspaceJobs.CreateHandlers(archive.Db, archive.Service).Select(h => h.Kind).SequenceEqual(kinds), "the earlier overload"); + + static WorkspaceJobOptions WorkspaceJobOptionsFor() => new(new Chronos.Data.Processing.ProcessingOptions(), () => false); + } +} diff --git a/tests/Chronos.Server.Tests/Storage/UploadTests.cs b/tests/Chronos.Server.Tests/Storage/UploadTests.cs index 2d4afee5..714ca766 100644 --- a/tests/Chronos.Server.Tests/Storage/UploadTests.cs +++ b/tests/Chronos.Server.Tests/Storage/UploadTests.cs @@ -341,6 +341,25 @@ public sealed class UploadTests(TestContext context) Assert.Equal("cancelled", (await state.ReadAsync(ProtocolJson.Default.UploadState)).State); } + [Test] + public void ARenderOfferOfAnEarlierClientReadsWithoutItsProjectAndAWorkspaceOneKeepsIt() + { + // As a client of phase 5b sends it: no project, no version. + var earlier = System.Text.Json.JsonSerializer.Deserialize(""" + { "renderId": "0192a4c1-7b3e-7cc0-8a51-2f9d0e6b1a01", "fileName": "Roof.mp4", "size": 10, "sha256": "ab", "presetName": "4K HEVC", + "codec": "hevc", "width": 3840, "height": 2160, "fps": 30, "durationSeconds": 10 } + """, ProtocolJson.Default.RenderUploadRequest); + Assert.NotNull(earlier); + Assert.Equal(("Roof.mp4", (Guid?)null, (Guid?)null), (earlier.FileName, earlier.ProjectId, earlier.ProjectVersionId)); + var omitted = System.Text.Json.JsonSerializer.Serialize(earlier, ProtocolJson.Default.RenderUploadRequest); + Assert.False(omitted.Contains("projectId", StringComparison.Ordinal), "an offer without a project names none"); + + var workspace = earlier with { ProjectId = Guid.CreateVersion7(), ProjectVersionId = Guid.CreateVersion7() }; + var json = System.Text.Json.JsonSerializer.Serialize(workspace, ProtocolJson.Default.RenderUploadRequest); + Assert.Contains("\"projectVersionId\"", json); + Assert.Equal(workspace, System.Text.Json.JsonSerializer.Deserialize(json, ProtocolJson.Default.RenderUploadRequest)); + } + /// Reports synchronously (Progress<T> posts to the thread pool and may arrive late). private sealed class SyncProgress(Action report) : IProgress {