merge: Titano Uploader (queue, watch folders, tray, resumable uploads)
This commit is contained in:
52 files changed
+6384
-1
No files matched your search
@@ -54,6 +54,43 @@
|
||||
<data name="Tooltips.Shell.CollapseRail" xml:space="preserve"><value>Collapse navigation to icons</value></data>
|
||||
<data name="Tooltips.Shell.ExpandRail" xml:space="preserve"><value>Show navigation names</value></data>
|
||||
<data name="Tooltips.Shell.StopJob" xml:space="preserve"><value>Stop the current job · it can be resumed later</value></data>
|
||||
<data name="Tooltips.Uploader.AddWatchFolder" xml:space="preserve"><value>Add a folder to watch</value></data>
|
||||
<data name="Tooltips.Uploader.Browse" xml:space="preserve"><value>Pick files, a folder or a card</value></data>
|
||||
<data name="Tooltips.Uploader.BrowseFiles" xml:space="preserve"><value>Pick one or more photos</value></data>
|
||||
<data name="Tooltips.Uploader.BrowseFolder" xml:space="preserve"><value>Pick a folder or a card; every photo inside is added</value></data>
|
||||
<data name="Tooltips.Uploader.CancelTrust" xml:space="preserve"><value>Do not connect to this server</value></data>
|
||||
<data name="Tooltips.Uploader.ChooseSequence" xml:space="preserve"><value>Choose the sequence</value></data>
|
||||
<data name="Tooltips.Uploader.CloseSettings" xml:space="preserve"><value>Close settings</value></data>
|
||||
<data name="Tooltips.Uploader.ConfirmDelete" xml:space="preserve"><value>Delete each source file once the server has verified it</value></data>
|
||||
<data name="Tooltips.Uploader.DeleteSource" xml:space="preserve"><value>Delete the local file only after the server has confirmed its hash; asks before turning on</value></data>
|
||||
<data name="Tooltips.Uploader.DiscoveredServer" xml:space="preserve"><value>Titano Server found on this network · click to use it</value></data>
|
||||
<data name="Tooltips.Uploader.Fingerprint" xml:space="preserve"><value>SHA-256 fingerprint of the server certificate</value></data>
|
||||
<data name="Tooltips.Uploader.KeepFiles" xml:space="preserve"><value>Leave source files where they are</value></data>
|
||||
<data name="Tooltips.Uploader.Limit" xml:space="preserve"><value>Bandwidth limit in MB/s; 0 means no limit</value></data>
|
||||
<data name="Tooltips.Uploader.MinimizeToTray" xml:space="preserve"><value>Closing the window keeps the uploader running in the tray</value></data>
|
||||
<data name="Tooltips.Uploader.NewTitle" xml:space="preserve"><value>Title of the new sequence; leave empty to let the server name it</value></data>
|
||||
<data name="Tooltips.Uploader.Password" xml:space="preserve"><value>Your password; only a sign-in token is kept, encrypted for your Windows account</value></data>
|
||||
<data name="Tooltips.Uploader.Pause" xml:space="preserve"><value>Pause; the queue survives a restart</value></data>
|
||||
<data name="Tooltips.Uploader.Quota" xml:space="preserve"><value>Space left in your quota on the server</value></data>
|
||||
<data name="Tooltips.Uploader.RemoveWatchFolder" xml:space="preserve"><value>Stop watching this folder; files already uploaded stay on the server</value></data>
|
||||
<data name="Tooltips.Uploader.Resume" xml:space="preserve"><value>Resume uploading</value></data>
|
||||
<data name="Tooltips.Uploader.Retry" xml:space="preserve"><value>Try again</value></data>
|
||||
<data name="Tooltips.Uploader.RetryItem" xml:space="preserve"><value>Try this file again now</value></data>
|
||||
<data name="Tooltips.Uploader.ServerAddress" xml:space="preserve"><value>Address of the Titano Server, such as https://nas.local:8443</value></data>
|
||||
<data name="Tooltips.Uploader.Settings" xml:space="preserve"><value>Server, sign in, bandwidth, startup, tray</value></data>
|
||||
<data name="Tooltips.Uploader.SignIn" xml:space="preserve"><value>Check the server certificate and sign in</value></data>
|
||||
<data name="Tooltips.Uploader.SignOut" xml:space="preserve"><value>Sign out and forget the saved token</value></data>
|
||||
<data name="Tooltips.Uploader.StartWithWindows" xml:space="preserve"><value>Run when you sign in to Windows</value></data>
|
||||
<data name="Tooltips.Uploader.Stop" xml:space="preserve"><value>Stop and clear the queue; uploaded files stay on the server</value></data>
|
||||
<data name="Tooltips.Uploader.TargetNew" xml:space="preserve"><value>Create one new sequence with a title you type</value></data>
|
||||
<data name="Tooltips.Uploader.TargetSequence" xml:space="preserve"><value>Add every file to one existing sequence</value></data>
|
||||
<data name="Tooltips.Uploader.TargetSessions" xml:space="preserve"><value>The server splits the files into sessions and creates the sequences</value></data>
|
||||
<data name="Tooltips.Uploader.Trust" xml:space="preserve"><value>Remember this certificate; trust it only if the fingerprint matches the one on the server</value></data>
|
||||
<data name="Tooltips.Uploader.User" xml:space="preserve"><value>Your user name on the Titano Server</value></data>
|
||||
<data name="Tooltips.Uploader.WatchFolder" xml:space="preserve"><value>Checked every {0}; a file is uploaded once it has stopped growing · click to change or remove</value></data>
|
||||
<data name="Tooltips.Uploader.WatchFolderMissing" xml:space="preserve"><value>The folder cannot be reached; it is checked again every {0} · click to change or remove</value></data>
|
||||
<data name="Tooltips.Uploader.WatchFolderNetwork" xml:space="preserve"><value>Network share; polled every {0} because change notifications are unreliable on SMB · click to change or remove</value></data>
|
||||
<data name="Tooltips.Uploader.WatchInterval" xml:space="preserve"><value>Check the folder at this interval</value></data>
|
||||
<data name="Tooltips.Window.Close" xml:space="preserve"><value>Close</value></data>
|
||||
<data name="Tooltips.Window.Maximize" xml:space="preserve"><value>Maximize</value></data>
|
||||
<data name="Tooltips.Window.Minimize" xml:space="preserve"><value>Minimize</value></data>
|
||||
|
||||
@@ -0,0 +1,107 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<root>
|
||||
<resheader name="resmimetype"><value>text/microsoft-resx</value></resheader>
|
||||
<resheader name="version"><value>2.0</value></resheader>
|
||||
<resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
|
||||
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
|
||||
<data name="Uploader.Action.AddFolder" xml:space="preserve"><value>Add folder</value></data>
|
||||
<data name="Uploader.Action.Close" xml:space="preserve"><value>Close</value></data>
|
||||
<data name="Uploader.Action.Pause" xml:space="preserve"><value>Pause</value></data>
|
||||
<data name="Uploader.Action.Resume" xml:space="preserve"><value>Resume</value></data>
|
||||
<data name="Uploader.Action.Retry" xml:space="preserve"><value>Retry</value></data>
|
||||
<data name="Uploader.Action.Stop" xml:space="preserve"><value>Stop</value></data>
|
||||
<data name="Uploader.App.Title" xml:space="preserve"><value>Titano Uploader</value><comment>invariant</comment></data>
|
||||
<data name="Uploader.Browse.AllFiles" xml:space="preserve"><value>All files</value></data>
|
||||
<data name="Uploader.Browse.Button" xml:space="preserve"><value>Browse…</value></data>
|
||||
<data name="Uploader.Browse.Files" xml:space="preserve"><value>Files…</value></data>
|
||||
<data name="Uploader.Browse.FilesTitle" xml:space="preserve"><value>Add photos</value></data>
|
||||
<data name="Uploader.Browse.Folder" xml:space="preserve"><value>Folder or card…</value></data>
|
||||
<data name="Uploader.Browse.FolderTitle" xml:space="preserve"><value>Folder or card</value></data>
|
||||
<data name="Uploader.Browse.Photos" xml:space="preserve"><value>Photos</value></data>
|
||||
<data name="Uploader.Browse.WatchTitle" xml:space="preserve"><value>Watch a folder</value></data>
|
||||
<data name="Uploader.Connect.AddressPlaceholder" xml:space="preserve"><value>https://nas.local:8443</value><comment>invariant</comment></data>
|
||||
<data name="Uploader.Connect.Error.BadCredentials" xml:space="preserve"><value>Wrong user name or password.</value><comment>long</comment></data>
|
||||
<data name="Uploader.Connect.Error.Failed" xml:space="preserve"><value>The server reported an error.</value><comment>long</comment></data>
|
||||
<data name="Uploader.Connect.Error.InvalidAddress" xml:space="preserve"><value>Enter an address such as https://nas.local:8443.</value><comment>long</comment></data>
|
||||
<data name="Uploader.Connect.Error.NotTitano" xml:space="preserve"><value>This address is not a Titano Server.</value><comment>long</comment></data>
|
||||
<data name="Uploader.Connect.Error.Unreachable" xml:space="preserve"><value>The server did not answer.</value><comment>long</comment></data>
|
||||
<data name="Uploader.Connect.Error.Untrusted" xml:space="preserve"><value>The server certificate was not trusted.</value><comment>long</comment></data>
|
||||
<data name="Uploader.Connect.Found" xml:space="preserve"><value>Found</value></data>
|
||||
<data name="Uploader.Connect.Password" xml:space="preserve"><value>Password</value></data>
|
||||
<data name="Uploader.Connect.Server" xml:space="preserve"><value>Server</value></data>
|
||||
<data name="Uploader.Connect.SignIn" xml:space="preserve"><value>Sign in</value></data>
|
||||
<data name="Uploader.Connect.Title" xml:space="preserve"><value>Connect to server</value></data>
|
||||
<data name="Uploader.Connect.User" xml:space="preserve"><value>User</value></data>
|
||||
<data name="Uploader.Delete.Accept" xml:space="preserve"><value>Delete after upload</value></data>
|
||||
<data name="Uploader.Delete.Keep" xml:space="preserve"><value>Keep files</value></data>
|
||||
<data name="Uploader.Delete.Message" xml:space="preserve"><value>Each file is deleted from this PC only after the server has verified its hash.</value><comment>long</comment></data>
|
||||
<data name="Uploader.Delete.Title" xml:space="preserve"><value>Delete source files?</value></data>
|
||||
<data name="Uploader.Drop.Message" xml:space="preserve"><value>Drop photos, folders or a card here</value><comment>long</comment></data>
|
||||
<data name="Uploader.Failure.FileChanged" xml:space="preserve"><value>The file changed while it was read.</value><comment>long</comment></data>
|
||||
<data name="Uploader.Failure.FileMissing" xml:space="preserve"><value>The file is no longer there.</value><comment>long</comment></data>
|
||||
<data name="Uploader.Failure.FileUnreadable" xml:space="preserve"><value>The file could not be read.</value><comment>long</comment></data>
|
||||
<data name="Uploader.Failure.ServerRejected" xml:space="preserve"><value>The server refused the file: {0}</value><comment>long</comment></data>
|
||||
<data name="Uploader.Failure.Unexpected" xml:space="preserve"><value>The upload failed; the log has the details.</value><comment>long</comment></data>
|
||||
<data name="Uploader.Header.NotConnected" xml:space="preserve"><value>Not connected</value></data>
|
||||
<data name="Uploader.Header.Quota" xml:space="preserve"><value>{0} free of {1}</value></data>
|
||||
<data name="Uploader.Limit.Label" xml:space="preserve"><value>Limit</value></data>
|
||||
<data name="Uploader.Limit.Unit" xml:space="preserve"><value>MB/s</value><comment>invariant</comment></data>
|
||||
<data name="Uploader.Options.DeleteSource" xml:space="preserve"><value>Delete after upload</value></data>
|
||||
<data name="Uploader.Options.MinimizeToTray" xml:space="preserve"><value>Minimise to tray</value></data>
|
||||
<data name="Uploader.Options.StartWithWindows" xml:space="preserve"><value>Start with Windows</value></data>
|
||||
<data name="Uploader.Progress.Failed" xml:space="preserve"><value>{0:N0} failed</value></data>
|
||||
<data name="Uploader.Progress.Retries.one" xml:space="preserve"><value>{0:N0} retry</value></data>
|
||||
<data name="Uploader.Progress.Retries.other" xml:space="preserve"><value>{0:N0} retries</value></data>
|
||||
<data name="Uploader.Progress.Sent" xml:space="preserve"><value>{0:N0} of {1:N0} sent</value></data>
|
||||
<data name="Uploader.Progress.Verified" xml:space="preserve"><value>{0:N0} verified by the server</value></data>
|
||||
<data name="Uploader.Queue.Done" xml:space="preserve"><value>Done</value></data>
|
||||
<data name="Uploader.Queue.Empty" xml:space="preserve"><value>Nothing queued</value></data>
|
||||
<data name="Uploader.Queue.Files.one" xml:space="preserve"><value>{0:N0} file</value></data>
|
||||
<data name="Uploader.Queue.Files.other" xml:space="preserve"><value>{0:N0} files</value></data>
|
||||
<data name="Uploader.Queue.Label" xml:space="preserve"><value>Queue</value></data>
|
||||
<data name="Uploader.Queue.Left" xml:space="preserve"><value>{0} left</value></data>
|
||||
<data name="Uploader.Queue.Paused" xml:space="preserve"><value>Paused</value></data>
|
||||
<data name="Uploader.Queue.Waiting" xml:space="preserve"><value>Waiting for server</value></data>
|
||||
<data name="Uploader.Settings.Bandwidth" xml:space="preserve"><value>Bandwidth</value></data>
|
||||
<data name="Uploader.Settings.Files" xml:space="preserve"><value>Files</value></data>
|
||||
<data name="Uploader.Settings.Server" xml:space="preserve"><value>Server</value></data>
|
||||
<data name="Uploader.Settings.SignOut" xml:space="preserve"><value>Sign out</value></data>
|
||||
<data name="Uploader.Settings.Startup" xml:space="preserve"><value>Startup</value></data>
|
||||
<data name="Uploader.Settings.Title" xml:space="preserve"><value>Settings</value></data>
|
||||
<data name="Uploader.Settings.User" xml:space="preserve"><value>User</value></data>
|
||||
<data name="Uploader.State.Failed" xml:space="preserve"><value>Failed</value></data>
|
||||
<data name="Uploader.State.Hashing" xml:space="preserve"><value>Hashing</value></data>
|
||||
<data name="Uploader.State.Queued" xml:space="preserve"><value>Queued</value></data>
|
||||
<data name="Uploader.State.Skipped" xml:space="preserve"><value>On server</value></data>
|
||||
<data name="Uploader.State.Uploading" xml:space="preserve"><value>Uploading</value></data>
|
||||
<data name="Uploader.State.Verified" xml:space="preserve"><value>Verified</value></data>
|
||||
<data name="Uploader.Status.Connected" xml:space="preserve"><value>Connected</value></data>
|
||||
<data name="Uploader.Status.Offline" xml:space="preserve"><value>Offline</value></data>
|
||||
<data name="Uploader.Status.SignedOut" xml:space="preserve"><value>Signed out</value></data>
|
||||
<data name="Uploader.Status.SigningIn" xml:space="preserve"><value>Signing in</value></data>
|
||||
<data name="Uploader.Target.Label" xml:space="preserve"><value>Target</value></data>
|
||||
<data name="Uploader.Target.New" xml:space="preserve"><value>New</value></data>
|
||||
<data name="Uploader.Target.Sequence" xml:space="preserve"><value>Sequence</value></data>
|
||||
<data name="Uploader.Target.Sessions" xml:space="preserve"><value>Group into sessions</value></data>
|
||||
<data name="Uploader.Target.TitlePlaceholder" xml:space="preserve"><value>Title</value></data>
|
||||
<data name="Uploader.Toast.Added.one" xml:space="preserve"><value>{0:N0} file added</value></data>
|
||||
<data name="Uploader.Toast.Added.other" xml:space="preserve"><value>{0:N0} files added</value></data>
|
||||
<data name="Uploader.Toast.CertificateChanged" xml:space="preserve"><value>The server certificate changed.</value><comment>long</comment></data>
|
||||
<data name="Uploader.Toast.ChooseSequence" xml:space="preserve"><value>Choose a sequence first.</value></data>
|
||||
<data name="Uploader.Toast.NothingFound" xml:space="preserve"><value>No new photos were found there.</value><comment>long</comment></data>
|
||||
<data name="Uploader.Toast.SignedOut" xml:space="preserve"><value>The server ended the session.</value><comment>long</comment></data>
|
||||
<data name="Uploader.Tray.Done.Message.one" xml:space="preserve"><value>{0:N0} file verified by the server</value><comment>long</comment></data>
|
||||
<data name="Uploader.Tray.Done.Message.other" xml:space="preserve"><value>{0:N0} files verified by the server</value><comment>long</comment></data>
|
||||
<data name="Uploader.Tray.Done.Title" xml:space="preserve"><value>Upload complete</value></data>
|
||||
<data name="Uploader.Tray.Exit" xml:space="preserve"><value>Exit</value></data>
|
||||
<data name="Uploader.Tray.Show" xml:space="preserve"><value>Show</value></data>
|
||||
<data name="Uploader.Trust.Accept" xml:space="preserve"><value>Trust</value></data>
|
||||
<data name="Uploader.Trust.Cancel" xml:space="preserve"><value>Cancel</value></data>
|
||||
<data name="Uploader.Trust.Message" xml:space="preserve"><value>Compare this fingerprint with the one shown on the server.</value><comment>long</comment></data>
|
||||
<data name="Uploader.Trust.Title" xml:space="preserve"><value>Trust this server?</value></data>
|
||||
<data name="Uploader.Unit.PerSecond" xml:space="preserve"><value>{0}/s</value></data>
|
||||
<data name="Uploader.Watch.Chip" xml:space="preserve"><value>{0} · every {1}</value></data>
|
||||
<data name="Uploader.Watch.Every" xml:space="preserve"><value>Every {0}</value></data>
|
||||
<data name="Uploader.Watch.Label" xml:space="preserve"><value>Watch folders</value></data>
|
||||
<data name="Uploader.Watch.Remove" xml:space="preserve"><value>Remove</value></data>
|
||||
</root>
|
||||
@@ -54,6 +54,43 @@
|
||||
<data name="Tooltips.Shell.CollapseRail" xml:space="preserve"><value>Riduci la navigazione alle icone</value></data>
|
||||
<data name="Tooltips.Shell.ExpandRail" xml:space="preserve"><value>Mostra i nomi della navigazione</value></data>
|
||||
<data name="Tooltips.Shell.StopJob" xml:space="preserve"><value>Ferma l'attività in corso · potrai riprenderla</value></data>
|
||||
<data name="Tooltips.Uploader.AddWatchFolder" xml:space="preserve"><value>Aggiungi una cartella da controllare</value></data>
|
||||
<data name="Tooltips.Uploader.Browse" xml:space="preserve"><value>Scegli file, una cartella o una scheda</value></data>
|
||||
<data name="Tooltips.Uploader.BrowseFiles" xml:space="preserve"><value>Scegli una o più foto</value></data>
|
||||
<data name="Tooltips.Uploader.BrowseFolder" xml:space="preserve"><value>Scegli una cartella o una scheda; vengono aggiunte tutte le foto contenute</value></data>
|
||||
<data name="Tooltips.Uploader.CancelTrust" xml:space="preserve"><value>Non connetterti a questo server</value></data>
|
||||
<data name="Tooltips.Uploader.ChooseSequence" xml:space="preserve"><value>Scegli la sequenza</value></data>
|
||||
<data name="Tooltips.Uploader.CloseSettings" xml:space="preserve"><value>Chiudi le impostazioni</value></data>
|
||||
<data name="Tooltips.Uploader.ConfirmDelete" xml:space="preserve"><value>Elimina ogni file originale dopo la verifica del server</value></data>
|
||||
<data name="Tooltips.Uploader.DeleteSource" xml:space="preserve"><value>Elimina il file locale solo dopo che il server ne ha confermato l'hash; chiede conferma prima di attivarsi</value></data>
|
||||
<data name="Tooltips.Uploader.DiscoveredServer" xml:space="preserve"><value>Titano Server trovato in questa rete · fai clic per usarlo</value></data>
|
||||
<data name="Tooltips.Uploader.Fingerprint" xml:space="preserve"><value>Impronta SHA-256 del certificato del server</value></data>
|
||||
<data name="Tooltips.Uploader.KeepFiles" xml:space="preserve"><value>Lascia i file originali dove sono</value></data>
|
||||
<data name="Tooltips.Uploader.Limit" xml:space="preserve"><value>Limite di banda in MB/s; 0 significa nessun limite</value></data>
|
||||
<data name="Tooltips.Uploader.MinimizeToTray" xml:space="preserve"><value>Chiudendo la finestra l'uploader resta attivo nell'area di notifica</value></data>
|
||||
<data name="Tooltips.Uploader.NewTitle" xml:space="preserve"><value>Titolo della nuova sequenza; lascialo vuoto per farlo scegliere al server</value></data>
|
||||
<data name="Tooltips.Uploader.Password" xml:space="preserve"><value>La tua password; viene conservato solo un token di accesso, cifrato per il tuo account Windows</value></data>
|
||||
<data name="Tooltips.Uploader.Pause" xml:space="preserve"><value>Metti in pausa; la coda sopravvive a un riavvio</value></data>
|
||||
<data name="Tooltips.Uploader.Quota" xml:space="preserve"><value>Spazio rimasto nella tua quota sul server</value></data>
|
||||
<data name="Tooltips.Uploader.RemoveWatchFolder" xml:space="preserve"><value>Smetti di controllare questa cartella; i file già inviati restano sul server</value></data>
|
||||
<data name="Tooltips.Uploader.Resume" xml:space="preserve"><value>Riprendi l'invio</value></data>
|
||||
<data name="Tooltips.Uploader.Retry" xml:space="preserve"><value>Riprova</value></data>
|
||||
<data name="Tooltips.Uploader.RetryItem" xml:space="preserve"><value>Riprova subito questo file</value></data>
|
||||
<data name="Tooltips.Uploader.ServerAddress" xml:space="preserve"><value>Indirizzo del Titano Server, ad esempio https://nas.local:8443</value></data>
|
||||
<data name="Tooltips.Uploader.Settings" xml:space="preserve"><value>Server, accesso, banda, avvio, area di notifica</value></data>
|
||||
<data name="Tooltips.Uploader.SignIn" xml:space="preserve"><value>Controlla il certificato del server e accedi</value></data>
|
||||
<data name="Tooltips.Uploader.SignOut" xml:space="preserve"><value>Esci e dimentica il token salvato</value></data>
|
||||
<data name="Tooltips.Uploader.StartWithWindows" xml:space="preserve"><value>Avvia quando accedi a Windows</value></data>
|
||||
<data name="Tooltips.Uploader.Stop" xml:space="preserve"><value>Ferma e svuota la coda; i file inviati restano sul server</value></data>
|
||||
<data name="Tooltips.Uploader.TargetNew" xml:space="preserve"><value>Crea una nuova sequenza con il titolo che scrivi</value></data>
|
||||
<data name="Tooltips.Uploader.TargetSequence" xml:space="preserve"><value>Aggiungi tutti i file a una sequenza esistente</value></data>
|
||||
<data name="Tooltips.Uploader.TargetSessions" xml:space="preserve"><value>Il server divide i file in sessioni e crea le sequenze</value></data>
|
||||
<data name="Tooltips.Uploader.Trust" xml:space="preserve"><value>Ricorda questo certificato; accettalo solo se l'impronta coincide con quella sul server</value></data>
|
||||
<data name="Tooltips.Uploader.User" xml:space="preserve"><value>Il tuo nome utente sul Titano Server</value></data>
|
||||
<data name="Tooltips.Uploader.WatchFolder" xml:space="preserve"><value>Controllata ogni {0}; un file viene inviato quando smette di crescere · fai clic per modificare o rimuovere</value></data>
|
||||
<data name="Tooltips.Uploader.WatchFolderMissing" xml:space="preserve"><value>La cartella non è raggiungibile; viene ricontrollata ogni {0} · fai clic per modificare o rimuovere</value></data>
|
||||
<data name="Tooltips.Uploader.WatchFolderNetwork" xml:space="preserve"><value>Condivisione di rete; controllata ogni {0} perché le notifiche di modifica non sono affidabili su SMB · fai clic per modificare o rimuovere</value></data>
|
||||
<data name="Tooltips.Uploader.WatchInterval" xml:space="preserve"><value>Controlla la cartella con questo intervallo</value></data>
|
||||
<data name="Tooltips.Window.Close" xml:space="preserve"><value>Chiudi</value></data>
|
||||
<data name="Tooltips.Window.Maximize" xml:space="preserve"><value>Ingrandisci</value></data>
|
||||
<data name="Tooltips.Window.Minimize" xml:space="preserve"><value>Riduci a icona</value></data>
|
||||
|
||||
@@ -0,0 +1,104 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<root>
|
||||
<resheader name="resmimetype"><value>text/microsoft-resx</value></resheader>
|
||||
<resheader name="version"><value>2.0</value></resheader>
|
||||
<resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
|
||||
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
|
||||
<data name="Uploader.Action.AddFolder" xml:space="preserve"><value>Aggiungi cartella</value></data>
|
||||
<data name="Uploader.Action.Close" xml:space="preserve"><value>Chiudi</value></data>
|
||||
<data name="Uploader.Action.Pause" xml:space="preserve"><value>Pausa</value></data>
|
||||
<data name="Uploader.Action.Resume" xml:space="preserve"><value>Riprendi</value></data>
|
||||
<data name="Uploader.Action.Retry" xml:space="preserve"><value>Riprova</value></data>
|
||||
<data name="Uploader.Action.Stop" xml:space="preserve"><value>Ferma</value></data>
|
||||
<data name="Uploader.Browse.AllFiles" xml:space="preserve"><value>Tutti i file</value></data>
|
||||
<data name="Uploader.Browse.Button" xml:space="preserve"><value>Sfoglia…</value></data>
|
||||
<data name="Uploader.Browse.Files" xml:space="preserve"><value>File…</value></data>
|
||||
<data name="Uploader.Browse.FilesTitle" xml:space="preserve"><value>Aggiungi foto</value></data>
|
||||
<data name="Uploader.Browse.Folder" xml:space="preserve"><value>Cartella o scheda…</value></data>
|
||||
<data name="Uploader.Browse.FolderTitle" xml:space="preserve"><value>Cartella o scheda</value></data>
|
||||
<data name="Uploader.Browse.Photos" xml:space="preserve"><value>Foto</value></data>
|
||||
<data name="Uploader.Browse.WatchTitle" xml:space="preserve"><value>Controlla una cartella</value></data>
|
||||
<data name="Uploader.Connect.Error.BadCredentials" xml:space="preserve"><value>Nome utente o password errati.</value></data>
|
||||
<data name="Uploader.Connect.Error.Failed" xml:space="preserve"><value>Il server ha segnalato un errore.</value></data>
|
||||
<data name="Uploader.Connect.Error.InvalidAddress" xml:space="preserve"><value>Inserisci un indirizzo come https://nas.local:8443.</value></data>
|
||||
<data name="Uploader.Connect.Error.NotTitano" xml:space="preserve"><value>Questo indirizzo non è un Titano Server.</value></data>
|
||||
<data name="Uploader.Connect.Error.Unreachable" xml:space="preserve"><value>Il server non ha risposto.</value></data>
|
||||
<data name="Uploader.Connect.Error.Untrusted" xml:space="preserve"><value>Il certificato del server non è stato accettato.</value></data>
|
||||
<data name="Uploader.Connect.Found" xml:space="preserve"><value>Trovati</value></data>
|
||||
<data name="Uploader.Connect.Password" xml:space="preserve"><value>Password</value></data>
|
||||
<data name="Uploader.Connect.Server" xml:space="preserve"><value>Server</value></data>
|
||||
<data name="Uploader.Connect.SignIn" xml:space="preserve"><value>Accedi</value></data>
|
||||
<data name="Uploader.Connect.Title" xml:space="preserve"><value>Connetti al server</value></data>
|
||||
<data name="Uploader.Connect.User" xml:space="preserve"><value>Utente</value></data>
|
||||
<data name="Uploader.Delete.Accept" xml:space="preserve"><value>Elimina dopo l'invio</value></data>
|
||||
<data name="Uploader.Delete.Keep" xml:space="preserve"><value>Mantieni i file</value></data>
|
||||
<data name="Uploader.Delete.Message" xml:space="preserve"><value>Ogni file viene eliminato da questo PC solo dopo che il server ne ha verificato l'hash.</value></data>
|
||||
<data name="Uploader.Delete.Title" xml:space="preserve"><value>Eliminare i file originali?</value></data>
|
||||
<data name="Uploader.Drop.Message" xml:space="preserve"><value>Trascina qui foto, cartelle o una scheda</value></data>
|
||||
<data name="Uploader.Failure.FileChanged" xml:space="preserve"><value>Il file è cambiato durante la lettura.</value></data>
|
||||
<data name="Uploader.Failure.FileMissing" xml:space="preserve"><value>Il file non c'è più.</value></data>
|
||||
<data name="Uploader.Failure.FileUnreadable" xml:space="preserve"><value>Impossibile leggere il file.</value></data>
|
||||
<data name="Uploader.Failure.ServerRejected" xml:space="preserve"><value>Il server ha rifiutato il file: {0}</value></data>
|
||||
<data name="Uploader.Failure.Unexpected" xml:space="preserve"><value>Invio non riuscito; i dettagli sono nel log.</value></data>
|
||||
<data name="Uploader.Header.NotConnected" xml:space="preserve"><value>Non connesso</value></data>
|
||||
<data name="Uploader.Header.Quota" xml:space="preserve"><value>{0} liberi su {1}</value></data>
|
||||
<data name="Uploader.Limit.Label" xml:space="preserve"><value>Limite</value></data>
|
||||
<data name="Uploader.Options.DeleteSource" xml:space="preserve"><value>Elimina dopo l'invio</value></data>
|
||||
<data name="Uploader.Options.MinimizeToTray" xml:space="preserve"><value>Riduci nell'area notifiche</value></data>
|
||||
<data name="Uploader.Options.StartWithWindows" xml:space="preserve"><value>Avvia con Windows</value></data>
|
||||
<data name="Uploader.Progress.Failed" xml:space="preserve"><value>{0:N0} non riusciti</value></data>
|
||||
<data name="Uploader.Progress.Retries.one" xml:space="preserve"><value>{0:N0} nuovo tentativo</value></data>
|
||||
<data name="Uploader.Progress.Retries.other" xml:space="preserve"><value>{0:N0} nuovi tentativi</value></data>
|
||||
<data name="Uploader.Progress.Sent" xml:space="preserve"><value>{0:N0} di {1:N0} inviati</value></data>
|
||||
<data name="Uploader.Progress.Verified" xml:space="preserve"><value>{0:N0} verificati dal server</value></data>
|
||||
<data name="Uploader.Queue.Done" xml:space="preserve"><value>Completato</value></data>
|
||||
<data name="Uploader.Queue.Empty" xml:space="preserve"><value>Coda vuota</value></data>
|
||||
<data name="Uploader.Queue.Files.one" xml:space="preserve"><value>{0:N0} file</value></data>
|
||||
<data name="Uploader.Queue.Files.other" xml:space="preserve"><value>{0:N0} file</value></data>
|
||||
<data name="Uploader.Queue.Label" xml:space="preserve"><value>Coda</value></data>
|
||||
<data name="Uploader.Queue.Left" xml:space="preserve"><value>mancano {0}</value></data>
|
||||
<data name="Uploader.Queue.Paused" xml:space="preserve"><value>In pausa</value></data>
|
||||
<data name="Uploader.Queue.Waiting" xml:space="preserve"><value>In attesa del server</value></data>
|
||||
<data name="Uploader.Settings.Bandwidth" xml:space="preserve"><value>Banda</value></data>
|
||||
<data name="Uploader.Settings.Files" xml:space="preserve"><value>File</value></data>
|
||||
<data name="Uploader.Settings.Server" xml:space="preserve"><value>Server</value></data>
|
||||
<data name="Uploader.Settings.SignOut" xml:space="preserve"><value>Esci</value></data>
|
||||
<data name="Uploader.Settings.Startup" xml:space="preserve"><value>Avvio</value></data>
|
||||
<data name="Uploader.Settings.Title" xml:space="preserve"><value>Impostazioni</value></data>
|
||||
<data name="Uploader.Settings.User" xml:space="preserve"><value>Utente</value></data>
|
||||
<data name="Uploader.State.Failed" xml:space="preserve"><value>Non riuscito</value></data>
|
||||
<data name="Uploader.State.Hashing" xml:space="preserve"><value>Calcolo hash</value></data>
|
||||
<data name="Uploader.State.Queued" xml:space="preserve"><value>In coda</value></data>
|
||||
<data name="Uploader.State.Skipped" xml:space="preserve"><value>Già sul server</value></data>
|
||||
<data name="Uploader.State.Uploading" xml:space="preserve"><value>Invio</value></data>
|
||||
<data name="Uploader.State.Verified" xml:space="preserve"><value>Verificato</value></data>
|
||||
<data name="Uploader.Status.Connected" xml:space="preserve"><value>Connesso</value></data>
|
||||
<data name="Uploader.Status.Offline" xml:space="preserve"><value>Non in linea</value></data>
|
||||
<data name="Uploader.Status.SignedOut" xml:space="preserve"><value>Disconnesso</value></data>
|
||||
<data name="Uploader.Status.SigningIn" xml:space="preserve"><value>Accesso in corso</value></data>
|
||||
<data name="Uploader.Target.Label" xml:space="preserve"><value>Destinazione</value></data>
|
||||
<data name="Uploader.Target.New" xml:space="preserve"><value>Nuova</value></data>
|
||||
<data name="Uploader.Target.Sequence" xml:space="preserve"><value>Sequenza</value></data>
|
||||
<data name="Uploader.Target.Sessions" xml:space="preserve"><value>Raggruppa in sessioni</value></data>
|
||||
<data name="Uploader.Target.TitlePlaceholder" xml:space="preserve"><value>Titolo</value></data>
|
||||
<data name="Uploader.Toast.Added.one" xml:space="preserve"><value>{0:N0} file aggiunto</value></data>
|
||||
<data name="Uploader.Toast.Added.other" xml:space="preserve"><value>{0:N0} file aggiunti</value></data>
|
||||
<data name="Uploader.Toast.CertificateChanged" xml:space="preserve"><value>Il certificato del server è cambiato.</value></data>
|
||||
<data name="Uploader.Toast.ChooseSequence" xml:space="preserve"><value>Scegli prima una sequenza.</value></data>
|
||||
<data name="Uploader.Toast.NothingFound" xml:space="preserve"><value>Nessuna nuova foto trovata.</value></data>
|
||||
<data name="Uploader.Toast.SignedOut" xml:space="preserve"><value>Il server ha chiuso la sessione.</value></data>
|
||||
<data name="Uploader.Tray.Done.Message.one" xml:space="preserve"><value>{0:N0} file verificato dal server</value></data>
|
||||
<data name="Uploader.Tray.Done.Message.other" xml:space="preserve"><value>{0:N0} file verificati dal server</value></data>
|
||||
<data name="Uploader.Tray.Done.Title" xml:space="preserve"><value>Invio completato</value></data>
|
||||
<data name="Uploader.Tray.Exit" xml:space="preserve"><value>Esci</value></data>
|
||||
<data name="Uploader.Tray.Show" xml:space="preserve"><value>Mostra</value></data>
|
||||
<data name="Uploader.Trust.Accept" xml:space="preserve"><value>Accetta</value></data>
|
||||
<data name="Uploader.Trust.Cancel" xml:space="preserve"><value>Annulla</value></data>
|
||||
<data name="Uploader.Trust.Message" xml:space="preserve"><value>Confronta questa impronta con quella mostrata sul server.</value></data>
|
||||
<data name="Uploader.Trust.Title" xml:space="preserve"><value>Accettare questo server?</value></data>
|
||||
<data name="Uploader.Unit.PerSecond" xml:space="preserve"><value>{0}/s</value></data>
|
||||
<data name="Uploader.Watch.Chip" xml:space="preserve"><value>{0} · ogni {1}</value></data>
|
||||
<data name="Uploader.Watch.Every" xml:space="preserve"><value>Ogni {0}</value></data>
|
||||
<data name="Uploader.Watch.Label" xml:space="preserve"><value>Cartelle controllate</value></data>
|
||||
<data name="Uploader.Watch.Remove" xml:space="preserve"><value>Rimuovi</value></data>
|
||||
</root>
|
||||
@@ -1,4 +1,5 @@
|
||||
<Application x:Class="Titano.Uploader.App"
|
||||
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
|
||||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
|
||||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
|
||||
ShutdownMode="OnExplicitShutdown">
|
||||
</Application>
|
||||
@@ -1,7 +1,345 @@
|
||||
using System.ComponentModel;
|
||||
using System.Globalization;
|
||||
using System.IO;
|
||||
using System.Windows;
|
||||
using System.Windows.Threading;
|
||||
using Titano.Core.Diagnostics;
|
||||
using Titano.Core.Localization;
|
||||
using Titano.Ui.Mvvm;
|
||||
using Titano.Ui.Theming;
|
||||
using Titano.Uploader.DesignTime;
|
||||
using Titano.Uploader.Infrastructure;
|
||||
using Titano.Uploader.Interop;
|
||||
using Titano.Uploader.Server;
|
||||
using Titano.Uploader.Shell;
|
||||
using Titano.Uploader.Uploads;
|
||||
using Titano.Uploader.Watching;
|
||||
|
||||
namespace Titano.Uploader;
|
||||
|
||||
/// <summary>
|
||||
/// Titano Uploader (BRIEF §15): one instance per session, logging, language and theme, the persisted queue, the
|
||||
/// server session, watch folders and the tray icon. <c>--capture <dir></c> renders screenshots and exits.
|
||||
/// </summary>
|
||||
public partial class App : Application
|
||||
{
|
||||
private const int TrayShow = 1;
|
||||
private const int TrayPause = 2;
|
||||
private const int TrayExit = 3;
|
||||
|
||||
private readonly CoalescingWriter _writer = new();
|
||||
private FileLogSink? _log;
|
||||
private SingleInstance? _instance;
|
||||
private UploaderEnvironment? _environment;
|
||||
private UploaderSettings? _settings;
|
||||
private UploadQueue? _queue;
|
||||
private ProcessedFileMemory? _memory;
|
||||
private ServerSession? _session;
|
||||
private UploadEngine? _engine;
|
||||
private WatchFolderService? _watch;
|
||||
private DiscoveryListener? _discovery;
|
||||
private MainViewModel? _vm;
|
||||
private Shell.MainWindow? _window;
|
||||
private TrayIcon? _tray;
|
||||
private DispatcherTimer? _persist;
|
||||
private bool _queueDirty;
|
||||
private bool _exiting;
|
||||
|
||||
protected override void OnStartup(StartupEventArgs e)
|
||||
{
|
||||
base.OnStartup(e);
|
||||
var command = CommandLine.Parse(e.Args);
|
||||
_environment = UploaderEnvironment.Detect();
|
||||
_log = new FileLogSink(_environment.LogDirectory, "uploader");
|
||||
Log.SetSink(_log);
|
||||
Log.Info("app", $"Titano Uploader {typeof(App).Assembly.GetName().Version} starting; data at {_environment.DataDirectory}");
|
||||
HookUnhandledExceptions();
|
||||
|
||||
if (command.CaptureDirectory is { } captureDirectory)
|
||||
{
|
||||
RunCapture(captureDirectory);
|
||||
return;
|
||||
}
|
||||
|
||||
_instance = SingleInstance.TryAcquire();
|
||||
if (_instance is null)
|
||||
{
|
||||
SingleInstance.HandOver([.. command.Paths.Select(Absolute).OfType<string>()]);
|
||||
Log.Info("app", "Another uploader runs in this session; arguments handed over");
|
||||
Shutdown();
|
||||
return;
|
||||
}
|
||||
|
||||
_settings = UploaderSettings.Load(_environment.SettingsPath);
|
||||
ApplyLanguage(_settings.Language);
|
||||
ThemeManager.Initialize(this, _settings.Theme);
|
||||
BuildServices(_environment, _settings);
|
||||
|
||||
_instance.Listen(args => Dispatcher.BeginInvoke(() => OnHandOver(args)));
|
||||
_session!.Start();
|
||||
_engine!.Start();
|
||||
_vm!.Start();
|
||||
_vm.StartWatching();
|
||||
UpdateTray();
|
||||
UpdateDiscovery();
|
||||
if (command.Paths.Count > 0) _ = _vm.EnqueueAsync(command.Paths);
|
||||
|
||||
if (command.StartInTray && _settings.MinimizeToTray) return;
|
||||
if (command.StartInTray) _window!.WindowState = WindowState.Minimized;
|
||||
_window!.Show();
|
||||
}
|
||||
|
||||
protected override void OnExit(ExitEventArgs e)
|
||||
{
|
||||
_persist?.Stop();
|
||||
_vm?.Dispose();
|
||||
// Cancels transfers; interrupted items are written as queued and resume from the server's chunks.
|
||||
_engine?.Dispose();
|
||||
if (_queue is not null && _environment is not null)
|
||||
{
|
||||
Persist();
|
||||
_writer.Flush(TimeSpan.FromSeconds(10));
|
||||
}
|
||||
if (_window is not null && _settings is not null) _window.SavePlacement();
|
||||
SaveSettings();
|
||||
_watch?.Dispose();
|
||||
_discovery?.Dispose();
|
||||
_session?.Dispose();
|
||||
_tray?.Dispose();
|
||||
_instance?.Dispose();
|
||||
Log.Info("app", "Titano Uploader exiting");
|
||||
_log?.Dispose();
|
||||
base.OnExit(e);
|
||||
}
|
||||
|
||||
private void BuildServices(UploaderEnvironment environment, UploaderSettings settings)
|
||||
{
|
||||
_queue = new UploadQueue();
|
||||
QueueStore.Load(environment.QueuePath, _queue);
|
||||
_memory = ProcessedFileMemory.Load(environment.WatchMemoryPath);
|
||||
_session = new ServerSession(settings, SaveSettings);
|
||||
_engine = new UploadEngine(_queue, _session, () => settings.DeleteAfterUpload);
|
||||
_watch = new WatchFolderService(_memory, _queue.ContainsPath);
|
||||
var startup = new RunKeyStartupRegistration();
|
||||
startup.Refresh();
|
||||
var dialogs = new UploaderDialogs();
|
||||
_vm = new MainViewModel(new UploaderServices(settings, SaveSettings, _session, _queue, _engine, startup, dialogs, _watch, _memory, environment.LogDirectory));
|
||||
_window = new Shell.MainWindow(_vm, settings);
|
||||
dialogs.Owner = _window;
|
||||
MainWindow = _window;
|
||||
|
||||
AsyncRelayCommand.Failed += _vm.ReportError;
|
||||
_engine.ItemConfirmed += (_, item) =>
|
||||
{
|
||||
if (item.WatchRoot is { } root) _memory.Add(root, item.Path, item.Size, item.ModifiedUtc);
|
||||
};
|
||||
_watch.FilesReady += _vm.OnWatchFilesReady;
|
||||
_watch.AvailabilityChanged += _vm.OnWatchAvailabilityChanged;
|
||||
_queue.Changed += (_, _) => _queueDirty = true;
|
||||
_vm.UploadsCompleted += OnUploadsCompleted;
|
||||
_vm.PropertyChanged += OnViewModelChanged;
|
||||
_window.Closing += OnWindowClosing;
|
||||
_window.Closed += (_, _) => ExitApplication();
|
||||
_window.StateChanged += OnWindowStateChanged;
|
||||
_persist = new DispatcherTimer(DispatcherPriority.Background) { Interval = TimeSpan.FromSeconds(2) };
|
||||
_persist.Tick += (_, _) => Persist();
|
||||
_persist.Start();
|
||||
}
|
||||
|
||||
/// <summary>Switches the UI language (BRIEF §16); an unknown code falls back to the OS language.</summary>
|
||||
private static void ApplyLanguage(string? code)
|
||||
{
|
||||
CultureInfo requested;
|
||||
try
|
||||
{
|
||||
requested = code is null ? CultureInfo.CurrentUICulture : CultureInfo.GetCultureInfo(code);
|
||||
}
|
||||
catch (CultureNotFoundException)
|
||||
{
|
||||
requested = CultureInfo.CurrentUICulture;
|
||||
}
|
||||
var culture = Languages.BestMatch(requested);
|
||||
CultureInfo.DefaultThreadCurrentUICulture = culture;
|
||||
CultureInfo.CurrentUICulture = culture;
|
||||
Loc.SetCulture(culture);
|
||||
}
|
||||
|
||||
/// <summary>Writes the queue and the watch memory when they changed (every 2 s and at exit).</summary>
|
||||
private void Persist()
|
||||
{
|
||||
if (_queue is null || _memory is null || _environment is null) return;
|
||||
if (_queueDirty)
|
||||
{
|
||||
_queueDirty = false;
|
||||
_writer.Write(_environment.QueuePath, QueueStore.Serialize(_queue));
|
||||
}
|
||||
if (_memory.IsDirty) _writer.Write(_environment.WatchMemoryPath, _memory.Serialize());
|
||||
}
|
||||
|
||||
private void SaveSettings()
|
||||
{
|
||||
if (_settings is null || _environment is null) return;
|
||||
try
|
||||
{
|
||||
_settings.Save(_environment.SettingsPath);
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
||||
{
|
||||
Log.Warning("app", "Settings not saved", ex);
|
||||
}
|
||||
}
|
||||
|
||||
private void OnHandOver(IReadOnlyList<string> paths)
|
||||
{
|
||||
ShowWindow();
|
||||
if (paths.Count > 0) _ = _vm!.EnqueueAsync(paths);
|
||||
}
|
||||
|
||||
private void OnViewModelChanged(object? sender, PropertyChangedEventArgs e)
|
||||
{
|
||||
switch (e.PropertyName)
|
||||
{
|
||||
case nameof(MainViewModel.MinimizeToTray):
|
||||
UpdateTray();
|
||||
break;
|
||||
case nameof(MainViewModel.IsConnectVisible):
|
||||
UpdateDiscovery();
|
||||
break;
|
||||
case nameof(MainViewModel.TrayText):
|
||||
_tray?.SetToolTip(_vm!.TrayText);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>The tray icon exists while "Minimise to tray" is on.</summary>
|
||||
private void UpdateTray()
|
||||
{
|
||||
if (_settings!.MinimizeToTray && _tray is null)
|
||||
{
|
||||
_tray = new TrayIcon(_vm!.TrayText, TrayMenu, OnTrayCommand, ShowWindow);
|
||||
}
|
||||
else if (!_settings.MinimizeToTray && _tray is not null)
|
||||
{
|
||||
_tray.Dispose();
|
||||
_tray = null;
|
||||
if (_window is { IsVisible: false }) ShowWindow();
|
||||
}
|
||||
}
|
||||
|
||||
private IReadOnlyList<TrayMenuItem> TrayMenu() =>
|
||||
[
|
||||
new(TrayShow, Loc.L("Uploader.Tray.Show")),
|
||||
new(TrayPause, _vm!.PauseLabel),
|
||||
new(0, null),
|
||||
new(TrayExit, Loc.L("Uploader.Tray.Exit")),
|
||||
];
|
||||
|
||||
private void OnTrayCommand(int id)
|
||||
{
|
||||
switch (id)
|
||||
{
|
||||
case TrayShow:
|
||||
ShowWindow();
|
||||
break;
|
||||
case TrayPause:
|
||||
_vm!.TogglePause();
|
||||
break;
|
||||
case TrayExit:
|
||||
ExitApplication();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Listens for server beacons only while the sign-in form is shown.</summary>
|
||||
private void UpdateDiscovery()
|
||||
{
|
||||
if (_vm!.IsConnectVisible)
|
||||
{
|
||||
if (_discovery is not null) return;
|
||||
_discovery = new DiscoveryListener();
|
||||
_discovery.Found += _vm.Connect.AddDiscovered;
|
||||
_discovery.Start();
|
||||
}
|
||||
else if (_discovery is not null)
|
||||
{
|
||||
_discovery.Dispose();
|
||||
_discovery = null;
|
||||
}
|
||||
}
|
||||
|
||||
private void OnUploadsCompleted(int count)
|
||||
{
|
||||
if (_window is { IsVisible: true, WindowState: not WindowState.Minimized }) return;
|
||||
_tray?.ShowBalloon(Loc.L("Uploader.Tray.Done.Title"), Loc.Plural("Uploader.Tray.Done.Message", count));
|
||||
}
|
||||
|
||||
/// <summary>Closing keeps the uploader running in the tray when "Minimise to tray" is on.</summary>
|
||||
private void OnWindowClosing(object? sender, CancelEventArgs e)
|
||||
{
|
||||
if (_exiting || !_settings!.MinimizeToTray) return;
|
||||
e.Cancel = true;
|
||||
_window!.SavePlacement();
|
||||
_window.Hide();
|
||||
}
|
||||
|
||||
private void OnWindowStateChanged(object? sender, EventArgs e)
|
||||
{
|
||||
if (_window is { WindowState: WindowState.Minimized } && _settings!.MinimizeToTray) _window.Hide();
|
||||
}
|
||||
|
||||
private void ShowWindow()
|
||||
{
|
||||
if (_window is null) return;
|
||||
_window.Show();
|
||||
if (_window.WindowState == WindowState.Minimized) _window.WindowState = WindowState.Normal;
|
||||
_window.Activate();
|
||||
}
|
||||
|
||||
private void ExitApplication()
|
||||
{
|
||||
if (_exiting) return;
|
||||
_exiting = true;
|
||||
Shutdown();
|
||||
}
|
||||
|
||||
private void RunCapture(string directory)
|
||||
{
|
||||
ApplyLanguage(null);
|
||||
ThemeManager.Initialize(this, AppTheme.Dark);
|
||||
var sample = new SampleData();
|
||||
var vm = sample.CreateViewModel();
|
||||
var window = new Shell.MainWindow(vm, sample.Settings);
|
||||
MainWindow = window;
|
||||
ScreenCapture.Run(window, vm, sample, directory);
|
||||
}
|
||||
|
||||
private void HookUnhandledExceptions()
|
||||
{
|
||||
DispatcherUnhandledException += (_, e) =>
|
||||
{
|
||||
Log.Error("app", "Unhandled UI exception", e.Exception);
|
||||
if (_vm is null) return;
|
||||
_vm.ReportError(e.Exception);
|
||||
e.Handled = true;
|
||||
};
|
||||
AppDomain.CurrentDomain.UnhandledException += (_, e) => Log.Error("app", "Unhandled exception", e.ExceptionObject as Exception);
|
||||
TaskScheduler.UnobservedTaskException += (_, e) =>
|
||||
{
|
||||
Log.Error("app", "Unobserved task exception", e.Exception);
|
||||
e.SetObserved();
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>Paths handed to the running instance must not depend on this process's working directory.</summary>
|
||||
private static string? Absolute(string path)
|
||||
{
|
||||
try
|
||||
{
|
||||
return Path.GetFullPath(path);
|
||||
}
|
||||
catch (Exception ex) when (ex is ArgumentException or NotSupportedException or PathTooLongException)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,171 @@
|
||||
using System.ComponentModel;
|
||||
using System.Globalization;
|
||||
using System.Runtime.CompilerServices;
|
||||
using Titano.Protocol;
|
||||
using Titano.Uploader.Infrastructure;
|
||||
using Titano.Uploader.Server;
|
||||
using Titano.Uploader.Shell;
|
||||
using Titano.Uploader.Uploads;
|
||||
using Titano.Uploader.Watching;
|
||||
|
||||
namespace Titano.Uploader.DesignTime;
|
||||
|
||||
/// <summary>
|
||||
/// Sample content for <c>--capture</c> screenshots ONLY: a fake signed-in session, a running queue of 4,812 files
|
||||
/// and two watch folders. Nothing here touches the network, the registry or the user's data files.
|
||||
/// </summary>
|
||||
public sealed class SampleData
|
||||
{
|
||||
private const int FileCount = 4_812;
|
||||
private const long FileSize = 20_000_000;
|
||||
|
||||
private readonly SampleSession _session = new();
|
||||
private readonly UploadQueue _queue = new();
|
||||
private MainViewModel? _vm;
|
||||
|
||||
public UploaderSettings Settings { get; } = new()
|
||||
{
|
||||
ServerUrl = "https://nas.local:8443/",
|
||||
Username = "alberto",
|
||||
BandwidthLimit = 50,
|
||||
MinimizeToTray = true,
|
||||
WatchFolders =
|
||||
[
|
||||
new UploaderSettings.WatchFolderSettings { Path = @"D:\Cam\Roof", IntervalSeconds = 60 },
|
||||
new UploaderSettings.WatchFolderSettings { Path = @"\\garage-pi\cam", IntervalSeconds = 300 },
|
||||
],
|
||||
};
|
||||
|
||||
/// <summary>A view model over in-memory sample services; settings changes are discarded.</summary>
|
||||
public MainViewModel CreateViewModel()
|
||||
{
|
||||
var memory = new ProcessedFileMemory();
|
||||
_session.BandwidthLimit = Settings.BandwidthLimit;
|
||||
_vm = new MainViewModel(new UploaderServices(
|
||||
Settings, () => { }, _session, _queue, new SampleEngine(_queue), new SampleStartup(), new UploaderDialogs(),
|
||||
new WatchFolderService(memory, _queue.ContainsPath), memory, string.Empty));
|
||||
foreach (var w in _vm.WatchFolders) w.IsAvailable = true;
|
||||
return _vm;
|
||||
}
|
||||
|
||||
/// <summary>First run: no server yet, one server found on the LAN.</summary>
|
||||
public void ShowConnect()
|
||||
{
|
||||
_session.SetState(ConnectionState.NotConfigured);
|
||||
_vm!.Connect.Address = string.Empty;
|
||||
_vm.Connect.Username = string.Empty;
|
||||
_vm.Connect.Discovered.Clear();
|
||||
_vm.Connect.Discovered.Add(new DiscoveredServer("Studio NAS", "https://192.168.1.20:8443"));
|
||||
}
|
||||
|
||||
/// <summary>Signed in, a card being uploaded at 38 MB/s.</summary>
|
||||
public void ShowQueue()
|
||||
{
|
||||
_session.SetState(ConnectionState.Connected);
|
||||
if (_queue.Items.Count == 0) FillQueue();
|
||||
_vm!.Sequences.Clear();
|
||||
_vm.Sequences.Add(new SequenceOption(Guid.Empty, "Harbour sunset"));
|
||||
_vm.SelectedSequence = _vm.Sequences[0];
|
||||
_vm.RefreshQueue();
|
||||
}
|
||||
|
||||
private void FillQueue()
|
||||
{
|
||||
var batch = new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions };
|
||||
var start = new DateTime(2026, 9, 28, 15, 22, 0);
|
||||
_queue.Add(batch, Enumerable.Range(0, FileCount).Select(i =>
|
||||
{
|
||||
var shot = start.AddSeconds(i * 5);
|
||||
var name = shot.ToString("yyyy-MM-dd_HH-mm-ss", CultureInfo.InvariantCulture) + "_" + (i + 1).ToString("0000", CultureInfo.InvariantCulture) + ".CR2";
|
||||
return new QueueEntry(@"E:\DCIM\100CANON\" + name, FileSize, shot.ToUniversalTime(), shot, "1a2b3c4d-20260928-152200", null);
|
||||
}));
|
||||
for (var i = 0; i < 2_201; i++) _queue.Items[i].State = i % 200 == 7 ? UploadItemState.Skipped : UploadItemState.Verified;
|
||||
_queue.Items[1_640].Retries = 1;
|
||||
_queue.Items[2_201].State = UploadItemState.Uploading;
|
||||
_queue.Items[2_201].BytesSent = FileSize * 46 / 100;
|
||||
_queue.Items[2_202].State = UploadItemState.Hashing;
|
||||
_queue.Fail(_queue.Items[2_203], UploadFailure.FileUnreadable, null, DateTime.UtcNow);
|
||||
}
|
||||
|
||||
private sealed class SampleSession : IServerSession
|
||||
{
|
||||
private ConnectionState _state = ConnectionState.Connected;
|
||||
|
||||
public event PropertyChangedEventHandler? PropertyChanged;
|
||||
|
||||
public event EventHandler<ServerProblem>? SessionEnded
|
||||
{
|
||||
add { }
|
||||
remove { }
|
||||
}
|
||||
|
||||
public ConnectionState State => _state;
|
||||
public string? Address => "https://nas.local:8443/";
|
||||
public string? Username => "alberto";
|
||||
public long QuotaBytes => 5_000_000_000_000;
|
||||
public long UsedBytes => 3_100_000_000_000;
|
||||
public int BandwidthLimit { get; set; }
|
||||
|
||||
public void SetState(ConnectionState state)
|
||||
{
|
||||
_state = state;
|
||||
Raise(nameof(State));
|
||||
}
|
||||
|
||||
public Task<(SignInResult Result, string? Fingerprint)> SignInAsync(string address, string username, string password, CancellationToken ct) =>
|
||||
Task.FromResult<(SignInResult, string?)>((SignInResult.Failed, null));
|
||||
|
||||
public void Trust(string fingerprint)
|
||||
{
|
||||
}
|
||||
|
||||
public Task SignOutAsync() => Task.CompletedTask;
|
||||
|
||||
public Task RefreshAsync() => Task.CompletedTask;
|
||||
|
||||
public Task<IReadOnlyList<SequenceDto>> ListSequencesAsync(CancellationToken ct) => Task.FromResult<IReadOnlyList<SequenceDto>>([]);
|
||||
|
||||
private void Raise([CallerMemberName] string? name = null) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
|
||||
}
|
||||
|
||||
private sealed class SampleEngine(UploadQueue queue) : IUploadEngine
|
||||
{
|
||||
public event PropertyChangedEventHandler? PropertyChanged
|
||||
{
|
||||
add { }
|
||||
remove { }
|
||||
}
|
||||
|
||||
public event EventHandler? Drained
|
||||
{
|
||||
add { }
|
||||
remove { }
|
||||
}
|
||||
|
||||
public EngineStatus Status => queue.IsPaused ? EngineStatus.Paused : EngineStatus.Running;
|
||||
public double BytesPerSecond => 38_000_000;
|
||||
|
||||
public void Pump()
|
||||
{
|
||||
}
|
||||
|
||||
public void Pause() => queue.IsPaused = true;
|
||||
|
||||
public void Resume() => queue.IsPaused = false;
|
||||
|
||||
public void StopAndClear()
|
||||
{
|
||||
}
|
||||
|
||||
public void Retry(UploadItem item)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
private sealed class SampleStartup : IStartupRegistration
|
||||
{
|
||||
public bool IsEnabled { get; private set; } = true;
|
||||
|
||||
public void SetEnabled(bool enabled) => IsEnabled = enabled;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
using System.IO;
|
||||
using Titano.Core.Diagnostics;
|
||||
using Titano.Core.IO;
|
||||
|
||||
namespace Titano.Uploader.Infrastructure;
|
||||
|
||||
/// <summary>
|
||||
/// Writes state files off the UI thread with <see cref="AtomicFile"/>. Only the newest content of each file is kept
|
||||
/// while a write is in progress, so a slow disk never writes an older snapshot after a newer one.
|
||||
/// </summary>
|
||||
public sealed class CoalescingWriter
|
||||
{
|
||||
private readonly Lock _gate = new();
|
||||
private readonly Dictionary<string, byte[]> _pending = new(StringComparer.OrdinalIgnoreCase);
|
||||
private Task _worker = Task.CompletedTask;
|
||||
private bool _running;
|
||||
|
||||
public void Write(string path, byte[] content)
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
_pending[path] = content;
|
||||
if (_running) return;
|
||||
_running = true;
|
||||
_worker = Task.Run(Drain);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Waits for pending writes (at exit).</summary>
|
||||
public void Flush(TimeSpan timeout)
|
||||
{
|
||||
Task worker;
|
||||
lock (_gate) worker = _worker;
|
||||
if (!worker.Wait(timeout)) Log.Warning("persist", "State files still being written at exit");
|
||||
}
|
||||
|
||||
private void Drain()
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
KeyValuePair<string, byte[]> next;
|
||||
lock (_gate)
|
||||
{
|
||||
if (_pending.Count == 0)
|
||||
{
|
||||
_running = false;
|
||||
return;
|
||||
}
|
||||
next = _pending.First();
|
||||
_pending.Remove(next.Key);
|
||||
}
|
||||
try
|
||||
{
|
||||
AtomicFile.WriteAllBytes(next.Key, next.Value);
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
||||
{
|
||||
Log.Warning("persist", $"{next.Key} not written", ex);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
namespace Titano.Uploader.Infrastructure;
|
||||
|
||||
/// <summary>
|
||||
/// <c>Titano.Uploader.exe [--tray] [--capture <dir>] [files or folders…]</c>: paths are enqueued, <c>--tray</c>
|
||||
/// starts hidden (used by the Run key), <c>--capture</c> renders screenshots and exits.
|
||||
/// </summary>
|
||||
public sealed record CommandLine(IReadOnlyList<string> Paths, bool StartInTray, string? CaptureDirectory)
|
||||
{
|
||||
public const string TrayOption = "--tray";
|
||||
public const string CaptureOption = "--capture";
|
||||
|
||||
public static CommandLine Parse(IReadOnlyList<string> args)
|
||||
{
|
||||
var paths = new List<string>();
|
||||
var tray = false;
|
||||
string? capture = null;
|
||||
for (var i = 0; i < args.Count; i++)
|
||||
{
|
||||
var a = args[i];
|
||||
if (a.Equals(TrayOption, StringComparison.OrdinalIgnoreCase)) tray = true;
|
||||
else if (a.Equals(CaptureOption, StringComparison.OrdinalIgnoreCase))
|
||||
capture = i + 1 < args.Count && !args[i + 1].StartsWith("--", StringComparison.Ordinal) ? args[++i] : "screenshots";
|
||||
else if (!a.StartsWith("--", StringComparison.Ordinal) && a.Length > 0) paths.Add(a);
|
||||
}
|
||||
return new CommandLine(paths, tray, capture);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
using System.Diagnostics;
|
||||
using System.IO;
|
||||
using System.IO.Pipes;
|
||||
using System.Text;
|
||||
using Titano.Core.Diagnostics;
|
||||
|
||||
namespace Titano.Uploader.Infrastructure;
|
||||
|
||||
/// <summary>
|
||||
/// One uploader per Windows session: a named mutex marks the running instance, and a second launch hands its
|
||||
/// file arguments over a named pipe (current user only) before exiting.
|
||||
/// </summary>
|
||||
public sealed class SingleInstance : IDisposable
|
||||
{
|
||||
private const string MutexName = @"Local\Titano.Uploader";
|
||||
private const string Header = "TITANO-UPLOADER/1";
|
||||
private const int MaxMessageBytes = 1 << 20;
|
||||
|
||||
private readonly Mutex _mutex;
|
||||
private readonly CancellationTokenSource _stop = new();
|
||||
|
||||
private SingleInstance(Mutex mutex) => _mutex = mutex;
|
||||
|
||||
private static string PipeName => $"Titano.Uploader.{Process.GetCurrentProcess().SessionId}.{Environment.UserName}";
|
||||
|
||||
/// <summary>The instance guard, or null when another uploader already runs in this session.</summary>
|
||||
public static SingleInstance? TryAcquire()
|
||||
{
|
||||
var mutex = new Mutex(initiallyOwned: true, MutexName, out var createdNew);
|
||||
if (createdNew) return new SingleInstance(mutex);
|
||||
mutex.Dispose();
|
||||
return null;
|
||||
}
|
||||
|
||||
/// <summary>Sends <paramref name="args"/> (absolute paths; empty = just show the window) to the running instance.</summary>
|
||||
public static void HandOver(IReadOnlyList<string> args)
|
||||
{
|
||||
try
|
||||
{
|
||||
using var pipe = new NamedPipeClientStream(".", PipeName, PipeDirection.Out, PipeOptions.CurrentUserOnly);
|
||||
pipe.Connect(3000);
|
||||
pipe.Write(Encode(args));
|
||||
pipe.Flush();
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or TimeoutException or UnauthorizedAccessException)
|
||||
{
|
||||
Log.Warning("instance", "Could not reach the running uploader", ex);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Receives messages from later launches; <paramref name="received"/> runs on a pool thread.</summary>
|
||||
public void Listen(Action<IReadOnlyList<string>> received) => _ = ListenAsync(received, _stop.Token);
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
_stop.Cancel();
|
||||
_mutex.ReleaseMutex();
|
||||
_mutex.Dispose();
|
||||
_stop.Dispose();
|
||||
}
|
||||
|
||||
/// <summary>UTF-8: a header line, then one argument per line (paths cannot contain line breaks).</summary>
|
||||
public static byte[] Encode(IReadOnlyList<string> args) =>
|
||||
Encoding.UTF8.GetBytes(Header + "\n" + string.Join("\n", args.Where(a => !a.Contains('\n', StringComparison.Ordinal))));
|
||||
|
||||
/// <summary>Arguments of a message, or null when it is not one of ours.</summary>
|
||||
public static IReadOnlyList<string>? Decode(ReadOnlySpan<byte> message)
|
||||
{
|
||||
if (message.Length > MaxMessageBytes) return null;
|
||||
var lines = Encoding.UTF8.GetString(message).Split('\n');
|
||||
if (lines[0] != Header) return null;
|
||||
return [.. lines.Skip(1).Where(l => l.Length > 0)];
|
||||
}
|
||||
|
||||
private static async Task ListenAsync(Action<IReadOnlyList<string>> received, CancellationToken ct)
|
||||
{
|
||||
while (!ct.IsCancellationRequested)
|
||||
{
|
||||
try
|
||||
{
|
||||
await using var pipe = new NamedPipeServerStream(PipeName, PipeDirection.In, 1, PipeTransmissionMode.Byte,
|
||||
PipeOptions.Asynchronous | PipeOptions.CurrentUserOnly);
|
||||
await pipe.WaitForConnectionAsync(ct).ConfigureAwait(false);
|
||||
using var buffer = new MemoryStream();
|
||||
await pipe.CopyToAsync(buffer, ct).ConfigureAwait(false);
|
||||
if (Decode(buffer.GetBuffer().AsSpan(0, (int)buffer.Length)) is { } args) received(args);
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
return;
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
Log.Warning("instance", "Hand-over pipe failed; listening again", ex);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
using System.Security;
|
||||
using Microsoft.Win32;
|
||||
using Titano.Core.Diagnostics;
|
||||
|
||||
namespace Titano.Uploader.Infrastructure;
|
||||
|
||||
/// <summary>"Start with Windows".</summary>
|
||||
public interface IStartupRegistration
|
||||
{
|
||||
bool IsEnabled { get; }
|
||||
|
||||
void SetEnabled(bool enabled);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// <c>HKCU\Software\Microsoft\Windows\CurrentVersion\Run</c> value that starts the uploader in the tray at sign-in.
|
||||
/// The registry stays the source of truth because Task Manager can turn it off.
|
||||
/// </summary>
|
||||
public sealed class RunKeyStartupRegistration : IStartupRegistration
|
||||
{
|
||||
private const string RunKey = @"Software\Microsoft\Windows\CurrentVersion\Run";
|
||||
private const string ValueName = "Titano Uploader";
|
||||
|
||||
public bool IsEnabled
|
||||
{
|
||||
get
|
||||
{
|
||||
try
|
||||
{
|
||||
using var key = Registry.CurrentUser.OpenSubKey(RunKey);
|
||||
return key?.GetValue(ValueName) is string { Length: > 0 };
|
||||
}
|
||||
catch (SecurityException)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static string Command => $"\"{Environment.ProcessPath}\" {CommandLine.TrayOption}";
|
||||
|
||||
public void SetEnabled(bool enabled)
|
||||
{
|
||||
try
|
||||
{
|
||||
using var key = Registry.CurrentUser.CreateSubKey(RunKey, writable: true);
|
||||
if (enabled) key.SetValue(ValueName, Command, RegistryValueKind.String);
|
||||
else key.DeleteValue(ValueName, throwOnMissingValue: false);
|
||||
}
|
||||
catch (Exception ex) when (ex is SecurityException or UnauthorizedAccessException)
|
||||
{
|
||||
Log.Warning("startup", "Run key not updated", ex);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Points an existing entry at the current executable (after an update moved it).</summary>
|
||||
public void Refresh()
|
||||
{
|
||||
if (IsEnabled) SetEnabled(true);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
|
||||
namespace Titano.Uploader.Infrastructure;
|
||||
|
||||
/// <summary>
|
||||
/// Encrypts the sign-in token for the current Windows user with DPAPI (<c>CryptProtectData</c>, no machine scope),
|
||||
/// so <c>uploader.json</c> copied to another account or PC cannot be used.
|
||||
/// </summary>
|
||||
public static partial class TokenProtector
|
||||
{
|
||||
private const int CryptProtectUiForbidden = 0x1;
|
||||
|
||||
// Ties the blob to this program; other DPAPI consumers of the same user cannot unwrap it by accident.
|
||||
private static readonly byte[] Entropy = "Titano.Uploader.Token.v1"u8.ToArray();
|
||||
|
||||
/// <summary>Base64 DPAPI blob of <paramref name="token"/>.</summary>
|
||||
public static string Protect(string token)
|
||||
{
|
||||
var plain = Encoding.UTF8.GetBytes(token);
|
||||
try
|
||||
{
|
||||
return Convert.ToBase64String(Transform(plain, protect: true));
|
||||
}
|
||||
finally
|
||||
{
|
||||
CryptographicOperations.ZeroMemory(plain);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>The token, or null when the blob is corrupt or belongs to another user.</summary>
|
||||
public static string? Unprotect(string protectedToken)
|
||||
{
|
||||
byte[] blob;
|
||||
try
|
||||
{
|
||||
blob = Convert.FromBase64String(protectedToken);
|
||||
}
|
||||
catch (FormatException)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
try
|
||||
{
|
||||
var plain = Transform(blob, protect: false);
|
||||
var token = Encoding.UTF8.GetString(plain);
|
||||
CryptographicOperations.ZeroMemory(plain);
|
||||
return token;
|
||||
}
|
||||
catch (CryptographicException)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
private static unsafe byte[] Transform(byte[] input, bool protect)
|
||||
{
|
||||
fixed (byte* inPtr = input)
|
||||
fixed (byte* entropyPtr = Entropy)
|
||||
{
|
||||
var source = new DataBlob { Size = input.Length, Data = (IntPtr)inPtr };
|
||||
var entropy = new DataBlob { Size = Entropy.Length, Data = (IntPtr)entropyPtr };
|
||||
var ok = protect
|
||||
? CryptProtectData(source, null, entropy, IntPtr.Zero, IntPtr.Zero, CryptProtectUiForbidden, out var output)
|
||||
: CryptUnprotectData(source, IntPtr.Zero, entropy, IntPtr.Zero, IntPtr.Zero, CryptProtectUiForbidden, out output);
|
||||
if (!ok) throw new CryptographicException(Marshal.GetLastPInvokeError());
|
||||
try
|
||||
{
|
||||
var result = new byte[output.Size];
|
||||
Marshal.Copy(output.Data, result, 0, output.Size);
|
||||
return result;
|
||||
}
|
||||
finally
|
||||
{
|
||||
LocalFree(output.Data);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
private struct DataBlob
|
||||
{
|
||||
public int Size;
|
||||
public IntPtr Data;
|
||||
}
|
||||
|
||||
[LibraryImport("crypt32.dll", SetLastError = true, StringMarshalling = StringMarshalling.Utf16)]
|
||||
[return: MarshalAs(UnmanagedType.Bool)]
|
||||
private static partial bool CryptProtectData(in DataBlob dataIn, string? description, in DataBlob entropy, IntPtr reserved, IntPtr prompt, int flags, out DataBlob dataOut);
|
||||
|
||||
[LibraryImport("crypt32.dll", SetLastError = true)]
|
||||
[return: MarshalAs(UnmanagedType.Bool)]
|
||||
private static partial bool CryptUnprotectData(in DataBlob dataIn, IntPtr description, in DataBlob entropy, IntPtr reserved, IntPtr prompt, int flags, out DataBlob dataOut);
|
||||
|
||||
[LibraryImport("kernel32.dll")]
|
||||
private static partial IntPtr LocalFree(IntPtr memory);
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
using System.IO;
|
||||
|
||||
namespace Titano.Uploader.Infrastructure;
|
||||
|
||||
/// <summary>
|
||||
/// Where the uploader keeps its files: <c>%LOCALAPPDATA%\Titano</c> (shared with the client), or <c>.\data</c> next
|
||||
/// to the executable when <c>portable.txt</c> exists — the same rule as the desktop client.
|
||||
/// </summary>
|
||||
public sealed class UploaderEnvironment
|
||||
{
|
||||
private UploaderEnvironment(string dataDirectory)
|
||||
{
|
||||
DataDirectory = dataDirectory;
|
||||
Directory.CreateDirectory(DataDirectory);
|
||||
Directory.CreateDirectory(LogDirectory);
|
||||
}
|
||||
|
||||
public string DataDirectory { get; }
|
||||
public string LogDirectory => Path.Combine(DataDirectory, "logs");
|
||||
|
||||
/// <summary>Settings, DPAPI-protected token and trusted certificate fingerprints.</summary>
|
||||
public string SettingsPath => Path.Combine(DataDirectory, "uploader.json");
|
||||
|
||||
/// <summary>The persisted upload queue.</summary>
|
||||
public string QueuePath => Path.Combine(DataDirectory, "uploader-queue.json");
|
||||
|
||||
/// <summary>Files of watch folders the server already confirmed.</summary>
|
||||
public string WatchMemoryPath => Path.Combine(DataDirectory, "uploader-watch.json");
|
||||
|
||||
public static UploaderEnvironment Detect()
|
||||
{
|
||||
var exeDir = AppContext.BaseDirectory;
|
||||
if (File.Exists(Path.Combine(exeDir, "portable.txt"))) return new UploaderEnvironment(Path.Combine(exeDir, "data"));
|
||||
var local = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
|
||||
return new UploaderEnvironment(Path.Combine(local, "Titano"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
using System.IO;
|
||||
using System.Text.Json;
|
||||
using System.Text.Json.Serialization;
|
||||
using Titano.Core.Diagnostics;
|
||||
using Titano.Core.IO;
|
||||
using Titano.Ui.Theming;
|
||||
using Titano.Uploader.Uploads;
|
||||
|
||||
namespace Titano.Uploader.Infrastructure;
|
||||
|
||||
/// <summary>
|
||||
/// <c>uploader.json</c>. The bearer token is stored only DPAPI-protected for the current Windows user
|
||||
/// (<see cref="TokenProtector"/>); "Start with Windows" lives in the registry, which stays the source of truth.
|
||||
/// </summary>
|
||||
public sealed class UploaderSettings
|
||||
{
|
||||
public string? ServerUrl { get; set; }
|
||||
public string? Username { get; set; }
|
||||
|
||||
/// <summary>Base64 of the DPAPI (CurrentUser) blob of the bearer token.</summary>
|
||||
public string? ProtectedToken { get; set; }
|
||||
|
||||
/// <summary>SHA-256 fingerprints (XX:XX:…) of self-signed certificates the user trusted (TOFU).</summary>
|
||||
public List<string> TrustedFingerprints { get; set; } = [];
|
||||
|
||||
/// <summary>Upload limit in MB/s (decimal megabytes); 0 = unlimited.</summary>
|
||||
public int BandwidthLimit { get; set; }
|
||||
|
||||
public bool MinimizeToTray { get; set; } = true;
|
||||
public bool DeleteAfterUpload { get; set; }
|
||||
public UploadTargetMode Target { get; set; } = UploadTargetMode.Sessions;
|
||||
public Guid? TargetSequenceId { get; set; }
|
||||
public string? NewSequenceTitle { get; set; }
|
||||
public List<WatchFolderSettings> WatchFolders { get; set; } = [];
|
||||
public string? Language { get; set; }
|
||||
public AppTheme Theme { get; set; } = AppTheme.Dark;
|
||||
public WindowPlacement? Window { get; set; }
|
||||
|
||||
public sealed class WatchFolderSettings
|
||||
{
|
||||
public string Path { get; set; } = string.Empty;
|
||||
public int IntervalSeconds { get; set; } = 60;
|
||||
}
|
||||
|
||||
public sealed class WindowPlacement
|
||||
{
|
||||
public double Left { get; set; }
|
||||
public double Top { get; set; }
|
||||
public double Width { get; set; }
|
||||
public double Height { get; set; }
|
||||
}
|
||||
|
||||
public static UploaderSettings Load(string path)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (File.Exists(path))
|
||||
return JsonSerializer.Deserialize(File.ReadAllBytes(path), UploaderSettingsJson.Default.UploaderSettings) ?? new UploaderSettings();
|
||||
}
|
||||
catch (JsonException ex)
|
||||
{
|
||||
// A corrupt settings file must never block startup; defaults apply.
|
||||
Log.Warning("settings", "uploader.json unreadable; using defaults", ex);
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
Log.Warning("settings", "uploader.json unreadable; using defaults", ex);
|
||||
}
|
||||
return new UploaderSettings();
|
||||
}
|
||||
|
||||
public void Save(string path) => AtomicFile.WriteAllBytes(path, JsonSerializer.SerializeToUtf8Bytes(this, UploaderSettingsJson.Default.UploaderSettings));
|
||||
}
|
||||
|
||||
[JsonSourceGenerationOptions(WriteIndented = true, PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase, UseStringEnumConverter = true)]
|
||||
[JsonSerializable(typeof(UploaderSettings))]
|
||||
internal sealed partial class UploaderSettingsJson : JsonSerializerContext;
|
||||
@@ -0,0 +1,187 @@
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace Titano.Uploader.Interop;
|
||||
|
||||
/// <summary>A filter of the Open dialog: display name and patterns such as <c>*.jpg;*.cr2</c>.</summary>
|
||||
public readonly record struct FileFilter(string Name, string Patterns);
|
||||
|
||||
/// <summary>
|
||||
/// The shell's Open dialog through <c>IFileOpenDialog</c> COM (no WinForms): several files at once, or one folder
|
||||
/// (which also picks a card root such as <c>E:\</c>).
|
||||
/// </summary>
|
||||
public static class FileDialogs
|
||||
{
|
||||
private const uint FosPickFolders = 0x20;
|
||||
private const uint FosForceFileSystem = 0x40;
|
||||
private const uint FosAllowMultiSelect = 0x200;
|
||||
private const uint FosPathMustExist = 0x800;
|
||||
private const uint FosFileMustExist = 0x1000;
|
||||
private const uint SigdnFileSysPath = 0x80058000;
|
||||
private const int ErrorCancelled = unchecked((int)0x800704C7);
|
||||
|
||||
/// <summary>Selected files; empty when cancelled.</summary>
|
||||
public static IReadOnlyList<string> PickFiles(IntPtr owner, string title, IReadOnlyList<FileFilter> filters) =>
|
||||
Show(owner, title, FosAllowMultiSelect | FosFileMustExist, filters);
|
||||
|
||||
/// <summary>Selected folder; null when cancelled.</summary>
|
||||
public static string? PickFolder(IntPtr owner, string title) => Show(owner, title, FosPickFolders, []).FirstOrDefault();
|
||||
|
||||
private static List<string> Show(IntPtr owner, string title, uint options, IReadOnlyList<FileFilter> filters)
|
||||
{
|
||||
var dialog = (IFileOpenDialog)new FileOpenDialogClass();
|
||||
try
|
||||
{
|
||||
dialog.GetOptions(out var current);
|
||||
dialog.SetOptions(current | options | FosForceFileSystem | FosPathMustExist);
|
||||
dialog.SetTitle(title);
|
||||
if (filters.Count > 0)
|
||||
{
|
||||
var specs = filters.Select(f => new FilterSpec { Name = f.Name, Spec = f.Patterns }).ToArray();
|
||||
dialog.SetFileTypes((uint)specs.Length, specs);
|
||||
dialog.SetFileTypeIndex(1);
|
||||
}
|
||||
var hr = dialog.Show(owner);
|
||||
if (hr == ErrorCancelled) return [];
|
||||
Marshal.ThrowExceptionForHR(hr);
|
||||
|
||||
dialog.GetResults(out var items);
|
||||
try
|
||||
{
|
||||
items.GetCount(out var count);
|
||||
var paths = new List<string>((int)count);
|
||||
for (uint i = 0; i < count; i++)
|
||||
{
|
||||
items.GetItemAt(i, out var item);
|
||||
try
|
||||
{
|
||||
item.GetDisplayName(SigdnFileSysPath, out var path);
|
||||
paths.Add(path);
|
||||
}
|
||||
finally
|
||||
{
|
||||
Marshal.ReleaseComObject(item);
|
||||
}
|
||||
}
|
||||
return paths;
|
||||
}
|
||||
finally
|
||||
{
|
||||
Marshal.ReleaseComObject(items);
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
Marshal.ReleaseComObject(dialog);
|
||||
}
|
||||
}
|
||||
|
||||
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
|
||||
private struct FilterSpec
|
||||
{
|
||||
[MarshalAs(UnmanagedType.LPWStr)]
|
||||
public string Name;
|
||||
|
||||
[MarshalAs(UnmanagedType.LPWStr)]
|
||||
public string Spec;
|
||||
}
|
||||
|
||||
[ComImport]
|
||||
[Guid("DC1C5A9C-E88A-4dde-A5A1-60F82A20AEF7")]
|
||||
private class FileOpenDialogClass;
|
||||
|
||||
// Classic COM interop does not inherit vtables: IModalWindow and IFileDialog members are repeated in order.
|
||||
[ComImport]
|
||||
[Guid("d57c7288-d4ad-4768-be02-9d969532d960")]
|
||||
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||||
private interface IFileOpenDialog
|
||||
{
|
||||
[PreserveSig]
|
||||
int Show(IntPtr owner);
|
||||
|
||||
void SetFileTypes(uint count, [In, MarshalAs(UnmanagedType.LPArray)] FilterSpec[] filters);
|
||||
|
||||
void SetFileTypeIndex(uint index);
|
||||
|
||||
void GetFileTypeIndex(out uint index);
|
||||
|
||||
void Advise(IntPtr events, out uint cookie);
|
||||
|
||||
void Unadvise(uint cookie);
|
||||
|
||||
void SetOptions(uint options);
|
||||
|
||||
void GetOptions(out uint options);
|
||||
|
||||
void SetDefaultFolder(IShellItem item);
|
||||
|
||||
void SetFolder(IShellItem item);
|
||||
|
||||
void GetFolder(out IShellItem item);
|
||||
|
||||
void GetCurrentSelection(out IShellItem item);
|
||||
|
||||
void SetFileName([MarshalAs(UnmanagedType.LPWStr)] string name);
|
||||
|
||||
void GetFileName([MarshalAs(UnmanagedType.LPWStr)] out string name);
|
||||
|
||||
void SetTitle([MarshalAs(UnmanagedType.LPWStr)] string title);
|
||||
|
||||
void SetOkButtonLabel([MarshalAs(UnmanagedType.LPWStr)] string text);
|
||||
|
||||
void SetFileNameLabel([MarshalAs(UnmanagedType.LPWStr)] string label);
|
||||
|
||||
void GetResult(out IShellItem item);
|
||||
|
||||
void AddPlace(IShellItem item, int placement);
|
||||
|
||||
void SetDefaultExtension([MarshalAs(UnmanagedType.LPWStr)] string extension);
|
||||
|
||||
void Close(int hr);
|
||||
|
||||
void SetClientGuid(ref Guid guid);
|
||||
|
||||
void ClearClientData();
|
||||
|
||||
void SetFilter(IntPtr filter);
|
||||
|
||||
void GetResults(out IShellItemArray items);
|
||||
|
||||
void GetSelectedItems(out IShellItemArray items);
|
||||
}
|
||||
|
||||
[ComImport]
|
||||
[Guid("43826d1e-e718-42ee-bc55-a1e261c37bfe")]
|
||||
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||||
private interface IShellItem
|
||||
{
|
||||
void BindToHandler(IntPtr bindContext, ref Guid handler, ref Guid iid, out IntPtr result);
|
||||
|
||||
void GetParent(out IShellItem parent);
|
||||
|
||||
void GetDisplayName(uint form, [MarshalAs(UnmanagedType.LPWStr)] out string name);
|
||||
|
||||
void GetAttributes(uint mask, out uint attributes);
|
||||
|
||||
void Compare(IShellItem other, uint hint, out int order);
|
||||
}
|
||||
|
||||
[ComImport]
|
||||
[Guid("b63ea76d-1f85-456f-a19c-48159efa858b")]
|
||||
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||||
private interface IShellItemArray
|
||||
{
|
||||
void BindToHandler(IntPtr bindContext, ref Guid handler, ref Guid iid, out IntPtr result);
|
||||
|
||||
void GetPropertyStore(int flags, ref Guid iid, out IntPtr store);
|
||||
|
||||
void GetPropertyDescriptionList(IntPtr keyType, ref Guid iid, out IntPtr list);
|
||||
|
||||
void GetAttributes(int flags, uint mask, out uint attributes);
|
||||
|
||||
void GetCount(out uint count);
|
||||
|
||||
void GetItemAt(uint index, out IShellItem item);
|
||||
|
||||
void EnumItems(out IntPtr items);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,251 @@
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Windows.Interop;
|
||||
using Titano.Core.Diagnostics;
|
||||
|
||||
namespace Titano.Uploader.Interop;
|
||||
|
||||
/// <summary>One entry of the tray menu; an id of 0 is a separator.</summary>
|
||||
public readonly record struct TrayMenuItem(int Id, string? Text);
|
||||
|
||||
/// <summary>
|
||||
/// Notification-area icon through <c>Shell_NotifyIconW</c>: the program icon from the executable's resources, a tooltip,
|
||||
/// a native context menu and balloons. A hidden window receives the callbacks and re-adds the icon after Explorer restarts.
|
||||
/// </summary>
|
||||
public sealed unsafe partial class TrayIcon : IDisposable
|
||||
{
|
||||
private const uint NimAdd = 0;
|
||||
private const uint NimModify = 1;
|
||||
private const uint NimDelete = 2;
|
||||
private const uint NifMessage = 0x1;
|
||||
private const uint NifIcon = 0x2;
|
||||
private const uint NifTip = 0x4;
|
||||
private const uint NifInfo = 0x10;
|
||||
private const uint NiifUser = 0x4;
|
||||
private const int CallbackMessage = 0x8000 + 1; // WM_APP + 1
|
||||
private const int WmContextMenu = 0x007B;
|
||||
private const int WmLButtonUp = 0x0202;
|
||||
private const int WmLButtonDblClk = 0x0203;
|
||||
private const int WmRButtonUp = 0x0205;
|
||||
private const int NinBalloonUserClick = 0x0405;
|
||||
private const uint MfString = 0x0;
|
||||
private const uint MfSeparator = 0x800;
|
||||
private const uint TpmRightButton = 0x2;
|
||||
private const uint TpmNoNotify = 0x80;
|
||||
private const uint TpmReturnCmd = 0x100;
|
||||
|
||||
private readonly HwndSource _window;
|
||||
private readonly IntPtr _icon;
|
||||
private readonly bool _ownsIcon;
|
||||
private readonly uint _taskbarCreated;
|
||||
private readonly Func<IReadOnlyList<TrayMenuItem>> _menu;
|
||||
private readonly Action<int> _command;
|
||||
private readonly Action _show;
|
||||
private string _toolTip;
|
||||
private bool _added;
|
||||
|
||||
/// <param name="toolTip">Hover text (up to 127 characters).</param>
|
||||
/// <param name="menu">Builds the context menu when it opens.</param>
|
||||
/// <param name="command">Runs a chosen menu id.</param>
|
||||
/// <param name="show">Left click or balloon click.</param>
|
||||
public TrayIcon(string toolTip, Func<IReadOnlyList<TrayMenuItem>> menu, Action<int> command, Action show)
|
||||
{
|
||||
_toolTip = toolTip;
|
||||
_menu = menu;
|
||||
_command = command;
|
||||
_show = show;
|
||||
// A hidden top-level window: message-only windows miss the TaskbarCreated broadcast.
|
||||
_window = new HwndSource(new HwndSourceParameters("TitanoUploaderTray") { Width = 0, Height = 0, WindowStyle = 0 });
|
||||
_window.AddHook(WndProc);
|
||||
_taskbarCreated = RegisterWindowMessageW("TaskbarCreated");
|
||||
(_icon, _ownsIcon) = LoadProgramIcon();
|
||||
Add();
|
||||
}
|
||||
|
||||
public void SetToolTip(string text)
|
||||
{
|
||||
_toolTip = text;
|
||||
var data = NewData(NifTip);
|
||||
Copy(_toolTip, data.Tip, 128);
|
||||
Notify(NimModify, &data);
|
||||
}
|
||||
|
||||
/// <summary>Shows a balloon (a toast on Windows 10/11) with the program icon.</summary>
|
||||
public void ShowBalloon(string title, string text)
|
||||
{
|
||||
var data = NewData(NifInfo);
|
||||
Copy(title, data.InfoTitle, 64);
|
||||
Copy(text, data.Info, 256);
|
||||
data.InfoFlags = NiifUser;
|
||||
Notify(NimModify, &data);
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
if (_added)
|
||||
{
|
||||
var data = NewData(0);
|
||||
Notify(NimDelete, &data);
|
||||
_added = false;
|
||||
}
|
||||
if (_ownsIcon) DestroyIcon(_icon);
|
||||
_window.Dispose();
|
||||
}
|
||||
|
||||
private void Add()
|
||||
{
|
||||
var data = NewData(NifMessage | NifIcon | NifTip);
|
||||
data.CallbackMessage = CallbackMessage;
|
||||
data.Icon = _icon;
|
||||
Copy(_toolTip, data.Tip, 128);
|
||||
_added = Notify(NimAdd, &data);
|
||||
}
|
||||
|
||||
private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
|
||||
{
|
||||
if (msg == CallbackMessage)
|
||||
{
|
||||
switch ((int)(lParam.ToInt64() & 0xFFFF))
|
||||
{
|
||||
case WmLButtonUp or WmLButtonDblClk or NinBalloonUserClick:
|
||||
_show();
|
||||
break;
|
||||
case WmRButtonUp or WmContextMenu:
|
||||
ShowMenu();
|
||||
break;
|
||||
}
|
||||
handled = true;
|
||||
}
|
||||
else if (_taskbarCreated != 0 && msg == (int)_taskbarCreated)
|
||||
{
|
||||
Add();
|
||||
}
|
||||
return IntPtr.Zero;
|
||||
}
|
||||
|
||||
private void ShowMenu()
|
||||
{
|
||||
var menu = CreatePopupMenu();
|
||||
if (menu == IntPtr.Zero) return;
|
||||
try
|
||||
{
|
||||
foreach (var item in _menu())
|
||||
{
|
||||
if (item.Id == 0 || item.Text is null) AppendMenuW(menu, MfSeparator, 0, null);
|
||||
else AppendMenuW(menu, MfString, (nuint)item.Id, item.Text);
|
||||
}
|
||||
GetCursorPos(out var point);
|
||||
// Without foreground the menu would not close when the user clicks elsewhere.
|
||||
SetForegroundWindow(_window.Handle);
|
||||
var chosen = TrackPopupMenuEx(menu, TpmReturnCmd | TpmRightButton | TpmNoNotify, point.X, point.Y, _window.Handle, IntPtr.Zero);
|
||||
PostMessageW(_window.Handle, 0, IntPtr.Zero, IntPtr.Zero);
|
||||
if (chosen != 0) _command(chosen);
|
||||
}
|
||||
finally
|
||||
{
|
||||
DestroyMenu(menu);
|
||||
}
|
||||
}
|
||||
|
||||
private NotifyIconData NewData(uint flags) => new()
|
||||
{
|
||||
Size = (uint)sizeof(NotifyIconData),
|
||||
Window = _window.Handle,
|
||||
Id = 1,
|
||||
Flags = flags,
|
||||
};
|
||||
|
||||
private static bool Notify(uint message, NotifyIconData* data)
|
||||
{
|
||||
if (Shell_NotifyIconW(message, data)) return true;
|
||||
Log.Info("tray", $"Shell_NotifyIcon({message}) failed");
|
||||
return false;
|
||||
}
|
||||
|
||||
private static void Copy(string text, char* destination, int capacity)
|
||||
{
|
||||
var length = Math.Min(text.Length, capacity - 1);
|
||||
text.AsSpan(0, length).CopyTo(new Span<char>(destination, capacity));
|
||||
destination[length] = '\0';
|
||||
}
|
||||
|
||||
/// <summary>The generated titano-uploader icon embedded in the executable; the stock icon if it cannot be read.</summary>
|
||||
private static (IntPtr Icon, bool Owned) LoadProgramIcon()
|
||||
{
|
||||
if (Environment.ProcessPath is { } exe)
|
||||
{
|
||||
IntPtr small;
|
||||
if (ExtractIconExW(exe, 0, null, &small, 1) > 0 && small != IntPtr.Zero) return (small, true);
|
||||
}
|
||||
return (LoadIconW(IntPtr.Zero, 32512), false); // IDI_APPLICATION
|
||||
}
|
||||
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
private struct NotifyIconData
|
||||
{
|
||||
public uint Size;
|
||||
public IntPtr Window;
|
||||
public uint Id;
|
||||
public uint Flags;
|
||||
public uint CallbackMessage;
|
||||
public IntPtr Icon;
|
||||
public fixed char Tip[128];
|
||||
public uint State;
|
||||
public uint StateMask;
|
||||
public fixed char Info[256];
|
||||
public uint TimeoutOrVersion;
|
||||
public fixed char InfoTitle[64];
|
||||
public uint InfoFlags;
|
||||
public Guid Item;
|
||||
public IntPtr BalloonIcon;
|
||||
}
|
||||
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
private struct Point
|
||||
{
|
||||
public int X;
|
||||
public int Y;
|
||||
}
|
||||
|
||||
[LibraryImport("shell32.dll")]
|
||||
[return: MarshalAs(UnmanagedType.Bool)]
|
||||
private static partial bool Shell_NotifyIconW(uint message, NotifyIconData* data);
|
||||
|
||||
[LibraryImport("shell32.dll", StringMarshalling = StringMarshalling.Utf16)]
|
||||
private static partial uint ExtractIconExW(string file, int index, IntPtr* large, IntPtr* small, uint count);
|
||||
|
||||
[LibraryImport("user32.dll")]
|
||||
private static partial IntPtr LoadIconW(IntPtr instance, nint name);
|
||||
|
||||
[LibraryImport("user32.dll")]
|
||||
[return: MarshalAs(UnmanagedType.Bool)]
|
||||
private static partial bool DestroyIcon(IntPtr icon);
|
||||
|
||||
[LibraryImport("user32.dll", StringMarshalling = StringMarshalling.Utf16)]
|
||||
private static partial uint RegisterWindowMessageW(string name);
|
||||
|
||||
[LibraryImport("user32.dll")]
|
||||
private static partial IntPtr CreatePopupMenu();
|
||||
|
||||
[LibraryImport("user32.dll", StringMarshalling = StringMarshalling.Utf16)]
|
||||
[return: MarshalAs(UnmanagedType.Bool)]
|
||||
private static partial bool AppendMenuW(IntPtr menu, uint flags, nuint id, string? text);
|
||||
|
||||
[LibraryImport("user32.dll")]
|
||||
private static partial int TrackPopupMenuEx(IntPtr menu, uint flags, int x, int y, IntPtr window, IntPtr parameters);
|
||||
|
||||
[LibraryImport("user32.dll")]
|
||||
[return: MarshalAs(UnmanagedType.Bool)]
|
||||
private static partial bool DestroyMenu(IntPtr menu);
|
||||
|
||||
[LibraryImport("user32.dll")]
|
||||
[return: MarshalAs(UnmanagedType.Bool)]
|
||||
private static partial bool GetCursorPos(out Point point);
|
||||
|
||||
[LibraryImport("user32.dll")]
|
||||
[return: MarshalAs(UnmanagedType.Bool)]
|
||||
private static partial bool SetForegroundWindow(IntPtr window);
|
||||
|
||||
[LibraryImport("user32.dll")]
|
||||
[return: MarshalAs(UnmanagedType.Bool)]
|
||||
private static partial bool PostMessageW(IntPtr window, int message, IntPtr wParam, IntPtr lParam);
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
using Titano.Core.Diagnostics;
|
||||
using Titano.Protocol;
|
||||
|
||||
namespace Titano.Uploader.Server;
|
||||
|
||||
/// <summary>A Titano Server announced on the LAN.</summary>
|
||||
public sealed record DiscoveredServer(string Name, string Address);
|
||||
|
||||
/// <summary>
|
||||
/// Listens for the server's UDP beacon (<see cref="DiscoveryBeacon.Port"/>) while the connect form is open and reports
|
||||
/// each server once. Beacons are unauthenticated: they only fill the address field, never trust a certificate.
|
||||
/// </summary>
|
||||
public sealed class DiscoveryListener : IDisposable
|
||||
{
|
||||
private readonly HashSet<string> _seen = new(StringComparer.OrdinalIgnoreCase);
|
||||
private CancellationTokenSource? _cts;
|
||||
|
||||
/// <summary>Raised on the thread that called <see cref="Start"/>.</summary>
|
||||
public event Action<DiscoveredServer>? Found;
|
||||
|
||||
public void Start()
|
||||
{
|
||||
if (_cts is not null) return;
|
||||
_cts = new CancellationTokenSource();
|
||||
var context = SynchronizationContext.Current;
|
||||
_ = Task.Run(() => ListenAsync(context, _cts.Token));
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
_cts?.Cancel();
|
||||
_cts?.Dispose();
|
||||
_cts = null;
|
||||
}
|
||||
|
||||
/// <summary>The address the client should use for <paramref name="beacon"/> sent from <paramref name="sender"/>.</summary>
|
||||
private static string AddressOf(DiscoveryBeacon beacon, IPAddress sender)
|
||||
{
|
||||
var host = sender.AddressFamily == AddressFamily.InterNetworkV6 ? "[" + sender + "]" : sender.ToString();
|
||||
return beacon.HttpsPort > 0 ? $"https://{host}:{beacon.HttpsPort}" : $"http://{host}:{beacon.HttpPort}";
|
||||
}
|
||||
|
||||
private async Task ListenAsync(SynchronizationContext? context, CancellationToken ct)
|
||||
{
|
||||
try
|
||||
{
|
||||
using var udp = new UdpClient();
|
||||
// The desktop client may listen on the same port.
|
||||
udp.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
|
||||
udp.Client.Bind(new IPEndPoint(IPAddress.Any, DiscoveryBeacon.Port));
|
||||
while (!ct.IsCancellationRequested)
|
||||
{
|
||||
var datagram = await udp.ReceiveAsync(ct).ConfigureAwait(false);
|
||||
if (DiscoveryBeacon.TryParse(datagram.Buffer) is not { } beacon) continue;
|
||||
var server = new DiscoveredServer(beacon.Name, AddressOf(beacon, datagram.RemoteEndPoint.Address));
|
||||
lock (_seen)
|
||||
{
|
||||
if (!_seen.Add(server.Address)) continue;
|
||||
}
|
||||
if (context is null) Found?.Invoke(server);
|
||||
else context.Post(_ => Found?.Invoke(server), null);
|
||||
}
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
}
|
||||
catch (SocketException ex)
|
||||
{
|
||||
Log.Info("discovery", "LAN discovery unavailable: " + ex.Message);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
namespace Titano.Uploader.Server;
|
||||
|
||||
/// <summary>Server addresses as typed in the sign-in form.</summary>
|
||||
public static class ServerAddress
|
||||
{
|
||||
/// <summary>
|
||||
/// Accepts "nas.local:8443" (https assumed) or a full http(s) URL; the result is the API base, ending with "/".
|
||||
/// </summary>
|
||||
public static bool TryParse(string? text, out Uri uri)
|
||||
{
|
||||
uri = null!;
|
||||
if (string.IsNullOrWhiteSpace(text)) return false;
|
||||
var trimmed = text.Trim();
|
||||
if (!trimmed.Contains("://", StringComparison.Ordinal)) trimmed = "https://" + trimmed;
|
||||
if (!Uri.TryCreate(trimmed, UriKind.Absolute, out var parsed) || parsed.Scheme is not ("https" or "http") || parsed.Host.Length == 0) return false;
|
||||
var builder = new UriBuilder(parsed) { Query = string.Empty, Fragment = string.Empty };
|
||||
if (!builder.Path.EndsWith('/')) builder.Path += "/";
|
||||
uri = builder.Uri;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,460 @@
|
||||
using System.ComponentModel;
|
||||
using System.Net;
|
||||
using System.Net.Http;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Text.Json;
|
||||
using Titano.Core.Diagnostics;
|
||||
using Titano.Protocol;
|
||||
using Titano.Protocol.Client;
|
||||
using Titano.Uploader.Infrastructure;
|
||||
using Titano.Uploader.Uploads;
|
||||
|
||||
namespace Titano.Uploader.Server;
|
||||
|
||||
/// <summary>Connection shown in the header.</summary>
|
||||
public enum ConnectionState
|
||||
{
|
||||
/// <summary>First run: no server chosen yet.</summary>
|
||||
NotConfigured,
|
||||
SigningIn,
|
||||
Connected,
|
||||
|
||||
/// <summary>Signed in, but the server cannot be reached; probed every 30 s.</summary>
|
||||
Offline,
|
||||
|
||||
/// <summary>A server is known but there is no valid token.</summary>
|
||||
SignedOut,
|
||||
}
|
||||
|
||||
/// <summary>Outcome of the sign-in form.</summary>
|
||||
public enum SignInResult
|
||||
{
|
||||
Success,
|
||||
InvalidAddress,
|
||||
Unreachable,
|
||||
NotTitano,
|
||||
|
||||
/// <summary>The certificate is self-signed and unknown: ask the user to trust its fingerprint.</summary>
|
||||
Untrusted,
|
||||
BadCredentials,
|
||||
Failed,
|
||||
}
|
||||
|
||||
/// <summary>The server connection as the window sees it.</summary>
|
||||
public interface IServerSession : INotifyPropertyChanged
|
||||
{
|
||||
ConnectionState State { get; }
|
||||
|
||||
/// <summary>Server address as the user typed or discovered it.</summary>
|
||||
string? Address { get; }
|
||||
|
||||
string? Username { get; }
|
||||
|
||||
/// <summary>Quota in bytes; 0 = unlimited.</summary>
|
||||
long QuotaBytes { get; }
|
||||
|
||||
long UsedBytes { get; }
|
||||
|
||||
/// <summary>Upload limit in MB/s; 0 = unlimited.</summary>
|
||||
int BandwidthLimit { get; set; }
|
||||
|
||||
/// <summary>Raised when the server ended the session (token rejected or certificate changed).</summary>
|
||||
event EventHandler<ServerProblem>? SessionEnded;
|
||||
|
||||
/// <summary>Signs in; <see cref="SignInResult.Untrusted"/> comes with the fingerprint to show.</summary>
|
||||
Task<(SignInResult Result, string? Fingerprint)> SignInAsync(string address, string username, string password, CancellationToken ct);
|
||||
|
||||
/// <summary>Remembers a certificate fingerprint the user confirmed (trust on first use).</summary>
|
||||
void Trust(string fingerprint);
|
||||
|
||||
Task SignOutAsync();
|
||||
|
||||
/// <summary>Refreshes the account (quota) when connected.</summary>
|
||||
Task RefreshAsync();
|
||||
|
||||
Task<IReadOnlyList<SequenceDto>> ListSequencesAsync(CancellationToken ct);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Owns the <see cref="TitanoClient"/>: sign-in with trust-on-first-use, token restore from DPAPI, offline probing,
|
||||
/// and the upload transport. Runs on the UI thread.
|
||||
/// </summary>
|
||||
public sealed class ServerSession : IServerSession, IUploadTransport, IDisposable
|
||||
{
|
||||
private static readonly TimeSpan ProbeInterval = TimeSpan.FromSeconds(30);
|
||||
|
||||
private readonly UploaderSettings _settings;
|
||||
private readonly Action _saveSettings;
|
||||
private TitanoClient? _client;
|
||||
private ConnectionState _state;
|
||||
private string? _username;
|
||||
private long _quotaBytes;
|
||||
private long _usedBytes;
|
||||
private int _bandwidthLimit;
|
||||
private CancellationTokenSource? _probe;
|
||||
|
||||
public ServerSession(UploaderSettings settings, Action saveSettings)
|
||||
{
|
||||
_settings = settings;
|
||||
_saveSettings = saveSettings;
|
||||
_username = settings.Username;
|
||||
_bandwidthLimit = Math.Max(0, settings.BandwidthLimit);
|
||||
_state = settings.ServerUrl is null ? ConnectionState.NotConfigured : ConnectionState.SignedOut;
|
||||
}
|
||||
|
||||
public event PropertyChangedEventHandler? PropertyChanged;
|
||||
|
||||
public event EventHandler? ReadyChanged;
|
||||
|
||||
public event EventHandler<ServerProblem>? SessionEnded;
|
||||
|
||||
public ConnectionState State
|
||||
{
|
||||
get => _state;
|
||||
private set
|
||||
{
|
||||
if (_state == value) return;
|
||||
var wasReady = IsReady;
|
||||
_state = value;
|
||||
OnPropertyChanged();
|
||||
if (wasReady != IsReady) ReadyChanged?.Invoke(this, EventArgs.Empty);
|
||||
}
|
||||
}
|
||||
|
||||
public bool IsReady => _state == ConnectionState.Connected && _client is not null;
|
||||
|
||||
public string? Address => _settings.ServerUrl;
|
||||
|
||||
public string? Username
|
||||
{
|
||||
get => _username;
|
||||
private set => Set(ref _username, value);
|
||||
}
|
||||
|
||||
public long QuotaBytes
|
||||
{
|
||||
get => _quotaBytes;
|
||||
private set => Set(ref _quotaBytes, value);
|
||||
}
|
||||
|
||||
public long UsedBytes
|
||||
{
|
||||
get => _usedBytes;
|
||||
private set => Set(ref _usedBytes, value);
|
||||
}
|
||||
|
||||
public int BandwidthLimit
|
||||
{
|
||||
get => _bandwidthLimit;
|
||||
set
|
||||
{
|
||||
if (!Set(ref _bandwidthLimit, Math.Max(0, value))) return;
|
||||
ApplyBandwidth();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Restores the saved session, if any, in the background.</summary>
|
||||
public void Start()
|
||||
{
|
||||
if (_settings.ServerUrl is null || _settings.ProtectedToken is null) return;
|
||||
var token = TokenProtector.Unprotect(_settings.ProtectedToken);
|
||||
if (token is null || !ServerAddress.TryParse(_settings.ServerUrl, out var uri))
|
||||
{
|
||||
Log.Warning("session", "Saved token cannot be used; sign in again");
|
||||
State = ConnectionState.SignedOut;
|
||||
return;
|
||||
}
|
||||
UseClient(CreateClient(uri));
|
||||
_client!.Token = token;
|
||||
State = ConnectionState.SigningIn;
|
||||
_ = RefreshAsync();
|
||||
}
|
||||
|
||||
public async Task<(SignInResult Result, string? Fingerprint)> SignInAsync(string address, string username, string password, CancellationToken ct)
|
||||
{
|
||||
if (!ServerAddress.TryParse(address, out var uri)) return (SignInResult.InvalidAddress, null);
|
||||
StopProbing();
|
||||
var previous = State;
|
||||
State = ConnectionState.SigningIn;
|
||||
var client = CreateClient(uri);
|
||||
try
|
||||
{
|
||||
await client.GetInfoAsync(ct);
|
||||
var login = await client.LoginAsync(username, password, ct);
|
||||
if (login.Token is null) throw new TitanoApiException(HttpStatusCode.Unauthorized, new ApiError("no_token", "No token issued"));
|
||||
|
||||
_settings.ServerUrl = uri.ToString();
|
||||
_settings.Username = login.User.Username;
|
||||
_settings.ProtectedToken = TokenProtector.Protect(login.Token);
|
||||
_saveSettings();
|
||||
UseClient(client);
|
||||
OnPropertyChanged(nameof(Address));
|
||||
Username = login.User.Username;
|
||||
SetQuota(login.User);
|
||||
State = ConnectionState.Connected;
|
||||
Log.Info("session", $"Signed in to {uri} as {login.User.Username}");
|
||||
return (SignInResult.Success, null);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
client.Dispose();
|
||||
State = previous == ConnectionState.SigningIn ? ConnectionState.NotConfigured : previous;
|
||||
var result = Classify(ex, ct);
|
||||
if (result == SignInResult.Failed) Log.Warning("session", $"Sign-in to {uri} failed", ex);
|
||||
return (result, (ex as UntrustedCertificateException)?.Fingerprint);
|
||||
}
|
||||
}
|
||||
|
||||
public void Trust(string fingerprint)
|
||||
{
|
||||
if (_settings.TrustedFingerprints.Contains(fingerprint, StringComparer.OrdinalIgnoreCase)) return;
|
||||
_settings.TrustedFingerprints.Add(fingerprint);
|
||||
_saveSettings();
|
||||
Log.Info("session", $"Trusted certificate {fingerprint}");
|
||||
}
|
||||
|
||||
public async Task SignOutAsync()
|
||||
{
|
||||
StopProbing();
|
||||
if (_client is { Token: not null } client)
|
||||
{
|
||||
try
|
||||
{
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
await client.LogoutAsync(timeout.Token);
|
||||
}
|
||||
catch (Exception ex) when (ex is HttpRequestException or TitanoApiException or OperationCanceledException or UntrustedCertificateException)
|
||||
{
|
||||
// The token is forgotten locally either way.
|
||||
Log.Info("session", "Logout not confirmed by the server: " + ex.Message);
|
||||
}
|
||||
}
|
||||
ForgetToken();
|
||||
}
|
||||
|
||||
public async Task RefreshAsync()
|
||||
{
|
||||
if (_client is not { } client) return;
|
||||
try
|
||||
{
|
||||
var me = await client.MeAsync();
|
||||
Username = me.Username;
|
||||
SetQuota(me);
|
||||
State = ConnectionState.Connected;
|
||||
StopProbing();
|
||||
}
|
||||
catch (Exception ex) when (IsServerProblem(ex, CancellationToken.None, out var problem))
|
||||
{
|
||||
OnServerProblem(problem, ex);
|
||||
}
|
||||
catch (TitanoApiException ex)
|
||||
{
|
||||
Log.Warning("session", "Account refresh failed", ex);
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<IReadOnlyList<SequenceDto>> ListSequencesAsync(CancellationToken ct)
|
||||
{
|
||||
if (!IsReady) return [];
|
||||
var all = new List<SequenceDto>();
|
||||
string? cursor = null;
|
||||
try
|
||||
{
|
||||
// Five pages of 200 cover any realistic choice list.
|
||||
for (var page = 0; page < 5; page++)
|
||||
{
|
||||
var result = await _client!.ListSequencesAsync(cursor: cursor, ct: ct);
|
||||
all.AddRange(result.Items);
|
||||
cursor = result.NextCursor;
|
||||
if (cursor is null) break;
|
||||
}
|
||||
}
|
||||
catch (Exception ex) when (IsServerProblem(ex, ct, out var problem))
|
||||
{
|
||||
OnServerProblem(problem, ex);
|
||||
}
|
||||
catch (TitanoApiException ex)
|
||||
{
|
||||
Log.Warning("session", "Sequence list unavailable", ex);
|
||||
}
|
||||
return all;
|
||||
}
|
||||
|
||||
// ---------------- IUploadTransport ----------------
|
||||
|
||||
public async Task<(UploadOutcome Outcome, Guid? FrameId)> UploadAsync(UploadItem item, Guid? sequenceId, string sha256, IProgress<UploadProgress> progress, CancellationToken ct)
|
||||
{
|
||||
var client = _client ?? throw new ServerUnavailableException(ServerProblem.SignedOut);
|
||||
try
|
||||
{
|
||||
var result = await client.UploadFileAsync(item.Path, sequenceId, item.CapturedAt, item.SessionKey, sha256, progress, ct);
|
||||
// The client reports an existing file as index −1 (or no frame at all).
|
||||
return result is null || result.Index < 0 ? (UploadOutcome.AlreadyOnServer, result?.FrameId) : (UploadOutcome.Verified, result.FrameId);
|
||||
}
|
||||
catch (Exception ex) when (IsServerProblem(ex, ct, out var problem))
|
||||
{
|
||||
OnServerProblem(problem, ex);
|
||||
throw new ServerUnavailableException(problem, ex);
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<Guid> CreateSequenceAsync(string? title, CancellationToken ct)
|
||||
{
|
||||
var client = _client ?? throw new ServerUnavailableException(ServerProblem.SignedOut);
|
||||
try
|
||||
{
|
||||
var created = await client.CreateSequenceAsync(new CreateSequenceRequest(string.IsNullOrWhiteSpace(title) ? null : title.Trim(), null), ct);
|
||||
Log.Info("session", $"Created sequence {created.Id} \"{created.DisplayTitle}\"");
|
||||
return created.Id;
|
||||
}
|
||||
catch (Exception ex) when (IsServerProblem(ex, ct, out var problem))
|
||||
{
|
||||
OnServerProblem(problem, ex);
|
||||
throw new ServerUnavailableException(problem, ex);
|
||||
}
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
StopProbing();
|
||||
_client?.Dispose();
|
||||
}
|
||||
|
||||
// ---------------- Plumbing ----------------
|
||||
|
||||
private TitanoClient CreateClient(Uri uri)
|
||||
{
|
||||
// A fresh pinning per client: the protocol's last-rejected fingerprint must not outlive a trust decision.
|
||||
var client = new TitanoClient(uri, new CertificatePinning(_settings.TrustedFingerprints), $"Titano Uploader ({Environment.MachineName})");
|
||||
client.Bandwidth.BytesPerSecond = _bandwidthLimit * 1_000_000L;
|
||||
return client;
|
||||
}
|
||||
|
||||
private void UseClient(TitanoClient client)
|
||||
{
|
||||
if (ReferenceEquals(_client, client)) return;
|
||||
_client?.Dispose();
|
||||
_client = client;
|
||||
}
|
||||
|
||||
private void ApplyBandwidth()
|
||||
{
|
||||
if (_client is not null) _client.Bandwidth.BytesPerSecond = _bandwidthLimit * 1_000_000L;
|
||||
}
|
||||
|
||||
private void SetQuota(UserDto user)
|
||||
{
|
||||
QuotaBytes = user.QuotaBytes;
|
||||
UsedBytes = user.UsedBytes;
|
||||
}
|
||||
|
||||
private void ForgetToken()
|
||||
{
|
||||
if (_client is not null) _client.Token = null;
|
||||
_settings.ProtectedToken = null;
|
||||
_saveSettings();
|
||||
QuotaBytes = 0;
|
||||
UsedBytes = 0;
|
||||
State = _settings.ServerUrl is null ? ConnectionState.NotConfigured : ConnectionState.SignedOut;
|
||||
}
|
||||
|
||||
private bool IsServerProblem(Exception ex, CancellationToken ct, out ServerProblem problem)
|
||||
{
|
||||
problem = ServerProblem.Unreachable;
|
||||
switch (ex)
|
||||
{
|
||||
case TitanoApiException { Status: HttpStatusCode.Unauthorized }:
|
||||
problem = ServerProblem.SignedOut;
|
||||
return true;
|
||||
case TitanoApiException api:
|
||||
return api.IsTransient;
|
||||
case UntrustedCertificateException untrusted:
|
||||
// The pinning remembers its last rejection; once trusted, a later network error can still carry it.
|
||||
if (!_settings.TrustedFingerprints.Contains(untrusted.Fingerprint, StringComparer.OrdinalIgnoreCase))
|
||||
problem = ServerProblem.CertificateChanged;
|
||||
return true;
|
||||
case HttpRequestException:
|
||||
return true;
|
||||
case OperationCanceledException when !ct.IsCancellationRequested:
|
||||
return true; // request timeout
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private void OnServerProblem(ServerProblem problem, Exception ex)
|
||||
{
|
||||
switch (problem)
|
||||
{
|
||||
case ServerProblem.SignedOut:
|
||||
Log.Warning("session", "The server rejected the token; signing out");
|
||||
StopProbing();
|
||||
ForgetToken();
|
||||
SessionEnded?.Invoke(this, problem);
|
||||
break;
|
||||
case ServerProblem.CertificateChanged:
|
||||
// Never upload to a server whose certificate changed: the user must sign in and confirm it again.
|
||||
Log.Warning("session", "The server certificate changed; sign in again to review it", ex);
|
||||
StopProbing();
|
||||
ForgetToken();
|
||||
SessionEnded?.Invoke(this, problem);
|
||||
break;
|
||||
default:
|
||||
if (State != ConnectionState.Offline) Log.Warning("session", "Server unreachable; retrying every 30 s", ex);
|
||||
State = ConnectionState.Offline;
|
||||
StartProbing();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private void StartProbing()
|
||||
{
|
||||
if (_probe is not null) return;
|
||||
_probe = new CancellationTokenSource();
|
||||
_ = ProbeAsync(_probe.Token);
|
||||
}
|
||||
|
||||
private void StopProbing()
|
||||
{
|
||||
_probe?.Cancel();
|
||||
_probe?.Dispose();
|
||||
_probe = null;
|
||||
}
|
||||
|
||||
private async Task ProbeAsync(CancellationToken ct)
|
||||
{
|
||||
try
|
||||
{
|
||||
while (!ct.IsCancellationRequested && State == ConnectionState.Offline)
|
||||
{
|
||||
await Task.Delay(ProbeInterval, ct);
|
||||
await RefreshAsync();
|
||||
}
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
private static SignInResult Classify(Exception ex, CancellationToken ct) => ex switch
|
||||
{
|
||||
UntrustedCertificateException => SignInResult.Untrusted,
|
||||
TitanoApiException { Status: HttpStatusCode.Unauthorized or HttpStatusCode.Forbidden } => SignInResult.BadCredentials,
|
||||
TitanoApiException { Status: HttpStatusCode.NotFound } => SignInResult.NotTitano,
|
||||
TitanoApiException api when api.IsTransient => SignInResult.Unreachable,
|
||||
JsonException or NotSupportedException => SignInResult.NotTitano,
|
||||
HttpRequestException => SignInResult.Unreachable,
|
||||
OperationCanceledException when !ct.IsCancellationRequested => SignInResult.Unreachable,
|
||||
_ => SignInResult.Failed,
|
||||
};
|
||||
|
||||
private bool Set<T>(ref T field, T value, [CallerMemberName] string? name = null)
|
||||
{
|
||||
if (EqualityComparer<T>.Default.Equals(field, value)) return false;
|
||||
field = value;
|
||||
OnPropertyChanged(name);
|
||||
return true;
|
||||
}
|
||||
|
||||
private void OnPropertyChanged([CallerMemberName] string? name = null) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
<ui:TitanoWindow x:Class="Titano.Uploader.Shell.ConfirmDialog"
|
||||
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
|
||||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
|
||||
xmlns:ui="clr-namespace:Titano.Ui.Controls;assembly=Titano.Ui"
|
||||
xmlns:l="clr-namespace:Titano.Ui.Localization;assembly=Titano.Ui"
|
||||
Title="{l:Loc Uploader.App.Title}"
|
||||
IsDialog="True" ResizeMode="NoResize" SizeToContent="Height" Width="440"
|
||||
WindowStartupLocation="CenterOwner" ShowInTaskbar="False">
|
||||
<!-- DESIGN §4 dialog: two buttons, safe action left and default, the action on the right. -->
|
||||
<StackPanel Margin="24,18,24,20">
|
||||
<TextBlock Text="{Binding Heading}" Style="{StaticResource Text.Title}" TextWrapping="Wrap" TextTrimming="None" />
|
||||
<TextBlock Text="{Binding Message}" Margin="0,8,0,0" Foreground="{DynamicResource Brush.TextMuted}" TextWrapping="Wrap" />
|
||||
<Border Style="{StaticResource Border.Card}" Margin="0,16,0,0" Padding="12,10" ToolTip="{Binding DetailToolTip}"
|
||||
Visibility="{Binding Detail, Converter={x:Static ui:NullToCollapsedConverter.Instance}}">
|
||||
<TextBlock Text="{Binding Detail}" FontFamily="{StaticResource Font.Mono}" FontSize="{StaticResource Size.Secondary}" TextWrapping="Wrap" LineHeight="18" />
|
||||
</Border>
|
||||
<StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,24,0,0">
|
||||
<Button Content="{Binding SafeText}" ToolTip="{Binding SafeToolTip}" IsDefault="True" IsCancel="True" MinWidth="96" Click="OnSafe" />
|
||||
<Button x:Name="Action" Content="{Binding ActionText}" ToolTip="{Binding ActionToolTip}" MinWidth="96" Margin="8,0,0,0" Click="OnAction" />
|
||||
</StackPanel>
|
||||
</StackPanel>
|
||||
</ui:TitanoWindow>
|
||||
@@ -0,0 +1,47 @@
|
||||
using System.Windows;
|
||||
using Titano.Ui.Controls;
|
||||
|
||||
namespace Titano.Uploader.Shell;
|
||||
|
||||
/// <summary>Texts of a <see cref="ConfirmDialog"/>.</summary>
|
||||
public sealed record ConfirmRequest
|
||||
{
|
||||
public required string Heading { get; init; }
|
||||
public required string Message { get; init; }
|
||||
|
||||
/// <summary>Monospaced detail (certificate fingerprint); null hides it.</summary>
|
||||
public string? Detail { get; init; }
|
||||
|
||||
public string? DetailToolTip { get; init; }
|
||||
public required string SafeText { get; init; }
|
||||
public required string SafeToolTip { get; init; }
|
||||
public required string ActionText { get; init; }
|
||||
public required string ActionToolTip { get; init; }
|
||||
|
||||
/// <summary>Warning-outlined action (never a primary) for data-destroying choices.</summary>
|
||||
public bool IsDestructive { get; init; }
|
||||
}
|
||||
|
||||
/// <summary>Modal confirmation used for trusting a certificate and for destructive options (BRIEF §12.1).</summary>
|
||||
public sealed partial class ConfirmDialog : TitanoWindow
|
||||
{
|
||||
private ConfirmDialog(ConfirmRequest request)
|
||||
{
|
||||
DataContext = request;
|
||||
InitializeComponent();
|
||||
Action.SetResourceReference(StyleProperty, request.IsDestructive ? "Button.Destructive" : "Button.Primary");
|
||||
}
|
||||
|
||||
/// <summary>True when the user chose the action.</summary>
|
||||
public static bool Ask(Window? owner, ConfirmRequest request)
|
||||
{
|
||||
var dialog = new ConfirmDialog(request);
|
||||
if (owner is { IsVisible: true }) dialog.Owner = owner;
|
||||
else dialog.WindowStartupLocation = WindowStartupLocation.CenterScreen;
|
||||
return dialog.ShowDialog() == true;
|
||||
}
|
||||
|
||||
private void OnSafe(object sender, RoutedEventArgs e) => DialogResult = false;
|
||||
|
||||
private void OnAction(object sender, RoutedEventArgs e) => DialogResult = true;
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
using System.Collections.ObjectModel;
|
||||
using System.Windows.Input;
|
||||
using Titano.Core.Localization;
|
||||
using Titano.Ui.Mvvm;
|
||||
using Titano.Uploader.Server;
|
||||
|
||||
namespace Titano.Uploader.Shell;
|
||||
|
||||
/// <summary>
|
||||
/// First-run and signed-out form: server address (with servers found on the LAN), user, password. A self-signed
|
||||
/// certificate is shown to the user once (trust on first use) before the password is sent.
|
||||
/// </summary>
|
||||
public sealed class ConnectViewModel : ObservableObject
|
||||
{
|
||||
private readonly IServerSession _session;
|
||||
private readonly IUploaderDialogs _dialogs;
|
||||
private string _address;
|
||||
private string _username;
|
||||
private string? _errorText;
|
||||
|
||||
public ConnectViewModel(IServerSession session, IUploaderDialogs dialogs, string? address, string? username)
|
||||
{
|
||||
_session = session;
|
||||
_dialogs = dialogs;
|
||||
_address = Display(address);
|
||||
_username = username ?? string.Empty;
|
||||
SignInCommand = new AsyncRelayCommand(SignInAsync);
|
||||
UseServerCommand = new RelayCommand(p =>
|
||||
{
|
||||
if (p is DiscoveredServer s) Address = s.Address;
|
||||
});
|
||||
}
|
||||
|
||||
/// <summary>Servers that announced themselves on this network.</summary>
|
||||
public ObservableCollection<DiscoveredServer> Discovered { get; } = [];
|
||||
|
||||
public ICommand SignInCommand { get; }
|
||||
public ICommand UseServerCommand { get; }
|
||||
|
||||
public string Address
|
||||
{
|
||||
get => _address;
|
||||
set => Set(ref _address, value);
|
||||
}
|
||||
|
||||
public string Username
|
||||
{
|
||||
get => _username;
|
||||
set => Set(ref _username, value);
|
||||
}
|
||||
|
||||
/// <summary>Set from the view's PasswordBox; never stored.</summary>
|
||||
public string Password { private get; set; } = string.Empty;
|
||||
|
||||
/// <summary>One sentence saying what went wrong; the retry action sits next to it.</summary>
|
||||
public string? ErrorText
|
||||
{
|
||||
get => _errorText;
|
||||
private set => Set(ref _errorText, value);
|
||||
}
|
||||
|
||||
/// <summary>Shows the server address without the trailing slash of the stored base URL.</summary>
|
||||
public static string Display(string? address) => address?.TrimEnd('/') ?? string.Empty;
|
||||
|
||||
public void AddDiscovered(DiscoveredServer server)
|
||||
{
|
||||
if (Discovered.Any(d => d.Address == server.Address)) return;
|
||||
Discovered.Add(server);
|
||||
if (Address.Length == 0 && Discovered.Count == 1) Address = server.Address;
|
||||
}
|
||||
|
||||
private async Task SignInAsync()
|
||||
{
|
||||
if (_session.State is not (ConnectionState.NotConfigured or ConnectionState.SignedOut)) return;
|
||||
ErrorText = null;
|
||||
var (result, fingerprint) = await _session.SignInAsync(Address, Username.Trim(), Password, CancellationToken.None);
|
||||
if (result == SignInResult.Untrusted && fingerprint is not null)
|
||||
{
|
||||
if (!_dialogs.ConfirmTrust(Display(Address), fingerprint))
|
||||
{
|
||||
ErrorText = Loc.L("Uploader.Connect.Error.Untrusted");
|
||||
return;
|
||||
}
|
||||
_session.Trust(fingerprint);
|
||||
(result, _) = await _session.SignInAsync(Address, Username.Trim(), Password, CancellationToken.None);
|
||||
}
|
||||
ErrorText = result switch
|
||||
{
|
||||
SignInResult.Success => null,
|
||||
SignInResult.InvalidAddress => Loc.L("Uploader.Connect.Error.InvalidAddress"),
|
||||
SignInResult.Unreachable => Loc.L("Uploader.Connect.Error.Unreachable"),
|
||||
SignInResult.NotTitano => Loc.L("Uploader.Connect.Error.NotTitano"),
|
||||
SignInResult.BadCredentials => Loc.L("Uploader.Connect.Error.BadCredentials"),
|
||||
SignInResult.Untrusted => Loc.L("Uploader.Connect.Error.Untrusted"),
|
||||
_ => Loc.L("Uploader.Connect.Error.Failed"),
|
||||
};
|
||||
if (result != SignInResult.Success) return;
|
||||
Address = Display(_session.Address);
|
||||
Password = string.Empty;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
using System.Globalization;
|
||||
using System.Windows;
|
||||
using System.Windows.Data;
|
||||
using Titano.Core.Localization;
|
||||
using Titano.Ui.Controls;
|
||||
using Titano.Uploader.Text;
|
||||
using Titano.Uploader.Uploads;
|
||||
|
||||
namespace Titano.Uploader.Shell;
|
||||
|
||||
/// <summary><see cref="UploadItemState"/> → status glyph kind (DESIGN §4: colour always paired with a glyph and a word).</summary>
|
||||
public sealed class UploadStateKindConverter : IValueConverter
|
||||
{
|
||||
public static UploadStateKindConverter Instance { get; } = new();
|
||||
|
||||
public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture) => value switch
|
||||
{
|
||||
UploadItemState.Hashing => StatusKind.Analysing,
|
||||
UploadItemState.Uploading => StatusKind.Running,
|
||||
UploadItemState.Verified => StatusKind.Done,
|
||||
UploadItemState.Skipped => StatusKind.Synced,
|
||||
UploadItemState.Failed => StatusKind.Failed,
|
||||
_ => StatusKind.Queued,
|
||||
};
|
||||
|
||||
public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) => throw new NotSupportedException();
|
||||
}
|
||||
|
||||
/// <summary><see cref="UploadItemState"/> → its localized word.</summary>
|
||||
public sealed class UploadStateTextConverter : IValueConverter
|
||||
{
|
||||
public static UploadStateTextConverter Instance { get; } = new();
|
||||
|
||||
public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture) => value switch
|
||||
{
|
||||
UploadItemState.Hashing => Loc.L("Uploader.State.Hashing"),
|
||||
UploadItemState.Uploading => Loc.L("Uploader.State.Uploading"),
|
||||
UploadItemState.Verified => Loc.L("Uploader.State.Verified"),
|
||||
UploadItemState.Skipped => Loc.L("Uploader.State.Skipped"),
|
||||
UploadItemState.Failed => Loc.L("Uploader.State.Failed"),
|
||||
_ => Loc.L("Uploader.State.Queued"),
|
||||
};
|
||||
|
||||
public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) => throw new NotSupportedException();
|
||||
}
|
||||
|
||||
/// <summary>(<see cref="UploadFailure"/>, detail) → one sentence for the tooltip of a failed item; null otherwise.</summary>
|
||||
public sealed class FailureTextConverter : IMultiValueConverter
|
||||
{
|
||||
public static FailureTextConverter Instance { get; } = new();
|
||||
|
||||
public object? Convert(object?[] values, Type targetType, object? parameter, CultureInfo culture) =>
|
||||
values is [UploadFailure failure, var detail, ..] ? Describe(failure, detail as string) : null;
|
||||
|
||||
public object[] ConvertBack(object? value, Type[] targetTypes, object? parameter, CultureInfo culture) => throw new NotSupportedException();
|
||||
|
||||
private static string? Describe(UploadFailure failure, string? detail) => failure switch
|
||||
{
|
||||
UploadFailure.FileMissing => Loc.L("Uploader.Failure.FileMissing"),
|
||||
UploadFailure.FileUnreadable => Loc.L("Uploader.Failure.FileUnreadable"),
|
||||
UploadFailure.FileChanged => Loc.L("Uploader.Failure.FileChanged"),
|
||||
UploadFailure.ServerRejected => Loc.L("Uploader.Failure.ServerRejected", detail ?? string.Empty),
|
||||
UploadFailure.Unexpected => Loc.L("Uploader.Failure.Unexpected"),
|
||||
_ => null,
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>Visible only for <see cref="UploadItemState.Failed"/>; hidden (keeping its space) otherwise so rows stay aligned.</summary>
|
||||
public sealed class FailedToVisibleConverter : IValueConverter
|
||||
{
|
||||
public static FailedToVisibleConverter Instance { get; } = new();
|
||||
|
||||
public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture) =>
|
||||
value is UploadItemState.Failed ? Visibility.Visible : Visibility.Hidden;
|
||||
|
||||
public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) => throw new NotSupportedException();
|
||||
}
|
||||
|
||||
/// <summary>Byte count → "25.4 MB".</summary>
|
||||
public sealed class SizeConverter : IValueConverter
|
||||
{
|
||||
public static SizeConverter Instance { get; } = new();
|
||||
|
||||
public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture) =>
|
||||
value is long bytes ? UploaderText.Bytes(bytes, Loc.Culture) : string.Empty;
|
||||
|
||||
public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) => throw new NotSupportedException();
|
||||
}
|
||||
@@ -0,0 +1,554 @@
|
||||
using System.Collections.ObjectModel;
|
||||
using System.ComponentModel;
|
||||
using System.Diagnostics;
|
||||
using System.Globalization;
|
||||
using System.IO;
|
||||
using System.Windows.Input;
|
||||
using System.Windows.Threading;
|
||||
using Titano.Core.Diagnostics;
|
||||
using Titano.Core.Localization;
|
||||
using Titano.Ui.Controls;
|
||||
using Titano.Ui.Mvvm;
|
||||
using Titano.Uploader.Infrastructure;
|
||||
using Titano.Uploader.Server;
|
||||
using Titano.Uploader.Sources;
|
||||
using Titano.Uploader.Text;
|
||||
using Titano.Uploader.Uploads;
|
||||
using Titano.Uploader.Watching;
|
||||
|
||||
namespace Titano.Uploader.Shell;
|
||||
|
||||
/// <summary>A sequence offered as upload target.</summary>
|
||||
public sealed record SequenceOption(Guid Id, string Title);
|
||||
|
||||
/// <summary>Everything the window works with; the capture mode passes design-time implementations.</summary>
|
||||
public sealed record UploaderServices(
|
||||
UploaderSettings Settings,
|
||||
Action SaveSettings,
|
||||
IServerSession Session,
|
||||
UploadQueue Queue,
|
||||
IUploadEngine Engine,
|
||||
IStartupRegistration Startup,
|
||||
IUploaderDialogs Dialogs,
|
||||
WatchFolderService Watch,
|
||||
ProcessedFileMemory Memory,
|
||||
string LogDirectory);
|
||||
|
||||
/// <summary>State of the uploader window (BRIEF §15, mockup Uploader.html).</summary>
|
||||
public sealed class MainViewModel : LocalizedViewModel
|
||||
{
|
||||
private readonly UploaderServices _s;
|
||||
private readonly DispatcherTimer _refresh;
|
||||
private UploadTargetMode _target;
|
||||
private SequenceOption? _selectedSequence;
|
||||
private bool _loadingSequences;
|
||||
private string _newTitle;
|
||||
private bool _isSettingsOpen;
|
||||
private bool _startWithWindows;
|
||||
private string _queueText = string.Empty;
|
||||
private string _progressText = string.Empty;
|
||||
private string? _currentFileText;
|
||||
private double _progress;
|
||||
private UploadItem? _currentItem;
|
||||
|
||||
public MainViewModel(UploaderServices services)
|
||||
{
|
||||
_s = services;
|
||||
_target = services.Settings.Target;
|
||||
_newTitle = services.Settings.NewSequenceTitle ?? string.Empty;
|
||||
_startWithWindows = services.Startup.IsEnabled;
|
||||
Connect = new ConnectViewModel(services.Session, services.Dialogs, services.Settings.ServerUrl, services.Settings.Username);
|
||||
foreach (var w in services.Settings.WatchFolders) WatchFolders.Add(NewWatchFolder(w.Path, w.IntervalSeconds));
|
||||
|
||||
OpenSettingsCommand = new RelayCommand(() => IsSettingsOpen = true);
|
||||
CloseSettingsCommand = new RelayCommand(() => IsSettingsOpen = false);
|
||||
SignOutCommand = new AsyncRelayCommand(SignOutAsync);
|
||||
BrowseFilesCommand = new AsyncRelayCommand(() => EnqueueAsync(_s.Dialogs.PickFiles()));
|
||||
BrowseFolderCommand = new AsyncRelayCommand(() => _s.Dialogs.PickFolder() is { } folder ? EnqueueAsync([folder]) : Task.CompletedTask);
|
||||
RefreshSequencesCommand = new AsyncRelayCommand(LoadSequencesAsync);
|
||||
PauseCommand = new RelayCommand(TogglePause, () => HasItems);
|
||||
StopCommand = new RelayCommand(() => _s.Engine.StopAndClear(), () => HasItems);
|
||||
RetryItemCommand = new RelayCommand(p =>
|
||||
{
|
||||
if (p is UploadItem item) _s.Engine.Retry(item);
|
||||
});
|
||||
AddWatchFolderCommand = new RelayCommand(AddWatchFolder);
|
||||
ToggleDeleteAfterUploadCommand = new RelayCommand(ToggleDeleteAfterUpload);
|
||||
|
||||
_s.Session.PropertyChanged += OnSessionChanged;
|
||||
_s.Session.SessionEnded += OnSessionEnded;
|
||||
_s.Engine.PropertyChanged += (_, _) => RefreshQueue();
|
||||
_s.Engine.Drained += OnDrained;
|
||||
_s.Queue.Items.CollectionChanged += (_, _) =>
|
||||
{
|
||||
OnPropertyChanged(nameof(HasItems));
|
||||
CommandManager.InvalidateRequerySuggested();
|
||||
};
|
||||
_refresh = new DispatcherTimer(DispatcherPriority.Background) { Interval = TimeSpan.FromMilliseconds(500) };
|
||||
_refresh.Tick += (_, _) => RefreshQueue();
|
||||
RefreshQueue();
|
||||
}
|
||||
|
||||
/// <summary>Raised when the queue finished while work was done, with the number of files the server confirmed.</summary>
|
||||
public event Action<int>? UploadsCompleted;
|
||||
|
||||
public ConnectViewModel Connect { get; }
|
||||
|
||||
/// <summary>In-window notifications; the window forwards them to its <see cref="ToastHost"/>.</summary>
|
||||
public ObservableCollection<Toast> PendingToasts { get; } = [];
|
||||
|
||||
public ICommand OpenSettingsCommand { get; }
|
||||
public ICommand CloseSettingsCommand { get; }
|
||||
public ICommand SignOutCommand { get; }
|
||||
public ICommand BrowseFilesCommand { get; }
|
||||
public ICommand BrowseFolderCommand { get; }
|
||||
public ICommand RefreshSequencesCommand { get; }
|
||||
public ICommand PauseCommand { get; }
|
||||
public ICommand StopCommand { get; }
|
||||
public ICommand RetryItemCommand { get; }
|
||||
public ICommand AddWatchFolderCommand { get; }
|
||||
public ICommand ToggleDeleteAfterUploadCommand { get; }
|
||||
|
||||
// ---------------- Header ----------------
|
||||
|
||||
public string ServerText => _s.Session.State == ConnectionState.NotConfigured
|
||||
? Loc.L("Uploader.Header.NotConnected")
|
||||
: ConnectViewModel.Display(_s.Session.Address);
|
||||
|
||||
public string? UserText => _s.Session.State is ConnectionState.Connected or ConnectionState.Offline or ConnectionState.SigningIn ? _s.Session.Username : null;
|
||||
|
||||
public StatusKind ConnectionKind => _s.Session.State switch
|
||||
{
|
||||
ConnectionState.Connected => StatusKind.Online,
|
||||
ConnectionState.SigningIn => StatusKind.Running,
|
||||
_ => StatusKind.Offline,
|
||||
};
|
||||
|
||||
/// <summary>Null on first run, when the server line already says "Not connected".</summary>
|
||||
public string? ConnectionText => _s.Session.State switch
|
||||
{
|
||||
ConnectionState.Connected => Loc.L("Uploader.Status.Connected"),
|
||||
ConnectionState.SigningIn => Loc.L("Uploader.Status.SigningIn"),
|
||||
ConnectionState.Offline => Loc.L("Uploader.Status.Offline"),
|
||||
ConnectionState.SignedOut => Loc.L("Uploader.Status.SignedOut"),
|
||||
_ => null,
|
||||
};
|
||||
|
||||
/// <summary>"1.9 TB free of 5 TB"; null without a quota.</summary>
|
||||
public string? QuotaText => _s.Session.State == ConnectionState.Connected && _s.Session.QuotaBytes > 0
|
||||
? Loc.L("Uploader.Header.Quota", UploaderText.Bytes(Math.Max(0, _s.Session.QuotaBytes - _s.Session.UsedBytes), Loc.Culture), UploaderText.Bytes(_s.Session.QuotaBytes, Loc.Culture))
|
||||
: null;
|
||||
|
||||
/// <summary>The sign-in form replaces the queue on first run and after signing out.</summary>
|
||||
public bool IsConnectVisible => _s.Session.State is ConnectionState.NotConfigured or ConnectionState.SignedOut;
|
||||
|
||||
public bool IsSettingsOpen
|
||||
{
|
||||
get => _isSettingsOpen;
|
||||
set => Set(ref _isSettingsOpen, value);
|
||||
}
|
||||
|
||||
// ---------------- Target ----------------
|
||||
|
||||
public bool IsSessionsTarget
|
||||
{
|
||||
get => _target == UploadTargetMode.Sessions;
|
||||
set => SetTarget(value, UploadTargetMode.Sessions);
|
||||
}
|
||||
|
||||
public bool IsSequenceTarget
|
||||
{
|
||||
get => _target == UploadTargetMode.Sequence;
|
||||
set => SetTarget(value, UploadTargetMode.Sequence);
|
||||
}
|
||||
|
||||
public bool IsNewTarget
|
||||
{
|
||||
get => _target == UploadTargetMode.NewSequence;
|
||||
set => SetTarget(value, UploadTargetMode.NewSequence);
|
||||
}
|
||||
|
||||
public ObservableCollection<SequenceOption> Sequences { get; } = [];
|
||||
|
||||
public SequenceOption? SelectedSequence
|
||||
{
|
||||
get => _selectedSequence;
|
||||
set
|
||||
{
|
||||
if (_loadingSequences || !Set(ref _selectedSequence, value)) return;
|
||||
_s.Settings.TargetSequenceId = value?.Id;
|
||||
_s.SaveSettings();
|
||||
}
|
||||
}
|
||||
|
||||
public string NewTitle
|
||||
{
|
||||
get => _newTitle;
|
||||
set
|
||||
{
|
||||
if (!Set(ref _newTitle, value)) return;
|
||||
_s.Settings.NewSequenceTitle = value;
|
||||
_s.SaveSettings();
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------- Queue ----------------
|
||||
|
||||
public ObservableCollection<UploadItem> Items => _s.Queue.Items;
|
||||
|
||||
public bool HasItems => _s.Queue.Items.Count > 0;
|
||||
|
||||
/// <summary>"4,812 files · 96.2 GB · 38 MB/s · 41 min left".</summary>
|
||||
public string QueueText
|
||||
{
|
||||
get => _queueText;
|
||||
private set => Set(ref _queueText, value);
|
||||
}
|
||||
|
||||
/// <summary>"2,214 of 4,812 sent · 2,201 verified by the server · 0 retries".</summary>
|
||||
public string ProgressText
|
||||
{
|
||||
get => _progressText;
|
||||
private set => Set(ref _progressText, value);
|
||||
}
|
||||
|
||||
public string? CurrentFileText
|
||||
{
|
||||
get => _currentFileText;
|
||||
private set => Set(ref _currentFileText, value);
|
||||
}
|
||||
|
||||
public double Progress
|
||||
{
|
||||
get => _progress;
|
||||
private set => Set(ref _progress, value);
|
||||
}
|
||||
|
||||
/// <summary>The item being uploaded; the list keeps it in view.</summary>
|
||||
public UploadItem? CurrentItem
|
||||
{
|
||||
get => _currentItem;
|
||||
private set => Set(ref _currentItem, value);
|
||||
}
|
||||
|
||||
public bool IsPaused => _s.Queue.IsPaused;
|
||||
|
||||
public string PauseToolTip => Loc.L(IsPaused ? "Tooltips.Uploader.Resume" : "Tooltips.Uploader.Pause");
|
||||
|
||||
/// <summary>Accessible name of the pause/resume button (also the tray menu entry).</summary>
|
||||
public string PauseLabel => Loc.L(IsPaused ? "Uploader.Action.Resume" : "Uploader.Action.Pause");
|
||||
|
||||
/// <summary>Upload limit in MB/s as typed; 0 = unlimited. Text that is not a whole number reverts.</summary>
|
||||
public string BandwidthLimitText
|
||||
{
|
||||
get => _s.Session.BandwidthLimit.ToString(Loc.Culture);
|
||||
set
|
||||
{
|
||||
if (int.TryParse(value, NumberStyles.Integer, Loc.Culture, out var limit))
|
||||
{
|
||||
limit = Math.Clamp(limit, 0, 100_000);
|
||||
if (limit != _s.Session.BandwidthLimit)
|
||||
{
|
||||
_s.Session.BandwidthLimit = limit;
|
||||
_s.Settings.BandwidthLimit = limit;
|
||||
_s.SaveSettings();
|
||||
}
|
||||
}
|
||||
OnPropertyChanged();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Tray hover text.</summary>
|
||||
public string TrayText => Loc.L("Uploader.App.Title") + (HasItems ? " · " + QueueText : string.Empty);
|
||||
|
||||
// ---------------- Watch folders ----------------
|
||||
|
||||
public ObservableCollection<WatchFolderViewModel> WatchFolders { get; } = [];
|
||||
|
||||
// ---------------- Options ----------------
|
||||
|
||||
/// <summary>Turned on only through <see cref="ToggleDeleteAfterUploadCommand"/>, which asks first.</summary>
|
||||
public bool DeleteAfterUpload => _s.Settings.DeleteAfterUpload;
|
||||
|
||||
public bool StartWithWindows
|
||||
{
|
||||
get => _startWithWindows;
|
||||
set
|
||||
{
|
||||
_s.Startup.SetEnabled(value);
|
||||
// Read back: the registry may refuse the change.
|
||||
_startWithWindows = _s.Startup.IsEnabled;
|
||||
OnPropertyChanged();
|
||||
}
|
||||
}
|
||||
|
||||
public bool MinimizeToTray
|
||||
{
|
||||
get => _s.Settings.MinimizeToTray;
|
||||
set
|
||||
{
|
||||
if (_s.Settings.MinimizeToTray == value) return;
|
||||
_s.Settings.MinimizeToTray = value;
|
||||
_s.SaveSettings();
|
||||
OnPropertyChanged();
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------- Actions ----------------
|
||||
|
||||
/// <summary>Starts the periodic refresh and, when signed in, loads the sequence list.</summary>
|
||||
public void Start()
|
||||
{
|
||||
_refresh.Start();
|
||||
if (_s.Session.State == ConnectionState.Connected) _ = LoadSequencesAsync();
|
||||
}
|
||||
|
||||
/// <summary>Starts watching every configured folder.</summary>
|
||||
public void StartWatching()
|
||||
{
|
||||
foreach (var w in WatchFolders) _s.Watch.Watch(w.Path, TimeSpan.FromSeconds(w.IntervalSeconds));
|
||||
}
|
||||
|
||||
/// <summary>Adds the photos under <paramref name="paths"/> (files, folders, card roots) to the queue.</summary>
|
||||
public async Task EnqueueAsync(IReadOnlyList<string> paths)
|
||||
{
|
||||
if (paths.Count == 0) return;
|
||||
if (_target == UploadTargetMode.Sequence && SelectedSequence is null)
|
||||
{
|
||||
ShowToast(Loc.L("Uploader.Toast.ChooseSequence"));
|
||||
return;
|
||||
}
|
||||
var found = await Task.Run(() => PhotoScanner.Scan(paths));
|
||||
var fresh = found.Where(f => !_s.Queue.ContainsPath(f.Path)).ToList();
|
||||
if (fresh.Count == 0)
|
||||
{
|
||||
ShowToast(Loc.L("Uploader.Toast.NothingFound"));
|
||||
return;
|
||||
}
|
||||
var batch = new UploadBatch
|
||||
{
|
||||
Id = Guid.CreateVersion7(),
|
||||
Mode = _target,
|
||||
SequenceId = _target == UploadTargetMode.Sequence ? SelectedSequence?.Id : null,
|
||||
Title = _target == UploadTargetMode.NewSequence ? NewTitle.Trim() : null,
|
||||
};
|
||||
var entries = _target == UploadTargetMode.Sessions
|
||||
? SessionEntries(fresh, null, null, out _)
|
||||
: [.. fresh.OrderBy(f => f.CapturedAt).Select(f => new QueueEntry(f.Path, f.Size, f.ModifiedUtc, f.CapturedAt, null, null))];
|
||||
var added = Add(batch, entries);
|
||||
Log.Info("queue", $"{added} file(s) added from {paths.Count} path(s), target {_target}");
|
||||
ShowToast(Loc.Plural("Uploader.Toast.Added", added));
|
||||
}
|
||||
|
||||
/// <summary>Queues stable new photos of a watch folder; they join the folder's last session when close in time.</summary>
|
||||
public void OnWatchFilesReady(string root, IReadOnlyList<SourceFile> files)
|
||||
{
|
||||
var fresh = files.Where(f => !_s.Queue.ContainsPath(f.Path)).ToList();
|
||||
if (fresh.Count == 0) return;
|
||||
var entries = SessionEntries(fresh, root, _s.Memory.GetSession(root), out var last);
|
||||
Add(new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions }, entries);
|
||||
_s.Memory.SetSession(root, last);
|
||||
}
|
||||
|
||||
public void OnWatchAvailabilityChanged(string root, bool available)
|
||||
{
|
||||
var folder = WatchFolders.FirstOrDefault(w => string.Equals(w.Path, root, StringComparison.OrdinalIgnoreCase));
|
||||
if (folder is not null) folder.IsAvailable = available;
|
||||
}
|
||||
|
||||
/// <summary>Errors are one sentence plus one action (BRIEF §0.2 rule 6).</summary>
|
||||
public void ReportError(Exception ex)
|
||||
{
|
||||
Log.Error("ui", "Operation failed", ex);
|
||||
ShowToast(Loc.L("Errors.Unexpected"), Loc.L("Common.OpenLogs"), Loc.L("Tooltips.Common.OpenLogs"), new RelayCommand(OpenLogs));
|
||||
}
|
||||
|
||||
public void TogglePause()
|
||||
{
|
||||
if (_s.Queue.IsPaused) _s.Engine.Resume();
|
||||
else _s.Engine.Pause();
|
||||
RefreshQueue();
|
||||
}
|
||||
|
||||
public override void Dispose()
|
||||
{
|
||||
_refresh.Stop();
|
||||
_s.Session.PropertyChanged -= OnSessionChanged;
|
||||
_s.Session.SessionEnded -= OnSessionEnded;
|
||||
_s.Engine.Drained -= OnDrained;
|
||||
base.Dispose();
|
||||
}
|
||||
|
||||
private int Add(UploadBatch batch, IReadOnlyList<QueueEntry> entries)
|
||||
{
|
||||
// A new batch after a finished one starts a fresh count.
|
||||
if (!_s.Queue.HasPending) _s.Queue.RemoveCompleted();
|
||||
var added = _s.Queue.Add(batch, entries);
|
||||
_s.Engine.Pump();
|
||||
RefreshQueue();
|
||||
return added;
|
||||
}
|
||||
|
||||
/// <summary>Session keys per source folder (BRIEF §13 rules), entries in capture order.</summary>
|
||||
private static List<QueueEntry> SessionEntries(IReadOnlyList<SourceFile> files, string? watchRoot, SessionContinuation? previous, out SessionContinuation? last)
|
||||
{
|
||||
var entries = new List<QueueEntry>(files.Count);
|
||||
last = previous;
|
||||
foreach (var group in files.GroupBy(f => watchRoot ?? f.Root, StringComparer.OrdinalIgnoreCase))
|
||||
{
|
||||
var ordered = group.OrderBy(f => f.CapturedAt).ToList();
|
||||
var assignment = SessionGrouper.Assign([.. ordered.Select(f => f.CapturedAt)], SessionGrouper.SourceTag(group.Key), watchRoot is null ? null : previous);
|
||||
for (var i = 0; i < ordered.Count; i++)
|
||||
{
|
||||
var f = ordered[i];
|
||||
entries.Add(new QueueEntry(f.Path, f.Size, f.ModifiedUtc, f.CapturedAt, assignment.Keys[i], watchRoot));
|
||||
}
|
||||
last = assignment.Last;
|
||||
}
|
||||
return entries;
|
||||
}
|
||||
|
||||
/// <summary>Recomputes the queue line, progress and current file (also every 500 ms once started).</summary>
|
||||
public void RefreshQueue()
|
||||
{
|
||||
var summary = QueueSummary.From(_s.Queue.Items);
|
||||
var rate = _s.Engine.BytesPerSecond;
|
||||
var activity = summary.Files == 0 ? QueueActivity.Idle : _s.Engine.Status switch
|
||||
{
|
||||
EngineStatus.Paused => QueueActivity.Paused,
|
||||
EngineStatus.WaitingForServer => QueueActivity.WaitingForServer,
|
||||
EngineStatus.Running => QueueActivity.Running,
|
||||
_ => QueueActivity.Done,
|
||||
};
|
||||
QueueText = UploaderText.QueueLine(summary, activity, rate, RateMeter.TimeLeft(summary.RemainingBytes, rate), Loc.Culture);
|
||||
ProgressText = summary.Files == 0 ? string.Empty : UploaderText.ProgressLine(summary, Loc.Culture);
|
||||
Progress = summary.Progress;
|
||||
CurrentFileText = summary.CurrentFile;
|
||||
CurrentItem = _s.Queue.Items.FirstOrDefault(i => i.State == UploadItemState.Uploading) ?? _s.Queue.Items.FirstOrDefault(i => i.IsActive);
|
||||
OnPropertyChanged(nameof(IsPaused));
|
||||
OnPropertyChanged(nameof(PauseToolTip));
|
||||
OnPropertyChanged(nameof(PauseLabel));
|
||||
OnPropertyChanged(nameof(TrayText));
|
||||
}
|
||||
|
||||
private void SetTarget(bool selected, UploadTargetMode mode)
|
||||
{
|
||||
if (!selected || _target == mode) return;
|
||||
_target = mode;
|
||||
_s.Settings.Target = mode;
|
||||
_s.SaveSettings();
|
||||
OnPropertyChanged(nameof(IsSessionsTarget));
|
||||
OnPropertyChanged(nameof(IsSequenceTarget));
|
||||
OnPropertyChanged(nameof(IsNewTarget));
|
||||
if (mode == UploadTargetMode.Sequence && Sequences.Count == 0) _ = LoadSequencesAsync();
|
||||
}
|
||||
|
||||
private async Task LoadSequencesAsync()
|
||||
{
|
||||
var list = await _s.Session.ListSequencesAsync(CancellationToken.None);
|
||||
if (list.Count == 0 && Sequences.Count > 0) return;
|
||||
_loadingSequences = true;
|
||||
try
|
||||
{
|
||||
Sequences.Clear();
|
||||
foreach (var s in list.OrderBy(s => s.DisplayTitle, StringComparer.CurrentCultureIgnoreCase)) Sequences.Add(new SequenceOption(s.Id, s.DisplayTitle));
|
||||
}
|
||||
finally
|
||||
{
|
||||
_loadingSequences = false;
|
||||
}
|
||||
_selectedSequence = Sequences.FirstOrDefault(s => s.Id == _s.Settings.TargetSequenceId);
|
||||
OnPropertyChanged(nameof(SelectedSequence));
|
||||
}
|
||||
|
||||
private async Task SignOutAsync()
|
||||
{
|
||||
IsSettingsOpen = false;
|
||||
await _s.Session.SignOutAsync();
|
||||
}
|
||||
|
||||
private void ToggleDeleteAfterUpload()
|
||||
{
|
||||
var enable = !_s.Settings.DeleteAfterUpload;
|
||||
if (enable && !_s.Dialogs.ConfirmDeleteAfterUpload())
|
||||
{
|
||||
// The check box toggled itself; put it back.
|
||||
OnPropertyChanged(nameof(DeleteAfterUpload));
|
||||
return;
|
||||
}
|
||||
_s.Settings.DeleteAfterUpload = enable;
|
||||
_s.SaveSettings();
|
||||
Log.Info("settings", "Delete after verified upload " + (enable ? "on" : "off"));
|
||||
OnPropertyChanged(nameof(DeleteAfterUpload));
|
||||
}
|
||||
|
||||
private void AddWatchFolder()
|
||||
{
|
||||
if (_s.Dialogs.PickWatchFolder() is not { } path) return;
|
||||
if (WatchFolders.Any(w => string.Equals(w.Path, path, StringComparison.OrdinalIgnoreCase))) return;
|
||||
var interval = (int)WatchFolderService.DefaultInterval(path).TotalSeconds;
|
||||
_s.Settings.WatchFolders.Add(new UploaderSettings.WatchFolderSettings { Path = path, IntervalSeconds = interval });
|
||||
_s.SaveSettings();
|
||||
WatchFolders.Add(NewWatchFolder(path, interval));
|
||||
_s.Watch.Watch(path, TimeSpan.FromSeconds(interval));
|
||||
}
|
||||
|
||||
private WatchFolderViewModel NewWatchFolder(string path, int intervalSeconds) =>
|
||||
new(path, intervalSeconds, WatchFolderService.IsNetworkPath(path), SetWatchInterval, RemoveWatchFolder);
|
||||
|
||||
private void SetWatchInterval(WatchFolderViewModel folder, int seconds)
|
||||
{
|
||||
folder.IntervalSeconds = seconds;
|
||||
foreach (var w in _s.Settings.WatchFolders.Where(w => string.Equals(w.Path, folder.Path, StringComparison.OrdinalIgnoreCase))) w.IntervalSeconds = seconds;
|
||||
_s.SaveSettings();
|
||||
_s.Watch.Watch(folder.Path, TimeSpan.FromSeconds(seconds));
|
||||
}
|
||||
|
||||
private void RemoveWatchFolder(WatchFolderViewModel folder)
|
||||
{
|
||||
_s.Watch.Stop(folder.Path);
|
||||
_s.Memory.RemoveFolder(folder.Path);
|
||||
_s.Settings.WatchFolders.RemoveAll(w => string.Equals(w.Path, folder.Path, StringComparison.OrdinalIgnoreCase));
|
||||
_s.SaveSettings();
|
||||
WatchFolders.Remove(folder);
|
||||
}
|
||||
|
||||
private void OnSessionChanged(object? sender, PropertyChangedEventArgs e)
|
||||
{
|
||||
OnPropertyChanged(nameof(ServerText));
|
||||
OnPropertyChanged(nameof(UserText));
|
||||
OnPropertyChanged(nameof(ConnectionKind));
|
||||
OnPropertyChanged(nameof(ConnectionText));
|
||||
OnPropertyChanged(nameof(QuotaText));
|
||||
OnPropertyChanged(nameof(IsConnectVisible));
|
||||
OnPropertyChanged(nameof(BandwidthLimitText));
|
||||
if (e.PropertyName != nameof(IServerSession.State)) return;
|
||||
if (_s.Session.State == ConnectionState.Connected) _ = LoadSequencesAsync();
|
||||
if (IsConnectVisible)
|
||||
{
|
||||
Connect.Address = ConnectViewModel.Display(_s.Session.Address);
|
||||
Connect.Username = _s.Session.Username ?? Connect.Username;
|
||||
}
|
||||
CommandManager.InvalidateRequerySuggested();
|
||||
}
|
||||
|
||||
private void OnSessionEnded(object? sender, ServerProblem problem) =>
|
||||
ShowToast(Loc.L(problem == ServerProblem.CertificateChanged ? "Uploader.Toast.CertificateChanged" : "Uploader.Toast.SignedOut"));
|
||||
|
||||
private void OnDrained(object? sender, EventArgs e)
|
||||
{
|
||||
// The queue restarts its count with each new batch, so every confirmed item belongs to this run.
|
||||
var confirmed = _s.Queue.Items.Count(i => i.IsDone);
|
||||
RefreshQueue();
|
||||
_ = _s.Session.RefreshAsync();
|
||||
if (confirmed > 0) UploadsCompleted?.Invoke(confirmed);
|
||||
}
|
||||
|
||||
private void ShowToast(string title, string? actionText = null, string? actionToolTip = null, ICommand? action = null) =>
|
||||
PendingToasts.Add(new Toast { Title = title, ActionText = actionText, ActionToolTip = actionToolTip, ActionCommand = action });
|
||||
|
||||
private void OpenLogs()
|
||||
{
|
||||
if (Directory.Exists(_s.LogDirectory)) Process.Start(new ProcessStartInfo(_s.LogDirectory) { UseShellExecute = true, Verb = "explore" });
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,433 @@
|
||||
<ui:TitanoWindow x:Class="Titano.Uploader.Shell.MainWindow"
|
||||
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
|
||||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
|
||||
xmlns:ui="clr-namespace:Titano.Ui.Controls;assembly=Titano.Ui"
|
||||
xmlns:l="clr-namespace:Titano.Ui.Localization;assembly=Titano.Ui"
|
||||
xmlns:s="clr-namespace:Titano.Uploader.Shell"
|
||||
xmlns:u="clr-namespace:Titano.Uploader.Uploads"
|
||||
Title="{l:Loc Uploader.App.Title}"
|
||||
Width="760" Height="560" MinWidth="640" MinHeight="480"
|
||||
WindowStartupLocation="CenterScreen" AllowDrop="True">
|
||||
<Window.Resources>
|
||||
<Style x:Key="Text.Label" TargetType="TextBlock" BasedOn="{StaticResource Text.Base}">
|
||||
<Setter Property="Foreground" Value="{DynamicResource Brush.TextMuted}" />
|
||||
<Setter Property="MinWidth" Value="92" />
|
||||
<Setter Property="Margin" Value="0,0,12,0" />
|
||||
</Style>
|
||||
|
||||
<!-- Watch-folder chip (mockup: 28 px pill, Card fill, status dot). -->
|
||||
<Style x:Key="Button.Chip" TargetType="Button" BasedOn="{StaticResource Button.Base}">
|
||||
<Setter Property="Height" Value="28" />
|
||||
<Setter Property="Padding" Value="10,0" />
|
||||
<Setter Property="ui:ControlState.CornerRadius" Value="14" />
|
||||
</Style>
|
||||
|
||||
<Style x:Key="Button.Round" TargetType="Button" BasedOn="{StaticResource Button.Icon}">
|
||||
<Setter Property="Width" Value="28" />
|
||||
<Setter Property="MinWidth" Value="28" />
|
||||
<Setter Property="Height" Value="28" />
|
||||
<Setter Property="ui:ControlState.CornerRadius" Value="14" />
|
||||
</Style>
|
||||
|
||||
<Style x:Key="Button.Square" TargetType="Button" BasedOn="{StaticResource Button.Icon}">
|
||||
<Setter Property="Width" Value="30" />
|
||||
<Setter Property="MinWidth" Value="30" />
|
||||
<Setter Property="Height" Value="30" />
|
||||
</Style>
|
||||
|
||||
<!-- Queue rows: hover only, no selection. -->
|
||||
<Style x:Key="QueueRow" TargetType="ListBoxItem">
|
||||
<Setter Property="Focusable" Value="False" />
|
||||
<Setter Property="HorizontalContentAlignment" Value="Stretch" />
|
||||
<Setter Property="Template">
|
||||
<Setter.Value>
|
||||
<ControlTemplate TargetType="ListBoxItem">
|
||||
<Border x:Name="Bd" Background="Transparent" CornerRadius="{StaticResource Radius.Control}" Padding="10,0,4,0">
|
||||
<ContentPresenter />
|
||||
</Border>
|
||||
<ControlTemplate.Triggers>
|
||||
<Trigger Property="IsMouseOver" Value="True">
|
||||
<Setter TargetName="Bd" Property="Background" Value="{DynamicResource Brush.Card}" />
|
||||
</Trigger>
|
||||
</ControlTemplate.Triggers>
|
||||
</ControlTemplate>
|
||||
</Setter.Value>
|
||||
</Setter>
|
||||
</Style>
|
||||
|
||||
<Style x:Key="WatchMenuItem" TargetType="MenuItem" BasedOn="{StaticResource {x:Type MenuItem}}">
|
||||
<Setter Property="Header" Value="{Binding Text}" />
|
||||
<Setter Property="Command" Value="{Binding Command}" />
|
||||
<Setter Property="IsChecked" Value="{Binding IsChecked, Mode=OneWay}" />
|
||||
<Setter Property="ToolTip" Value="{Binding ToolTip}" />
|
||||
<Style.Triggers>
|
||||
<DataTrigger Binding="{Binding IsSeparator}" Value="True">
|
||||
<Setter Property="Height" Value="9" />
|
||||
<Setter Property="IsEnabled" Value="False" />
|
||||
<Setter Property="Template">
|
||||
<Setter.Value>
|
||||
<ControlTemplate TargetType="MenuItem">
|
||||
<Border Height="1" Margin="4" Background="{DynamicResource Brush.Stroke}" />
|
||||
</ControlTemplate>
|
||||
</Setter.Value>
|
||||
</Setter>
|
||||
</DataTrigger>
|
||||
</Style.Triggers>
|
||||
</Style>
|
||||
</Window.Resources>
|
||||
|
||||
<Grid>
|
||||
<Grid.RowDefinitions>
|
||||
<RowDefinition Height="Auto" />
|
||||
<RowDefinition Height="*" />
|
||||
</Grid.RowDefinitions>
|
||||
|
||||
<!-- Header: server · user · connection, quota, settings. -->
|
||||
<Border Height="40" Background="{DynamicResource Brush.Surface}" BorderBrush="{DynamicResource Brush.Stroke}" BorderThickness="0,0,0,1" Padding="16,0,10,0">
|
||||
<DockPanel LastChildFill="True">
|
||||
<Button DockPanel.Dock="Right" Style="{StaticResource Button.Square}" ui:ButtonIcon.Glyph="{StaticResource Icon.Settings}"
|
||||
Command="{Binding OpenSettingsCommand}" ToolTip="{l:Loc Tooltips.Uploader.Settings}" AutomationProperties.Name="{l:Loc Uploader.Settings.Title}" />
|
||||
<TextBlock DockPanel.Dock="Right" Text="{Binding QuotaText}" Style="{StaticResource Text.Secondary}" Margin="12,0,12,0"
|
||||
ToolTip="{l:Loc Tooltips.Uploader.Quota}" Visibility="{Binding QuotaText, Converter={x:Static ui:NullToCollapsedConverter.Instance}}" />
|
||||
<StackPanel Orientation="Horizontal" VerticalAlignment="Center">
|
||||
<ui:Icon Glyph="{StaticResource Icon.Server}" Foreground="{DynamicResource Brush.Accent}" Margin="0,0,10,0" VerticalAlignment="Center" />
|
||||
<TextBlock Text="{Binding ServerText}" Style="{StaticResource Text.Body}" MaxWidth="320" />
|
||||
<StackPanel Orientation="Horizontal" Visibility="{Binding UserText, Converter={x:Static ui:NullToCollapsedConverter.Instance}}">
|
||||
<TextBlock Text="·" Foreground="{DynamicResource Brush.TextFaint}" Margin="10,0" VerticalAlignment="Center" />
|
||||
<TextBlock Text="{Binding UserText}" Style="{StaticResource Text.Body}" />
|
||||
</StackPanel>
|
||||
<StackPanel Orientation="Horizontal" Visibility="{Binding ConnectionText, Converter={x:Static ui:NullToCollapsedConverter.Instance}}">
|
||||
<TextBlock Text="·" Foreground="{DynamicResource Brush.TextFaint}" Margin="10,0" VerticalAlignment="Center" />
|
||||
<ui:StatusGlyph Kind="{Binding ConnectionKind}" Text="{Binding ConnectionText}" FontSize="{StaticResource Size.Body}" VerticalAlignment="Center" />
|
||||
</StackPanel>
|
||||
</StackPanel>
|
||||
</DockPanel>
|
||||
</Border>
|
||||
|
||||
<!-- First run / signed out: connect form. -->
|
||||
<Grid Grid.Row="1" Visibility="{Binding IsConnectVisible, Converter={StaticResource BoolToVisibility}}">
|
||||
<StackPanel DataContext="{Binding Connect}" Width="440" HorizontalAlignment="Center" VerticalAlignment="Center">
|
||||
<ui:BrandMarkIcon Width="48" Height="48" HorizontalAlignment="Center" />
|
||||
<TextBlock Text="{l:Loc Uploader.Connect.Title}" Style="{StaticResource Text.Title}" HorizontalAlignment="Center" Margin="0,14,0,20" />
|
||||
<Grid>
|
||||
<Grid.ColumnDefinitions>
|
||||
<ColumnDefinition Width="Auto" MinWidth="92" />
|
||||
<ColumnDefinition Width="*" />
|
||||
</Grid.ColumnDefinitions>
|
||||
<Grid.RowDefinitions>
|
||||
<RowDefinition Height="Auto" />
|
||||
<RowDefinition Height="Auto" />
|
||||
<RowDefinition Height="Auto" />
|
||||
<RowDefinition Height="Auto" />
|
||||
<RowDefinition Height="Auto" />
|
||||
<RowDefinition Height="Auto" />
|
||||
</Grid.RowDefinitions>
|
||||
|
||||
<TextBlock Text="{l:Loc Uploader.Connect.Server}" Style="{StaticResource Text.Label}" />
|
||||
<TextBox Grid.Column="1" Text="{Binding Address, UpdateSourceTrigger=PropertyChanged}" ui:Field.Glyph="{StaticResource Icon.Server}"
|
||||
ui:Field.Placeholder="{l:Loc Uploader.Connect.AddressPlaceholder}" ToolTip="{l:Loc Tooltips.Uploader.ServerAddress}" AutomationProperties.Name="{l:Loc Uploader.Connect.Server}" />
|
||||
|
||||
<TextBlock Grid.Row="1" Text="{l:Loc Uploader.Connect.Found}" Style="{StaticResource Text.Label}" Margin="0,8,12,0" VerticalAlignment="Top"
|
||||
Visibility="{Binding Discovered.Count, Converter={x:Static ui:ZeroToCollapsedConverter.Instance}}" />
|
||||
<ItemsControl Grid.Row="1" Grid.Column="1" ItemsSource="{Binding Discovered}" Margin="0,8,0,0" Focusable="False"
|
||||
Visibility="{Binding Discovered.Count, Converter={x:Static ui:ZeroToCollapsedConverter.Instance}}">
|
||||
<ItemsControl.ItemsPanel>
|
||||
<ItemsPanelTemplate>
|
||||
<WrapPanel />
|
||||
</ItemsPanelTemplate>
|
||||
</ItemsControl.ItemsPanel>
|
||||
<ItemsControl.ItemTemplate>
|
||||
<DataTemplate>
|
||||
<Button Style="{StaticResource Button.Chip}" Margin="0,0,8,4" Command="{Binding DataContext.UseServerCommand, RelativeSource={RelativeSource AncestorType=ItemsControl}}"
|
||||
CommandParameter="{Binding}" ToolTip="{l:Loc Tooltips.Uploader.DiscoveredServer}" AutomationProperties.Name="{Binding Name}">
|
||||
<StackPanel Orientation="Horizontal">
|
||||
<Ellipse Width="8" Height="8" Fill="{DynamicResource Brush.Accent}" Margin="0,0,8,0" VerticalAlignment="Center" />
|
||||
<TextBlock Text="{Binding Name}" VerticalAlignment="Center" />
|
||||
<TextBlock Text="{Binding Address}" Foreground="{DynamicResource Brush.TextMuted}" Margin="8,0,0,0" VerticalAlignment="Center" />
|
||||
</StackPanel>
|
||||
</Button>
|
||||
</DataTemplate>
|
||||
</ItemsControl.ItemTemplate>
|
||||
</ItemsControl>
|
||||
|
||||
<TextBlock Grid.Row="2" Text="{l:Loc Uploader.Connect.User}" Style="{StaticResource Text.Label}" Margin="0,12,12,0" />
|
||||
<TextBox Grid.Row="2" Grid.Column="1" Margin="0,12,0,0" Text="{Binding Username, UpdateSourceTrigger=PropertyChanged}" ui:Field.Glyph="{StaticResource Icon.User}"
|
||||
ToolTip="{l:Loc Tooltips.Uploader.User}" AutomationProperties.Name="{l:Loc Uploader.Connect.User}" />
|
||||
|
||||
<TextBlock Grid.Row="3" Text="{l:Loc Uploader.Connect.Password}" Style="{StaticResource Text.Label}" Margin="0,12,12,0" />
|
||||
<PasswordBox x:Name="Password" Grid.Row="3" Grid.Column="1" Margin="0,12,0,0" PasswordChanged="OnPasswordChanged"
|
||||
ToolTip="{l:Loc Tooltips.Uploader.Password}" AutomationProperties.Name="{l:Loc Uploader.Connect.Password}" />
|
||||
|
||||
<Border Grid.Row="4" Grid.Column="1" Margin="0,12,0,0" Padding="10,6,6,6" CornerRadius="{StaticResource Radius.Control}" Background="{DynamicResource Brush.ErrorSubtle}"
|
||||
Visibility="{Binding ErrorText, Converter={x:Static ui:NullToCollapsedConverter.Instance}}">
|
||||
<DockPanel>
|
||||
<Button DockPanel.Dock="Right" Style="{StaticResource Button.Compact}" Content="{l:Loc Uploader.Action.Retry}" Command="{Binding SignInCommand}"
|
||||
ToolTip="{l:Loc Tooltips.Uploader.Retry}" Margin="8,0,0,0" />
|
||||
<ui:Icon Glyph="{StaticResource Icon.ErrorCircle}" Foreground="{DynamicResource Brush.Error}" Margin="0,0,8,0" VerticalAlignment="Center" />
|
||||
<TextBlock Text="{Binding ErrorText}" TextWrapping="Wrap" VerticalAlignment="Center" />
|
||||
</DockPanel>
|
||||
</Border>
|
||||
|
||||
<Button Grid.Row="5" Grid.Column="1" Margin="0,20,0,0" HorizontalAlignment="Left" Style="{StaticResource Button.Primary}" MinWidth="120"
|
||||
IsDefault="{Binding IsVisible, RelativeSource={RelativeSource Self}}"
|
||||
Content="{l:Loc Uploader.Connect.SignIn}" Command="{Binding SignInCommand}" ToolTip="{l:Loc Tooltips.Uploader.SignIn}" />
|
||||
</Grid>
|
||||
</StackPanel>
|
||||
</Grid>
|
||||
|
||||
<!-- Signed in: drop zone, target, queue, watch folders, options. -->
|
||||
<Grid Grid.Row="1" Margin="16,14,16,14" Grid.IsSharedSizeScope="True"
|
||||
Visibility="{Binding IsConnectVisible, Converter={x:Static ui:InverseBoolToVisibilityConverter.Instance}}">
|
||||
<Grid.RowDefinitions>
|
||||
<RowDefinition Height="Auto" />
|
||||
<RowDefinition Height="Auto" />
|
||||
<RowDefinition Height="Auto" />
|
||||
<RowDefinition Height="Auto" />
|
||||
<RowDefinition Height="Auto" />
|
||||
<RowDefinition Height="*" />
|
||||
<RowDefinition Height="Auto" />
|
||||
</Grid.RowDefinitions>
|
||||
|
||||
<!-- Drop zone: the empty state's sentence and button. -->
|
||||
<Grid Height="150" Background="Transparent">
|
||||
<Rectangle x:Name="DropBorder" RadiusX="8" RadiusY="8" StrokeThickness="2" StrokeDashArray="3 2" SnapsToDevicePixels="True"
|
||||
Stroke="{DynamicResource Brush.Stroke}" Fill="Transparent" />
|
||||
<StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
|
||||
<ui:Icon Glyph="{StaticResource Icon.Upload}" Size="28" Foreground="{DynamicResource Brush.TextMuted}" HorizontalAlignment="Center" />
|
||||
<TextBlock Text="{l:Loc Uploader.Drop.Message}" FontSize="{StaticResource Size.Section}" Foreground="{DynamicResource Brush.TextMuted}"
|
||||
HorizontalAlignment="Center" Margin="0,10,0,10" />
|
||||
<Button Content="{l:Loc Uploader.Browse.Button}" Height="30" Padding="14,0" HorizontalAlignment="Center"
|
||||
ToolTip="{l:Loc Tooltips.Uploader.Browse}" Click="OnBrowseClick">
|
||||
<Button.ContextMenu>
|
||||
<ContextMenu>
|
||||
<MenuItem Header="{l:Loc Uploader.Browse.Files}" Command="{Binding BrowseFilesCommand}" ToolTip="{l:Loc Tooltips.Uploader.BrowseFiles}" />
|
||||
<MenuItem Header="{l:Loc Uploader.Browse.Folder}" Command="{Binding BrowseFolderCommand}" ToolTip="{l:Loc Tooltips.Uploader.BrowseFolder}" />
|
||||
</ContextMenu>
|
||||
</Button.ContextMenu>
|
||||
</Button>
|
||||
</StackPanel>
|
||||
</Grid>
|
||||
|
||||
<!-- Target -->
|
||||
<Grid Grid.Row="1" Margin="0,12,0,0" MinHeight="30">
|
||||
<Grid.ColumnDefinitions>
|
||||
<ColumnDefinition Width="Auto" SharedSizeGroup="Label" />
|
||||
<ColumnDefinition Width="*" />
|
||||
</Grid.ColumnDefinitions>
|
||||
<TextBlock Text="{l:Loc Uploader.Target.Label}" Style="{StaticResource Text.Label}" />
|
||||
<WrapPanel Grid.Column="1" VerticalAlignment="Center">
|
||||
<RadioButton GroupName="Target" Content="{l:Loc Uploader.Target.Sessions}" IsChecked="{Binding IsSessionsTarget}" Margin="0,0,16,0" VerticalAlignment="Center"
|
||||
ToolTip="{l:Loc Tooltips.Uploader.TargetSessions}" />
|
||||
<RadioButton GroupName="Target" Content="{l:Loc Uploader.Target.Sequence}" IsChecked="{Binding IsSequenceTarget}" Margin="0,0,8,0" VerticalAlignment="Center"
|
||||
ToolTip="{l:Loc Tooltips.Uploader.TargetSequence}" />
|
||||
<ComboBox Width="170" Height="30" Margin="0,0,16,0" ItemsSource="{Binding Sequences}" SelectedItem="{Binding SelectedSequence}" DisplayMemberPath="Title"
|
||||
IsEnabled="{Binding IsSequenceTarget}" DropDownOpened="OnSequencesDropDownOpened" ToolTip="{l:Loc Tooltips.Uploader.ChooseSequence}"
|
||||
AutomationProperties.Name="{l:Loc Uploader.Target.Sequence}" />
|
||||
<RadioButton GroupName="Target" Content="{l:Loc Uploader.Target.New}" IsChecked="{Binding IsNewTarget}" Margin="0,0,8,0" VerticalAlignment="Center"
|
||||
ToolTip="{l:Loc Tooltips.Uploader.TargetNew}" />
|
||||
<TextBox Width="150" Height="30" Text="{Binding NewTitle}" ui:Field.Placeholder="{l:Loc Uploader.Target.TitlePlaceholder}"
|
||||
Visibility="{Binding IsNewTarget, Converter={StaticResource BoolToVisibility}}" ToolTip="{l:Loc Tooltips.Uploader.NewTitle}"
|
||||
AutomationProperties.Name="{l:Loc Uploader.Target.TitlePlaceholder}" />
|
||||
</WrapPanel>
|
||||
</Grid>
|
||||
|
||||
<!-- Queue line, pause/stop, bandwidth limit -->
|
||||
<Grid Grid.Row="2" Margin="0,12,0,0" MinHeight="30">
|
||||
<Grid.ColumnDefinitions>
|
||||
<ColumnDefinition Width="Auto" SharedSizeGroup="Label" />
|
||||
<ColumnDefinition Width="*" />
|
||||
<ColumnDefinition Width="Auto" />
|
||||
<ColumnDefinition Width="Auto" />
|
||||
</Grid.ColumnDefinitions>
|
||||
<TextBlock Text="{l:Loc Uploader.Queue.Label}" Style="{StaticResource Text.Label}" />
|
||||
<TextBlock Grid.Column="1" Text="{Binding QueueText}" Style="{StaticResource Text.Body}" Typography.NumeralAlignment="Tabular" />
|
||||
<StackPanel Grid.Column="2" Orientation="Horizontal" Margin="10,0,0,0">
|
||||
<Button Command="{Binding PauseCommand}" ToolTip="{Binding PauseToolTip}" AutomationProperties.Name="{Binding PauseLabel}">
|
||||
<Button.Style>
|
||||
<Style TargetType="Button" BasedOn="{StaticResource Button.Square}">
|
||||
<Setter Property="ui:ButtonIcon.Glyph" Value="{StaticResource Icon.Pause}" />
|
||||
<Style.Triggers>
|
||||
<DataTrigger Binding="{Binding IsPaused}" Value="True">
|
||||
<Setter Property="ui:ButtonIcon.Glyph" Value="{StaticResource Icon.Play}" />
|
||||
</DataTrigger>
|
||||
</Style.Triggers>
|
||||
</Style>
|
||||
</Button.Style>
|
||||
</Button>
|
||||
<Button Style="{StaticResource Button.Square}" Margin="10,0,0,0" ui:ButtonIcon.Glyph="{StaticResource Icon.Stop}" Command="{Binding StopCommand}"
|
||||
ToolTip="{l:Loc Tooltips.Uploader.Stop}" AutomationProperties.Name="{l:Loc Uploader.Action.Stop}" />
|
||||
</StackPanel>
|
||||
<StackPanel Grid.Column="3" Orientation="Horizontal" Margin="16,0,0,0">
|
||||
<TextBlock Text="{l:Loc Uploader.Limit.Label}" Style="{StaticResource Text.Base}" Foreground="{DynamicResource Brush.TextMuted}" Margin="0,0,6,0" />
|
||||
<TextBox Width="58" Height="30" Text="{Binding BandwidthLimitText}" TextAlignment="Right" ToolTip="{l:Loc Tooltips.Uploader.Limit}"
|
||||
AutomationProperties.Name="{l:Loc Uploader.Limit.Label}" />
|
||||
<TextBlock Text="{l:Loc Uploader.Limit.Unit}" Style="{StaticResource Text.Base}" Foreground="{DynamicResource Brush.TextMuted}" Margin="6,0,0,0" />
|
||||
</StackPanel>
|
||||
</Grid>
|
||||
|
||||
<!-- Progress: bar, current file, counts -->
|
||||
<StackPanel Grid.Row="3" Margin="0,12,0,0" Visibility="{Binding HasItems, Converter={StaticResource BoolToVisibility}}">
|
||||
<ProgressBar Height="8" Maximum="1" Value="{Binding Progress, Mode=OneWay}" />
|
||||
<Grid Margin="0,5,0,0">
|
||||
<Grid.ColumnDefinitions>
|
||||
<ColumnDefinition Width="*" />
|
||||
<ColumnDefinition Width="Auto" />
|
||||
</Grid.ColumnDefinitions>
|
||||
<TextBlock Text="{Binding CurrentFileText}" Style="{StaticResource Text.Secondary}" />
|
||||
<TextBlock Grid.Column="1" Text="{Binding ProgressText}" Style="{StaticResource Text.Secondary}" Margin="12,0,0,0" Typography.NumeralAlignment="Tabular" />
|
||||
</Grid>
|
||||
</StackPanel>
|
||||
|
||||
<!-- Watch folders -->
|
||||
<Grid Grid.Row="4" Margin="0,12,0,0" MinHeight="30">
|
||||
<Grid.ColumnDefinitions>
|
||||
<ColumnDefinition Width="Auto" SharedSizeGroup="Label" />
|
||||
<ColumnDefinition Width="*" />
|
||||
</Grid.ColumnDefinitions>
|
||||
<TextBlock Text="{l:Loc Uploader.Watch.Label}" Style="{StaticResource Text.Label}" VerticalAlignment="Top" Margin="0,6,12,0" />
|
||||
<StackPanel Grid.Column="1" Orientation="Horizontal">
|
||||
<ItemsControl ItemsSource="{Binding WatchFolders}" Focusable="False">
|
||||
<ItemsControl.ItemsPanel>
|
||||
<ItemsPanelTemplate>
|
||||
<StackPanel Orientation="Horizontal" />
|
||||
</ItemsPanelTemplate>
|
||||
</ItemsControl.ItemsPanel>
|
||||
<ItemsControl.ItemTemplate>
|
||||
<DataTemplate DataType="{x:Type s:WatchFolderViewModel}">
|
||||
<Button Style="{StaticResource Button.Chip}" Margin="0,0,10,0" Click="OnWatchChipClick" ToolTip="{Binding ToolTip}" AutomationProperties.Name="{Binding Path}">
|
||||
<Button.ContextMenu>
|
||||
<ContextMenu ItemsSource="{Binding MenuOptions}" ItemContainerStyle="{StaticResource WatchMenuItem}" />
|
||||
</Button.ContextMenu>
|
||||
<StackPanel Orientation="Horizontal">
|
||||
<Ellipse x:Name="Dot" Width="8" Height="8" Margin="0,0,8,0" VerticalAlignment="Center" StrokeThickness="1.5"
|
||||
Fill="{DynamicResource Brush.TextFaint}" />
|
||||
<TextBlock Text="{Binding Text}" VerticalAlignment="Center" />
|
||||
</StackPanel>
|
||||
</Button>
|
||||
<DataTemplate.Triggers>
|
||||
<DataTrigger Binding="{Binding IsAvailable}" Value="True">
|
||||
<Setter TargetName="Dot" Property="Fill" Value="{DynamicResource Brush.Success}" />
|
||||
</DataTrigger>
|
||||
<!-- Unreachable: hollow ring (shape, not colour alone), reason in the tooltip. -->
|
||||
<DataTrigger Binding="{Binding IsAvailable}" Value="False">
|
||||
<Setter TargetName="Dot" Property="Fill" Value="Transparent" />
|
||||
<Setter TargetName="Dot" Property="Stroke" Value="{DynamicResource Brush.Error}" />
|
||||
</DataTrigger>
|
||||
</DataTemplate.Triggers>
|
||||
</DataTemplate>
|
||||
</ItemsControl.ItemTemplate>
|
||||
</ItemsControl>
|
||||
<Button Style="{StaticResource Button.Round}" ui:ButtonIcon.Glyph="{StaticResource Icon.Plus}" Command="{Binding AddWatchFolderCommand}"
|
||||
ToolTip="{l:Loc Tooltips.Uploader.AddWatchFolder}" AutomationProperties.Name="{l:Loc Uploader.Action.AddFolder}" />
|
||||
</StackPanel>
|
||||
</Grid>
|
||||
|
||||
<!-- Per-file state -->
|
||||
<Border Grid.Row="5" Margin="0,12,0,0" Style="{StaticResource Border.Panel}" Padding="4"
|
||||
Visibility="{Binding HasItems, Converter={StaticResource BoolToVisibility}}">
|
||||
<ListBox x:Name="ItemList" ItemsSource="{Binding Items}" ItemContainerStyle="{StaticResource QueueRow}">
|
||||
<ListBox.ItemTemplate>
|
||||
<DataTemplate DataType="{x:Type u:UploadItem}">
|
||||
<Grid Height="28">
|
||||
<Grid.ColumnDefinitions>
|
||||
<ColumnDefinition Width="*" />
|
||||
<ColumnDefinition Width="Auto" />
|
||||
<ColumnDefinition Width="Auto" MinWidth="120" />
|
||||
<ColumnDefinition Width="Auto" />
|
||||
</Grid.ColumnDefinitions>
|
||||
<TextBlock Text="{Binding FileName}" Style="{StaticResource Text.Body}" />
|
||||
<TextBlock Grid.Column="1" Text="{Binding Size, Converter={x:Static s:SizeConverter.Instance}}" Style="{StaticResource Text.Secondary}"
|
||||
Typography.NumeralAlignment="Tabular" Margin="12,0,0,0" />
|
||||
<ui:StatusGlyph Grid.Column="2" Margin="16,0,0,0" FontSize="{StaticResource Size.Secondary}" VerticalAlignment="Center"
|
||||
Kind="{Binding State, Converter={x:Static s:UploadStateKindConverter.Instance}}"
|
||||
Text="{Binding State, Converter={x:Static s:UploadStateTextConverter.Instance}}">
|
||||
<ui:StatusGlyph.ToolTip>
|
||||
<MultiBinding Converter="{x:Static s:FailureTextConverter.Instance}">
|
||||
<Binding Path="Failure" />
|
||||
<Binding Path="FailureDetail" />
|
||||
</MultiBinding>
|
||||
</ui:StatusGlyph.ToolTip>
|
||||
</ui:StatusGlyph>
|
||||
<Button Grid.Column="3" Style="{StaticResource Button.IconSubtle}" Width="26" Height="26" MinWidth="26" Margin="4,0,0,0"
|
||||
ui:ButtonIcon.Glyph="{StaticResource Icon.Retry}" CommandParameter="{Binding}"
|
||||
Command="{Binding DataContext.RetryItemCommand, RelativeSource={RelativeSource AncestorType=ListBox}}"
|
||||
Visibility="{Binding State, Converter={x:Static s:FailedToVisibleConverter.Instance}}"
|
||||
ToolTip="{l:Loc Tooltips.Uploader.RetryItem}" AutomationProperties.Name="{l:Loc Uploader.Action.Retry}" />
|
||||
</Grid>
|
||||
</DataTemplate>
|
||||
</ListBox.ItemTemplate>
|
||||
</ListBox>
|
||||
</Border>
|
||||
|
||||
<!-- Options -->
|
||||
<WrapPanel Grid.Row="6" Margin="0,12,0,0" MinHeight="30">
|
||||
<CheckBox Content="{l:Loc Uploader.Options.DeleteSource}" IsChecked="{Binding DeleteAfterUpload, Mode=OneWay}" Command="{Binding ToggleDeleteAfterUploadCommand}"
|
||||
ToolTip="{l:Loc Tooltips.Uploader.DeleteSource}" Margin="0,0,22,0" VerticalAlignment="Center" />
|
||||
<CheckBox Content="{l:Loc Uploader.Options.StartWithWindows}" IsChecked="{Binding StartWithWindows}" ToolTip="{l:Loc Tooltips.Uploader.StartWithWindows}"
|
||||
Margin="0,0,22,0" VerticalAlignment="Center" />
|
||||
<CheckBox Content="{l:Loc Uploader.Options.MinimizeToTray}" IsChecked="{Binding MinimizeToTray}" ToolTip="{l:Loc Tooltips.Uploader.MinimizeToTray}"
|
||||
VerticalAlignment="Center" />
|
||||
</WrapPanel>
|
||||
</Grid>
|
||||
|
||||
<!-- Settings panel over the window content. -->
|
||||
<Grid Grid.RowSpan="2" Visibility="{Binding IsSettingsOpen, Converter={StaticResource BoolToVisibility}}">
|
||||
<Border Background="{DynamicResource Brush.Scrim}">
|
||||
<Border.InputBindings>
|
||||
<MouseBinding MouseAction="LeftClick" Command="{Binding CloseSettingsCommand}" />
|
||||
</Border.InputBindings>
|
||||
</Border>
|
||||
<Border HorizontalAlignment="Right" Width="340" Background="{DynamicResource Brush.Surface}" BorderBrush="{DynamicResource Brush.Stroke}" BorderThickness="1,0,0,0">
|
||||
<DockPanel Margin="20,12,12,20">
|
||||
<DockPanel DockPanel.Dock="Top" Margin="0,0,0,12">
|
||||
<Button DockPanel.Dock="Right" Style="{StaticResource Button.IconSubtle}" ui:ButtonIcon.Glyph="{StaticResource Icon.Close}" Command="{Binding CloseSettingsCommand}"
|
||||
ToolTip="{l:Loc Tooltips.Uploader.CloseSettings}" AutomationProperties.Name="{l:Loc Uploader.Action.Close}" />
|
||||
<TextBlock Text="{l:Loc Uploader.Settings.Title}" Style="{StaticResource Text.Title}" />
|
||||
</DockPanel>
|
||||
<Grid Margin="0,0,8,0">
|
||||
<Grid.ColumnDefinitions>
|
||||
<ColumnDefinition Width="Auto" MinWidth="100" />
|
||||
<ColumnDefinition Width="*" />
|
||||
</Grid.ColumnDefinitions>
|
||||
<Grid.RowDefinitions>
|
||||
<RowDefinition Height="36" />
|
||||
<RowDefinition Height="36" />
|
||||
<RowDefinition Height="Auto" />
|
||||
<RowDefinition Height="44" />
|
||||
<RowDefinition Height="36" />
|
||||
<RowDefinition Height="36" />
|
||||
<RowDefinition Height="36" />
|
||||
</Grid.RowDefinitions>
|
||||
|
||||
<TextBlock Text="{l:Loc Uploader.Settings.Server}" Style="{StaticResource Text.Label}" MinWidth="0" />
|
||||
<TextBlock Grid.Column="1" Text="{Binding ServerText}" Style="{StaticResource Text.Body}" />
|
||||
<TextBlock Grid.Row="1" Text="{l:Loc Uploader.Settings.User}" Style="{StaticResource Text.Label}" MinWidth="0" />
|
||||
<TextBlock Grid.Row="1" Grid.Column="1" Text="{Binding UserText}" Style="{StaticResource Text.Body}" />
|
||||
<Button Grid.Row="2" Grid.Column="1" HorizontalAlignment="Left" Margin="0,4,0,8" Content="{l:Loc Uploader.Settings.SignOut}" Command="{Binding SignOutCommand}"
|
||||
ToolTip="{l:Loc Tooltips.Uploader.SignOut}" Visibility="{Binding IsConnectVisible, Converter={x:Static ui:InverseBoolToVisibilityConverter.Instance}}" />
|
||||
|
||||
<TextBlock Grid.Row="3" Text="{l:Loc Uploader.Settings.Bandwidth}" Style="{StaticResource Text.Label}" MinWidth="0" />
|
||||
<StackPanel Grid.Row="3" Grid.Column="1" Orientation="Horizontal" VerticalAlignment="Center">
|
||||
<TextBlock Text="{l:Loc Uploader.Limit.Label}" Style="{StaticResource Text.Base}" Foreground="{DynamicResource Brush.TextMuted}" Margin="0,0,6,0" />
|
||||
<TextBox Width="58" Height="30" Text="{Binding BandwidthLimitText}" TextAlignment="Right" ToolTip="{l:Loc Tooltips.Uploader.Limit}"
|
||||
AutomationProperties.Name="{l:Loc Uploader.Limit.Label}" />
|
||||
<TextBlock Text="{l:Loc Uploader.Limit.Unit}" Style="{StaticResource Text.Base}" Foreground="{DynamicResource Brush.TextMuted}" Margin="6,0,0,0" />
|
||||
</StackPanel>
|
||||
|
||||
<TextBlock Grid.Row="4" Text="{l:Loc Uploader.Settings.Startup}" Style="{StaticResource Text.Label}" MinWidth="0" />
|
||||
<CheckBox Grid.Row="4" Grid.Column="1" Content="{l:Loc Uploader.Options.StartWithWindows}" IsChecked="{Binding StartWithWindows}"
|
||||
ToolTip="{l:Loc Tooltips.Uploader.StartWithWindows}" VerticalAlignment="Center" />
|
||||
<CheckBox Grid.Row="5" Grid.Column="1" Content="{l:Loc Uploader.Options.MinimizeToTray}" IsChecked="{Binding MinimizeToTray}"
|
||||
ToolTip="{l:Loc Tooltips.Uploader.MinimizeToTray}" VerticalAlignment="Center" />
|
||||
|
||||
<TextBlock Grid.Row="6" Text="{l:Loc Uploader.Settings.Files}" Style="{StaticResource Text.Label}" MinWidth="0" />
|
||||
<CheckBox Grid.Row="6" Grid.Column="1" Content="{l:Loc Uploader.Options.DeleteSource}" IsChecked="{Binding DeleteAfterUpload, Mode=OneWay}"
|
||||
Command="{Binding ToggleDeleteAfterUploadCommand}" ToolTip="{l:Loc Tooltips.Uploader.DeleteSource}" VerticalAlignment="Center" />
|
||||
</Grid>
|
||||
</DockPanel>
|
||||
</Border>
|
||||
</Grid>
|
||||
|
||||
<ui:ToastHost x:Name="Toasts" Grid.RowSpan="2" Margin="0,0,16,16" />
|
||||
</Grid>
|
||||
</ui:TitanoWindow>
|
||||
@@ -0,0 +1,139 @@
|
||||
using System.Collections.Specialized;
|
||||
using System.ComponentModel;
|
||||
using System.Windows;
|
||||
using System.Windows.Controls;
|
||||
using System.Windows.Controls.Primitives;
|
||||
using System.Windows.Input;
|
||||
using System.Windows.Media;
|
||||
using System.Windows.Shapes;
|
||||
using Titano.Ui.Controls;
|
||||
using Titano.Uploader.Infrastructure;
|
||||
|
||||
namespace Titano.Uploader.Shell;
|
||||
|
||||
/// <summary>The uploader's single window (mockup Uploader.html).</summary>
|
||||
public sealed partial class MainWindow : TitanoWindow
|
||||
{
|
||||
private readonly MainViewModel _vm;
|
||||
private readonly UploaderSettings _settings;
|
||||
|
||||
public MainWindow(MainViewModel vm, UploaderSettings settings)
|
||||
{
|
||||
_vm = vm;
|
||||
_settings = settings;
|
||||
DataContext = vm;
|
||||
InitializeComponent();
|
||||
vm.PendingToasts.CollectionChanged += OnToastRequested;
|
||||
vm.PropertyChanged += OnViewModelChanged;
|
||||
PreviewKeyDown += OnPreviewKeyDown;
|
||||
RestorePlacement();
|
||||
}
|
||||
|
||||
/// <summary>Remembers size and position (also when the window only hides to the tray).</summary>
|
||||
public void SavePlacement()
|
||||
{
|
||||
var b = RestoreBounds;
|
||||
if (b.IsEmpty || b.Width < MinWidth || b.Height < MinHeight) return;
|
||||
_settings.Window = new UploaderSettings.WindowPlacement { Left = b.Left, Top = b.Top, Width = b.Width, Height = b.Height };
|
||||
}
|
||||
|
||||
protected override void OnDragOver(DragEventArgs e)
|
||||
{
|
||||
var accepted = CanDrop(e);
|
||||
e.Effects = accepted ? DragDropEffects.Copy : DragDropEffects.None;
|
||||
SetDropHighlight(accepted);
|
||||
e.Handled = true;
|
||||
}
|
||||
|
||||
protected override void OnDragLeave(DragEventArgs e) => SetDropHighlight(false);
|
||||
|
||||
protected override void OnDrop(DragEventArgs e)
|
||||
{
|
||||
SetDropHighlight(false);
|
||||
if (!CanDrop(e) || e.Data.GetData(DataFormats.FileDrop) is not string[] paths) return;
|
||||
e.Handled = true;
|
||||
_ = EnqueueAsync(paths);
|
||||
}
|
||||
|
||||
private async Task EnqueueAsync(IReadOnlyList<string> paths)
|
||||
{
|
||||
try
|
||||
{
|
||||
await _vm.EnqueueAsync(paths);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
// UI boundary: a drop must never take the window down.
|
||||
_vm.ReportError(ex);
|
||||
}
|
||||
}
|
||||
|
||||
private bool CanDrop(DragEventArgs e) => !_vm.IsConnectVisible && e.Data.GetDataPresent(DataFormats.FileDrop);
|
||||
|
||||
private void SetDropHighlight(bool on)
|
||||
{
|
||||
DropBorder.SetResourceReference(Shape.StrokeProperty, on ? "Brush.Accent" : "Brush.Stroke");
|
||||
if (on) DropBorder.SetResourceReference(Shape.FillProperty, "Brush.AccentSubtle");
|
||||
else DropBorder.Fill = Brushes.Transparent;
|
||||
}
|
||||
|
||||
private void OnBrowseClick(object sender, RoutedEventArgs e) => OpenMenu((Button)sender);
|
||||
|
||||
private void OnWatchChipClick(object sender, RoutedEventArgs e) => OpenMenu((Button)sender);
|
||||
|
||||
/// <summary>Opens a button's menu under it on a normal click.</summary>
|
||||
private static void OpenMenu(Button button)
|
||||
{
|
||||
if (button.ContextMenu is not { } menu) return;
|
||||
menu.DataContext = button.DataContext;
|
||||
menu.PlacementTarget = button;
|
||||
menu.Placement = PlacementMode.Bottom;
|
||||
menu.IsOpen = true;
|
||||
}
|
||||
|
||||
private void OnSequencesDropDownOpened(object? sender, EventArgs e) => _vm.RefreshSequencesCommand.Execute(null);
|
||||
|
||||
private void OnPasswordChanged(object sender, RoutedEventArgs e) => _vm.Connect.Password = Password.Password;
|
||||
|
||||
/// <summary>DESIGN §4 inputs: Enter commits, Esc reverts; Esc also closes the settings panel.</summary>
|
||||
private void OnPreviewKeyDown(object sender, KeyEventArgs e)
|
||||
{
|
||||
if (e.OriginalSource is TextBox box && (e.Key is Key.Enter or Key.Escape) && box.GetBindingExpression(TextBox.TextProperty) is { } binding)
|
||||
{
|
||||
if (e.Key == Key.Enter) binding.UpdateSource();
|
||||
else binding.UpdateTarget();
|
||||
if (e.Key == Key.Escape) e.Handled = true;
|
||||
return;
|
||||
}
|
||||
if (e.Key == Key.Escape && _vm.IsSettingsOpen)
|
||||
{
|
||||
_vm.IsSettingsOpen = false;
|
||||
e.Handled = true;
|
||||
}
|
||||
}
|
||||
|
||||
private void OnViewModelChanged(object? sender, PropertyChangedEventArgs e)
|
||||
{
|
||||
if (e.PropertyName == nameof(MainViewModel.CurrentItem) && _vm.CurrentItem is { } item) ItemList.ScrollIntoView(item);
|
||||
if (e.PropertyName == nameof(MainViewModel.IsConnectVisible) && _vm.IsConnectVisible) Password.Clear();
|
||||
}
|
||||
|
||||
private void OnToastRequested(object? sender, NotifyCollectionChangedEventArgs e)
|
||||
{
|
||||
if (e.Action != NotifyCollectionChangedAction.Add || e.NewItems is null) return;
|
||||
foreach (Toast t in e.NewItems) Toasts.Show(t);
|
||||
Dispatcher.BeginInvoke(() => _vm.PendingToasts.Clear());
|
||||
}
|
||||
|
||||
private void RestorePlacement()
|
||||
{
|
||||
if (_settings.Window is not { } p || p.Width < MinWidth || p.Height < MinHeight) return;
|
||||
var screen = new Rect(SystemParameters.VirtualScreenLeft, SystemParameters.VirtualScreenTop, SystemParameters.VirtualScreenWidth, SystemParameters.VirtualScreenHeight);
|
||||
if (!screen.IntersectsWith(new Rect(p.Left, p.Top, p.Width, p.Height))) return;
|
||||
WindowStartupLocation = WindowStartupLocation.Manual;
|
||||
Left = p.Left;
|
||||
Top = p.Top;
|
||||
Width = p.Width;
|
||||
Height = p.Height;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
using System.IO;
|
||||
using System.Windows;
|
||||
using System.Windows.Media;
|
||||
using System.Windows.Media.Imaging;
|
||||
using System.Windows.Threading;
|
||||
using Titano.Core.Diagnostics;
|
||||
using Titano.Ui.Theming;
|
||||
using Titano.Uploader.DesignTime;
|
||||
|
||||
namespace Titano.Uploader.Shell;
|
||||
|
||||
/// <summary>
|
||||
/// <c>Titano.Uploader.exe --capture <dir></c>: renders the window at 760×560 in the dark and light themes —
|
||||
/// first run (connect), queue running, settings panel — from <see cref="SampleData"/>, then exits.
|
||||
/// </summary>
|
||||
public static class ScreenCapture
|
||||
{
|
||||
public static void Run(MainWindow window, MainViewModel vm, SampleData sample, string directory)
|
||||
{
|
||||
Directory.CreateDirectory(directory);
|
||||
window.WindowStartupLocation = WindowStartupLocation.Manual;
|
||||
window.Left = -20000;
|
||||
window.Top = -20000;
|
||||
window.Width = 760;
|
||||
window.Height = 560;
|
||||
window.ShowActivated = false;
|
||||
window.ShowInTaskbar = false;
|
||||
window.Show();
|
||||
|
||||
window.Dispatcher.BeginInvoke(DispatcherPriority.ApplicationIdle, () =>
|
||||
{
|
||||
try
|
||||
{
|
||||
foreach (var theme in new[] { AppTheme.Dark, AppTheme.Light })
|
||||
{
|
||||
var suffix = theme.ToString().ToLowerInvariant();
|
||||
ThemeManager.Apply(theme);
|
||||
sample.ShowConnect();
|
||||
Save(window, Path.Combine(directory, $"uploader-connect-{suffix}.png"));
|
||||
sample.ShowQueue();
|
||||
Save(window, Path.Combine(directory, $"uploader-queue-{suffix}.png"));
|
||||
vm.IsSettingsOpen = true;
|
||||
Save(window, Path.Combine(directory, $"uploader-settings-{suffix}.png"));
|
||||
vm.IsSettingsOpen = false;
|
||||
}
|
||||
Log.Info("capture", $"Screenshots written to {Path.GetFullPath(directory)}");
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
Log.Error("capture", "Capture failed", ex);
|
||||
Environment.ExitCode = 1;
|
||||
}
|
||||
finally
|
||||
{
|
||||
Application.Current.Shutdown();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private static void Save(Window window, string path)
|
||||
{
|
||||
// Let bindings, templates and deferred layout complete.
|
||||
window.UpdateLayout();
|
||||
window.Dispatcher.Invoke(DispatcherPriority.ApplicationIdle, () => { });
|
||||
window.UpdateLayout();
|
||||
if (VisualTreeHelper.GetChildrenCount(window) == 0) return;
|
||||
var root = (FrameworkElement)VisualTreeHelper.GetChild(window, 0);
|
||||
var dpi = VisualTreeHelper.GetDpi(window);
|
||||
var width = (int)Math.Ceiling(root.ActualWidth * dpi.DpiScaleX);
|
||||
var height = (int)Math.Ceiling(root.ActualHeight * dpi.DpiScaleY);
|
||||
if (width <= 0 || height <= 0) return;
|
||||
var bitmap = new RenderTargetBitmap(width, height, dpi.PixelsPerInchX, dpi.PixelsPerInchY, PixelFormats.Pbgra32);
|
||||
bitmap.Render(root);
|
||||
var encoder = new PngBitmapEncoder();
|
||||
encoder.Frames.Add(BitmapFrame.Create(bitmap));
|
||||
using var stream = File.Create(path);
|
||||
encoder.Save(stream);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
using System.Windows;
|
||||
using System.Windows.Interop;
|
||||
using Titano.Core.Imaging;
|
||||
using Titano.Core.Localization;
|
||||
using Titano.Uploader.Interop;
|
||||
|
||||
namespace Titano.Uploader.Shell;
|
||||
|
||||
/// <summary>Pickers and confirmations the view model asks for.</summary>
|
||||
public interface IUploaderDialogs
|
||||
{
|
||||
/// <summary>Photos to add; empty when cancelled.</summary>
|
||||
IReadOnlyList<string> PickFiles();
|
||||
|
||||
/// <summary>A folder or card root to add; null when cancelled.</summary>
|
||||
string? PickFolder();
|
||||
|
||||
/// <summary>A folder to watch; null when cancelled.</summary>
|
||||
string? PickWatchFolder();
|
||||
|
||||
/// <summary>Trust-on-first-use: shows the certificate fingerprint; true when the user trusts it.</summary>
|
||||
bool ConfirmTrust(string address, string fingerprint);
|
||||
|
||||
/// <summary>Destructive confirmation for "Delete after upload"; true when the user turns it on.</summary>
|
||||
bool ConfirmDeleteAfterUpload();
|
||||
}
|
||||
|
||||
/// <summary>Window-owned implementation: shell Open dialogs and <see cref="ConfirmDialog"/>.</summary>
|
||||
public sealed class UploaderDialogs : IUploaderDialogs
|
||||
{
|
||||
/// <summary>Owner of the dialogs; set once the main window exists.</summary>
|
||||
public Window? Owner { get; set; }
|
||||
|
||||
private IntPtr OwnerHandle => Owner is null ? IntPtr.Zero : new WindowInteropHelper(Owner).Handle;
|
||||
|
||||
public IReadOnlyList<string> PickFiles()
|
||||
{
|
||||
var photos = string.Join(';', ImageFormatInfo.Known.SelectMany(f => f.Extensions).Select(e => "*." + e));
|
||||
return FileDialogs.PickFiles(OwnerHandle, Loc.L("Uploader.Browse.FilesTitle"),
|
||||
[
|
||||
new FileFilter(Loc.L("Uploader.Browse.Photos"), photos),
|
||||
new FileFilter(Loc.L("Uploader.Browse.AllFiles"), "*.*"),
|
||||
]);
|
||||
}
|
||||
|
||||
public string? PickFolder() => FileDialogs.PickFolder(OwnerHandle, Loc.L("Uploader.Browse.FolderTitle"));
|
||||
|
||||
public string? PickWatchFolder() => FileDialogs.PickFolder(OwnerHandle, Loc.L("Uploader.Browse.WatchTitle"));
|
||||
|
||||
public bool ConfirmTrust(string address, string fingerprint) => ConfirmDialog.Ask(Owner, new ConfirmRequest
|
||||
{
|
||||
Heading = Loc.L("Uploader.Trust.Title"),
|
||||
Message = Loc.L("Uploader.Trust.Message"),
|
||||
Detail = address + "\n" + FormatFingerprint(fingerprint),
|
||||
DetailToolTip = Loc.L("Tooltips.Uploader.Fingerprint"),
|
||||
SafeText = Loc.L("Uploader.Trust.Cancel"),
|
||||
SafeToolTip = Loc.L("Tooltips.Uploader.CancelTrust"),
|
||||
ActionText = Loc.L("Uploader.Trust.Accept"),
|
||||
ActionToolTip = Loc.L("Tooltips.Uploader.Trust"),
|
||||
IsDestructive = false,
|
||||
});
|
||||
|
||||
public bool ConfirmDeleteAfterUpload() => ConfirmDialog.Ask(Owner, new ConfirmRequest
|
||||
{
|
||||
Heading = Loc.L("Uploader.Delete.Title"),
|
||||
Message = Loc.L("Uploader.Delete.Message"),
|
||||
SafeText = Loc.L("Uploader.Delete.Keep"),
|
||||
SafeToolTip = Loc.L("Tooltips.Uploader.KeepFiles"),
|
||||
ActionText = Loc.L("Uploader.Delete.Accept"),
|
||||
ActionToolTip = Loc.L("Tooltips.Uploader.ConfirmDelete"),
|
||||
IsDestructive = true,
|
||||
});
|
||||
|
||||
/// <summary>Splits the 32-byte SHA-256 fingerprint into two readable lines of 16 bytes.</summary>
|
||||
public static string FormatFingerprint(string fingerprint)
|
||||
{
|
||||
var bytes = fingerprint.Split(':');
|
||||
return bytes.Length <= 16 ? fingerprint : string.Join(':', bytes.Take(16)) + "\n" + string.Join(':', bytes.Skip(16));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
using System.Windows.Input;
|
||||
using Titano.Core.Localization;
|
||||
using Titano.Ui.Mvvm;
|
||||
using Titano.Uploader.Text;
|
||||
|
||||
namespace Titano.Uploader.Shell;
|
||||
|
||||
/// <summary>An entry of a watch folder chip's menu: an interval choice, a separator (no text) or "Remove".</summary>
|
||||
public sealed record WatchMenuOption(string? Text, string? ToolTip, ICommand? Command, bool IsChecked)
|
||||
{
|
||||
public bool IsSeparator => Text is null;
|
||||
}
|
||||
|
||||
/// <summary>One watch folder chip: path, interval, reachability.</summary>
|
||||
public sealed class WatchFolderViewModel : ObservableObject
|
||||
{
|
||||
/// <summary>Intervals offered in the chip menu.</summary>
|
||||
public static readonly int[] IntervalChoices = [30, 60, 300, 900];
|
||||
|
||||
private readonly Action<WatchFolderViewModel, int> _setInterval;
|
||||
private readonly Action<WatchFolderViewModel> _remove;
|
||||
private int _intervalSeconds;
|
||||
private bool? _isAvailable;
|
||||
|
||||
public WatchFolderViewModel(string path, int intervalSeconds, bool isNetwork, Action<WatchFolderViewModel, int> setInterval, Action<WatchFolderViewModel> remove)
|
||||
{
|
||||
Path = path;
|
||||
IsNetwork = isNetwork;
|
||||
_intervalSeconds = intervalSeconds;
|
||||
_setInterval = setInterval;
|
||||
_remove = remove;
|
||||
}
|
||||
|
||||
public string Path { get; }
|
||||
public bool IsNetwork { get; }
|
||||
|
||||
public int IntervalSeconds
|
||||
{
|
||||
get => _intervalSeconds;
|
||||
set
|
||||
{
|
||||
if (!Set(ref _intervalSeconds, value)) return;
|
||||
OnPropertyChanged(nameof(Text));
|
||||
OnPropertyChanged(nameof(ToolTip));
|
||||
OnPropertyChanged(nameof(MenuOptions));
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Null until the first check finished.</summary>
|
||||
public bool? IsAvailable
|
||||
{
|
||||
get => _isAvailable;
|
||||
set
|
||||
{
|
||||
if (Set(ref _isAvailable, value)) OnPropertyChanged(nameof(ToolTip));
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>"D:\Cam\Roof · every 1 min".</summary>
|
||||
public string Text => Loc.L("Uploader.Watch.Chip", Path, Interval(IntervalSeconds));
|
||||
|
||||
public string ToolTip => IsAvailable == false ? Loc.L("Tooltips.Uploader.WatchFolderMissing", Interval(IntervalSeconds))
|
||||
: IsNetwork ? Loc.L("Tooltips.Uploader.WatchFolderNetwork", Interval(IntervalSeconds))
|
||||
: Loc.L("Tooltips.Uploader.WatchFolder", Interval(IntervalSeconds));
|
||||
|
||||
public IReadOnlyList<WatchMenuOption> MenuOptions =>
|
||||
[
|
||||
.. IntervalChoices.Select(s => new WatchMenuOption(
|
||||
Loc.L("Uploader.Watch.Every", Interval(s)),
|
||||
Loc.L("Tooltips.Uploader.WatchInterval"),
|
||||
new RelayCommand(() => _setInterval(this, s)),
|
||||
s == IntervalSeconds)),
|
||||
new WatchMenuOption(null, null, null, false),
|
||||
new WatchMenuOption(Loc.L("Uploader.Watch.Remove"), Loc.L("Tooltips.Uploader.RemoveWatchFolder"), new RelayCommand(() => _remove(this)), false),
|
||||
];
|
||||
|
||||
private static string Interval(int seconds) => UploaderText.Duration(TimeSpan.FromSeconds(seconds), Loc.Culture);
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
using System.IO;
|
||||
using Titano.Core.Diagnostics;
|
||||
using Titano.Core.Imaging;
|
||||
|
||||
namespace Titano.Uploader.Sources;
|
||||
|
||||
/// <summary>A photo found on disk. <see cref="Root"/> is the dropped folder (or the file's folder) it was found under.</summary>
|
||||
public sealed record SourceFile(string Path, long Size, DateTime ModifiedUtc, DateTime CapturedAt, string Root);
|
||||
|
||||
/// <summary>Finds supported photos under dropped files, folders and card roots (BRIEF §15: zero analysis).</summary>
|
||||
public static class PhotoScanner
|
||||
{
|
||||
private static readonly EnumerationOptions Recursive = new()
|
||||
{
|
||||
RecurseSubdirectories = true,
|
||||
IgnoreInaccessible = true,
|
||||
// Skips "System Volume Information", "$RECYCLE.BIN" and camera housekeeping files.
|
||||
AttributesToSkip = FileAttributes.Hidden | FileAttributes.System,
|
||||
MatchType = MatchType.Simple,
|
||||
};
|
||||
|
||||
/// <summary>Supported photos under <paramref name="paths"/>, in path order, without duplicates.</summary>
|
||||
public static IReadOnlyList<SourceFile> Scan(IEnumerable<string> paths, CancellationToken ct = default)
|
||||
{
|
||||
var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
||||
var result = new List<SourceFile>();
|
||||
foreach (var raw in paths)
|
||||
{
|
||||
ct.ThrowIfCancellationRequested();
|
||||
string full;
|
||||
try
|
||||
{
|
||||
full = Path.GetFullPath(raw);
|
||||
}
|
||||
catch (Exception ex) when (ex is ArgumentException or NotSupportedException or PathTooLongException)
|
||||
{
|
||||
Log.Warning("scan", $"Ignored path {raw}", ex);
|
||||
continue;
|
||||
}
|
||||
if (Directory.Exists(full))
|
||||
{
|
||||
try
|
||||
{
|
||||
foreach (var file in Files(full, ct))
|
||||
{
|
||||
if (seen.Add(file.FullName)) result.Add(ToSource(file, full));
|
||||
}
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
||||
{
|
||||
// A card pulled mid-scan: keep what was found; the rest can be dropped again.
|
||||
Log.Warning("scan", $"Listing of {full} stopped early", ex);
|
||||
}
|
||||
}
|
||||
else if (File.Exists(full) && ImageFormatInfo.IsSupportedExtension(full) && seen.Add(full))
|
||||
{
|
||||
var info = new FileInfo(full);
|
||||
result.Add(ToSource(info, info.DirectoryName ?? full));
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/// <summary>Supported photos under <paramref name="folder"/>, recursively. I/O errors while listing propagate.</summary>
|
||||
public static IEnumerable<FileInfo> Files(string folder, CancellationToken ct = default)
|
||||
{
|
||||
foreach (var file in new DirectoryInfo(folder).EnumerateFiles("*", Recursive))
|
||||
{
|
||||
ct.ThrowIfCancellationRequested();
|
||||
if (ImageFormatInfo.IsSupportedExtension(file.Name)) yield return file;
|
||||
}
|
||||
}
|
||||
|
||||
public static SourceFile ToSource(FileInfo file, string root) =>
|
||||
new(file.FullName, file.Length, file.LastWriteTimeUtc, CaptureTime(file), root);
|
||||
|
||||
/// <summary>
|
||||
/// Capture time read cheaply: the file's last-write time in local wall-clock, which cameras set to the shot time.
|
||||
/// Exif dates replace it when the metadata reader lands in Titano.Core.
|
||||
/// </summary>
|
||||
public static DateTime CaptureTime(FileInfo file) => DateTime.SpecifyKind(file.LastWriteTime, DateTimeKind.Unspecified);
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
using System.Globalization;
|
||||
using System.IO;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
|
||||
namespace Titano.Uploader.Sources;
|
||||
|
||||
/// <summary>The last session of a source, so later files within the gap join it (watch folders).</summary>
|
||||
public sealed record SessionContinuation(string Key, DateTime LastCapture);
|
||||
|
||||
/// <summary>Session key per input frame (input order) and the session the next batch may continue.</summary>
|
||||
public sealed record SessionAssignment(IReadOnlyList<string> Keys, SessionContinuation? Last);
|
||||
|
||||
/// <summary>
|
||||
/// Splits frames of one source into shooting sessions with the card-import rules (BRIEF §13): a gap longer than
|
||||
/// <see cref="Gap"/> starts a session; sessions with fewer than <see cref="MinimumFrames"/> frames (test shots) merge
|
||||
/// into the previous session, or into the next one when they come first. The server turns each key into a sequence.
|
||||
/// </summary>
|
||||
public static class SessionGrouper
|
||||
{
|
||||
/// <summary><c>SessionGapMinutes</c> default.</summary>
|
||||
public static readonly TimeSpan Gap = TimeSpan.FromMinutes(45);
|
||||
|
||||
/// <summary><c>MinimumSessionFrames</c> default.</summary>
|
||||
public const int MinimumFrames = 8;
|
||||
|
||||
/// <summary>Groups <paramref name="captureTimes"/>; keys start with <paramref name="sourceTag"/> so sources never collide.</summary>
|
||||
public static SessionAssignment Assign(IReadOnlyList<DateTime> captureTimes, string sourceTag, SessionContinuation? previous = null)
|
||||
{
|
||||
if (captureTimes.Count == 0) return new SessionAssignment([], previous);
|
||||
var order = Enumerable.Range(0, captureTimes.Count).OrderBy(i => captureTimes[i]).ToArray();
|
||||
|
||||
// Split on gaps; a group that continues the previous batch keeps its key and is never "small".
|
||||
var groups = new List<Group>();
|
||||
var current = new Group { Continues = previous is not null && (captureTimes[order[0]] - previous.LastCapture).Duration() <= Gap };
|
||||
for (var n = 0; n < order.Length; n++)
|
||||
{
|
||||
var i = order[n];
|
||||
if (n > 0 && captureTimes[i] - captureTimes[order[n - 1]] > Gap)
|
||||
{
|
||||
groups.Add(current);
|
||||
current = new Group();
|
||||
}
|
||||
current.Members.Add(i);
|
||||
}
|
||||
groups.Add(current);
|
||||
|
||||
var merged = new List<Group>();
|
||||
foreach (var g in groups)
|
||||
{
|
||||
if (merged.Count > 0 && g.Members.Count < MinimumFrames) merged[^1].Members.AddRange(g.Members);
|
||||
else merged.Add(g);
|
||||
}
|
||||
if (merged.Count > 1 && merged[0].Members.Count < MinimumFrames && !merged[0].Continues)
|
||||
{
|
||||
merged[0].Members.AddRange(merged[1].Members);
|
||||
merged.RemoveAt(1);
|
||||
}
|
||||
|
||||
var keys = new string[captureTimes.Count];
|
||||
string? lastKey = null;
|
||||
foreach (var g in merged)
|
||||
{
|
||||
var first = g.Members.Min(i => captureTimes[i]);
|
||||
lastKey = g.Continues ? previous!.Key : Key(sourceTag, first);
|
||||
foreach (var i in g.Members) keys[i] = lastKey;
|
||||
}
|
||||
var lastCapture = captureTimes[order[^1]];
|
||||
if (previous is not null && previous.LastCapture > lastCapture && merged[^1].Continues) lastCapture = previous.LastCapture;
|
||||
return new SessionAssignment(keys, new SessionContinuation(lastKey!, lastCapture));
|
||||
}
|
||||
|
||||
/// <summary>Short stable tag for a source folder: 8 hex digits of the SHA-256 of its normalised path.</summary>
|
||||
public static string SourceTag(string root)
|
||||
{
|
||||
var normalized = Path.TrimEndingDirectorySeparator(Path.GetFullPath(root)).ToUpperInvariant();
|
||||
return Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(normalized)))[..8];
|
||||
}
|
||||
|
||||
/// <summary><c>{tag}-{yyyyMMdd-HHmmss}</c> of the session's first frame.</summary>
|
||||
public static string Key(string sourceTag, DateTime firstCapture) =>
|
||||
sourceTag + "-" + firstCapture.ToString("yyyyMMdd-HHmmss", CultureInfo.InvariantCulture);
|
||||
|
||||
private sealed class Group
|
||||
{
|
||||
public List<int> Members { get; } = [];
|
||||
public bool Continues { get; init; }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,114 @@
|
||||
using System.Globalization;
|
||||
using Titano.Core.Localization;
|
||||
using Titano.Uploader.Uploads;
|
||||
|
||||
namespace Titano.Uploader.Text;
|
||||
|
||||
/// <summary>What the queue is doing, for the end of the queue line.</summary>
|
||||
public enum QueueActivity
|
||||
{
|
||||
Idle,
|
||||
Running,
|
||||
Paused,
|
||||
WaitingForServer,
|
||||
Done,
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Culture-aware texts of the uploader: sizes, rates, durations and the queue/progress lines
|
||||
/// ("4,812 files · 96.2 GB · 38 MB/s · 41 min left"). Every method takes the culture so results are deterministic.
|
||||
/// </summary>
|
||||
public static class UploaderText
|
||||
{
|
||||
private const string Separator = " · ";
|
||||
private static readonly string[] ByteUnits = ["B", "KB", "MB", "GB", "TB", "PB"];
|
||||
|
||||
/// <summary>Localized string for <paramref name="key"/> in <paramref name="culture"/>, formatted with <paramref name="args"/>.</summary>
|
||||
public static string L(string key, CultureInfo culture, params object?[] args)
|
||||
{
|
||||
var format = Loc.Get(key, culture) ?? "⟦" + key + "⟧";
|
||||
return args.Length == 0 ? format : string.Format(culture, format, args);
|
||||
}
|
||||
|
||||
/// <summary>Plural-aware lookup of <c>key.one/few/many/other</c>; <c>{0}</c> receives the count.</summary>
|
||||
public static string Plural(string key, long count, CultureInfo culture)
|
||||
{
|
||||
var category = PluralRules.Suffix(PluralRules.Select(culture, count));
|
||||
var format = Loc.Get(key + "." + category, culture) ?? Loc.Get(key + ".other", culture) ?? "⟦" + key + "⟧";
|
||||
return string.Format(culture, format, count);
|
||||
}
|
||||
|
||||
/// <summary>1,536 → "1.5 KB" (decimal units, as Explorer shows for drives).</summary>
|
||||
public static string Bytes(long bytes, CultureInfo culture)
|
||||
{
|
||||
var (value, unit) = Scale(bytes);
|
||||
var format = unit == 0 || value >= 100 ? "0" : "0.#";
|
||||
return value.ToString(format, culture) + " " + ByteUnits[unit];
|
||||
}
|
||||
|
||||
/// <summary>38,400,000 B/s → "38 MB/s"; one decimal below 10 units.</summary>
|
||||
public static string Rate(double bytesPerSecond, CultureInfo culture)
|
||||
{
|
||||
var (value, unit) = Scale(Math.Max(0, bytesPerSecond));
|
||||
var format = unit == 0 || value >= 10 ? "0" : "0.#";
|
||||
return L("Uploader.Unit.PerSecond", culture, value.ToString(format, culture) + " " + ByteUnits[unit]);
|
||||
}
|
||||
|
||||
/// <summary>Compact duration: "2 h 05 m", "41 min", "40 s".</summary>
|
||||
public static string Duration(TimeSpan t, CultureInfo culture)
|
||||
{
|
||||
if (t.TotalHours >= 24) return L("Common.Duration.Days", culture, (int)t.TotalDays, t.Hours);
|
||||
if (t.TotalMinutes >= 59.5) return L("Common.Duration.Hours", culture, (int)Math.Round(t.TotalMinutes) / 60, ((int)Math.Round(t.TotalMinutes) % 60).ToString("00", culture));
|
||||
if (t.TotalSeconds >= 59.5) return L("Common.Duration.Minutes", culture, (int)Math.Round(t.TotalMinutes));
|
||||
return L("Common.Duration.Seconds", culture, (int)Math.Round(t.TotalSeconds));
|
||||
}
|
||||
|
||||
/// <summary>"4,812 files · 96.2 GB · 38 MB/s · 41 min left", or the files and size followed by the activity.</summary>
|
||||
public static string QueueLine(QueueSummary summary, QueueActivity activity, double bytesPerSecond, TimeSpan? left, CultureInfo culture)
|
||||
{
|
||||
if (summary.Files == 0) return L("Uploader.Queue.Empty", culture);
|
||||
var parts = new List<string> { Plural("Uploader.Queue.Files", summary.Files, culture), Bytes(summary.Bytes, culture) };
|
||||
switch (activity)
|
||||
{
|
||||
case QueueActivity.Running:
|
||||
if (bytesPerSecond > 0) parts.Add(Rate(bytesPerSecond, culture));
|
||||
if (left is { } l) parts.Add(L("Uploader.Queue.Left", culture, Duration(l, culture)));
|
||||
break;
|
||||
case QueueActivity.Paused:
|
||||
parts.Add(L("Uploader.Queue.Paused", culture));
|
||||
break;
|
||||
case QueueActivity.WaitingForServer:
|
||||
parts.Add(L("Uploader.Queue.Waiting", culture));
|
||||
break;
|
||||
case QueueActivity.Done:
|
||||
parts.Add(L("Uploader.Queue.Done", culture));
|
||||
break;
|
||||
}
|
||||
return string.Join(Separator, parts);
|
||||
}
|
||||
|
||||
/// <summary>"2,214 of 4,812 sent · 2,201 verified by the server · 0 retries", plus failures when there are any.</summary>
|
||||
public static string ProgressLine(QueueSummary summary, CultureInfo culture)
|
||||
{
|
||||
var parts = new List<string>
|
||||
{
|
||||
L("Uploader.Progress.Sent", culture, summary.Sent, summary.Files),
|
||||
L("Uploader.Progress.Verified", culture, summary.Verified),
|
||||
Plural("Uploader.Progress.Retries", summary.Retries, culture),
|
||||
};
|
||||
if (summary.Failed > 0) parts.Add(L("Uploader.Progress.Failed", culture, summary.Failed));
|
||||
return string.Join(Separator, parts);
|
||||
}
|
||||
|
||||
private static (double Value, int Unit) Scale(double bytes)
|
||||
{
|
||||
var value = bytes;
|
||||
var unit = 0;
|
||||
while (value >= 999.95 && unit < ByteUnits.Length - 1)
|
||||
{
|
||||
value /= 1000;
|
||||
unit++;
|
||||
}
|
||||
return (value, unit);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
using Titano.Protocol.Client;
|
||||
|
||||
namespace Titano.Uploader.Uploads;
|
||||
|
||||
/// <summary>How the server answered a successful upload.</summary>
|
||||
public enum UploadOutcome
|
||||
{
|
||||
/// <summary>Committed after the server checked the SHA-256 (<c>CompleteUploadResponse</c>).</summary>
|
||||
Verified,
|
||||
|
||||
/// <summary>The server already held this SHA-256 (<c>AlreadyExists</c>).</summary>
|
||||
AlreadyOnServer,
|
||||
}
|
||||
|
||||
/// <summary>What the upload needs from the server connection.</summary>
|
||||
public interface IUploadTransport
|
||||
{
|
||||
/// <summary>True while signed in and reachable; the engine waits otherwise.</summary>
|
||||
bool IsReady { get; }
|
||||
|
||||
/// <summary>Raised (on the UI thread) when <see cref="IsReady"/> changes.</summary>
|
||||
event EventHandler? ReadyChanged;
|
||||
|
||||
/// <summary>
|
||||
/// Sends one file whose hash is known. Throws <see cref="ServerUnavailableException"/> when the server cannot be
|
||||
/// used right now (offline, signed out, certificate changed); other failures concern this file only.
|
||||
/// </summary>
|
||||
Task<(UploadOutcome Outcome, Guid? FrameId)> UploadAsync(UploadItem item, Guid? sequenceId, string sha256, IProgress<UploadProgress> progress, CancellationToken ct);
|
||||
|
||||
/// <summary>Creates a sequence for a "new sequence" batch.</summary>
|
||||
Task<Guid> CreateSequenceAsync(string? title, CancellationToken ct);
|
||||
}
|
||||
|
||||
/// <summary>Why the server cannot be used.</summary>
|
||||
public enum ServerProblem
|
||||
{
|
||||
Unreachable,
|
||||
SignedOut,
|
||||
CertificateChanged,
|
||||
}
|
||||
|
||||
/// <summary>The server cannot take uploads right now; the item goes back in line without spending a retry.</summary>
|
||||
public sealed class ServerUnavailableException(ServerProblem problem, Exception? inner = null)
|
||||
: Exception("Server unavailable: " + problem, inner)
|
||||
{
|
||||
public ServerProblem Problem { get; } = problem;
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
using System.IO;
|
||||
using System.Text.Json.Serialization;
|
||||
using System.Text.Json;
|
||||
using Titano.Core.Diagnostics;
|
||||
|
||||
namespace Titano.Uploader.Uploads;
|
||||
|
||||
/// <summary>
|
||||
/// <c>uploader-queue.json</c>: the queue survives restarts (BRIEF §15). Server-side upload ids are not stored —
|
||||
/// restarting an item calls <c>POST /uploads</c> again with the same SHA-256 and the server answers with the chunks
|
||||
/// it already holds.
|
||||
/// </summary>
|
||||
public static class QueueStore
|
||||
{
|
||||
public const int Version = 1;
|
||||
|
||||
/// <summary>Serializes the queue on the calling (owning) thread; the bytes can be written anywhere.</summary>
|
||||
public static byte[] Serialize(UploadQueue queue)
|
||||
{
|
||||
var file = new QueueFile
|
||||
{
|
||||
Version = Version,
|
||||
Paused = queue.IsPaused,
|
||||
Batches = [.. queue.Batches.Select(b => new BatchRecord(b.Id, b.Mode, b.SequenceId, b.Title))],
|
||||
Items =
|
||||
[
|
||||
.. queue.Items.Select(i => new ItemRecord(
|
||||
i.Id, i.BatchId, i.Path, i.Size, i.ModifiedUtc, i.CapturedAt, i.SessionKey, i.WatchRoot,
|
||||
i.IsActive ? UploadItemState.Queued : i.State, i.Failure, i.FailureDetail, i.Retries, i.Sha256, i.FrameId, i.NextRetryUtc)),
|
||||
],
|
||||
};
|
||||
return JsonSerializer.SerializeToUtf8Bytes(file, QueueJson.Default.QueueFile);
|
||||
}
|
||||
|
||||
/// <summary>Loads <paramref name="path"/> into <paramref name="queue"/>; a missing or corrupt file leaves it empty.</summary>
|
||||
public static void Load(string path, UploadQueue queue)
|
||||
{
|
||||
QueueFile? file = null;
|
||||
try
|
||||
{
|
||||
if (File.Exists(path)) file = JsonSerializer.Deserialize(File.ReadAllBytes(path), QueueJson.Default.QueueFile);
|
||||
}
|
||||
catch (JsonException ex)
|
||||
{
|
||||
Log.Warning("queue", "Queue file unreadable; starting empty", ex);
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
Log.Warning("queue", "Queue file unreadable; starting empty", ex);
|
||||
}
|
||||
if (file is null || file.Version != Version) return;
|
||||
queue.Restore(
|
||||
file.Batches.Select(b => new UploadBatch { Id = b.Id, Mode = b.Mode, SequenceId = b.SequenceId, Title = b.Title }),
|
||||
file.Items.Select(r => new UploadItem
|
||||
{
|
||||
Id = r.Id,
|
||||
BatchId = r.BatchId,
|
||||
Path = r.Path,
|
||||
Size = r.Size,
|
||||
ModifiedUtc = r.ModifiedUtc,
|
||||
CapturedAt = r.CapturedAt,
|
||||
SessionKey = r.SessionKey,
|
||||
WatchRoot = r.WatchRoot,
|
||||
State = r.State,
|
||||
Failure = r.Failure,
|
||||
FailureDetail = r.FailureDetail,
|
||||
Retries = r.Retries,
|
||||
Sha256 = r.Sha256,
|
||||
FrameId = r.FrameId,
|
||||
NextRetryUtc = r.NextRetryUtc,
|
||||
}),
|
||||
file.Paused);
|
||||
}
|
||||
|
||||
internal sealed class QueueFile
|
||||
{
|
||||
public int Version { get; set; }
|
||||
public bool Paused { get; set; }
|
||||
public List<BatchRecord> Batches { get; set; } = [];
|
||||
public List<ItemRecord> Items { get; set; } = [];
|
||||
}
|
||||
|
||||
internal sealed record BatchRecord(Guid Id, UploadTargetMode Mode, Guid? SequenceId, string? Title);
|
||||
|
||||
internal sealed record ItemRecord(
|
||||
Guid Id,
|
||||
Guid BatchId,
|
||||
string Path,
|
||||
long Size,
|
||||
DateTime ModifiedUtc,
|
||||
DateTime? CapturedAt,
|
||||
string? SessionKey,
|
||||
string? WatchRoot,
|
||||
UploadItemState State,
|
||||
UploadFailure Failure,
|
||||
string? FailureDetail,
|
||||
int Retries,
|
||||
string? Sha256,
|
||||
Guid? FrameId,
|
||||
DateTime? NextRetryUtc);
|
||||
}
|
||||
|
||||
[JsonSourceGenerationOptions(
|
||||
PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
|
||||
DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
|
||||
UseStringEnumConverter = true)]
|
||||
[JsonSerializable(typeof(QueueStore.QueueFile))]
|
||||
internal sealed partial class QueueJson : JsonSerializerContext;
|
||||
@@ -0,0 +1,115 @@
|
||||
namespace Titano.Uploader.Uploads;
|
||||
|
||||
/// <summary>Aggregate figures behind the queue line and the progress bar.</summary>
|
||||
public readonly record struct QueueSummary(
|
||||
int Files,
|
||||
long Bytes,
|
||||
int Sent,
|
||||
int Verified,
|
||||
int Failed,
|
||||
int Retries,
|
||||
long DoneBytes,
|
||||
string? CurrentFile)
|
||||
{
|
||||
/// <summary>0–1 share of bytes already on the server or in flight.</summary>
|
||||
public double Progress => Bytes <= 0 ? 0 : Math.Clamp(DoneBytes / (double)Bytes, 0, 1);
|
||||
|
||||
/// <summary>Bytes still to send, counting only items that can still succeed.</summary>
|
||||
public long RemainingBytes { get; init; }
|
||||
|
||||
public static QueueSummary From(IEnumerable<UploadItem> items)
|
||||
{
|
||||
int files = 0, sent = 0, verified = 0, failed = 0, retries = 0;
|
||||
long bytes = 0, done = 0, remaining = 0;
|
||||
UploadItem? current = null;
|
||||
foreach (var item in items)
|
||||
{
|
||||
files++;
|
||||
bytes += item.Size;
|
||||
retries += item.Retries;
|
||||
switch (item.State)
|
||||
{
|
||||
case UploadItemState.Verified or UploadItemState.Skipped:
|
||||
sent++;
|
||||
verified++;
|
||||
done += item.Size;
|
||||
break;
|
||||
case UploadItemState.Uploading:
|
||||
if (item.BytesSent >= item.Size) sent++;
|
||||
done += Math.Min(item.BytesSent, item.Size);
|
||||
remaining += Math.Max(0, item.Size - item.BytesSent);
|
||||
current = item;
|
||||
break;
|
||||
case UploadItemState.Hashing:
|
||||
remaining += item.Size;
|
||||
current ??= item;
|
||||
break;
|
||||
case UploadItemState.Failed:
|
||||
failed++;
|
||||
if (item.NextRetryUtc is not null) remaining += item.Size;
|
||||
break;
|
||||
default:
|
||||
remaining += item.Size;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return new QueueSummary(files, bytes, sent, verified, failed, retries, done, current?.FileName) { RemainingBytes = remaining };
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Throughput over a sliding window of cumulative byte counts.</summary>
|
||||
public sealed class RateMeter(TimeSpan window)
|
||||
{
|
||||
private readonly List<(TimeSpan At, long Total)> _samples = [];
|
||||
private long _total;
|
||||
|
||||
public RateMeter()
|
||||
: this(TimeSpan.FromSeconds(10))
|
||||
{
|
||||
}
|
||||
|
||||
/// <summary>Adds <paramref name="bytes"/> sent at <paramref name="now"/> (monotonic clock).</summary>
|
||||
public void Add(long bytes, TimeSpan now)
|
||||
{
|
||||
// The first sample is the zero baseline so the first chunk counts.
|
||||
if (_samples.Count == 0) _samples.Add((now, _total));
|
||||
_total += bytes;
|
||||
_samples.Add((now, _total));
|
||||
Trim(now);
|
||||
}
|
||||
|
||||
/// <summary>Bytes per second over the window; 0 until the window spans at least one second.</summary>
|
||||
public double BytesPerSecond(TimeSpan now)
|
||||
{
|
||||
Trim(now);
|
||||
if (_samples.Count == 0) return 0;
|
||||
var (at, total) = _samples[0];
|
||||
// Measured up to now, so a stalled transfer decays towards zero.
|
||||
var span = (now - at).TotalSeconds;
|
||||
return span < 1 ? 0 : (_total - total) / span;
|
||||
}
|
||||
|
||||
public void Reset()
|
||||
{
|
||||
_samples.Clear();
|
||||
_total = 0;
|
||||
}
|
||||
|
||||
/// <summary>Keeps the newest sample at or before <c>now − window</c> as the baseline and drops older ones.</summary>
|
||||
private void Trim(TimeSpan now)
|
||||
{
|
||||
var cutoff = now - window;
|
||||
var drop = 0;
|
||||
while (drop + 1 < _samples.Count && _samples[drop + 1].At <= cutoff) drop++;
|
||||
if (drop > 0) _samples.RemoveRange(0, drop);
|
||||
}
|
||||
|
||||
/// <summary>Time to send <paramref name="remainingBytes"/> at <paramref name="bytesPerSecond"/>; null without a usable rate.</summary>
|
||||
public static TimeSpan? TimeLeft(long remainingBytes, double bytesPerSecond)
|
||||
{
|
||||
if (remainingBytes <= 0) return TimeSpan.Zero;
|
||||
if (bytesPerSecond < 1024) return null;
|
||||
var seconds = Math.Ceiling(remainingBytes / bytesPerSecond);
|
||||
return seconds >= TimeSpan.FromDays(365).TotalSeconds ? null : TimeSpan.FromSeconds(seconds);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,365 @@
|
||||
using System.ComponentModel;
|
||||
using System.IO;
|
||||
using Titano.Core.Diagnostics;
|
||||
using Titano.Protocol.Client;
|
||||
|
||||
namespace Titano.Uploader.Uploads;
|
||||
|
||||
/// <summary>What the upload engine is doing.</summary>
|
||||
public enum EngineStatus
|
||||
{
|
||||
Idle,
|
||||
Running,
|
||||
Paused,
|
||||
WaitingForServer,
|
||||
}
|
||||
|
||||
/// <summary>Queue control used by the window and the tray.</summary>
|
||||
public interface IUploadEngine : INotifyPropertyChanged
|
||||
{
|
||||
EngineStatus Status { get; }
|
||||
|
||||
/// <summary>Current throughput over the last seconds.</summary>
|
||||
double BytesPerSecond { get; }
|
||||
|
||||
/// <summary>Raised when the last pending item finished (balloon on completion).</summary>
|
||||
event EventHandler? Drained;
|
||||
|
||||
/// <summary>Starts work for newly queued items without waiting for the next tick.</summary>
|
||||
void Pump();
|
||||
|
||||
void Pause();
|
||||
void Resume();
|
||||
|
||||
/// <summary>Stops every transfer and clears the queue; files already uploaded stay on the server.</summary>
|
||||
void StopAndClear();
|
||||
|
||||
/// <summary>Puts a failed item back in line with a fresh retry budget.</summary>
|
||||
void Retry(UploadItem item);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Works through the <see cref="UploadQueue"/> with <see cref="Parallelism"/> concurrent files: hash, upload
|
||||
/// (resumable chunks; the server verifies the SHA-256), then optionally delete the source the server confirmed.
|
||||
/// Lives on the UI thread: state changes happen there while hashing and HTTP run on the thread pool.
|
||||
/// </summary>
|
||||
public sealed class UploadEngine : IUploadEngine, IDisposable
|
||||
{
|
||||
public const int Parallelism = 2;
|
||||
|
||||
private readonly UploadQueue _queue;
|
||||
private readonly IUploadTransport _transport;
|
||||
private readonly Func<bool> _deleteAfterUpload;
|
||||
private readonly TimeProvider _time;
|
||||
private readonly long _origin;
|
||||
private readonly RateMeter _meter = new();
|
||||
private readonly Dictionary<UploadItem, CancellationTokenSource> _running = [];
|
||||
private readonly Dictionary<Guid, Task<Guid>> _creating = [];
|
||||
private readonly CancellationTokenSource _lifetime = new();
|
||||
private EngineStatus _status;
|
||||
private double _bytesPerSecond;
|
||||
private bool _hadWork;
|
||||
|
||||
public UploadEngine(UploadQueue queue, IUploadTransport transport, Func<bool> deleteAfterUpload, TimeProvider? time = null)
|
||||
{
|
||||
_queue = queue;
|
||||
_transport = transport;
|
||||
_deleteAfterUpload = deleteAfterUpload;
|
||||
_time = time ?? TimeProvider.System;
|
||||
_origin = _time.GetTimestamp();
|
||||
_transport.ReadyChanged += (_, _) => Pump();
|
||||
}
|
||||
|
||||
public event PropertyChangedEventHandler? PropertyChanged;
|
||||
|
||||
public event EventHandler? Drained;
|
||||
|
||||
/// <summary>Raised when the server confirmed an item (verified or already present).</summary>
|
||||
public event EventHandler<UploadItem>? ItemConfirmed;
|
||||
|
||||
public EngineStatus Status
|
||||
{
|
||||
get => _status;
|
||||
private set
|
||||
{
|
||||
if (_status == value) return;
|
||||
_status = value;
|
||||
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Status)));
|
||||
}
|
||||
}
|
||||
|
||||
public double BytesPerSecond
|
||||
{
|
||||
get => _bytesPerSecond;
|
||||
private set
|
||||
{
|
||||
if (_bytesPerSecond.Equals(value)) return;
|
||||
_bytesPerSecond = value;
|
||||
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(BytesPerSecond)));
|
||||
}
|
||||
}
|
||||
|
||||
private TimeSpan Now => _time.GetElapsedTime(_origin);
|
||||
private DateTime UtcNow => _time.GetUtcNow().UtcDateTime;
|
||||
|
||||
/// <summary>Starts the once-a-second pump on the calling (UI) thread.</summary>
|
||||
public void Start() => _ = TickAsync(_lifetime.Token);
|
||||
|
||||
/// <summary>Starts work for newly queued items without waiting for the next tick.</summary>
|
||||
public void Pump()
|
||||
{
|
||||
if (_lifetime.IsCancellationRequested) return;
|
||||
while (!_queue.IsPaused && _transport.IsReady && _running.Count < Parallelism)
|
||||
{
|
||||
var item = _queue.NextReady(UtcNow);
|
||||
if (item is null) break;
|
||||
Begin(item);
|
||||
}
|
||||
Refresh();
|
||||
}
|
||||
|
||||
public void Pause()
|
||||
{
|
||||
_queue.IsPaused = true;
|
||||
CancelRunning();
|
||||
Refresh();
|
||||
}
|
||||
|
||||
public void Resume()
|
||||
{
|
||||
_queue.IsPaused = false;
|
||||
Pump();
|
||||
}
|
||||
|
||||
public void StopAndClear()
|
||||
{
|
||||
CancelRunning();
|
||||
_queue.Clear();
|
||||
_creating.Clear();
|
||||
_meter.Reset();
|
||||
_hadWork = false;
|
||||
Refresh();
|
||||
}
|
||||
|
||||
public void Retry(UploadItem item)
|
||||
{
|
||||
_queue.Requeue(item);
|
||||
Pump();
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
_lifetime.Cancel();
|
||||
CancelRunning();
|
||||
_lifetime.Dispose();
|
||||
}
|
||||
|
||||
private async Task TickAsync(CancellationToken ct)
|
||||
{
|
||||
using var timer = new PeriodicTimer(TimeSpan.FromSeconds(1), _time);
|
||||
try
|
||||
{
|
||||
do
|
||||
{
|
||||
Pump();
|
||||
}
|
||||
while (await timer.WaitForNextTickAsync(ct));
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
private void Begin(UploadItem item)
|
||||
{
|
||||
if (item.State == UploadItemState.Failed)
|
||||
{
|
||||
item.Retries++;
|
||||
item.NextRetryUtc = null;
|
||||
item.Failure = UploadFailure.None;
|
||||
item.FailureDetail = null;
|
||||
}
|
||||
// Leaving Queued/Failed synchronously keeps NextReady from handing the item out twice.
|
||||
item.State = UploadItemState.Hashing;
|
||||
var cts = CancellationTokenSource.CreateLinkedTokenSource(_lifetime.Token);
|
||||
_running[item] = cts;
|
||||
_hadWork = true;
|
||||
_ = RunAsync(item, cts);
|
||||
}
|
||||
|
||||
private async Task RunAsync(UploadItem item, CancellationTokenSource cts)
|
||||
{
|
||||
var ct = cts.Token;
|
||||
try
|
||||
{
|
||||
await HashIfNeededAsync(item, ct);
|
||||
if (item.State == UploadItemState.Failed) return;
|
||||
|
||||
item.State = UploadItemState.Uploading;
|
||||
item.BytesSent = 0;
|
||||
var batch = _queue.GetBatch(item.BatchId);
|
||||
Guid? sequenceId = batch?.Mode switch
|
||||
{
|
||||
UploadTargetMode.Sequence => batch.SequenceId,
|
||||
UploadTargetMode.NewSequence => await EnsureSequenceAsync(batch, ct),
|
||||
_ => null,
|
||||
};
|
||||
|
||||
var baseline = true;
|
||||
var progress = new Progress<UploadProgress>(p =>
|
||||
{
|
||||
if (item.State != UploadItemState.Uploading) return;
|
||||
// The first report of a resumed upload counts chunks the server already had: not throughput.
|
||||
if (!baseline) _meter.Add(Math.Max(0, p.BytesSent - item.BytesSent), Now);
|
||||
baseline = false;
|
||||
item.BytesSent = p.BytesSent;
|
||||
});
|
||||
var (outcome, frameId) = await _transport.UploadAsync(item, sequenceId, item.Sha256!, progress, ct);
|
||||
|
||||
item.FrameId = frameId;
|
||||
item.BytesSent = item.Size;
|
||||
item.State = outcome == UploadOutcome.Verified ? UploadItemState.Verified : UploadItemState.Skipped;
|
||||
_queue.OnChanged();
|
||||
ItemConfirmed?.Invoke(this, item);
|
||||
if (_deleteAfterUpload()) DeleteConfirmedSource(item);
|
||||
}
|
||||
catch (OperationCanceledException) when (ct.IsCancellationRequested)
|
||||
{
|
||||
Requeue(item);
|
||||
}
|
||||
catch (ServerUnavailableException ex)
|
||||
{
|
||||
Log.Info("upload", $"{item.FileName} waits for the server ({ex.Problem})");
|
||||
Requeue(item);
|
||||
}
|
||||
catch (Exception ex) when (ex is FileNotFoundException or DirectoryNotFoundException)
|
||||
{
|
||||
_queue.Fail(item, UploadFailure.FileMissing, null, UtcNow);
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
||||
{
|
||||
Log.Warning("upload", $"Cannot read {item.Path}", ex);
|
||||
_queue.Fail(item, File.Exists(item.Path) ? UploadFailure.FileUnreadable : UploadFailure.FileMissing, null, UtcNow);
|
||||
}
|
||||
catch (TitanoApiException ex)
|
||||
{
|
||||
Log.Warning("upload", $"Server refused {item.Path}: {ex.Error.Code}", ex);
|
||||
_queue.Fail(item, UploadFailure.ServerRejected, ex.Error.Message, UtcNow);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
// Worker boundary: nothing may leave an item stuck in an active state.
|
||||
Log.Error("upload", $"Upload of {item.Path} failed", ex);
|
||||
_queue.Fail(item, UploadFailure.Unexpected, null, UtcNow);
|
||||
}
|
||||
finally
|
||||
{
|
||||
_running.Remove(item);
|
||||
cts.Dispose();
|
||||
Pump();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Hashes when the file is new or changed; a file that changes while being read fails for a later retry.</summary>
|
||||
private async Task HashIfNeededAsync(UploadItem item, CancellationToken ct)
|
||||
{
|
||||
var file = new FileInfo(item.Path);
|
||||
if (!file.Exists)
|
||||
{
|
||||
_queue.Fail(item, UploadFailure.FileMissing, null, UtcNow);
|
||||
return;
|
||||
}
|
||||
if (file.Length != item.Size || file.LastWriteTimeUtc != item.ModifiedUtc)
|
||||
{
|
||||
item.Sha256 = null;
|
||||
item.Size = file.Length;
|
||||
item.ModifiedUtc = file.LastWriteTimeUtc;
|
||||
}
|
||||
if (item.Sha256 is not null) return;
|
||||
|
||||
var sha = await Task.Run(() => TitanoClient.HashFileAsync(item.Path, ct), ct);
|
||||
file.Refresh();
|
||||
if (!file.Exists || file.Length != item.Size || file.LastWriteTimeUtc != item.ModifiedUtc)
|
||||
{
|
||||
_queue.Fail(item, UploadFailure.FileChanged, null, UtcNow);
|
||||
return;
|
||||
}
|
||||
item.Sha256 = sha;
|
||||
_queue.OnChanged();
|
||||
}
|
||||
|
||||
/// <summary>Creates the batch's sequence once, shared by concurrent items of the same batch.</summary>
|
||||
private async Task<Guid> EnsureSequenceAsync(UploadBatch batch, CancellationToken ct)
|
||||
{
|
||||
if (batch.SequenceId is { } known) return known;
|
||||
if (!_creating.TryGetValue(batch.Id, out var creation))
|
||||
{
|
||||
creation = _transport.CreateSequenceAsync(batch.Title, _lifetime.Token);
|
||||
_creating[batch.Id] = creation;
|
||||
}
|
||||
try
|
||||
{
|
||||
var id = await creation.WaitAsync(ct);
|
||||
batch.SequenceId = id;
|
||||
_queue.OnChanged();
|
||||
return id;
|
||||
}
|
||||
catch when (creation.IsFaulted || creation.IsCanceled)
|
||||
{
|
||||
_creating.Remove(batch.Id);
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// BRIEF §0.2 rule 8: deletes only a file the server confirmed by hash, and only when it is still exactly the
|
||||
/// bytes that were hashed (same size and write time).
|
||||
/// </summary>
|
||||
private static void DeleteConfirmedSource(UploadItem item)
|
||||
{
|
||||
try
|
||||
{
|
||||
var file = new FileInfo(item.Path);
|
||||
if (!file.Exists) return;
|
||||
if (file.Length != item.Size || file.LastWriteTimeUtc != item.ModifiedUtc)
|
||||
{
|
||||
Log.Warning("upload", $"Kept {item.Path}: it changed after the server verified it");
|
||||
return;
|
||||
}
|
||||
file.Delete();
|
||||
Log.Info("upload", $"Deleted {item.Path} after the server confirmed SHA-256 {item.Sha256}");
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
||||
{
|
||||
Log.Warning("upload", $"Could not delete {item.Path}", ex);
|
||||
}
|
||||
}
|
||||
|
||||
private void Requeue(UploadItem item)
|
||||
{
|
||||
if (!item.IsActive) return;
|
||||
item.State = UploadItemState.Queued;
|
||||
item.BytesSent = 0;
|
||||
}
|
||||
|
||||
private void CancelRunning()
|
||||
{
|
||||
foreach (var cts in _running.Values.ToList()) cts.Cancel();
|
||||
}
|
||||
|
||||
private void Refresh()
|
||||
{
|
||||
BytesPerSecond = _meter.BytesPerSecond(Now);
|
||||
var pending = _queue.HasPending;
|
||||
Status = _queue.IsPaused && pending ? EngineStatus.Paused
|
||||
: pending && !_transport.IsReady ? EngineStatus.WaitingForServer
|
||||
: pending || _running.Count > 0 ? EngineStatus.Running
|
||||
: EngineStatus.Idle;
|
||||
if (_hadWork && !pending && _running.Count == 0)
|
||||
{
|
||||
_hadWork = false;
|
||||
_meter.Reset();
|
||||
Drained?.Invoke(this, EventArgs.Empty);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,139 @@
|
||||
using System.ComponentModel;
|
||||
using System.Runtime.CompilerServices;
|
||||
|
||||
namespace Titano.Uploader.Uploads;
|
||||
|
||||
/// <summary>Per-file state in the upload queue (BRIEF §15).</summary>
|
||||
public enum UploadItemState
|
||||
{
|
||||
Queued,
|
||||
Hashing,
|
||||
Uploading,
|
||||
|
||||
/// <summary>The server committed the file after checking its SHA-256.</summary>
|
||||
Verified,
|
||||
|
||||
/// <summary>The server already held a file with the same SHA-256.</summary>
|
||||
Skipped,
|
||||
|
||||
Failed,
|
||||
}
|
||||
|
||||
/// <summary>Why an item failed; the UI turns it into one localized sentence.</summary>
|
||||
public enum UploadFailure
|
||||
{
|
||||
None,
|
||||
FileMissing,
|
||||
FileUnreadable,
|
||||
|
||||
/// <summary>The file changed while it was being hashed (still being written).</summary>
|
||||
FileChanged,
|
||||
|
||||
ServerRejected,
|
||||
Unexpected,
|
||||
}
|
||||
|
||||
/// <summary>Where a batch of files goes on the server.</summary>
|
||||
public enum UploadTargetMode
|
||||
{
|
||||
/// <summary>The server groups files by <see cref="UploadItem.SessionKey"/> into auto-created sequences.</summary>
|
||||
Sessions,
|
||||
|
||||
/// <summary>Every file goes to one existing sequence.</summary>
|
||||
Sequence,
|
||||
|
||||
/// <summary>One new sequence is created for the batch with the given title.</summary>
|
||||
NewSequence,
|
||||
}
|
||||
|
||||
/// <summary>Files added together share a target; a new sequence is created once per batch, on first upload.</summary>
|
||||
public sealed class UploadBatch
|
||||
{
|
||||
public required Guid Id { get; init; }
|
||||
public required UploadTargetMode Mode { get; init; }
|
||||
|
||||
/// <summary>Target sequence; for <see cref="UploadTargetMode.NewSequence"/> it is filled once the server created it.</summary>
|
||||
public Guid? SequenceId { get; set; }
|
||||
|
||||
public string? Title { get; init; }
|
||||
}
|
||||
|
||||
/// <summary>One file in the queue. Mutated only on the queue's owning (UI) thread.</summary>
|
||||
public sealed class UploadItem : INotifyPropertyChanged
|
||||
{
|
||||
private UploadItemState _state;
|
||||
private UploadFailure _failure;
|
||||
private string? _failureDetail;
|
||||
private int _retries;
|
||||
private long _bytesSent;
|
||||
|
||||
public required Guid Id { get; init; }
|
||||
public required Guid BatchId { get; init; }
|
||||
public required string Path { get; init; }
|
||||
|
||||
/// <summary>Size and write time when the file was last hashed or enqueued; a change forces a new hash.</summary>
|
||||
public required long Size { get; set; }
|
||||
|
||||
public required DateTime ModifiedUtc { get; set; }
|
||||
|
||||
/// <summary>Camera wall-clock capture time (unspecified kind).</summary>
|
||||
public DateTime? CapturedAt { get; init; }
|
||||
|
||||
public string? SessionKey { get; init; }
|
||||
|
||||
/// <summary>Watch folder the file came from; null for files added by hand.</summary>
|
||||
public string? WatchRoot { get; init; }
|
||||
|
||||
public string? Sha256 { get; set; }
|
||||
public Guid? FrameId { get; set; }
|
||||
|
||||
/// <summary>Earliest time a failed item may be retried by the queue.</summary>
|
||||
public DateTime? NextRetryUtc { get; set; }
|
||||
|
||||
public string FileName => System.IO.Path.GetFileName(Path);
|
||||
|
||||
public UploadItemState State
|
||||
{
|
||||
get => _state;
|
||||
set => Set(ref _state, value);
|
||||
}
|
||||
|
||||
public UploadFailure Failure
|
||||
{
|
||||
get => _failure;
|
||||
set => Set(ref _failure, value);
|
||||
}
|
||||
|
||||
/// <summary>Server message for <see cref="UploadFailure.ServerRejected"/>, otherwise null.</summary>
|
||||
public string? FailureDetail
|
||||
{
|
||||
get => _failureDetail;
|
||||
set => Set(ref _failureDetail, value);
|
||||
}
|
||||
|
||||
/// <summary>Queue-level retries already spent on this item.</summary>
|
||||
public int Retries
|
||||
{
|
||||
get => _retries;
|
||||
set => Set(ref _retries, value);
|
||||
}
|
||||
|
||||
/// <summary>Bytes sent in the current attempt (progress only; not persisted).</summary>
|
||||
public long BytesSent
|
||||
{
|
||||
get => _bytesSent;
|
||||
set => Set(ref _bytesSent, value);
|
||||
}
|
||||
|
||||
public bool IsDone => _state is UploadItemState.Verified or UploadItemState.Skipped;
|
||||
public bool IsActive => _state is UploadItemState.Hashing or UploadItemState.Uploading;
|
||||
|
||||
public event PropertyChangedEventHandler? PropertyChanged;
|
||||
|
||||
private void Set<T>(ref T field, T value, [CallerMemberName] string? name = null)
|
||||
{
|
||||
if (EqualityComparer<T>.Default.Equals(field, value)) return;
|
||||
field = value;
|
||||
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,167 @@
|
||||
using System.Collections.Concurrent;
|
||||
using System.Collections.ObjectModel;
|
||||
|
||||
namespace Titano.Uploader.Uploads;
|
||||
|
||||
/// <summary>A file about to be enqueued.</summary>
|
||||
public sealed record QueueEntry(string Path, long Size, DateTime ModifiedUtc, DateTime? CapturedAt, string? SessionKey, string? WatchRoot);
|
||||
|
||||
/// <summary>
|
||||
/// Ordered upload queue with its batches. Owned by the UI thread: every mutation happens there, so bindings can
|
||||
/// observe <see cref="Items"/> directly. <see cref="ContainsPath"/> is the only member safe from other threads.
|
||||
/// </summary>
|
||||
public sealed class UploadQueue
|
||||
{
|
||||
/// <summary>Queue-level retries per item after the client's own transient retries (BRIEF §15).</summary>
|
||||
public const int MaxRetries = 3;
|
||||
|
||||
/// <summary>Delay before a failed item is tried again.</summary>
|
||||
public static readonly TimeSpan RetryDelay = TimeSpan.FromSeconds(30);
|
||||
|
||||
private readonly Dictionary<Guid, UploadBatch> _batches = [];
|
||||
private readonly ConcurrentDictionary<string, byte> _paths = new(StringComparer.OrdinalIgnoreCase);
|
||||
private bool _isPaused;
|
||||
|
||||
public ObservableCollection<UploadItem> Items { get; } = [];
|
||||
|
||||
public IReadOnlyCollection<UploadBatch> Batches => _batches.Values;
|
||||
|
||||
/// <summary>True while the user has paused the queue; persisted so a restart keeps it paused.</summary>
|
||||
public bool IsPaused
|
||||
{
|
||||
get => _isPaused;
|
||||
set
|
||||
{
|
||||
if (_isPaused == value) return;
|
||||
_isPaused = value;
|
||||
OnChanged();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Raised after anything that must be persisted changed.</summary>
|
||||
public event EventHandler? Changed;
|
||||
|
||||
/// <summary>True while an item for <paramref name="path"/> is queued (any state). Thread-safe.</summary>
|
||||
public bool ContainsPath(string path) => _paths.ContainsKey(path);
|
||||
|
||||
/// <summary>True while some item still waits for, or is in, an upload attempt (retryable failures included).</summary>
|
||||
public bool HasPending => Items.Any(IsPending);
|
||||
|
||||
/// <summary>Appends files not already queued, in the given order, under one batch; returns how many were added.</summary>
|
||||
public int Add(UploadBatch batch, IEnumerable<QueueEntry> entries)
|
||||
{
|
||||
var added = 0;
|
||||
foreach (var e in entries)
|
||||
{
|
||||
if (!_paths.TryAdd(e.Path, 0)) continue;
|
||||
Items.Add(new UploadItem
|
||||
{
|
||||
Id = Guid.CreateVersion7(),
|
||||
BatchId = batch.Id,
|
||||
Path = e.Path,
|
||||
Size = e.Size,
|
||||
ModifiedUtc = e.ModifiedUtc,
|
||||
CapturedAt = e.CapturedAt,
|
||||
SessionKey = e.SessionKey,
|
||||
WatchRoot = e.WatchRoot,
|
||||
});
|
||||
added++;
|
||||
}
|
||||
if (added > 0)
|
||||
{
|
||||
_batches[batch.Id] = batch;
|
||||
OnChanged();
|
||||
}
|
||||
return added;
|
||||
}
|
||||
|
||||
public UploadBatch? GetBatch(Guid id) => _batches.GetValueOrDefault(id);
|
||||
|
||||
/// <summary>
|
||||
/// The next item to work on: the first queued one, otherwise the first failed one whose retry time has come.
|
||||
/// </summary>
|
||||
public UploadItem? NextReady(DateTime utcNow)
|
||||
{
|
||||
UploadItem? retry = null;
|
||||
foreach (var item in Items)
|
||||
{
|
||||
if (item.State == UploadItemState.Queued) return item;
|
||||
if (retry is null && IsRetryDue(item, utcNow)) retry = item;
|
||||
}
|
||||
return retry;
|
||||
}
|
||||
|
||||
/// <summary>Records a failure and schedules the queue-level retry when retries are left.</summary>
|
||||
public void Fail(UploadItem item, UploadFailure failure, string? detail, DateTime utcNow)
|
||||
{
|
||||
item.State = UploadItemState.Failed;
|
||||
item.Failure = failure;
|
||||
item.FailureDetail = detail;
|
||||
item.BytesSent = 0;
|
||||
item.NextRetryUtc = item.Retries < MaxRetries ? utcNow + RetryDelay : null;
|
||||
OnChanged();
|
||||
}
|
||||
|
||||
/// <summary>Puts a failed item back in line now, with a fresh retry budget (user action).</summary>
|
||||
public void Requeue(UploadItem item)
|
||||
{
|
||||
if (item.State != UploadItemState.Failed) return;
|
||||
item.State = UploadItemState.Queued;
|
||||
item.Failure = UploadFailure.None;
|
||||
item.FailureDetail = null;
|
||||
item.Retries = 0;
|
||||
item.NextRetryUtc = null;
|
||||
OnChanged();
|
||||
}
|
||||
|
||||
/// <summary>Drops finished items (verified or skipped) so a new batch starts a fresh count.</summary>
|
||||
public void RemoveCompleted()
|
||||
{
|
||||
var removed = false;
|
||||
for (var i = Items.Count - 1; i >= 0; i--)
|
||||
{
|
||||
if (!Items[i].IsDone) continue;
|
||||
_paths.TryRemove(Items[i].Path, out _);
|
||||
Items.RemoveAt(i);
|
||||
removed = true;
|
||||
}
|
||||
if (!removed) return;
|
||||
var used = Items.Select(i => i.BatchId).ToHashSet();
|
||||
foreach (var id in _batches.Keys.Where(id => !used.Contains(id)).ToList()) _batches.Remove(id);
|
||||
OnChanged();
|
||||
}
|
||||
|
||||
public void Clear()
|
||||
{
|
||||
Items.Clear();
|
||||
_paths.Clear();
|
||||
_batches.Clear();
|
||||
OnChanged();
|
||||
}
|
||||
|
||||
/// <summary>Signals a persisted-state change made directly on an item.</summary>
|
||||
public void OnChanged() => Changed?.Invoke(this, EventArgs.Empty);
|
||||
|
||||
/// <summary>Restores a persisted queue; interrupted attempts go back to <see cref="UploadItemState.Queued"/>.</summary>
|
||||
public void Restore(IEnumerable<UploadBatch> batches, IEnumerable<UploadItem> items, bool paused)
|
||||
{
|
||||
Items.Clear();
|
||||
_paths.Clear();
|
||||
_batches.Clear();
|
||||
foreach (var b in batches) _batches[b.Id] = b;
|
||||
foreach (var item in items)
|
||||
{
|
||||
if (!_batches.ContainsKey(item.BatchId) || !_paths.TryAdd(item.Path, 0)) continue;
|
||||
if (item.IsActive) item.State = UploadItemState.Queued;
|
||||
Items.Add(item);
|
||||
}
|
||||
_isPaused = paused;
|
||||
}
|
||||
|
||||
private static bool IsPending(UploadItem item) =>
|
||||
item.State is UploadItemState.Queued or UploadItemState.Hashing or UploadItemState.Uploading
|
||||
|| (item.State == UploadItemState.Failed && item.NextRetryUtc is not null);
|
||||
|
||||
private static bool IsRetryDue(UploadItem item, DateTime utcNow) =>
|
||||
item.State == UploadItemState.Failed && item.NextRetryUtc is { } due && due <= utcNow;
|
||||
}
|
||||
@@ -0,0 +1,165 @@
|
||||
using System.IO;
|
||||
using System.Text.Json.Serialization;
|
||||
using System.Text.Json;
|
||||
using Titano.Core.Diagnostics;
|
||||
using Titano.Uploader.Sources;
|
||||
|
||||
namespace Titano.Uploader.Watching;
|
||||
|
||||
/// <summary>
|
||||
/// Files of each watch folder the server already confirmed, keyed by path + size + write time, so a poll never
|
||||
/// uploads them again; plus the last session of each folder so new frames keep joining it. Thread-safe.
|
||||
/// Persisted in <c>uploader-watch.json</c>.
|
||||
/// </summary>
|
||||
public sealed class ProcessedFileMemory
|
||||
{
|
||||
public const int Version = 1;
|
||||
|
||||
private readonly Lock _gate = new();
|
||||
private readonly Dictionary<string, Folder> _folders = new(StringComparer.OrdinalIgnoreCase);
|
||||
private bool _dirty;
|
||||
|
||||
/// <summary>True when something changed since the last <see cref="Serialize"/>.</summary>
|
||||
public bool IsDirty
|
||||
{
|
||||
get
|
||||
{
|
||||
lock (_gate) return _dirty;
|
||||
}
|
||||
}
|
||||
|
||||
public bool Contains(string root, string path, long size, DateTime modifiedUtc)
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
return _folders.TryGetValue(root, out var f)
|
||||
&& f.Files.TryGetValue(Relative(root, path), out var known)
|
||||
&& known.Size == size && known.ModifiedTicks == modifiedUtc.Ticks;
|
||||
}
|
||||
}
|
||||
|
||||
public void Add(string root, string path, long size, DateTime modifiedUtc)
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
GetOrAdd(root).Files[Relative(root, path)] = new Entry(size, modifiedUtc.Ticks);
|
||||
_dirty = true;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Forgets files of <paramref name="root"/> that a complete scan no longer found.</summary>
|
||||
public void Prune(string root, IEnumerable<string> presentPaths)
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
if (!_folders.TryGetValue(root, out var f) || f.Files.Count == 0) return;
|
||||
var present = new HashSet<string>(presentPaths.Select(p => Relative(root, p)), StringComparer.OrdinalIgnoreCase);
|
||||
foreach (var key in f.Files.Keys.Where(k => !present.Contains(k)).ToList())
|
||||
{
|
||||
f.Files.Remove(key);
|
||||
_dirty = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void RemoveFolder(string root)
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
if (_folders.Remove(root)) _dirty = true;
|
||||
}
|
||||
}
|
||||
|
||||
public SessionContinuation? GetSession(string root)
|
||||
{
|
||||
lock (_gate) return _folders.TryGetValue(root, out var f) ? f.Session : null;
|
||||
}
|
||||
|
||||
public void SetSession(string root, SessionContinuation? session)
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
GetOrAdd(root).Session = session;
|
||||
_dirty = true;
|
||||
}
|
||||
}
|
||||
|
||||
public byte[] Serialize()
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
var file = new MemoryFile
|
||||
{
|
||||
Version = Version,
|
||||
Folders =
|
||||
[
|
||||
.. _folders.Select(kv => new FolderRecord(
|
||||
kv.Key,
|
||||
kv.Value.Session?.Key,
|
||||
kv.Value.Session?.LastCapture,
|
||||
[.. kv.Value.Files.Select(f => new FileRecord(f.Key, f.Value.Size, f.Value.ModifiedTicks))])),
|
||||
],
|
||||
};
|
||||
_dirty = false;
|
||||
return JsonSerializer.SerializeToUtf8Bytes(file, WatchJson.Default.MemoryFile);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Loads <paramref name="path"/>; a missing or corrupt file gives an empty memory.</summary>
|
||||
public static ProcessedFileMemory Load(string path)
|
||||
{
|
||||
var memory = new ProcessedFileMemory();
|
||||
MemoryFile? file = null;
|
||||
try
|
||||
{
|
||||
if (File.Exists(path)) file = JsonSerializer.Deserialize(File.ReadAllBytes(path), WatchJson.Default.MemoryFile);
|
||||
}
|
||||
catch (JsonException ex)
|
||||
{
|
||||
Log.Warning("watch", "Watch memory unreadable; starting empty", ex);
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
Log.Warning("watch", "Watch memory unreadable; starting empty", ex);
|
||||
}
|
||||
if (file is null || file.Version != Version) return memory;
|
||||
foreach (var record in file.Folders)
|
||||
{
|
||||
var folder = memory.GetOrAdd(record.Root);
|
||||
if (record.SessionKey is not null && record.LastCapture is { } last) folder.Session = new SessionContinuation(record.SessionKey, last);
|
||||
foreach (var f in record.Files) folder.Files[f.Path] = new Entry(f.Size, f.Modified);
|
||||
}
|
||||
return memory;
|
||||
}
|
||||
|
||||
private Folder GetOrAdd(string root)
|
||||
{
|
||||
if (!_folders.TryGetValue(root, out var f)) _folders[root] = f = new Folder();
|
||||
return f;
|
||||
}
|
||||
|
||||
/// <summary>Paths are stored relative to the folder to keep the file small.</summary>
|
||||
private static string Relative(string root, string path) => Path.GetRelativePath(root, path);
|
||||
|
||||
private readonly record struct Entry(long Size, long ModifiedTicks);
|
||||
|
||||
private sealed class Folder
|
||||
{
|
||||
public Dictionary<string, Entry> Files { get; } = new(StringComparer.OrdinalIgnoreCase);
|
||||
public SessionContinuation? Session { get; set; }
|
||||
}
|
||||
|
||||
internal sealed class MemoryFile
|
||||
{
|
||||
public int Version { get; set; }
|
||||
public List<FolderRecord> Folders { get; set; } = [];
|
||||
}
|
||||
|
||||
internal sealed record FolderRecord(string Root, string? SessionKey, DateTime? LastCapture, List<FileRecord> Files);
|
||||
|
||||
internal sealed record FileRecord(string Path, long Size, long Modified);
|
||||
}
|
||||
|
||||
[JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase, DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull)]
|
||||
[JsonSerializable(typeof(ProcessedFileMemory.MemoryFile))]
|
||||
internal sealed partial class WatchJson : JsonSerializerContext;
|
||||
@@ -0,0 +1,47 @@
|
||||
namespace Titano.Uploader.Watching;
|
||||
|
||||
/// <summary>Size and last-write time of a file at one check.</summary>
|
||||
public readonly record struct FileObservation(string Path, long Size, DateTime ModifiedUtc);
|
||||
|
||||
/// <summary>
|
||||
/// Decides when a file in a watch folder has stopped growing: it is reported once its size and write time were
|
||||
/// identical in <see cref="RequiredChecks"/> consecutive checks, then forgotten (the caller enqueues it).
|
||||
/// </summary>
|
||||
public sealed class StableFileTracker
|
||||
{
|
||||
public const int RequiredChecks = 2;
|
||||
|
||||
private readonly Dictionary<string, (long Size, DateTime Modified, int Count)> _seen = new(StringComparer.OrdinalIgnoreCase);
|
||||
|
||||
/// <summary>Files seen but not yet stable.</summary>
|
||||
public int PendingCount => _seen.Count;
|
||||
|
||||
/// <summary>
|
||||
/// Records a complete scan: returns the files that are now stable and forgets files missing from the scan.
|
||||
/// </summary>
|
||||
public IReadOnlyList<FileObservation> Check(IEnumerable<FileObservation> scan)
|
||||
{
|
||||
var present = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
||||
var stable = new List<FileObservation>();
|
||||
foreach (var o in scan)
|
||||
{
|
||||
present.Add(o.Path);
|
||||
if (Observe(o)) stable.Add(o);
|
||||
}
|
||||
foreach (var path in _seen.Keys.Where(p => !present.Contains(p)).ToList()) _seen.Remove(path);
|
||||
return stable;
|
||||
}
|
||||
|
||||
/// <summary>Records one observation; true when the file just became stable.</summary>
|
||||
public bool Observe(FileObservation o)
|
||||
{
|
||||
var count = _seen.TryGetValue(o.Path, out var last) && last.Size == o.Size && last.Modified == o.ModifiedUtc ? last.Count + 1 : 1;
|
||||
if (count >= RequiredChecks)
|
||||
{
|
||||
_seen.Remove(o.Path);
|
||||
return true;
|
||||
}
|
||||
_seen[o.Path] = (o.Size, o.ModifiedUtc, count);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,188 @@
|
||||
using System.IO;
|
||||
using Titano.Core.Diagnostics;
|
||||
using Titano.Uploader.Sources;
|
||||
|
||||
namespace Titano.Uploader.Watching;
|
||||
|
||||
/// <summary>
|
||||
/// Polls each watch folder at its interval, with <see cref="FileSystemWatcher"/> hints on local disks (change
|
||||
/// notifications are unreliable on network shares, which are only polled). A photo is reported once it is stable
|
||||
/// (<see cref="StableFileTracker"/>), not yet confirmed by the server (<see cref="ProcessedFileMemory"/>) and not queued.
|
||||
/// </summary>
|
||||
public sealed class WatchFolderService(ProcessedFileMemory memory, Func<string, bool> isQueued) : IDisposable
|
||||
{
|
||||
/// <summary>Re-check cadence while some file is still growing.</summary>
|
||||
private static readonly TimeSpan QuickCheck = TimeSpan.FromSeconds(10);
|
||||
|
||||
/// <summary>Lets a burst of change notifications settle before scanning.</summary>
|
||||
private static readonly TimeSpan HintDebounce = TimeSpan.FromSeconds(2);
|
||||
|
||||
private readonly Dictionary<string, Folder> _folders = new(StringComparer.OrdinalIgnoreCase);
|
||||
private readonly ProcessedFileMemory _memory = memory;
|
||||
private readonly Func<string, bool> _isQueued = isQueued;
|
||||
|
||||
/// <summary>Stable new photos of a folder; raised on the thread that called <see cref="Watch"/>.</summary>
|
||||
public event Action<string, IReadOnlyList<SourceFile>>? FilesReady;
|
||||
|
||||
/// <summary>A folder became reachable (true) or unreachable (false); raised like <see cref="FilesReady"/>.</summary>
|
||||
public event Action<string, bool>? AvailabilityChanged;
|
||||
|
||||
/// <summary>UNC paths and mapped network drives.</summary>
|
||||
public static bool IsNetworkPath(string path)
|
||||
{
|
||||
if (path.StartsWith(@"\\", StringComparison.Ordinal)) return true;
|
||||
try
|
||||
{
|
||||
var root = Path.GetPathRoot(Path.GetFullPath(path));
|
||||
return !string.IsNullOrEmpty(root) && new DriveInfo(root).DriveType == DriveType.Network;
|
||||
}
|
||||
catch (Exception ex) when (ex is ArgumentException or IOException)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>60 s on local disks; 5 min on network shares, where every poll lists the share.</summary>
|
||||
public static TimeSpan DefaultInterval(string path) => IsNetworkPath(path) ? TimeSpan.FromMinutes(5) : TimeSpan.FromSeconds(60);
|
||||
|
||||
/// <summary>Starts (or restarts with a new interval) watching <paramref name="root"/>.</summary>
|
||||
public void Watch(string root, TimeSpan interval)
|
||||
{
|
||||
Stop(root);
|
||||
var folder = new Folder(root, interval, IsNetworkPath(root), SynchronizationContext.Current, this);
|
||||
_folders[root] = folder;
|
||||
folder.Start();
|
||||
}
|
||||
|
||||
public void Stop(string root)
|
||||
{
|
||||
if (_folders.Remove(root, out var folder)) folder.Dispose();
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
foreach (var f in _folders.Values) f.Dispose();
|
||||
_folders.Clear();
|
||||
}
|
||||
|
||||
private void Raise(SynchronizationContext? context, Action action)
|
||||
{
|
||||
if (context is null) action();
|
||||
else context.Post(_ => action(), null);
|
||||
}
|
||||
|
||||
private sealed class Folder(string root, TimeSpan interval, bool network, SynchronizationContext? context, WatchFolderService owner) : IDisposable
|
||||
{
|
||||
private readonly StableFileTracker _tracker = new();
|
||||
private readonly CancellationTokenSource _cts = new();
|
||||
private FileSystemWatcher? _watcher;
|
||||
private TaskCompletionSource _hint = NewHint();
|
||||
private bool? _available;
|
||||
|
||||
public void Start() => _ = Task.Run(() => LoopAsync(_cts.Token));
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
_cts.Cancel();
|
||||
_watcher?.Dispose();
|
||||
_watcher = null;
|
||||
}
|
||||
|
||||
private async Task LoopAsync(CancellationToken ct)
|
||||
{
|
||||
while (!ct.IsCancellationRequested)
|
||||
{
|
||||
// Replaced before the scan so notifications arriving during it trigger the next one.
|
||||
Volatile.Write(ref _hint, NewHint());
|
||||
var available = Scan(ct);
|
||||
if (available != _available)
|
||||
{
|
||||
_available = available;
|
||||
if (available && !network) StartWatcher();
|
||||
owner.Raise(context, () => owner.AvailabilityChanged?.Invoke(root, available));
|
||||
}
|
||||
var wait = _tracker.PendingCount > 0 && QuickCheck < interval ? QuickCheck : interval;
|
||||
try
|
||||
{
|
||||
var hint = Volatile.Read(ref _hint).Task;
|
||||
if (await Task.WhenAny(Task.Delay(wait, ct), hint).ConfigureAwait(false) == hint)
|
||||
await Task.Delay(HintDebounce, ct).ConfigureAwait(false);
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>One complete listing; false when the folder cannot be reached.</summary>
|
||||
private bool Scan(CancellationToken ct)
|
||||
{
|
||||
if (!Directory.Exists(root)) return false;
|
||||
var present = new List<string>();
|
||||
var candidates = new Dictionary<string, FileInfo>(StringComparer.OrdinalIgnoreCase);
|
||||
try
|
||||
{
|
||||
foreach (var file in PhotoScanner.Files(root, ct))
|
||||
{
|
||||
present.Add(file.FullName);
|
||||
if (IsKnown(file)) continue;
|
||||
candidates[file.FullName] = file;
|
||||
}
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
||||
{
|
||||
// A partial listing must not prune the memory or report files.
|
||||
Log.Info("watch", $"{root} not readable: {ex.Message}");
|
||||
return false;
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
return _available ?? false;
|
||||
}
|
||||
|
||||
owner._memory.Prune(root, present);
|
||||
var stable = _tracker.Check(candidates.Values.Select(f => new FileObservation(f.FullName, f.Length, f.LastWriteTimeUtc)));
|
||||
if (stable.Count > 0)
|
||||
{
|
||||
var files = stable.Select(o => PhotoScanner.ToSource(candidates[o.Path], root)).ToList();
|
||||
Log.Info("watch", $"{files.Count} new file(s) in {root}");
|
||||
owner.Raise(context, () => owner.FilesReady?.Invoke(root, files));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>Already confirmed by the server, or already in the queue.</summary>
|
||||
private bool IsKnown(FileInfo file) =>
|
||||
owner._memory.Contains(root, file.FullName, file.Length, file.LastWriteTimeUtc) || owner._isQueued(file.FullName);
|
||||
|
||||
private void StartWatcher()
|
||||
{
|
||||
_watcher?.Dispose();
|
||||
try
|
||||
{
|
||||
_watcher = new FileSystemWatcher(root)
|
||||
{
|
||||
IncludeSubdirectories = true,
|
||||
NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.Size | NotifyFilters.LastWrite,
|
||||
};
|
||||
_watcher.Created += (_, _) => Hint();
|
||||
_watcher.Changed += (_, _) => Hint();
|
||||
_watcher.Renamed += (_, _) => Hint();
|
||||
// A lost buffer means unknown changes: scan.
|
||||
_watcher.Error += (_, _) => Hint();
|
||||
_watcher.EnableRaisingEvents = true;
|
||||
}
|
||||
catch (Exception ex) when (ex is ArgumentException or IOException or PlatformNotSupportedException)
|
||||
{
|
||||
Log.Info("watch", $"No change notifications for {root}; polling only: {ex.Message}");
|
||||
_watcher?.Dispose();
|
||||
_watcher = null;
|
||||
}
|
||||
}
|
||||
|
||||
private void Hint() => Volatile.Read(ref _hint).TrySetResult();
|
||||
|
||||
private static TaskCompletionSource NewHint() => new(TaskCreationOptions.RunContinuationsAsynchronously);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
using System.IO;
|
||||
using Titano.Testing;
|
||||
using Titano.Uploader.Infrastructure;
|
||||
|
||||
namespace Titano.App.Tests.Uploader;
|
||||
|
||||
public sealed class CoalescingWriterTests(TestContext context)
|
||||
{
|
||||
[Test]
|
||||
public void KeepsTheNewestContent()
|
||||
{
|
||||
var path = Path.Combine(context.CreateTempDirectory(), "uploader-queue.json");
|
||||
var writer = new CoalescingWriter();
|
||||
for (var i = 0; i < 50; i++) writer.Write(path, [(byte)i]);
|
||||
writer.Flush(TimeSpan.FromSeconds(10));
|
||||
Assert.SequenceEqual([(byte)49], File.ReadAllBytes(path));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
using Titano.Testing;
|
||||
using Titano.Uploader.Infrastructure;
|
||||
|
||||
namespace Titano.App.Tests.Uploader;
|
||||
|
||||
public sealed class CommandLineTests
|
||||
{
|
||||
[Test]
|
||||
public void PathsAndOptionsAreSeparated()
|
||||
{
|
||||
var c = CommandLine.Parse([@"E:\", "--tray", @"D:\Cam\IMG_0001.CR2"]);
|
||||
Assert.SequenceEqual([@"E:\", @"D:\Cam\IMG_0001.CR2"], c.Paths);
|
||||
Assert.True(c.StartInTray);
|
||||
Assert.Null(c.CaptureDirectory);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void CaptureTakesAnOptionalDirectory()
|
||||
{
|
||||
Assert.Equal("out/shots", CommandLine.Parse(["--capture", "out/shots"]).CaptureDirectory);
|
||||
Assert.Equal("screenshots", CommandLine.Parse(["--capture"]).CaptureDirectory);
|
||||
Assert.Equal("screenshots", CommandLine.Parse(["--capture", "--tray"]).CaptureDirectory);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void HandOverMessageRoundTrips()
|
||||
{
|
||||
string[] args = [@"E:\", @"\\garage-pi\cam\IMG 1.jpg"];
|
||||
Assert.SequenceEqual(args, SingleInstance.Decode(SingleInstance.Encode(args))!);
|
||||
Assert.Empty(SingleInstance.Decode(SingleInstance.Encode([]))!);
|
||||
Assert.Null(SingleInstance.Decode("hello\nE:\\"u8));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,83 @@
|
||||
using System.IO;
|
||||
using Titano.Testing;
|
||||
using Titano.Uploader.Sources;
|
||||
using Titano.Uploader.Watching;
|
||||
|
||||
namespace Titano.App.Tests.Uploader;
|
||||
|
||||
public sealed class ProcessedFileMemoryTests(TestContext context)
|
||||
{
|
||||
private static readonly DateTime Written = new(2026, 9, 28, 16, 2, 11, DateTimeKind.Utc);
|
||||
|
||||
[Test]
|
||||
public void RemembersPathSizeAndWriteTime()
|
||||
{
|
||||
var root = Path.Combine(Path.GetTempPath(), "roof");
|
||||
var photo = Path.Combine(root, "100CANON", "IMG_0413.CR2");
|
||||
var memory = new ProcessedFileMemory();
|
||||
Assert.False(memory.Contains(root, photo, 25_000_000, Written));
|
||||
|
||||
memory.Add(root, photo, 25_000_000, Written);
|
||||
Assert.True(memory.IsDirty);
|
||||
Assert.True(memory.Contains(root, photo, 25_000_000, Written));
|
||||
Assert.False(memory.Contains(root, photo, 25_000_001, Written), "a resized file is new");
|
||||
Assert.False(memory.Contains(root, photo, 25_000_000, Written.AddSeconds(1)), "a rewritten file is new");
|
||||
Assert.False(memory.Contains(Path.Combine(Path.GetTempPath(), "garden"), photo, 25_000_000, Written), "folders are separate");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void PruneForgetsFilesNoLongerInTheFolder()
|
||||
{
|
||||
var root = Path.Combine(Path.GetTempPath(), "roof");
|
||||
var kept = Path.Combine(root, "a.jpg");
|
||||
var gone = Path.Combine(root, "b.jpg");
|
||||
var memory = new ProcessedFileMemory();
|
||||
memory.Add(root, kept, 1, Written);
|
||||
memory.Add(root, gone, 2, Written);
|
||||
|
||||
memory.Prune(root, [kept]);
|
||||
Assert.True(memory.Contains(root, kept, 1, Written));
|
||||
Assert.False(memory.Contains(root, gone, 2, Written));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void RoundTripKeepsFilesAndTheLastSession()
|
||||
{
|
||||
var dir = context.CreateTempDirectory();
|
||||
var root = Path.Combine(dir, "cam");
|
||||
var photo = Path.Combine(root, "IMG_0001.JPG");
|
||||
var memory = new ProcessedFileMemory();
|
||||
memory.Add(root, photo, 4_200_000, Written);
|
||||
memory.SetSession(root, new SessionContinuation("1a2b3c4d-20260928-180000", new DateTime(2026, 9, 28, 18, 40, 0)));
|
||||
|
||||
var path = Path.Combine(dir, "uploader-watch.json");
|
||||
File.WriteAllBytes(path, memory.Serialize());
|
||||
Assert.False(memory.IsDirty);
|
||||
var restored = ProcessedFileMemory.Load(path);
|
||||
|
||||
Assert.True(restored.Contains(root, photo, 4_200_000, Written));
|
||||
Assert.Equal(new SessionContinuation("1a2b3c4d-20260928-180000", new DateTime(2026, 9, 28, 18, 40, 0)), restored.GetSession(root));
|
||||
Assert.False(restored.IsDirty);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void RemovedFolderIsForgotten()
|
||||
{
|
||||
var root = Path.Combine(Path.GetTempPath(), "roof");
|
||||
var memory = new ProcessedFileMemory();
|
||||
memory.Add(root, Path.Combine(root, "a.jpg"), 1, Written);
|
||||
memory.SetSession(root, new SessionContinuation("k", Written));
|
||||
memory.RemoveFolder(root);
|
||||
Assert.False(memory.Contains(root, Path.Combine(root, "a.jpg"), 1, Written));
|
||||
Assert.Null(memory.GetSession(root));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void CorruptFileGivesAnEmptyMemory()
|
||||
{
|
||||
var path = Path.Combine(context.CreateTempDirectory(), "uploader-watch.json");
|
||||
File.WriteAllText(path, "[1,2");
|
||||
var memory = ProcessedFileMemory.Load(path);
|
||||
Assert.False(memory.Contains("x", "x/a.jpg", 1, Written));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
using Titano.Testing;
|
||||
using Titano.Uploader.Server;
|
||||
|
||||
namespace Titano.App.Tests.Uploader;
|
||||
|
||||
public sealed class ServerAddressTests
|
||||
{
|
||||
[Theory]
|
||||
[Case("nas.local:8443", "https://nas.local:8443/")]
|
||||
[Case("https://nas.local:8443", "https://nas.local:8443/")]
|
||||
[Case(" http://192.168.1.20:8080/titano ", "http://192.168.1.20:8080/titano/")]
|
||||
[Case("https://nas.local/?x=1#y", "https://nas.local/")]
|
||||
public void ServerAddressesBecomeApiBases(string typed, string expected)
|
||||
{
|
||||
Assert.True(ServerAddress.TryParse(typed, out var uri));
|
||||
Assert.Equal(expected, uri.ToString());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[Case("")]
|
||||
[Case(" ")]
|
||||
[Case("ftp://nas.local")]
|
||||
[Case("https://")]
|
||||
public void InvalidServerAddressesAreRejected(string typed) => Assert.False(ServerAddress.TryParse(typed, out _));
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
using System.IO;
|
||||
using Titano.Testing;
|
||||
using Titano.Uploader.Sources;
|
||||
|
||||
namespace Titano.App.Tests.Uploader;
|
||||
|
||||
public sealed class SessionGrouperTests
|
||||
{
|
||||
private static readonly DateTime Evening = new(2026, 9, 28, 18, 0, 0);
|
||||
|
||||
[Test]
|
||||
public void SplitsWhereTheGapExceedsFortyFiveMinutes()
|
||||
{
|
||||
var times = Series(Evening, 10).Concat(Series(Evening.AddMinutes(9 + 46), 10)).ToList();
|
||||
var result = SessionGrouper.Assign(times, "abcd1234");
|
||||
Assert.Equal(2, result.Keys.Distinct().Count());
|
||||
Assert.Equal("abcd1234-20260928-180000", result.Keys[0]);
|
||||
Assert.Equal("abcd1234-20260928-185500", result.Keys[^1]);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GapOfExactlyFortyFiveMinutesStaysInOneSession()
|
||||
{
|
||||
var times = Series(Evening, 10).Concat(Series(Evening.AddMinutes(9 + 45), 10)).ToList();
|
||||
Assert.Equal(1, SessionGrouper.Assign(times, "t").Keys.Distinct().Count());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void TestShotsAfterASessionMergeIntoIt()
|
||||
{
|
||||
var times = Series(Evening, 20).Concat(Series(Evening.AddHours(3), 3)).ToList();
|
||||
var result = SessionGrouper.Assign(times, "t");
|
||||
Assert.Equal(1, result.Keys.Distinct().Count());
|
||||
Assert.Equal(Evening.AddHours(3).AddMinutes(2), result.Last!.LastCapture);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void LeadingTestShotsJoinTheFollowingSession()
|
||||
{
|
||||
var times = Series(Evening, 3).Concat(Series(Evening.AddHours(2), 30)).ToList();
|
||||
var result = SessionGrouper.Assign(times, "t");
|
||||
Assert.Equal(1, result.Keys.Distinct().Count());
|
||||
Assert.Equal("t-20260928-180000", result.Keys[0]);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void KeysFollowTheInputOrder()
|
||||
{
|
||||
var first = Series(Evening, 10);
|
||||
var second = Series(Evening.AddHours(5), 10);
|
||||
var shuffled = new List<DateTime> { second[3], first[7], second[0], first[0] };
|
||||
shuffled.AddRange(first.Skip(1).Take(6));
|
||||
shuffled.AddRange(second.Skip(4));
|
||||
var result = SessionGrouper.Assign(shuffled, "t");
|
||||
Assert.Equal("t-20260928-230000", result.Keys[0]);
|
||||
Assert.Equal("t-20260928-180000", result.Keys[1]);
|
||||
Assert.Equal(result.Keys[0], result.Keys[2]);
|
||||
Assert.Equal(result.Keys[1], result.Keys[3]);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void NewFramesWithinTheGapContinueThePreviousSession()
|
||||
{
|
||||
var previous = new SessionContinuation("t-20260928-180000", Evening.AddMinutes(30));
|
||||
var result = SessionGrouper.Assign(Series(Evening.AddMinutes(40), 2), "t", previous);
|
||||
Assert.SequenceEqual(["t-20260928-180000", "t-20260928-180000"], result.Keys);
|
||||
Assert.Equal(Evening.AddMinutes(41), result.Last!.LastCapture);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void NewFramesAfterTheGapStartANewSession()
|
||||
{
|
||||
var previous = new SessionContinuation("t-20260928-180000", Evening.AddMinutes(30));
|
||||
var result = SessionGrouper.Assign(Series(Evening.AddHours(2), 10), "t", previous);
|
||||
Assert.Equal("t-20260928-200000", result.Keys[0]);
|
||||
Assert.Equal("t-20260928-200000", result.Last!.Key);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void EmptyInputKeepsThePreviousSession()
|
||||
{
|
||||
var previous = new SessionContinuation("k", Evening);
|
||||
var result = SessionGrouper.Assign([], "t", previous);
|
||||
Assert.Empty(result.Keys);
|
||||
Assert.Same(previous, result.Last);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SourceTagIsStableShortAndPerFolder()
|
||||
{
|
||||
var a = SessionGrouper.SourceTag(Path.Combine(Path.GetTempPath(), "cam", "roof"));
|
||||
Assert.Equal(8, a.Length);
|
||||
Assert.True(a.All(Uri.IsHexDigit));
|
||||
Assert.Equal(a, SessionGrouper.SourceTag(Path.Combine(Path.GetTempPath(), "cam", "roof") + Path.DirectorySeparatorChar));
|
||||
Assert.NotEqual(a, SessionGrouper.SourceTag(Path.Combine(Path.GetTempPath(), "cam", "garden")));
|
||||
}
|
||||
|
||||
private static List<DateTime> Series(DateTime start, int count) => [.. Enumerable.Range(0, count).Select(i => start.AddMinutes(i))];
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
using System.Collections.Concurrent;
|
||||
|
||||
namespace Titano.App.Tests.Uploader;
|
||||
|
||||
/// <summary>Runs async test code on one thread, as the UI dispatcher does for the upload engine.</summary>
|
||||
internal sealed class SingleThreadedContext : SynchronizationContext
|
||||
{
|
||||
private readonly BlockingCollection<(SendOrPostCallback Callback, object? State)> _queue = [];
|
||||
|
||||
public override void Post(SendOrPostCallback d, object? state)
|
||||
{
|
||||
try
|
||||
{
|
||||
_queue.Add((d, state));
|
||||
}
|
||||
catch (InvalidOperationException)
|
||||
{
|
||||
// Late progress reports after the test body finished are dropped.
|
||||
}
|
||||
}
|
||||
|
||||
public override void Send(SendOrPostCallback d, object? state) => throw new NotSupportedException();
|
||||
|
||||
public static void Run(Func<Task> body)
|
||||
{
|
||||
var previous = Current;
|
||||
var context = new SingleThreadedContext();
|
||||
SetSynchronizationContext(context);
|
||||
try
|
||||
{
|
||||
var task = body();
|
||||
task.ContinueWith(_ => context._queue.CompleteAdding(), TaskScheduler.Default);
|
||||
foreach (var (callback, state) in context._queue.GetConsumingEnumerable()) callback(state);
|
||||
task.GetAwaiter().GetResult();
|
||||
}
|
||||
finally
|
||||
{
|
||||
SetSynchronizationContext(previous);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
using Titano.Testing;
|
||||
using Titano.Uploader.Watching;
|
||||
|
||||
namespace Titano.App.Tests.Uploader;
|
||||
|
||||
public sealed class StableFileTrackerTests
|
||||
{
|
||||
private static readonly DateTime T0 = new(2026, 9, 28, 16, 0, 0, DateTimeKind.Utc);
|
||||
|
||||
[Test]
|
||||
public void FileIsStableAfterTwoIdenticalChecks()
|
||||
{
|
||||
var tracker = new StableFileTracker();
|
||||
var photo = new FileObservation("a.cr2", 25_000_000, T0);
|
||||
Assert.Empty(tracker.Check([photo]));
|
||||
Assert.Equal(1, tracker.PendingCount);
|
||||
Assert.SequenceEqual([photo], tracker.Check([photo]));
|
||||
Assert.Equal(0, tracker.PendingCount);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GrowingFileWaitsUntilItStopsGrowing()
|
||||
{
|
||||
var tracker = new StableFileTracker();
|
||||
Assert.Empty(tracker.Check([new("a.cr2", 1_000, T0)]));
|
||||
Assert.Empty(tracker.Check([new("a.cr2", 9_000, T0.AddSeconds(1))]));
|
||||
Assert.Empty(tracker.Check([new("a.cr2", 25_000, T0.AddSeconds(2))]));
|
||||
Assert.Count(1, tracker.Check([new("a.cr2", 25_000, T0.AddSeconds(2))]));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void TouchedFileWithSameSizeRestartsTheCount()
|
||||
{
|
||||
var tracker = new StableFileTracker();
|
||||
Assert.Empty(tracker.Check([new("a.jpg", 500, T0)]));
|
||||
Assert.Empty(tracker.Check([new("a.jpg", 500, T0.AddSeconds(5))]));
|
||||
Assert.Count(1, tracker.Check([new("a.jpg", 500, T0.AddSeconds(5))]));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void FileMissingFromAScanIsForgotten()
|
||||
{
|
||||
var tracker = new StableFileTracker();
|
||||
var photo = new FileObservation("a.jpg", 500, T0);
|
||||
Assert.Empty(tracker.Check([photo]));
|
||||
Assert.Empty(tracker.Check([]));
|
||||
Assert.Empty(tracker.Check([photo]));
|
||||
Assert.Count(1, tracker.Check([photo]));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void FilesProgressIndependently()
|
||||
{
|
||||
var tracker = new StableFileTracker();
|
||||
var done = new FileObservation("done.jpg", 500, T0);
|
||||
Assert.Empty(tracker.Check([done, new("growing.jpg", 10, T0)]));
|
||||
var stable = tracker.Check([done, new("growing.jpg", 20, T0.AddSeconds(1))]);
|
||||
Assert.SequenceEqual([done], stable);
|
||||
Assert.Equal(1, tracker.PendingCount);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SingleObservationsUseTheSameRule()
|
||||
{
|
||||
var tracker = new StableFileTracker();
|
||||
var photo = new FileObservation("a.nef", 42, T0);
|
||||
Assert.False(tracker.Observe(photo));
|
||||
Assert.True(tracker.Observe(photo));
|
||||
Assert.False(tracker.Observe(photo));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
using Titano.Testing;
|
||||
using Titano.Uploader.Infrastructure;
|
||||
|
||||
namespace Titano.App.Tests.Uploader;
|
||||
|
||||
public sealed class TokenProtectorTests
|
||||
{
|
||||
[Test]
|
||||
[WindowsOnly]
|
||||
public void TokenRoundTripsThroughDpapiWithoutPlainText()
|
||||
{
|
||||
const string token = "ttn_4f9a1c2e7b";
|
||||
var blob = TokenProtector.Protect(token);
|
||||
Assert.False(blob.Contains(token, StringComparison.Ordinal));
|
||||
Assert.Equal(token, TokenProtector.Unprotect(blob));
|
||||
}
|
||||
|
||||
[Test]
|
||||
[WindowsOnly]
|
||||
public void DamagedBlobsGiveNoToken()
|
||||
{
|
||||
var blob = Convert.FromBase64String(TokenProtector.Protect("secret"));
|
||||
blob[^1] ^= 0xFF;
|
||||
Assert.Null(TokenProtector.Unprotect(Convert.ToBase64String(blob)));
|
||||
Assert.Null(TokenProtector.Unprotect("not base64!"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,224 @@
|
||||
using System.Diagnostics;
|
||||
using System.IO;
|
||||
using System.Net;
|
||||
using System.Security.Cryptography;
|
||||
using Titano.Protocol;
|
||||
using Titano.Protocol.Client;
|
||||
using Titano.Testing;
|
||||
using Titano.Uploader.Uploads;
|
||||
|
||||
namespace Titano.App.Tests.Uploader;
|
||||
|
||||
public sealed class UploadEngineTests(TestContext context)
|
||||
{
|
||||
private readonly ManualTime _time = new();
|
||||
|
||||
[Test]
|
||||
public void VerifiedUploadsKeepTheSourceByDefault() => SingleThreadedContext.Run(async () =>
|
||||
{
|
||||
var queue = Queue(UploadTargetMode.Sessions, 2);
|
||||
var transport = new FakeTransport();
|
||||
using var engine = new UploadEngine(queue, transport, () => false, _time);
|
||||
var confirmed = new List<UploadItem>();
|
||||
engine.ItemConfirmed += (_, item) => confirmed.Add(item);
|
||||
|
||||
engine.Pump();
|
||||
await Until(() => queue.Items.All(i => i.IsDone));
|
||||
|
||||
Assert.True(queue.Items.All(i => i.State == UploadItemState.Verified && i.FrameId is not null));
|
||||
Assert.True(queue.Items.All(i => File.Exists(i.Path)));
|
||||
// Two workers hash in parallel, so calls arrive in either order.
|
||||
foreach (var item in queue.Items) Assert.Equal(Sha256(item.Path), transport.Calls.Single(c => c.Path == item.Path).Sha256);
|
||||
Assert.Equal(2, confirmed.Count);
|
||||
});
|
||||
|
||||
[Test]
|
||||
public void DeleteAfterUploadRemovesOnlyConfirmedUnchangedFiles() => SingleThreadedContext.Run(async () =>
|
||||
{
|
||||
var queue = Queue(UploadTargetMode.Sessions, 3);
|
||||
var (verified, existing, changed) = (queue.Items[0], queue.Items[1], queue.Items[2]);
|
||||
var transport = new FakeTransport
|
||||
{
|
||||
Respond = item =>
|
||||
{
|
||||
if (item == existing) return (UploadOutcome.AlreadyOnServer, null);
|
||||
// Written to after it was hashed: the bytes on disk are no longer the verified ones.
|
||||
if (item == changed) File.AppendAllText(item.Path, "more");
|
||||
return (UploadOutcome.Verified, Guid.CreateVersion7());
|
||||
},
|
||||
};
|
||||
using var engine = new UploadEngine(queue, transport, () => true, _time);
|
||||
|
||||
engine.Pump();
|
||||
await Until(() => queue.Items.All(i => i.IsDone));
|
||||
|
||||
Assert.Equal(UploadItemState.Skipped, existing.State);
|
||||
Assert.False(File.Exists(verified.Path));
|
||||
Assert.False(File.Exists(existing.Path));
|
||||
Assert.True(File.Exists(changed.Path), "a file changed after verification is kept");
|
||||
});
|
||||
|
||||
[Test]
|
||||
public void RejectedFileIsRetriedAfterThirtySeconds() => SingleThreadedContext.Run(async () =>
|
||||
{
|
||||
var queue = Queue(UploadTargetMode.Sessions, 1);
|
||||
var item = queue.Items[0];
|
||||
var attempts = 0;
|
||||
var transport = new FakeTransport
|
||||
{
|
||||
Respond = _ => ++attempts == 1
|
||||
? throw new TitanoApiException(HttpStatusCode.UnprocessableEntity, new ApiError("hash_mismatch", "Hash mismatch"))
|
||||
: (UploadOutcome.Verified, Guid.CreateVersion7()),
|
||||
};
|
||||
using var engine = new UploadEngine(queue, transport, () => false, _time);
|
||||
|
||||
engine.Pump();
|
||||
await Until(() => item.State == UploadItemState.Failed);
|
||||
Assert.Equal(UploadFailure.ServerRejected, item.Failure);
|
||||
Assert.Equal("Hash mismatch", item.FailureDetail);
|
||||
Assert.Equal(_time.UtcNow + UploadQueue.RetryDelay, item.NextRetryUtc);
|
||||
|
||||
_time.Advance(TimeSpan.FromSeconds(29));
|
||||
engine.Pump();
|
||||
Assert.Equal(UploadItemState.Failed, item.State);
|
||||
|
||||
_time.Advance(TimeSpan.FromSeconds(1));
|
||||
engine.Pump();
|
||||
await Until(() => item.IsDone);
|
||||
Assert.Equal(1, item.Retries);
|
||||
Assert.Equal(UploadFailure.None, item.Failure);
|
||||
});
|
||||
|
||||
[Test]
|
||||
public void UnreachableServerRequeuesWithoutSpendingARetry() => SingleThreadedContext.Run(async () =>
|
||||
{
|
||||
var queue = Queue(UploadTargetMode.Sessions, 1);
|
||||
var item = queue.Items[0];
|
||||
var transport = new FakeTransport();
|
||||
transport.Respond = _ =>
|
||||
{
|
||||
transport.SetReady(false);
|
||||
throw new ServerUnavailableException(ServerProblem.Unreachable);
|
||||
};
|
||||
using var engine = new UploadEngine(queue, transport, () => false, _time);
|
||||
|
||||
engine.Pump();
|
||||
await Until(() => item.State == UploadItemState.Queued && transport.Calls.Count == 1);
|
||||
Assert.Equal(0, item.Retries);
|
||||
Assert.NotNull(item.Sha256);
|
||||
Assert.Equal(EngineStatus.WaitingForServer, engine.Status);
|
||||
|
||||
transport.Respond = _ => (UploadOutcome.Verified, Guid.CreateVersion7());
|
||||
transport.SetReady(true);
|
||||
await Until(() => item.IsDone);
|
||||
});
|
||||
|
||||
[Test]
|
||||
public void NewSequenceIsCreatedOnceForTheBatch() => SingleThreadedContext.Run(async () =>
|
||||
{
|
||||
var queue = Queue(UploadTargetMode.NewSequence, 3);
|
||||
var transport = new FakeTransport();
|
||||
using var engine = new UploadEngine(queue, transport, () => false, _time);
|
||||
|
||||
engine.Pump();
|
||||
await Until(() => queue.Items.All(i => i.IsDone));
|
||||
|
||||
Assert.Equal(1, transport.SequencesCreated);
|
||||
Assert.True(transport.Calls.All(c => c.SequenceId == FakeTransport.CreatedSequence));
|
||||
Assert.Equal(FakeTransport.CreatedSequence, queue.Batches.Single().SequenceId);
|
||||
});
|
||||
|
||||
[Test]
|
||||
public void AtMostTwoFilesAreInFlightAndPauseRequeuesThem() => SingleThreadedContext.Run(async () =>
|
||||
{
|
||||
var queue = Queue(UploadTargetMode.Sessions, 4);
|
||||
var transport = new FakeTransport { Block = true };
|
||||
using var engine = new UploadEngine(queue, transport, () => false, _time);
|
||||
|
||||
engine.Pump();
|
||||
await Until(() => queue.Items.Count(i => i.State == UploadItemState.Uploading) == UploadEngine.Parallelism);
|
||||
Assert.Equal(UploadEngine.Parallelism, queue.Items.Count(i => i.IsActive));
|
||||
|
||||
engine.Pause();
|
||||
await Until(() => queue.Items.All(i => i.State == UploadItemState.Queued));
|
||||
Assert.Equal(EngineStatus.Paused, engine.Status);
|
||||
|
||||
transport.Block = false;
|
||||
engine.Resume();
|
||||
await Until(() => queue.Items.All(i => i.IsDone));
|
||||
Assert.False(queue.IsPaused);
|
||||
});
|
||||
|
||||
private UploadQueue Queue(UploadTargetMode mode, int count)
|
||||
{
|
||||
var dir = context.CreateTempDirectory();
|
||||
var queue = new UploadQueue();
|
||||
var entries = Enumerable.Range(0, count).Select(i =>
|
||||
{
|
||||
var path = Path.Combine(dir, $"IMG_{i:0000}.JPG");
|
||||
File.WriteAllBytes(path, RandomNumberGenerator.GetBytes(4096 + i));
|
||||
var info = new FileInfo(path);
|
||||
return new QueueEntry(path, info.Length, info.LastWriteTimeUtc, info.LastWriteTime, "k", null);
|
||||
}).ToList();
|
||||
queue.Add(new UploadBatch { Id = Guid.CreateVersion7(), Mode = mode, Title = mode == UploadTargetMode.NewSequence ? "Roof" : null }, entries);
|
||||
return queue;
|
||||
}
|
||||
|
||||
private static string Sha256(string path) => Convert.ToHexStringLower(SHA256.HashData(File.ReadAllBytes(path)));
|
||||
|
||||
private static async Task Until(Func<bool> condition)
|
||||
{
|
||||
var clock = Stopwatch.StartNew();
|
||||
while (!condition())
|
||||
{
|
||||
if (clock.Elapsed > TimeSpan.FromSeconds(15)) throw new TimeoutException("Condition not reached");
|
||||
await Task.Delay(5);
|
||||
}
|
||||
}
|
||||
|
||||
private sealed class ManualTime : TimeProvider
|
||||
{
|
||||
private DateTimeOffset _now = new(2026, 9, 28, 18, 0, 0, TimeSpan.Zero);
|
||||
|
||||
public DateTime UtcNow => _now.UtcDateTime;
|
||||
|
||||
public void Advance(TimeSpan by) => _now += by;
|
||||
|
||||
public override DateTimeOffset GetUtcNow() => _now;
|
||||
}
|
||||
|
||||
private sealed class FakeTransport : IUploadTransport
|
||||
{
|
||||
public static readonly Guid CreatedSequence = Guid.CreateVersion7();
|
||||
|
||||
public event EventHandler? ReadyChanged;
|
||||
|
||||
public bool IsReady { get; private set; } = true;
|
||||
public bool Block { get; set; }
|
||||
public int SequencesCreated { get; private set; }
|
||||
public List<(string Path, Guid? SequenceId, string Sha256)> Calls { get; } = [];
|
||||
public Func<UploadItem, (UploadOutcome, Guid?)> Respond { get; set; } = _ => (UploadOutcome.Verified, Guid.CreateVersion7());
|
||||
|
||||
public void SetReady(bool ready)
|
||||
{
|
||||
IsReady = ready;
|
||||
ReadyChanged?.Invoke(this, EventArgs.Empty);
|
||||
}
|
||||
|
||||
public async Task<(UploadOutcome Outcome, Guid? FrameId)> UploadAsync(UploadItem item, Guid? sequenceId, string sha256, IProgress<UploadProgress> progress, CancellationToken ct)
|
||||
{
|
||||
Calls.Add((item.Path, sequenceId, sha256));
|
||||
progress.Report(new UploadProgress(0, item.Size));
|
||||
while (Block) await Task.Delay(5, ct);
|
||||
await Task.Yield();
|
||||
progress.Report(new UploadProgress(item.Size, item.Size));
|
||||
return Respond(item);
|
||||
}
|
||||
|
||||
public Task<Guid> CreateSequenceAsync(string? title, CancellationToken ct)
|
||||
{
|
||||
SequencesCreated++;
|
||||
return Task.FromResult(CreatedSequence);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,143 @@
|
||||
using System.IO;
|
||||
using Titano.Testing;
|
||||
using Titano.Uploader.Uploads;
|
||||
|
||||
namespace Titano.App.Tests.Uploader;
|
||||
|
||||
public sealed class UploadQueueTests(TestContext context)
|
||||
{
|
||||
private static readonly DateTime Now = new(2026, 9, 28, 18, 30, 0, DateTimeKind.Utc);
|
||||
|
||||
[Test]
|
||||
public void PersistenceRoundTripKeepsBatchesItemsAndStates()
|
||||
{
|
||||
var queue = new UploadQueue();
|
||||
var sessions = new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions };
|
||||
var created = new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.NewSequence, Title = "Harbour sunset", SequenceId = Guid.CreateVersion7() };
|
||||
queue.Add(sessions, [Entry("a.cr2", "k1", @"D:\Cam\Roof"), Entry("b.cr2", "k1", null)]);
|
||||
queue.Add(created, [Entry("c.jpg", null, null)]);
|
||||
var verified = queue.Items[0];
|
||||
verified.State = UploadItemState.Verified;
|
||||
verified.Sha256 = new string('a', 64);
|
||||
verified.FrameId = Guid.CreateVersion7();
|
||||
var failed = queue.Items[1];
|
||||
failed.Retries = 2;
|
||||
queue.Fail(failed, UploadFailure.ServerRejected, "quota exceeded", Now);
|
||||
queue.IsPaused = true;
|
||||
|
||||
var path = Path.Combine(context.CreateTempDirectory(), "uploader-queue.json");
|
||||
File.WriteAllBytes(path, QueueStore.Serialize(queue));
|
||||
var restored = new UploadQueue();
|
||||
QueueStore.Load(path, restored);
|
||||
|
||||
Assert.True(restored.IsPaused);
|
||||
Assert.Equal(2, restored.Batches.Count);
|
||||
Assert.Equal("Harbour sunset", restored.GetBatch(created.Id)!.Title);
|
||||
Assert.Equal(created.SequenceId, restored.GetBatch(created.Id)!.SequenceId);
|
||||
Assert.Equal(3, restored.Items.Count);
|
||||
for (var i = 0; i < 3; i++)
|
||||
{
|
||||
var (a, b) = (queue.Items[i], restored.Items[i]);
|
||||
Assert.Equal(a.Id, b.Id);
|
||||
Assert.Equal(a.BatchId, b.BatchId);
|
||||
Assert.Equal(a.Path, b.Path);
|
||||
Assert.Equal(a.Size, b.Size);
|
||||
Assert.Equal(a.ModifiedUtc, b.ModifiedUtc);
|
||||
Assert.Equal(a.CapturedAt, b.CapturedAt);
|
||||
Assert.Equal(a.SessionKey, b.SessionKey);
|
||||
Assert.Equal(a.WatchRoot, b.WatchRoot);
|
||||
Assert.Equal(a.State, b.State);
|
||||
}
|
||||
Assert.Equal(verified.Sha256, restored.Items[0].Sha256);
|
||||
Assert.Equal(verified.FrameId, restored.Items[0].FrameId);
|
||||
Assert.Equal(UploadFailure.ServerRejected, restored.Items[1].Failure);
|
||||
Assert.Equal("quota exceeded", restored.Items[1].FailureDetail);
|
||||
Assert.Equal(2, restored.Items[1].Retries);
|
||||
Assert.Equal(Now + UploadQueue.RetryDelay, restored.Items[1].NextRetryUtc);
|
||||
Assert.True(restored.ContainsPath("c.jpg"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void InterruptedTransfersResumeAsQueued()
|
||||
{
|
||||
var queue = new UploadQueue();
|
||||
queue.Add(new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions }, [Entry("a.cr2", null, null), Entry("b.cr2", null, null)]);
|
||||
queue.Items[0].State = UploadItemState.Uploading;
|
||||
queue.Items[0].Sha256 = new string('b', 64);
|
||||
queue.Items[1].State = UploadItemState.Hashing;
|
||||
|
||||
var path = Path.Combine(context.CreateTempDirectory(), "q.json");
|
||||
File.WriteAllBytes(path, QueueStore.Serialize(queue));
|
||||
var restored = new UploadQueue();
|
||||
QueueStore.Load(path, restored);
|
||||
|
||||
Assert.Equal(UploadItemState.Queued, restored.Items[0].State);
|
||||
Assert.Equal(UploadItemState.Queued, restored.Items[1].State);
|
||||
// The known hash is kept: the server resumes from the chunks it already holds.
|
||||
Assert.Equal(new string('b', 64), restored.Items[0].Sha256);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void CorruptOrMissingFileGivesAnEmptyQueue()
|
||||
{
|
||||
var dir = context.CreateTempDirectory();
|
||||
var corrupt = Path.Combine(dir, "q.json");
|
||||
File.WriteAllText(corrupt, "{ not json");
|
||||
var queue = new UploadQueue();
|
||||
QueueStore.Load(corrupt, queue);
|
||||
QueueStore.Load(Path.Combine(dir, "missing.json"), queue);
|
||||
Assert.Empty(queue.Items);
|
||||
Assert.False(queue.IsPaused);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void AddingSkipsPathsAlreadyQueued()
|
||||
{
|
||||
var queue = new UploadQueue();
|
||||
var batch = new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions };
|
||||
Assert.Equal(2, queue.Add(batch, [Entry("a.jpg", null, null), Entry("b.jpg", null, null)]));
|
||||
Assert.Equal(1, queue.Add(batch, [Entry("b.jpg", null, null), Entry("c.jpg", null, null)]));
|
||||
Assert.Equal(3, queue.Items.Count);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void FailedItemsComeBackAfterTheDelayUntilRetriesRunOut()
|
||||
{
|
||||
var queue = new UploadQueue();
|
||||
queue.Add(new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions }, [Entry("a.jpg", null, null)]);
|
||||
var item = queue.Items[0];
|
||||
item.State = UploadItemState.Hashing;
|
||||
queue.Fail(item, UploadFailure.FileUnreadable, null, Now);
|
||||
Assert.Null(queue.NextReady(Now.AddSeconds(29)));
|
||||
Assert.Same(item, queue.NextReady(Now + UploadQueue.RetryDelay));
|
||||
Assert.True(queue.HasPending);
|
||||
|
||||
item.Retries = UploadQueue.MaxRetries;
|
||||
queue.Fail(item, UploadFailure.FileUnreadable, null, Now);
|
||||
Assert.Null(item.NextRetryUtc);
|
||||
Assert.Null(queue.NextReady(Now.AddDays(1)));
|
||||
Assert.False(queue.HasPending);
|
||||
|
||||
queue.Requeue(item);
|
||||
Assert.Equal(0, item.Retries);
|
||||
Assert.Same(item, queue.NextReady(Now));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void RemovingCompletedItemsKeepsTheRest()
|
||||
{
|
||||
var queue = new UploadQueue();
|
||||
var batch = new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions };
|
||||
queue.Add(batch, [Entry("a.jpg", null, null), Entry("b.jpg", null, null), Entry("c.jpg", null, null)]);
|
||||
queue.Items[0].State = UploadItemState.Verified;
|
||||
queue.Items[2].State = UploadItemState.Skipped;
|
||||
queue.RemoveCompleted();
|
||||
Assert.Equal(1, queue.Items.Count);
|
||||
Assert.False(queue.ContainsPath("a.jpg"));
|
||||
Assert.True(queue.ContainsPath("b.jpg"));
|
||||
Assert.Equal(1, queue.Batches.Count);
|
||||
}
|
||||
|
||||
private static QueueEntry Entry(string name, string? session, string? watchRoot) =>
|
||||
new(name, 1_000 + name.Length, new DateTime(2026, 9, 28, 16, 2, 11, DateTimeKind.Utc), new DateTime(2026, 9, 28, 18, 2, 11), session, watchRoot);
|
||||
}
|
||||
@@ -0,0 +1,124 @@
|
||||
using System.Globalization;
|
||||
using Titano.Testing;
|
||||
using Titano.Uploader.Text;
|
||||
using Titano.Uploader.Uploads;
|
||||
|
||||
namespace Titano.App.Tests.Uploader;
|
||||
|
||||
public sealed class UploaderTextTests
|
||||
{
|
||||
private static readonly CultureInfo En = CultureInfo.GetCultureInfo("en");
|
||||
private static readonly CultureInfo It = CultureInfo.GetCultureInfo("it");
|
||||
|
||||
private static readonly QueueSummary Mockup = new(4_812, 96_200_000_000, 2_214, 2_201, 0, 0, 44_000_000_000, "2026-09-28_18-02-11_0413.CR2")
|
||||
{
|
||||
RemainingBytes = 93_480_000_000,
|
||||
};
|
||||
|
||||
[Test]
|
||||
public void QueueLineMatchesTheMockup()
|
||||
{
|
||||
var left = RateMeter.TimeLeft(Mockup.RemainingBytes, 38_000_000);
|
||||
Assert.Equal("4,812 files · 96.2 GB · 38 MB/s · 41 min left", UploaderText.QueueLine(Mockup, QueueActivity.Running, 38_000_000, left, En));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void QueueLineFollowsTheCulture()
|
||||
{
|
||||
Assert.Equal("4.812 file · 96,2 GB · 38 MB/s · mancano 41 min", UploaderText.QueueLine(Mockup, QueueActivity.Running, 38_000_000, TimeSpan.FromMinutes(41), It));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void QueueLineNamesTheActivityWhenNotRunning()
|
||||
{
|
||||
Assert.Equal("4,812 files · 96.2 GB · Paused", UploaderText.QueueLine(Mockup, QueueActivity.Paused, 0, null, En));
|
||||
Assert.Equal("4,812 files · 96.2 GB · Waiting for server", UploaderText.QueueLine(Mockup, QueueActivity.WaitingForServer, 0, null, En));
|
||||
Assert.Equal("1 file · 25 MB · Done", UploaderText.QueueLine(Mockup with { Files = 1, Bytes = 25_000_000 }, QueueActivity.Done, 0, null, En));
|
||||
Assert.Equal("Nothing queued", UploaderText.QueueLine(default, QueueActivity.Idle, 0, null, En));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void RunningLineOmitsRateAndTimeUntilKnown()
|
||||
{
|
||||
Assert.Equal("4,812 files · 96.2 GB", UploaderText.QueueLine(Mockup, QueueActivity.Running, 0, null, En));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ProgressLineMatchesTheMockup()
|
||||
{
|
||||
Assert.Equal("2,214 of 4,812 sent · 2,201 verified by the server · 0 retries", UploaderText.ProgressLine(Mockup, En));
|
||||
Assert.Equal("2,214 of 4,812 sent · 2,201 verified by the server · 1 retry · 3 failed", UploaderText.ProgressLine(Mockup with { Retries = 1, Failed = 3 }, En));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[Case(0.0, "0 B/s")]
|
||||
[Case(950_000.0, "950 KB/s")]
|
||||
[Case(4_240_000.0, "4.2 MB/s")]
|
||||
[Case(38_400_000.0, "38 MB/s")]
|
||||
[Case(1_260_000_000.0, "1.3 GB/s")]
|
||||
public void RatesUseDecimalUnits(double bytesPerSecond, string expected) =>
|
||||
Assert.Equal(expected, UploaderText.Rate(bytesPerSecond, En));
|
||||
|
||||
[Theory]
|
||||
[Case(40.0, "40 s")]
|
||||
[Case(299.0, "5 min")]
|
||||
[Case(3_590.0, "1 h 00 m")]
|
||||
[Case(7_500.0, "2 h 05 m")]
|
||||
[Case(93_600.0, "1 d 2 h")]
|
||||
public void DurationsAreCompact(double seconds, string expected) =>
|
||||
Assert.Equal(expected, UploaderText.Duration(TimeSpan.FromSeconds(seconds), En));
|
||||
|
||||
[Theory]
|
||||
[Case(999L, "999 B")]
|
||||
[Case(1_536L, "1.5 KB")]
|
||||
[Case(96_200_000_000L, "96.2 GB")]
|
||||
[Case(1_900_000_000_000L, "1.9 TB")]
|
||||
public void SizesUseDecimalUnits(long bytes, string expected) => Assert.Equal(expected, UploaderText.Bytes(bytes, En));
|
||||
|
||||
[Test]
|
||||
public void TimeLeftNeedsAUsableRate()
|
||||
{
|
||||
Assert.Equal(TimeSpan.FromMinutes(41), RateMeter.TimeLeft(93_480_000_000, 38_000_000));
|
||||
Assert.Equal(TimeSpan.Zero, RateMeter.TimeLeft(0, 0));
|
||||
Assert.Null(RateMeter.TimeLeft(1_000, 10));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void RateMeterAveragesTheWindowAndDecaysWhenStalled()
|
||||
{
|
||||
var meter = new RateMeter(TimeSpan.FromSeconds(10));
|
||||
Assert.Equal(0.0, meter.BytesPerSecond(TimeSpan.Zero));
|
||||
for (var s = 0; s <= 20; s++) meter.Add(4_000_000, TimeSpan.FromSeconds(s));
|
||||
Assert.Approximately(4_000_000, meter.BytesPerSecond(TimeSpan.FromSeconds(20)), 1);
|
||||
// Nothing sent for 20 s: the window holds no transfer any more.
|
||||
Assert.Equal(0.0, meter.BytesPerSecond(TimeSpan.FromSeconds(40)));
|
||||
meter.Reset();
|
||||
Assert.Equal(0.0, meter.BytesPerSecond(TimeSpan.FromSeconds(40)));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SummaryCountsStatesAndBytes()
|
||||
{
|
||||
var queue = new UploadQueue();
|
||||
queue.Add(new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions },
|
||||
Enumerable.Range(0, 5).Select(i => new QueueEntry($"{i}.jpg", 100, DateTime.UtcNow, null, null, null)));
|
||||
queue.Items[0].State = UploadItemState.Verified;
|
||||
queue.Items[1].State = UploadItemState.Skipped;
|
||||
queue.Items[2].State = UploadItemState.Uploading;
|
||||
queue.Items[2].BytesSent = 40;
|
||||
queue.Items[3].State = UploadItemState.Failed;
|
||||
queue.Items[3].Retries = 1;
|
||||
|
||||
var s = QueueSummary.From(queue.Items);
|
||||
Assert.Equal(5, s.Files);
|
||||
Assert.Equal(500L, s.Bytes);
|
||||
Assert.Equal(2, s.Sent);
|
||||
Assert.Equal(2, s.Verified);
|
||||
Assert.Equal(1, s.Failed);
|
||||
Assert.Equal(1, s.Retries);
|
||||
Assert.Equal(240L, s.DoneBytes);
|
||||
Assert.Equal(160L, s.RemainingBytes);
|
||||
Assert.Equal("2.jpg", s.CurrentFile);
|
||||
Assert.Approximately(0.48, s.Progress, 1e-9);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user