diff --git a/src/Titano.App/Sections/SettingsViewModel.cs b/src/Titano.App/Sections/SettingsViewModel.cs
index 36b24d14..cb43a7fc 100644
--- a/src/Titano.App/Sections/SettingsViewModel.cs
+++ b/src/Titano.App/Sections/SettingsViewModel.cs
@@ -319,6 +319,9 @@ public sealed class SettingsViewModel : SectionViewModel
/// The latest archive folder change: done once the rows show what the folder holds (tests wait for it).
internal Task ArchiveRetarget => _retarget;
+ /// The read of the open archive's settings when Settings was last shown: done once the rows show them (tests wait for it).
+ internal Task ArchiveReload { get; private set; } = Task.CompletedTask;
+
/// A portable copy leaves nothing in the registry (BRIEF §6.2): it offers no Startup row.
public bool ShowsStartup => !Shell.Services.Environment.IsPortable;
@@ -901,7 +904,7 @@ public sealed class SettingsViewModel : SectionViewModel
if (!DefaultServer.IsDirty) DefaultServer.Load(ServerAddress.Display(_s.ServerUrl));
OnPropertyChanged(nameof(StartWithWindows));
UpdateArchiveFree();
- _ = LoadArchiveAsync();
+ ArchiveReload = LoadArchiveAsync();
if (_page == SettingsPage.Advanced) LoadBackups();
}
@@ -940,9 +943,9 @@ public sealed class SettingsViewModel : SectionViewModel
new ProxyPolicy { LongEdge = archive.ProxyLongEdge }, new ThumbnailPolicy { LongEdge = _s.ThumbnailLongEdge });
if (!IsArchiveFolder(root)) return archive;
// A read that overlapped an edit being written may have missed it: it is not shown, and the rows are read
- // again now, or once the last edit being written ends (ArchiveReadGate).
- if (_archiveReads.IsCurrent(read, out var readAgain)) break;
- if (!readAgain) return archive;
+ // again once no edit is being written (ArchiveReadGate), so this is done only when they show the archive.
+ if (_archiveReads.IsCurrent(read)) break;
+ await _archiveReads.WrittenAsync();
}
if (!FolderTemplate.IsDirty) FolderTemplate.Load(settings.Templates.Folder);
if (!FileTemplate.IsDirty) FileTemplate.Load(settings.Templates.File);
@@ -1016,9 +1019,10 @@ public sealed class SettingsViewModel : SectionViewModel
}
finally
{
- // A read of the archive's settings this write overlapped was dropped: the rows are read again.
- if (_archiveReads.EndWrite()) reload = true;
+ // A read of the archive's settings this write overlapped was not shown: it reads again once no edit is written.
+ _archiveReads.EndWrite();
}
+ // Only once the write ended: a read begun while it is written waits for that end.
if (reload) await LoadArchiveAsync();
}
diff --git a/src/Titano.App/Settings/ArchiveReadGate.cs b/src/Titano.App/Settings/ArchiveReadGate.cs
index a4c3cadc..8be3cabf 100644
--- a/src/Titano.App/Settings/ArchiveReadGate.cs
+++ b/src/Titano.App/Settings/ArchiveReadGate.cs
@@ -4,9 +4,9 @@ namespace Titano.App.Settings;
/// Orders Settings › Archive's reads of the open archive's settings (its archive.json and index row) against the edits
/// written into them. A read that overlapped a write may hold the file as it was before the edit (a share waking up
/// answers late, and reads take no settings lease): showing it would undo the edit on the rows and in this PC's defaults
-/// while the archive keeps it. Such a read is dropped, and the rows are read again once no edit is being written: at
-/// once when none is left (), else when the last one ends (). Used from the
-/// interface thread only.
+/// while the archive keeps it. Such a read is not shown (): its reader waits until no edit is being
+/// written () and reads again, so a read is done only once the rows show what the archive holds.
+/// Used from the interface thread only.
///
public sealed class ArchiveReadGate
{
@@ -15,7 +15,7 @@ public sealed class ArchiveReadGate
private int _begun;
private int _writing;
- private bool _readAfterWrites;
+ private TaskCompletionSource? _written;
/// An edit starts being written into the archive.
public void BeginWrite()
@@ -24,17 +24,14 @@ public sealed class ArchiveReadGate
_writing++;
}
- ///
- /// The edit was written, or failed. True when the rows must be read again now: a read it overlapped was dropped and
- /// no other edit is being written.
- ///
- public bool EndWrite()
+ /// The edit was written, or failed. When it was the last one being written, the reads waiting for it go on.
+ public void EndWrite()
{
if (_writing == 0) throw new InvalidOperationException("No edit is being written.");
- _writing--;
- if (_writing > 0 || !_readAfterWrites) return false;
- _readAfterWrites = false;
- return true;
+ if (--_writing > 0) return;
+ var written = _written;
+ _written = null;
+ written?.SetResult();
}
/// A read starts; its token tells which edits it may have missed.
@@ -42,15 +39,14 @@ public sealed class ArchiveReadGate
///
/// Whether what a read begun with found may be shown: no edit was being written when it began
- /// and none began since. When it may not, the rows are read again: now () when every edit
- /// it overlapped is written, else once the last one ends.
+ /// and none began since. When it may not, its reader awaits and reads again.
///
- public bool IsCurrent(int token, out bool readAgain)
- {
- readAgain = false;
- if (token == _begun) return true;
- if (_writing > 0) _readAfterWrites = true;
- else readAgain = true;
- return false;
- }
+ public bool IsCurrent(int token) => token == _begun;
+
+ ///
+ /// Done once no edit is being written: at once when none is, else when the last one ends. Its continuations run after
+ /// returns, never inside it.
+ ///
+ public Task WrittenAsync() =>
+ _writing == 0 ? Task.CompletedTask : (_written ??= new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously)).Task;
}
diff --git a/tests/Titano.App.Tests/Settings/ArchiveReadGateTests.cs b/tests/Titano.App.Tests/Settings/ArchiveReadGateTests.cs
index c642eb0d..c7ab69aa 100644
--- a/tests/Titano.App.Tests/Settings/ArchiveReadGateTests.cs
+++ b/tests/Titano.App.Tests/Settings/ArchiveReadGateTests.cs
@@ -6,7 +6,8 @@ namespace Titano.App.Tests.Settings;
///
/// Settings › Archive never shows a read of the archive's settings that overlapped an edit being written: on a slow share
/// that read can hold archive.json as it was before the edit, and would undo the edit on the rows and in this PC's
-/// defaults while the archive keeps it.
+/// defaults while the archive keeps it. Its reader waits for the edits instead and reads again, so the read is done only
+/// once the rows show what the archive holds.
///
public sealed class ArchiveReadGateTests
{
@@ -14,69 +15,79 @@ public sealed class ArchiveReadGateTests
public void AReadWithNoEditMeanwhileIsShown()
{
var gate = new ArchiveReadGate();
- Assert.True(gate.IsCurrent(gate.BeginRead(), out var again));
- Assert.False(again);
+ Assert.True(gate.IsCurrent(gate.BeginRead()));
+ Assert.True(gate.WrittenAsync().IsCompleted, "no edit is being written");
// An edit written and ended before the read began is in the file it reads.
gate.BeginWrite();
- Assert.False(gate.EndWrite(), "no read overlapped it");
- Assert.True(gate.IsCurrent(gate.BeginRead(), out again));
- Assert.False(again);
+ gate.EndWrite();
+ Assert.True(gate.IsCurrent(gate.BeginRead()));
+ Assert.True(gate.WrittenAsync().IsCompleted);
}
[Test]
- public void AReadThatAnEditOverlapsIsReadAgainWhenTheEditIsWritten()
+ public void AReadThatAnEditOverlapsWaitsForTheEditAndReadsAgain()
{
// Settings is shown and reads archive.json; the user commits a template before the read answers.
var gate = new ArchiveReadGate();
var read = gate.BeginRead();
gate.BeginWrite();
- Assert.False(gate.IsCurrent(read, out var again), "the read may hold the file before the edit");
- Assert.False(again, "the edit is still being written: its end reads again");
- Assert.True(gate.EndWrite(), "the edit's end reads the rows again");
+ Assert.False(gate.IsCurrent(read), "the read may hold the file before the edit");
+ var written = gate.WrittenAsync();
+ Assert.False(written.IsCompleted, "the edit is still being written");
+ gate.EndWrite();
+ Assert.True(written.IsCompleted, "the reader reads again once the edit is written");
+ Assert.True(gate.IsCurrent(gate.BeginRead()));
- // That read is shown, and asks nothing more of later edits.
- Assert.True(gate.IsCurrent(gate.BeginRead(), out again));
- gate.BeginWrite();
- Assert.False(gate.EndWrite());
- }
-
- [Test]
- public void AReadOverlappingAnEditAlreadyWrittenIsReadAgainAtOnce()
- {
- // The edit began and ended while the read was out.
- var gate = new ArchiveReadGate();
- var read = gate.BeginRead();
- gate.BeginWrite();
- Assert.False(gate.EndWrite(), "the read was not dropped yet");
- Assert.False(gate.IsCurrent(read, out var again));
- Assert.True(again, "nothing else reads again: the read does");
-
- // A read that began while an edit was being written, which ended before the read answered.
- gate.BeginWrite();
+ // The edit began and ended while the read was out: the reader reads again at once.
read = gate.BeginRead();
- Assert.False(gate.EndWrite());
- Assert.False(gate.IsCurrent(read, out again));
- Assert.True(again);
- Assert.True(gate.IsCurrent(gate.BeginRead(), out again));
+ gate.BeginWrite();
+ gate.EndWrite();
+ Assert.False(gate.IsCurrent(read));
+ Assert.True(gate.WrittenAsync().IsCompleted);
+ Assert.True(gate.IsCurrent(gate.BeginRead()));
}
[Test]
- public void OnlyTheLastOfSeveralEditsReadsAgain()
+ public void AReadBegunWhileAnEditIsWrittenIsNeverShown()
+ {
+ // The rows are read again (a folder change, the screen shown) while an edit is still being written.
+ var gate = new ArchiveReadGate();
+ gate.BeginWrite();
+ var read = gate.BeginRead();
+ Assert.False(gate.IsCurrent(read));
+ var written = gate.WrittenAsync();
+ gate.EndWrite();
+ Assert.False(gate.IsCurrent(read), "it began before the edit was written");
+ Assert.True(written.IsCompleted);
+ Assert.True(gate.IsCurrent(gate.BeginRead()));
+ }
+
+ [Test]
+ public async Task AReaderGoesOnOnlyOnceTheLastOfSeveralEditsIsWrittenAndNeverInsideIt()
{
// A proxy size and a thumbnail size picked one after the other, both overlapping a read.
var gate = new ArchiveReadGate();
var read = gate.BeginRead();
gate.BeginWrite();
gate.BeginWrite();
- Assert.False(gate.IsCurrent(read, out var again));
- Assert.False(again);
- Assert.False(gate.EndWrite(), "another edit is still being written");
- // A read begun meanwhile is dropped too, and left to the last edit.
- read = gate.BeginRead();
- Assert.False(gate.IsCurrent(read, out again));
- Assert.False(again);
- Assert.True(gate.EndWrite());
+ Assert.False(gate.IsCurrent(read));
+ var written = gate.WrittenAsync();
+ Assert.Same(written, gate.WrittenAsync());
+ gate.EndWrite();
+ Assert.False(written.IsCompleted, "another edit is still being written");
+
+ // The reader goes on once the last edit ends, never inside its EndWrite: the writer finishes first.
+ var thread = Environment.CurrentManagedThreadId;
+ var ending = false;
+ var inside = written.ContinueWith(_ => ending && Environment.CurrentManagedThreadId == thread, CancellationToken.None,
+ TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
+ ending = true;
+ gate.EndWrite();
+ ending = false;
+ Assert.True(written.IsCompleted);
+ Assert.False(await inside, "the reader did not go on inside EndWrite");
+ Assert.True(gate.IsCurrent(gate.BeginRead()));
Assert.Throws(() => gate.EndWrite());
}
}
diff --git a/tests/Titano.App.Tests/Settings/SettingsScreenSmokeTests.cs b/tests/Titano.App.Tests/Settings/SettingsScreenSmokeTests.cs
index 7215198c..34ca3119 100644
--- a/tests/Titano.App.Tests/Settings/SettingsScreenSmokeTests.cs
+++ b/tests/Titano.App.Tests/Settings/SettingsScreenSmokeTests.cs
@@ -217,9 +217,12 @@ public sealed class SettingsScreenSmokeTests
settings.ArchiveRoot.Text = otherRoot;
Assert.True(settings.ArchiveRoot.Commit());
await WaitAsync(() => Read(manifestPath).LayoutTemplates.File == "{date}-{n:0000}", "the edit reached the archive of the folder it was made for");
+ // The folder change is done only once the rows show that folder's archive, also when its read overlapped the
+ // edit written into the first archive: that read waits for the edit and reads again instead of leaving the rows.
await settings.ArchiveRetarget;
Assert.NotEqual("{date}-{n:0000}", Read(otherManifestPath).LayoutTemplates.File);
Assert.Equal(Read(otherManifestPath).LayoutTemplates.File, settings.FileTemplate.Text);
+ Assert.Equal(Read(otherManifestPath).LayoutTemplates.File, shell.Services.Settings.FileTemplate);
settings.ArchiveRoot.Text = archive.RootPath;
Assert.True(settings.ArchiveRoot.Commit());
await settings.ArchiveRetarget;
@@ -239,6 +242,56 @@ public sealed class SettingsScreenSmokeTests
Assert.Equal(480, settings.SelectedThumbnailSize.Value);
});
+ [Test]
+ public Task AnArchiveRowEditedWhileSettingsReadsTheArchiveIsNotUndoneByThatRead() => ScreenHost.RunAsync(async () =>
+ {
+ await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
+ var shell = app.Shell;
+ await app.Sample.FillAsync();
+ var settings = shell.Settings;
+ var archive = Assert.NotNull(await Titano.App.Archiving.CurrentArchive.FindAsync(shell.Services.Database!, null));
+ var paths = new Titano.Core.Archiving.ArchivePaths(archive.RootPath);
+ static Titano.Core.Archiving.ArchiveManifest Read(string path) => Titano.Core.Archiving.ManifestStore.ReadArchive(path);
+ shell.Navigate(SectionKey.Settings);
+ settings.Page = SettingsPage.Archive;
+ settings.ArchiveRoot.Text = archive.RootPath;
+ Assert.True(settings.ArchiveRoot.Commit());
+ await settings.ArchiveRetarget;
+ var before = Read(paths.ManifestPath).LayoutTemplates.File;
+ const string edited = "{camera}_{n:00000}";
+ Assert.NotEqual(edited, before);
+ Assert.Equal(before, settings.FileTemplate.Text);
+
+ // Another PC holds the archive's settings, so the edit waits to be written. Settings is shown again just before
+ // the edit is committed: its read of archive.json answers meanwhile, with the file from before the edit.
+ var lease = Assert.NotNull(Titano.Core.Archiving.LeaseFile.TryAcquire(paths.LocksDirectory, "archive-settings", "other-pc"));
+ Task reload;
+ try
+ {
+ shell.Navigate(SectionKey.Library);
+ shell.Navigate(SectionKey.Settings);
+ reload = settings.ArchiveReload;
+ Assert.False(reload.IsCompleted, "the read is in flight");
+ settings.FileTemplate.Text = edited;
+ Assert.True(settings.FileTemplate.Commit());
+ await Task.WhenAny(reload, Task.Delay(1500));
+ Assert.False(reload.IsCompleted, "the read waits for the edit it overlapped");
+ Assert.Equal(edited, settings.FileTemplate.Text);
+ Assert.Equal(edited, shell.Services.Settings.FileTemplate);
+ Assert.Equal(before, Read(paths.ManifestPath).LayoutTemplates.File);
+ }
+ finally
+ {
+ lease.Dispose();
+ }
+
+ // Once the edit is written, the read is made again and shows it.
+ await reload.WaitAsync(TimeSpan.FromSeconds(20));
+ Assert.Equal(edited, Read(paths.ManifestPath).LayoutTemplates.File);
+ Assert.Equal(edited, settings.FileTemplate.Text);
+ Assert.Equal(edited, shell.Services.Settings.FileTemplate);
+ });
+
[Test]
public Task TheFirstRunDialogKeepsTheKeyboardInside() => ScreenHost.RunAsync(async () =>
{