From aff81dfac9884098fa2aeb4d97bc3e5992127a9c Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 14 Oct 2026 00:21:13 +0000 Subject: [PATCH] Collegamento e motore: correzioni regole-1, regole-2, regole-6, websec-1, websec-5, websec-6, engine-1, engine-2, sched-1 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Pagine aperte da Alberto non sono segnali (regole-1); cookie perso fuori sessione = disconnessione (regole-2); pagina a riposo quando Alberto lascia il browser (regole-6); la lease di «Accedi»/«Usa il browser» finisce da sola dopo 2 minuti senza vista remota né finestra (websec-1); ping con scadenza sulla vista remota (websec-5); aperture della vista remota serializzate (websec-6); orologio virtuale senza fine anticipata (engine-1); la sincronizzazione della coda non duplica il compito in corso (engine-2); raccolte in evidenza programmate (sched-1). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Mzbb6zeFTjT6Rp8b92AVkA --- src/Febe.App/BrowserConnectionService.cs | 196 ++++++++++++++++-- src/Febe.App/FebeApp.cs | 3 + src/Febe.Browser/Hosting/HostingHelpers.cs | 12 ++ .../Recipes/CollectionPipeline.cs | 8 +- src/Febe.Core/Collection/SignalDetector.cs | 21 +- src/Febe.Core/Engine/CheckPolicy.cs | 13 ++ src/Febe.Core/Engine/EngineHost.cs | 48 ++++- src/Febe.Core/Engine/SessionComposer.cs | 142 +++++++++++-- src/Febe.Core/Simulation/VirtualClock.cs | 66 +++--- src/Febe.Server/BrowserRemoteView.cs | 88 +++++--- src/Febe.Web/Connection/RemoteViewSocket.cs | 25 ++- .../Collection/SignalOwnershipTests.cs | 40 ++++ .../Desktop/ConnectionLifecycleTests.cs | 188 +++++++++++++++++ .../Desktop/Support/FakeDesktopShell.cs | 62 +++++- tests/Febe.Tests/Engine/EngineHostTests.cs | 137 ++++++++++++ .../Engine/Support/ScriptedRunner.cs | 11 + tests/Febe.Tests/Engine/VirtualClockTests.cs | 65 ++++++ .../Server/RemoteViewSocketTests.cs | 33 +++ .../Febe.Tests/Server/ServerEndToEndTests.cs | 56 +++++ 19 files changed, 1122 insertions(+), 92 deletions(-) create mode 100644 tests/Febe.Tests/Collection/SignalOwnershipTests.cs create mode 100644 tests/Febe.Tests/Desktop/ConnectionLifecycleTests.cs diff --git a/src/Febe.App/BrowserConnectionService.cs b/src/Febe.App/BrowserConnectionService.cs index 80cf36a..c3e1ce3 100644 --- a/src/Febe.App/BrowserConnectionService.cs +++ b/src/Febe.App/BrowserConnectionService.cs @@ -2,6 +2,7 @@ using System.Globalization; using Febe.Browser.Cdp; using Febe.Browser.Hosting; using Febe.Core.Abstractions; +using Febe.Core.Collection; using Febe.Core.Domain; using Febe.Core.Engine; using Febe.Core.Storage; @@ -20,11 +21,27 @@ namespace Febe.App; /// «Ho finito» and «Annulla» put it back out of view, «Scollega» closes it before deleting the profile. In Docker /// showing and hiding do nothing (the remote view shows the browser). /// +/// +/// +/// The lease taken by «Accedi a Instagram» and «Usa il browser» ends with «Ho finito», «Annulla» or «Scollega», and also +/// by itself when for it is the only sign that Alberto uses the browser — no remote view open +/// in Docker, the window «Browser di Febe» out of view on Windows: he went away without either button, and the engine +/// must not stay still for ever. +/// +/// +/// A session cookie that disappears outside a session (or is missing at start-up after a connection) is a disconnection +/// (spec §7.6): reported to the breaker as the recipes would, so that it is an incident with its alert and only +/// «Riprendi» restarts the engine. Not when Alberto himself is at the browser, nor after his «Scollega». +/// +/// public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposable { /// Setting written at the first connection ever (Unix ms): the gradual start begins only once. public const string FirstConnectionKey = "collegamento.primo"; + /// Setting set by «Scollega» and removed by the next connection: until then a missing session is expected. + public const string DisconnectedByUserKey = "collegamento.scollegato"; + /// A cookie check younger than this is reused by the status (the sidebar asks often). public static readonly TimeSpan CookieCacheLifetime = TimeSpan.FromSeconds(3); @@ -42,7 +59,10 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa private readonly Lock _gate = new(); private EngineHost? _engine; private IDisposable? _lease; + private CancellationTokenSource? _leaseWatch; + private DateTimeOffset _lastDrivingSign; private bool? _connected; + private bool? _disconnectedByUser; private DateTimeOffset _checkedAt = DateTimeOffset.MinValue; public BrowserConnectionService(IFebeBrowser browser, IFebeStorage storage, BrowserUseTracker tracker, IClock clock, FebeLog log, string loginUrl, SessionCookieOptions cookie) @@ -78,6 +98,12 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa /// public event EventHandler? ConnectionChanged; + /// + /// How long the lease of «Accedi a Instagram» / «Usa il browser» outlives every other lease of the browser (remote + /// view, window in front) before it ends by itself. Read at every look; tests shorten it. + /// + public TimeSpan DrivingGrace { get; set; } = TimeSpan.FromMinutes(2); + /// The engine, once it exists (it is built after the browser). public void AttachEngine(EngineHost engine) => _engine = engine ?? throw new ArgumentNullException(nameof(engine)); @@ -92,7 +118,7 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa var breaker = _engine?.Services.Breaker.State.Status; var state = breaker is BreakerStatus.Challenge or BreakerStatus.Disconnected ? ConnectionState.VerificationRequired - : await CheckAsync(force: false, ct).ConfigureAwait(false) == true ? ConnectionState.Connected : ConnectionState.NotConnected; + : await CheckAsync(force: false, mayReport: true, ct).ConfigureAwait(false) == true ? ConnectionState.Connected : ConnectionState.NotConnected; Account? mine = null; if (state != ConnectionState.NotConnected) @@ -111,7 +137,16 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa { lock (_gate) { - _lease ??= _browser.UserDriving.Begin(); + if (_lease is null) + { + _lease = _browser.UserDriving.Begin(); + var watch = new CancellationTokenSource(); + _leaseWatch = watch; + var lease = _lease; + _ = Task.Run(() => WatchLeaseAsync(lease, watch.Token), CancellationToken.None); + } + + _lastDrivingSign = _clock.Now; } _tracker.MarkUsed(_clock.Now); @@ -149,10 +184,11 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa return new FinishResult(false, "Il browser di Febe non è in funzione in questo momento, quindi Febe non può controllare il collegamento. Riprova fra qualche minuto; se il problema resta, guarda il registro."); } - var connected = await CheckAsync(force: true, ct).ConfigureAwait(false) == true; + // Alberto has just been at the browser: a session he did not complete is said here, not reported as a stop. + var connected = await CheckAsync(force: true, mayReport: false, ct).ConfigureAwait(false) == true; _tracker.MarkUsed(_clock.Now); var first = connected && await MarkConnectedAsync(ct).ConfigureAwait(false); - await RestQuietlyAsync().ConfigureAwait(false); + await RestIfAlbertosAsync().ConfigureAwait(false); await HideQuietlyAsync().ConfigureAwait(false); ReleaseLease(); @@ -191,7 +227,7 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa { if (_browser.IsAvailable) { - await RestQuietlyAsync().ConfigureAwait(false); + await RestIfAlbertosAsync().ConfigureAwait(false); await HideQuietlyAsync().ConfigureAwait(false); } @@ -210,6 +246,8 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa var hold = _browser.UserDriving.Begin(); try { + // From now on a missing session is Alberto's choice, not a disconnection to report (until he connects again). + await RememberUserDisconnectAsync().ConfigureAwait(false); var engine = _engine; if (engine is not null) { @@ -264,7 +302,8 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa /// /// Looks at the cookie now (outside the cache) and records the change. Used at start-up, by the background loop - /// and after the test site's automatic login. + /// and after the test site's automatic login. A session that went away (or is missing at start-up after a + /// connection) while Alberto is not at the browser is reported to the breaker as a disconnection (spec §7.6). /// public async Task RefreshAsync(CancellationToken ct) { @@ -273,7 +312,7 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa return IsConnected; } - var connected = await CheckAsync(force: true, ct).ConfigureAwait(false); + var connected = await CheckAsync(force: true, mayReport: true, ct).ConfigureAwait(false); if (connected == true) { await MarkConnectedAsync(ct).ConfigureAwait(false); @@ -313,7 +352,7 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa return ValueTask.CompletedTask; } - private async Task CheckAsync(bool force, CancellationToken ct) + private async Task CheckAsync(bool force, bool mayReport, CancellationToken ct) { lock (_gate) { @@ -333,21 +372,31 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa return IsConnected; } - SetConnected(has); + var previous = SetConnected(has); + if (has) + { + await ForgetUserDisconnectAsync(ct).ConfigureAwait(false); + } + else if (mayReport && previous != false && !_browser.UserIsDriving) + { + await ReportLostSessionAsync(previous, ct).ConfigureAwait(false); + } + return has; } - private void SetConnected(bool connected) + /// Records the state of the cookie; returns the one before (null before the first check). + private bool? SetConnected(bool connected) { - bool changed; + bool? previous; lock (_gate) { - changed = _connected != connected; + previous = _connected; _connected = connected; _checkedAt = _clock.Now; } - if (changed) + if (previous != connected) { _log.Info("collegamento", connected ? "Sessione presente nel browser: collegato." : "Nessuna sessione nel browser: non collegato."); @@ -355,6 +404,102 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa _engine?.NotifyUserDrivingChanged(); ConnectionChanged?.Invoke(this, connected); } + + return previous; + } + + /// + /// The session cookie is gone while Alberto is not at the browser (spec §7.6 «il cookie di sessione non c'è più»): + /// the same disconnection the recipes report, so the breaker writes the incident, the alert goes out and only + /// «Riprendi» (with the gradual start) restarts the engine. Not after «Scollega», and at start-up only when the + /// profile had been connected. + /// + private async Task ReportLostSessionAsync(bool? previous, CancellationToken ct) + { + if (_engine is not { } engine || await IsDisconnectedByUserAsync(ct).ConfigureAwait(false)) + { + return; + } + + if (previous is null && await _storage.Settings.GetInt64Async(FirstConnectionKey, ct).ConfigureAwait(false) is null) + { + return; // never connected: nothing was lost + } + + engine.Services.Breaker.Report(new Signal(SignalLevel.Disconnect, SignalRules.SessionCookieMissingCode, null, _clock.Now)); + _log.Warn("collegamento", "La sessione di Instagram non c'è più nel browser: Febe si ferma finché non accedi di nuovo e premi «Riprendi»."); + } + + private async Task IsDisconnectedByUserAsync(CancellationToken ct) + { + if (_disconnectedByUser is { } known) + { + return known; + } + + var stored = await _storage.Settings.GetBoolAsync(DisconnectedByUserKey, false, ct).ConfigureAwait(false); + _disconnectedByUser = stored; + return stored; + } + + private async Task RememberUserDisconnectAsync() + { + _disconnectedByUser = true; + await _storage.Settings.SetBoolAsync(DisconnectedByUserKey, true, CancellationToken.None).ConfigureAwait(false); + } + + /// A session is in the browser again: from now on its loss is a disconnection. + private async Task ForgetUserDisconnectAsync(CancellationToken ct) + { + if (await IsDisconnectedByUserAsync(ct).ConfigureAwait(false)) + { + _disconnectedByUser = false; + await _storage.Settings.SetAsync(DisconnectedByUserKey, null, ct).ConfigureAwait(false); + } + } + + /// + /// The «driving» lease of this service ends by itself once it has been the only lease of the browser for + /// : the remote view closed (Docker) or the window went out of view (Windows), and + /// neither «Ho finito» nor «Annulla» came. The page is not touched here (the engine puts it to rest). + /// + private async Task WatchLeaseAsync(IDisposable lease, CancellationToken ct) + { + try + { + while (true) + { + var grace = DrivingGrace; + var poll = TimeSpan.FromTicks(Math.Clamp(grace.Ticks / 8, TimeSpan.FromMilliseconds(20).Ticks, TimeSpan.FromSeconds(5).Ticks)); + await _clock.Delay(poll, ct).ConfigureAwait(false); + DateTimeOffset lastSign; + lock (_gate) + { + if (!ReferenceEquals(_lease, lease)) + { + return; + } + + // Besides this lease: the remote view, the browser window in front, «Scollega» in progress. + if (_browser.UserDriving.Leases > 1) + { + _lastDrivingSign = _clock.Now; + } + + lastSign = _lastDrivingSign; + } + + if (_clock.Now - lastSign >= grace && ReleaseLease(lease)) + { + _log.Info("collegamento", $"Nessuna vista del browser aperta da {ItalianText.Duration(grace)} senza «Ho finito» né «Annulla»: il motore può riprendere."); + return; + } + } + } + catch (OperationCanceledException) when (ct.IsCancellationRequested) + { + // The lease ended with a command of Alberto. + } } /// The first connection ever starts the gradual start (spec §7.2). True when it was the first. @@ -408,6 +553,13 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa } } + /// + /// Puts the page to rest while it is Alberto's (a lease holds the engine still). Once every lease ended — this + /// service's ended by itself after — the page is the engine's again: a late «Ho finito» or + /// «Annulla» must not navigate under a session (the engine rested the page when the driving ended). + /// + private Task RestIfAlbertosAsync() => _browser.UserIsDriving ? RestQuietlyAsync() : Task.CompletedTask; + private async Task RestQuietlyAsync() { try @@ -444,16 +596,32 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa } } - private void ReleaseLease() + /// Ends the lease (only , when given). True when a lease ended. + private bool ReleaseLease(IDisposable? expected = null) { IDisposable? lease; + CancellationTokenSource? watch; lock (_gate) { + if (expected is not null && !ReferenceEquals(_lease, expected)) + { + return false; + } + lease = _lease; + watch = _leaseWatch; _lease = null; + _leaseWatch = null; + } + + if (watch is not null) + { + watch.Cancel(); + watch.Dispose(); } lease?.Dispose(); + return lease is not null; } private void EnsureBrowser() diff --git a/src/Febe.App/FebeApp.cs b/src/Febe.App/FebeApp.cs index 8536c9d..8e613d8 100644 --- a/src/Febe.App/FebeApp.cs +++ b/src/Febe.App/FebeApp.cs @@ -365,6 +365,9 @@ public sealed class FebeApp : IAsyncDisposable ConfigFolder = Data!.Root, Pace = services.Settings.Pace, UserIsDriving = () => browser.UserIsDriving, + + // Rule 7: the pages Alberto opens (login, verification) are his, not the engine's, while no session runs. + UserOwnsPage = () => browser.UserIsDriving && services.Runtime.CurrentSession is null, Log = Log.ForBrowser(), }, ct).ConfigureAwait(false); diff --git a/src/Febe.Browser/Hosting/HostingHelpers.cs b/src/Febe.Browser/Hosting/HostingHelpers.cs index f7bab57..ef96806 100644 --- a/src/Febe.Browser/Hosting/HostingHelpers.cs +++ b/src/Febe.Browser/Hosting/HostingHelpers.cs @@ -42,6 +42,18 @@ public sealed class UserDrivingGate } } + /// How many leases are open (an owner can tell whether someone besides it still holds one). + public int Leases + { + get + { + lock (_gate) + { + return _leases; + } + } + } + /// Raised when changes; the argument is the new value. public event EventHandler? Changed; diff --git a/src/Febe.Browser/Recipes/CollectionPipeline.cs b/src/Febe.Browser/Recipes/CollectionPipeline.cs index 268855b..9e2e219 100644 --- a/src/Febe.Browser/Recipes/CollectionPipeline.cs +++ b/src/Febe.Browser/Recipes/CollectionPipeline.cs @@ -77,6 +77,12 @@ public sealed record CollectionPipelineOptions /// True while Alberto uses the browser: gestures are not performed. public Func? UserIsDriving { get; init; } + /// + /// True while the page is Alberto's (he uses the browser and no engine session runs): what he opens is not a stop + /// signal (). Null: always the engine's. + /// + public Func? UserOwnsPage { get; init; } + public IBrowserLog? Log { get; init; } } @@ -131,7 +137,7 @@ public sealed class CollectionPipeline : IAsyncDisposable var rules = rulesFile is not null && File.Exists(rulesFile) ? SignalRules.Load(rulesFile) : SignalRules.LoadEmbedded(site.SignalsFile); var tap = new ResponseTap(options.Cdp, site.Hosts, options.Clock, options.Log); - var signals = new SignalDetector(rules, options.Breaker, options.Clock); + var signals = new SignalDetector(rules, options.Breaker, options.Clock) { UserOwnsPage = options.UserOwnsPage }; var capture = new CaptureCollector(new ShapeReader(vocabulary), options.Clock); var driver = new BrowserPageDriver(options.Cdp, targets, site.Hosts, options.Clock, options.Random, new BrowserDriverOptions { diff --git a/src/Febe.Core/Collection/SignalDetector.cs b/src/Febe.Core/Collection/SignalDetector.cs index f547c23..c4e9278 100644 --- a/src/Febe.Core/Collection/SignalDetector.cs +++ b/src/Febe.Core/Collection/SignalDetector.cs @@ -31,6 +31,15 @@ public sealed class SignalDetector : IResponseObserver, IResponseConsumer, IStop public TimeSpan DedupeWindow { get; } + /// + /// True while the page is Alberto's, not the engine's: he holds the «driving» lease and no session runs. The + /// addresses he opens then — the login page of «Accedi a Instagram», a verification he completes by hand — are not + /// engine actions (rule 7 of §2) nor the page «going back to the login» of §7.6, so path rules (navigations and + /// main documents) are not signals. Status and text rules, and the cookie check of the recipes, still are. + /// Null: the page is always the engine's. + /// + public Func? UserOwnsPage { get; init; } + /// Raised after a signal has been reported to the breaker. public event EventHandler? SignalRaised; @@ -49,6 +58,7 @@ public sealed class SignalDetector : IResponseObserver, IResponseConsumer, IStop { ArgumentNullException.ThrowIfNull(response); var scope = response.IsMainFrameDocument ? SignalScope.Document : SignalScope.Subresource; + var paths = !UserIsOnPage(); foreach (var rule in _rules.Rules) { if (!rule.HostKinds.Contains(response.HostKind) || (rule.Scope & scope) == 0) @@ -57,7 +67,7 @@ public sealed class SignalDetector : IResponseObserver, IResponseConsumer, IStop } if ((rule.Statuses.Count > 0 && rule.Statuses.Contains(response.Status)) - || (rule.Path is not null && SafeIsMatch(rule.Path, response.Path))) + || (paths && rule.Path is not null && SafeIsMatch(rule.Path, response.Path))) { return Raise(rule.Level, rule.Code, response.Url); } @@ -66,10 +76,15 @@ public sealed class SignalDetector : IResponseObserver, IResponseConsumer, IStop return null; } - /// Path rules on a main-frame navigation. + /// Path rules on a main-frame navigation (none while the page is Alberto's: ). public Signal? ObserveNavigation(NavigationDescriptor navigation) { ArgumentNullException.ThrowIfNull(navigation); + if (UserIsOnPage()) + { + return null; + } + foreach (var rule in _rules.Rules) { if (rule.Path is null || (rule.Scope & SignalScope.Navigation) == 0 || !rule.HostKinds.Contains(navigation.HostKind)) @@ -144,6 +159,8 @@ public sealed class SignalDetector : IResponseObserver, IResponseConsumer, IStop public Signal? ObserveSessionCookie(bool present) => present ? null : Raise(SignalLevel.Disconnect, SignalRules.SessionCookieMissingCode, null); + private bool UserIsOnPage() => UserOwnsPage?.Invoke() == true; + private Signal? Raise(SignalLevel level, string code, string? url) { var now = _clock.Now; diff --git a/src/Febe.Core/Engine/CheckPolicy.cs b/src/Febe.Core/Engine/CheckPolicy.cs index 045fec1..86a154d 100644 --- a/src/Febe.Core/Engine/CheckPolicy.cs +++ b/src/Febe.Core/Engine/CheckPolicy.cs @@ -44,6 +44,19 @@ public static class CheckPolicy public static bool WantsStories(Account account) => (account.ContentTypes & ContentTypes.Stories) != 0; + public static bool WantsHighlights(Account account) => (account.ContentTypes & ContentTypes.Highlights) != 0; + + /// + /// Interval between two looks at the same highlight collection («Raccolta in evidenza»): eight story intervals of + /// the frequency, between one and seven days (High 1 day, Normal 2, Low a little less than 3). Collections change far + /// less often than stories, and mostly with stories already saved (H9); a new collection is looked at at once. + /// + public static TimeSpan HighlightInterval(Account account) + { + var ticks = StoryMaxInterval(account).Ticks * 8; + return TimeSpan.FromTicks(Math.Clamp(ticks, TimeSpan.FromDays(1).Ticks, TimeSpan.FromDays(7).Ticks)); + } + /// /// Interval between profile checks. Not followed: ~12 h / ~3 h / ~75 min (Su misura: the hours chosen). Followed: the /// sweep discovers new posts, the profile check is only a reconciliation every 24 / 12 / 6 hours (Su misura: four diff --git a/src/Febe.Core/Engine/EngineHost.cs b/src/Febe.Core/Engine/EngineHost.cs index 9c2cc0c..63717ad 100644 --- a/src/Febe.Core/Engine/EngineHost.cs +++ b/src/Febe.Core/Engine/EngineHost.cs @@ -51,6 +51,7 @@ public sealed class EngineHost : IAsyncDisposable private Task? _loop; private bool _initialized; private bool _manualWaiting; + private int _restAfterDriving; private DateTimeOffset? _plannedAfterStop; public EngineHost(EngineServices services, IRecipeRunner runner) @@ -363,11 +364,15 @@ public sealed class EngineHost : IAsyncDisposable _s.Events.Publish(EngineNotificationKind.StateChanged); } - /// Alberto started or finished using the browser: when he starts, the session in progress ends at once. + /// + /// Alberto started or finished using the browser: when he starts, the session in progress ends at once (leaving the + /// page to him); when he lets go, the loop puts the page back to rest. + /// public void NotifyUserDrivingChanged() { if (_s.Runtime.UserIsDriving) { + Volatile.Write(ref _restAfterDriving, 1); CancelSession(); } @@ -451,6 +456,15 @@ public sealed class EngineHost : IAsyncDisposable { var now = _s.Clock.Now; var runtime = _s.Runtime; + if (runtime.UserIsDriving) + { + Volatile.Write(ref _restAfterDriving, 1); + } + else if (Interlocked.Exchange(ref _restAfterDriving, 0) == 1) + { + await RestAfterDrivingAsync(ct).ConfigureAwait(false); + } + if (runtime.IsPaused) { return LongWait; @@ -630,6 +644,8 @@ public sealed class EngineHost : IAsyncDisposable var keepPage = breaker.Status is BreakerStatus.Challenge or BreakerStatus.Disconnected || s.Runtime.UserIsDriving; if (!keepPage) { + // This rest also serves a driving period that ended during the session. + Interlocked.Exchange(ref _restAfterDriving, 0); try { await _runner.RestAsync(ct).ConfigureAwait(false); @@ -687,6 +703,36 @@ public sealed class EngineHost : IAsyncDisposable s.Events.Publish(EngineNotificationKind.StateChanged); } + /// + /// Alberto let go of the browser and no session runs: the page goes back to rest (spec §6.1), so that nothing he or a + /// cancelled session left open stays on the site — a story viewer moves on by itself to other accounts (§6.3). + /// After a verification or a disconnection the page stays as it is until «Riprendi» (§7.6). + /// + private async Task RestAfterDrivingAsync(CancellationToken ct) + { + if (_s.Breaker.State.Status is BreakerStatus.Challenge or BreakerStatus.Disconnected) + { + return; + } + + try + { + await _runner.RestAsync(ct).ConfigureAwait(false); + } + catch (OperationCanceledException) when (ct.IsCancellationRequested) + { + throw; + } + catch (Exception ex) when (ex is not OutOfMemoryException) + { + await _s.Events.WriteAsync( + EventSeverity.Warning, + EngineEventCodes.RecipeFailed, + $"Non sono riuscito a portare il browser sulla pagina vuota ({ex.GetType().Name}).", + ct: CancellationToken.None).ConfigureAwait(false); + } + } + private SessionOutcome StopOutcome() => _s.Breaker.State.Status == BreakerStatus.Throttled ? SessionOutcome.Throttled : SessionOutcome.Stopped; diff --git a/src/Febe.Core/Engine/SessionComposer.cs b/src/Febe.Core/Engine/SessionComposer.cs index b79b835..df2017e 100644 --- a/src/Febe.Core/Engine/SessionComposer.cs +++ b/src/Febe.Core/Engine/SessionComposer.cs @@ -7,9 +7,10 @@ namespace Febe.Core.Engine; /// /// Composes and runs one session (spec §7.2, §7.3): commands of Alberto first, then usually the Giro dei seguiti, -/// the flagged and due stories, the expired profile checks, finally a few pages of history on one account. About one -/// session in three stops after the sweep and the stories. Accounts are taken in a random order weighted by frequency -/// and delay. Planned work lives in the persisted task queue; this class keeps it in step with the accounts. +/// the flagged and due stories, the expired profile checks and highlight collections, finally a few pages of history on +/// one account. About one session in three stops after the sweep and the stories. Accounts are taken in a random order +/// weighted by frequency and delay. Planned work lives in the persisted task queue; this class keeps it in step with +/// the accounts. /// internal sealed class SessionComposer { @@ -22,6 +23,12 @@ internal sealed class SessionComposer private readonly Action _manualDone; private readonly Lock _noticeGate = new(); private readonly HashSet<(string Code, long? Account, DateOnly Day)> _notices = []; + + // The interface calls SyncQueueAsync while a session may be running. A recipe's task is Running in the database + // between its start and its bookkeeping, and then has its successor: under this gate the queue is looked at only + // when every task is pending, in flight (_inFlight) or already replaced by its successor, never in between. + private readonly SemaphoreSlim _queueGate = new(1, 1); + private EngineTask? _inFlight; private DateTimeOffset? _lastSweepAt; private bool _lastSweepLoaded; @@ -114,7 +121,7 @@ internal sealed class SessionComposer } } - // 4. Expired profile checks and other planned work. + // 4. Expired profile checks, highlight collections and other planned work. if (!light && !Over(state, ct)) { var now = Clock.Now; @@ -146,11 +153,25 @@ internal sealed class SessionComposer /// /// Keeps the queue in step with the accounts: a profile check and a story check (as the account wants them) for - /// every contactable account, a backfill task for every account «Storico in corso», a Giro dei seguiti when someone - /// is followed; pending planned tasks of accounts that may not be contacted are cancelled. Commands of Alberto - /// are left alone. + /// every contactable account, a look at each highlight collection on its profile, a backfill task for every account + /// «Storico in corso», a Giro dei seguiti when someone is followed; pending planned tasks of accounts that may not be + /// contacted are cancelled. Commands of Alberto are left alone, and so is the task of the recipe in progress: its + /// own bookkeeping plans the next one. /// public async Task> SyncQueueAsync(CancellationToken ct) + { + await _queueGate.WaitAsync(ct).ConfigureAwait(false); + try + { + return await SyncQueueLockedAsync(ct).ConfigureAwait(false); + } + finally + { + _queueGate.Release(); + } + } + + private async Task> SyncQueueLockedAsync(CancellationToken ct) { var now = Clock.Now; var accounts = (await Store.Accounts.ListAsync(ct).ConfigureAwait(false)).ToDictionary(a => a.Id); @@ -161,14 +182,14 @@ internal sealed class SessionComposer { var tasks = byAccount[account.Id].Where(t => !t.IsManual).ToList(); var wanted = WantedKinds(account); - foreach (var task in tasks.Where(t => !wanted.ContainsKey(t.Kind) && !(t.Kind == EngineTaskKind.AccountStories && t.Priority >= Options.FlaggedStoriesPriority && CheckPolicy.IsContactable(account)))) + foreach (var task in tasks.Where(t => t.Kind != EngineTaskKind.HighlightCheck && !wanted.ContainsKey(t.Kind) && !(t.Kind == EngineTaskKind.AccountStories && t.Priority >= Options.FlaggedStoriesPriority && CheckPolicy.IsContactable(account)))) { await Store.Tasks.CancelAsync(task.Id, now, ct).ConfigureAwait(false); } foreach (var (kind, dueAt) in wanted) { - if (tasks.Any(t => t.Kind == kind)) + if (tasks.Any(t => t.Kind == kind) || InFlight(account.Id, kind, null)) { continue; } @@ -177,6 +198,8 @@ internal sealed class SessionComposer new EngineTask { Kind = kind, AccountId = account.Id, DueAt = dueAt ?? now, CreatedAt = now }, ct).ConfigureAwait(false); } + + await SyncHighlightsAsync(account, tasks, now, ct).ConfigureAwait(false); } var anyFollowed = accounts.Values.Any(a => a.IsFollowed && CheckPolicy.IsContactable(a)); @@ -196,6 +219,52 @@ internal sealed class SessionComposer return accounts; } + /// + /// «Raccolta in evidenza» (spec §6.3) for an account that wants «Storie in evidenza»: one task per collection the + /// profile check found (payload: its Instagram identifier), due at once for a collection never looked at, then + /// after . Tasks of collections that left the profile, or of accounts + /// that no longer want them or may not be contacted, are cancelled. + /// + private async Task SyncHighlightsAsync(Account account, List tasks, DateTimeOffset now, CancellationToken ct) + { + var planned = tasks.Where(t => t.Kind == EngineTaskKind.HighlightCheck).ToList(); + var collections = new Dictionary(StringComparer.Ordinal); + if (CheckPolicy.IsContactable(account) && CheckPolicy.WantsHighlights(account)) + { + foreach (var highlight in await Store.Highlights.ListAsync(account.Id, includeRemoved: false, ct).ConfigureAwait(false)) + { + if (highlight.InstagramId is { Length: > 0 } id) + { + collections.TryAdd(id, highlight); + } + } + } + + foreach (var task in planned.Where(t => t.Payload is null || !collections.ContainsKey(t.Payload))) + { + await Store.Tasks.CancelAsync(task.Id, now, ct).ConfigureAwait(false); + } + + foreach (var (id, highlight) in collections) + { + if (planned.Any(t => t.Payload == id) || InFlight(account.Id, EngineTaskKind.HighlightCheck, id)) + { + continue; + } + + var due = highlight.LastCheckedAt is { } last + ? last + CheckPolicy.NextCheckDelay(_s.Random, CheckPolicy.HighlightInterval(account)) + : now; + await Store.Tasks.EnqueueAsync( + new EngineTask { Kind = EngineTaskKind.HighlightCheck, AccountId = account.Id, Payload = id, DueAt = due, CreatedAt = now }, + ct).ConfigureAwait(false); + } + } + + /// Whether the recipe in progress runs a task of this kind (and payload) for the account. Under the queue gate. + private bool InFlight(long accountId, EngineTaskKind kind, string? payload) => + _inFlight is { } task && task.AccountId == accountId && task.Kind == kind && (payload is null || task.Payload == payload); + /// The Giro dei seguiti shown in the queue at the next session. public Task EnsureSweepTaskAsync(DateTimeOffset dueAt, CancellationToken ct) => Store.Tasks.EnqueueAsync( @@ -359,6 +428,13 @@ internal sealed class SessionComposer { return; } + + // One highlight collection per account and session, and none on a profile already opened in this session: + // the others wait for the next session instead of reopening the same profile again and again. + if (task.Kind == EngineTaskKind.HighlightCheck && (state.Visited.Contains(id) || !state.HighlightAccounts.Add(id))) + { + return; + } } switch (task.Kind) @@ -610,7 +686,7 @@ internal sealed class SessionComposer return null; } - if (task is not null && !await Store.Tasks.TryStartAsync(task.Id, Clock.Now, ct).ConfigureAwait(false)) + if (task is not null && !await StartTaskAsync(task, ct).ConfigureAwait(false)) { return null; } @@ -627,7 +703,16 @@ internal sealed class SessionComposer { if (task is not null) { - await RequeueAsync(task, "Interrotta", Clock.Now).ConfigureAwait(false); + await _queueGate.WaitAsync(CancellationToken.None).ConfigureAwait(false); + try + { + await RequeueAsync(task, "Interrotta", Clock.Now).ConfigureAwait(false); + } + finally + { + _inFlight = null; + _queueGate.Release(); + } } throw; @@ -643,11 +728,41 @@ internal sealed class SessionComposer } context.AddNewEntries(outcome.NewEntries); - await ApplyOutcomeAsync(task, request, account, outcome, state).ConfigureAwait(false); + await _queueGate.WaitAsync(CancellationToken.None).ConfigureAwait(false); + try + { + await ApplyOutcomeAsync(task, request, account, outcome, state).ConfigureAwait(false); + } + finally + { + _inFlight = null; + _queueGate.Release(); + } + _s.Events.Publish(EngineNotificationKind.ActivityChanged); return outcome; } + /// Pending → Running, recorded as the task in flight under the queue gate. False when it was not pending. + private async Task StartTaskAsync(EngineTask task, CancellationToken ct) + { + await _queueGate.WaitAsync(ct).ConfigureAwait(false); + try + { + if (!await Store.Tasks.TryStartAsync(task.Id, Clock.Now, ct).ConfigureAwait(false)) + { + return false; + } + + _inFlight = task; + return true; + } + finally + { + _queueGate.Release(); + } + } + private async Task ApplyOutcomeAsync(EngineTask? task, RecipeRequest request, Account? account, RecipeOutcome outcome, SessionState state) { // Bookkeeping always completes, even when the session has just been cancelled. Independent writes are queued @@ -1022,6 +1137,9 @@ internal sealed class SessionComposer /// Commands of Alberto already taken up in this session. public HashSet ManualDone { get; } = []; + /// Accounts whose highlight collection was taken up in this session (one per account and session). + public HashSet HighlightAccounts { get; } = []; + public bool Stop { get; set; } public int Recipes { get; set; } diff --git a/src/Febe.Core/Simulation/VirtualClock.cs b/src/Febe.Core/Simulation/VirtualClock.cs index 4696211..cea373f 100644 --- a/src/Febe.Core/Simulation/VirtualClock.cs +++ b/src/Febe.Core/Simulation/VirtualClock.cs @@ -13,6 +13,11 @@ namespace Febe.Core.Simulation; /// Delays are rounded up to whole milliseconds, the resolution of the database, so stored and computed times compare exactly. /// With a delay moves time forward at once: handy for one component under test, without a driver. /// Each actor must wait on at most one delay at a time, otherwise the driver could advance before the second is registered. +/// +/// A delay may be cancelled from any thread, also one that is not an actor (the engine cancels a session from the thread +/// pool when a signal arrives). The cancelled actor runs again, so the driver decides whether to fire the next timer or +/// to finish under the same lock in which it looks again at how many actors still wait. +/// /// public sealed class VirtualClock : IClock { @@ -120,17 +125,9 @@ public sealed class VirtualClock : IClock /// Moves time to , firing in order the timers that fall due on the way. public void AdvanceTo(DateTimeOffset target) { - while (TryFireNext(target)) + while (FireNextOrFinish(target, running: 0) != Step.Finished) { } - - lock (_gate) - { - if (target > _now) - { - _now = target; - } - } } /// @@ -152,16 +149,9 @@ public sealed class VirtualClock : IClock await failed.ConfigureAwait(false); } - if (!TryFireNext(target)) + var running = Actors - actors.Count(a => a.IsCompleted); + if (FireNextOrFinish(target, running) == Step.Finished) { - lock (_gate) - { - if (target > _now) - { - _now = target; - } - } - return; } } @@ -198,11 +188,22 @@ public sealed class VirtualClock : IClock } } - private bool TryFireNext(DateTimeOffset limit) + /// + /// One step of the driver, atomic with a fresh look at the waiting actors: fires the earliest live timer due by + /// ; when there is none, moves time to and says the run is finished. + /// With actors expected to wait, fewer pending timers mean that an actor's timer was + /// cancelled from another thread after the quiescence check: that actor runs again and nothing moves. + /// + private Step FireNextOrFinish(DateTimeOffset limit, int running) { PendingDelay? fired = null; lock (_gate) { + if (running > 0 && _active < running) + { + return Step.NotQuiescent; + } + while (_timers.TryPeek(out var next, out _)) { if (next.Done) @@ -228,16 +229,21 @@ public sealed class VirtualClock : IClock FiredTimers++; break; } - } - if (fired is null) - { - return false; + if (fired is null) + { + if (limit > _now) + { + _now = limit; + } + + return Step.Finished; + } } fired.Registration.Dispose(); fired.Completion.TrySetResult(); - return true; + return Step.Fired; } private void Cancel(PendingDelay delay, CancellationToken ct) @@ -259,6 +265,18 @@ public sealed class VirtualClock : IClock delay.Completion.TrySetCanceled(ct); } + private enum Step + { + /// A timer fired: an actor runs. + Fired, + + /// An actor runs again (its timer was cancelled from outside): wait until it waits. + NotQuiescent, + + /// Nothing left before the limit: time is at the limit. + Finished, + } + private sealed class PendingDelay { public DateTimeOffset Due { get; set; } diff --git a/src/Febe.Server/BrowserRemoteView.cs b/src/Febe.Server/BrowserRemoteView.cs index ac3ffbf..310262b 100644 --- a/src/Febe.Server/BrowserRemoteView.cs +++ b/src/Febe.Server/BrowserRemoteView.cs @@ -13,11 +13,14 @@ namespace Febe.Server; /// /// The remote view over the real Chromium (spec §4.1, §11, PROTOCOLLO.md): a per open /// view, which holds the «Alberto is driving» lease while it is open, so the engine is still. One view at a time: a -/// view opened in another tab replaces the older one. Keys go to the browser and nowhere else. +/// view opened in another tab replaces the older one, also when two open at the same moment (opening is serialized, so +/// the older view is always ended — and its screencast stopped — before the newer one starts). Keys go to the browser +/// and nowhere else. /// internal sealed class BrowserRemoteViewHost(ChromiumBrowser browser, BrowserUseTracker tracker, IClock clock, FebeLog log) : IRemoteViewHost { private readonly Lock _gate = new(); + private readonly SemaphoreSlim _opening = new(1, 1); private BrowserRemoteViewConnection? _current; private bool _shuttingDown; @@ -30,41 +33,70 @@ internal sealed class BrowserRemoteViewHost(ChromiumBrowser browser, BrowserUseT : "Il browser di Febe si sta avviando: riprova fra qualche secondo."); } - BrowserRemoteViewConnection? previous; - lock (_gate) + // From the look at the current view to the new one in its place, one opening at a time: two views opened at once + // would both start and the later assignment would orphan the other (still holding its lease, and stopping the + // shared screencast when it closes). + await _opening.WaitAsync(ct).ConfigureAwait(false); + try { - if (_shuttingDown) + BrowserRemoteViewConnection? previous; + lock (_gate) { + if (_shuttingDown) + { + throw new RemoteViewUnavailableException("Febe si sta fermando."); + } + + previous = _current; + _current = null; + } + + if (previous is not null) + { + await previous.EndAsync(RemoteViewEnd.Replaced).ConfigureAwait(false); + } + + var connection = new BrowserRemoteViewConnection(this, browser, tracker, clock); + try + { + await connection.StartAsync(browser.BrowserOptions.WindowWidth, browser.BrowserOptions.WindowHeight, ct).ConfigureAwait(false); + } + catch (Exception ex) + { + // Whatever went wrong (the page gone away, an unexpected frame tree), nothing of the view stays behind: + // no lease, no screencast, no subscription. + await connection.DisposeAsync().ConfigureAwait(false); + if (ex is CdpDisconnectedException or BrowserUnavailableException or CdpCommandException or TimeoutException) + { + throw new RemoteViewUnavailableException("Il browser di Febe non risponde: riprova fra qualche secondo.", ex); + } + + throw; + } + + bool stopping; + lock (_gate) + { + stopping = _shuttingDown; + if (!stopping) + { + _current = connection; + } + } + + if (stopping) + { + await connection.EndAsync(RemoteViewEnd.ShuttingDown).ConfigureAwait(false); throw new RemoteViewUnavailableException("Febe si sta fermando."); } - previous = _current; - _current = null; + log.Info("vista", "Vista remota aperta: il motore resta fermo finché è aperta."); + return connection; } - - if (previous is not null) + finally { - await previous.EndAsync(RemoteViewEnd.Replaced).ConfigureAwait(false); + _opening.Release(); } - - var connection = new BrowserRemoteViewConnection(this, browser, tracker, clock); - try - { - await connection.StartAsync(browser.BrowserOptions.WindowWidth, browser.BrowserOptions.WindowHeight, ct).ConfigureAwait(false); - } - catch (Exception ex) when (ex is CdpDisconnectedException or BrowserUnavailableException or CdpCommandException or TimeoutException) - { - await connection.DisposeAsync().ConfigureAwait(false); - throw new RemoteViewUnavailableException("Il browser di Febe non risponde: riprova fra qualche secondo.", ex); - } - - lock (_gate) - { - _current = connection; - } - - log.Info("vista", "Vista remota aperta: il motore resta fermo finché è aperta."); - return connection; } /// Febe is stopping: the open view is closed with a reason the page can show. diff --git a/src/Febe.Web/Connection/RemoteViewSocket.cs b/src/Febe.Web/Connection/RemoteViewSocket.cs index 0d2c3e4..8751e13 100644 --- a/src/Febe.Web/Connection/RemoteViewSocket.cs +++ b/src/Febe.Web/Connection/RemoteViewSocket.cs @@ -28,6 +28,15 @@ public static class RemoteViewSocket /// Close code when the browser stopped or is restarting. public const int CloseBrowserStopped = 4002; + /// How often the server pings the page. + public static readonly TimeSpan KeepAliveInterval = TimeSpan.FromSeconds(20); + + /// + /// How long a ping may stay unanswered: a page that vanished without closing (laptop lid, lost Wi-Fi) is dropped + /// then, and with it the «Alberto is driving» lease of its view, instead of when TCP gives up many minutes later. + /// + public static readonly TimeSpan KeepAliveTimeout = TimeSpan.FromSeconds(30); + public static void Map(IEndpointRouteBuilder endpoints) { ArgumentNullException.ThrowIfNull(endpoints); @@ -69,15 +78,21 @@ public static class RemoteViewSocket await using (connection.ConfigureAwait(false)) { - using var socket = await context.WebSockets.AcceptWebSocketAsync(new WebSocketAcceptContext - { - KeepAliveInterval = TimeSpan.FromSeconds(20), - DangerousEnableCompression = false, - }).ConfigureAwait(false); + using var socket = await context.WebSockets.AcceptWebSocketAsync(AcceptContext()).ConfigureAwait(false); await RunAsync(socket, connection, context.RequestAborted).ConfigureAwait(false); } } + /// + /// Pings with a timeout: with an interval alone ASP.NET Core sends unsolicited pongs and never notices a dead page. + /// + internal static WebSocketAcceptContext AcceptContext() => new() + { + KeepAliveInterval = KeepAliveInterval, + KeepAliveTimeout = KeepAliveTimeout, + DangerousEnableCompression = false, + }; + /// Pumps one view until either side closes it. internal static async Task RunAsync(WebSocket socket, IRemoteViewConnection connection, CancellationToken aborted) { diff --git a/tests/Febe.Tests/Collection/SignalOwnershipTests.cs b/tests/Febe.Tests/Collection/SignalOwnershipTests.cs new file mode 100644 index 0000000..e2d658a --- /dev/null +++ b/tests/Febe.Tests/Collection/SignalOwnershipTests.cs @@ -0,0 +1,40 @@ +using Febe.Core.Abstractions; +using Febe.Core.Collection; +using Febe.Tests.Browser.TestSupport; + +namespace Febe.Tests.Collection; + +/// +/// Rule 7 of §2 against §7.6: the pages Alberto opens while he drives and no session runs — the login of «Accedi a +/// Instagram», a verification he completes — are not the page «going back to the login»; Instagram's own answers +/// (status, text) still are signals. +/// +[TestClass] +public sealed class SignalOwnershipTests +{ + [TestMethod] + public void PathRulesAreNotSignalsWhileThePageIsAlbertos() + { + var clock = new VirtualClock(); + var breaker = new RecordingBreaker(); + var albertos = true; + var detector = new SignalDetector(SignalRules.LoadDefault(), breaker, clock, TimeSpan.Zero) { UserOwnsPage = () => albertos }; + NavigationDescriptor Nav(string path) => new(HostKind.Site, "https://www.instagram.com" + path, "www.instagram.com", path, clock.Now); + ResponseDescriptor Document(string path, int status) => + new("1", HostKind.Site, "https://www.instagram.com" + path, "www.instagram.com", path, status, "text/html", "Document", true, clock.Now); + + Assert.IsNull(detector.ObserveNavigation(Nav("/accounts/login/"))); + Assert.IsNull(detector.ObserveNavigation(Nav("/challenge/AbC123/"))); + Assert.IsNull(detector.ObserveResponse(Document("/accounts/login/", 200))); + Assert.IsEmpty(breaker.Signals); + + // Instagram's own answers keep counting: a 429 is a 429 whoever loaded the page. + Assert.AreEqual(SignalLevel.Throttle, detector.ObserveResponse(Document("/accounts/login/", 429))?.Level); + Assert.IsFalse(detector.ObserveSessionCookie(false) is null, "the recipes' cookie check is not a path rule"); + + // The engine's page (Alberto not at the browser, or a session running): the same addresses are signals. + albertos = false; + Assert.AreEqual(SignalLevel.Disconnect, detector.ObserveNavigation(Nav("/accounts/login/"))?.Level); + Assert.AreEqual(SignalLevel.Challenge, detector.ObserveResponse(Document("/challenge/AbC123/", 200))?.Level); + } +} diff --git a/tests/Febe.Tests/Desktop/ConnectionLifecycleTests.cs b/tests/Febe.Tests/Desktop/ConnectionLifecycleTests.cs new file mode 100644 index 0000000..4624ccf --- /dev/null +++ b/tests/Febe.Tests/Desktop/ConnectionLifecycleTests.cs @@ -0,0 +1,188 @@ +using System.Net; +using Febe.App; +using Febe.Core.Abstractions; +using Febe.Core.Collection; +using Febe.Core.Engine; +using Febe.Core.Storage; +using Febe.Tests.Desktop.Support; +using Febe.Tests.Support; + +namespace Febe.Tests.Desktop; + +/// +/// The link to Instagram in the shared composition (spec §4.1, §7.6, rule 7 of §2), with the real Instagram rules of +/// segnali.json and a fake browser that only answers by itself: the pages Alberto opens are not stop signals, a +/// session lost outside a session is a disconnection, and the «driving» lease of the connection page does not outlive +/// the browser window. Never Instagram. +/// +[TestClass] +public sealed class ConnectionLifecycleTests +{ + public TestContext TestContext { get; set; } = null!; + + [TestMethod] + [Timeout(60_000, CooperativeCancellation = true)] + public async Task TheLoginPageAlbertoOpensIsNotADisconnectionButTheEnginesPageGoingBackToItIs() + { + var ct = TestContext.CancellationToken; + await using var bed = await DesktopTestBed.StartAsync(); + await bed.App.Running.WaitAsync(TimeSpan.FromSeconds(20), ct); + var browser = bed.Browser!; + var breaker = bed.App.Engine!.Services.Breaker; + + // «Accedi a Instagram»: the real login page, which segnali.json calls «login-url» (a disconnection). + using (var begin = await bed.SendAsync(HttpMethod.Post, "/api/connection/begin", """{"openLogin":true}""")) + { + Assert.AreEqual(HttpStatusCode.NoContent, begin.StatusCode); + } + + Assert.AreEqual("https://www.instagram.com/accounts/login/", browser.FakeCdp.Url); + + // Instagram asks the new device to confirm during his login: his to complete, not the engine's (rule 7). + browser.FakeCdp.Navigated("https://www.instagram.com/challenge/AbC123/"); + await breaker.FlushAsync(); + Assert.AreEqual(BreakerStatus.Closed, breaker.State.Status, "the pages Alberto opens are not stop signals"); + Assert.IsEmpty(await bed.App.Database.Incidents.ListOpenAsync(ct)); + + browser.FakeCdp.LoggedIn = true; + var finish = await bed.JsonAsync(HttpMethod.Post, "/api/connection/finish"); + Assert.IsTrue(finish.GetProperty("connected").GetBoolean()); + Assert.DoesNotContain("Riprendi", finish.GetProperty("message").GetString()!, "nothing to resume after a plain login"); + + // Without Alberto at the browser, the same address is the page going back to the login (§7.6). + browser.FakeCdp.Navigated("https://www.instagram.com/accounts/login/"); + await breaker.FlushAsync(); + Assert.AreEqual(BreakerStatus.Disconnected, breaker.State.Status); + Assert.AreEqual("login-url", (await bed.App.Database.Incidents.ListOpenAsync(ct)).Single().Signal); + } + + [TestMethod] + [Timeout(90_000, CooperativeCancellation = true)] + public async Task ASessionLostOutsideASessionStopsTheEngineUntilResumeButScollegaDoesNot() + { + var ct = TestContext.CancellationToken; + using var temp = new TempFolder("collegamento"); + var locations = new MemoryLocationStore(); + await using (var bed = await DesktopTestBed.StartAsync(temp: temp, locations: locations)) + { + await bed.App.Running.WaitAsync(TimeSpan.FromSeconds(20), ct); + var engine = bed.App.Engine!; + var breaker = engine.Services.Breaker; + await breaker.FlushAsync(); + Assert.AreEqual(BreakerStatus.Closed, breaker.State.Status, "never connected: no session is no news"); + + await LoginAsync(bed); + + // The page at rest, Alberto away: the session cookie goes (expired, dropped by Instagram). The background + // check notices: a disconnection, with its incident and its line in Attività (the alert follows it). + bed.Browser!.FakeCdp.LoggedIn = false; + await bed.App.Connection!.RefreshAsync(ct); + await breaker.FlushAsync(); + Assert.AreEqual(BreakerStatus.Disconnected, breaker.State.Status); + Assert.AreEqual(SignalRules.SessionCookieMissingCode, (await bed.App.Database.Incidents.ListOpenAsync(ct)).Single().Signal); + var events = await bed.App.Database.Events.ListAsync(new EventQuery(), ct); + Assert.IsTrue(events.Any(e => e.Code == EngineEventCodes.DisconnectStop), "the «disconnessione» line that the alerts follow"); + Assert.AreEqual("verificationRequired", (await bed.JsonAsync(HttpMethod.Get, "/api/connection")).GetProperty("state").GetString()); + + // A new login is not enough: «Riprendi», with the gradual start, restarts the engine. + var again = await LoginAsync(bed); + StringAssert.Contains(again, "premi «Riprendi»"); + Assert.IsTrue((await engine.ResumeAsync(ct)).Resumed); + Assert.AreEqual(BreakerStatus.Closed, breaker.State.Status); + await bed.StopAsync(); + } + + // Next start: the profile lost the session meanwhile (a crash, S3). It had been connected: a disconnection. + await using (var bed = await DesktopTestBed.StartAsync(temp: temp, locations: locations)) + { + await bed.App.Running.WaitAsync(TimeSpan.FromSeconds(20), ct); + var engine = bed.App.Engine!; + await engine.Services.Breaker.FlushAsync(); + Assert.AreEqual(BreakerStatus.Disconnected, engine.Services.Breaker.State.Status, "missing at start-up after a connection"); + Assert.IsTrue((await engine.ResumeAsync(ct)).Resumed); + + // «Scollega»: the session goes because Alberto wants so. Not a disconnection, now or at the next start. + await LoginAsync(bed); + using (var disconnect = await bed.SendAsync(HttpMethod.Post, "/api/connection/disconnect")) + { + Assert.AreEqual(HttpStatusCode.NoContent, disconnect.StatusCode); + } + + await bed.App.Connection!.RefreshAsync(ct); + await engine.Services.Breaker.FlushAsync(); + Assert.AreEqual(BreakerStatus.Closed, engine.Services.Breaker.State.Status); + Assert.AreEqual("notConnected", (await bed.JsonAsync(HttpMethod.Get, "/api/connection")).GetProperty("state").GetString()); + await bed.StopAsync(); + } + + await using (var bed = await DesktopTestBed.StartAsync(temp: temp, locations: locations)) + { + await bed.App.Running.WaitAsync(TimeSpan.FromSeconds(20), ct); + await bed.App.Engine!.Services.Breaker.FlushAsync(); + Assert.AreEqual(BreakerStatus.Closed, bed.App.Engine.Services.Breaker.State.Status, "after «Scollega» a missing session is expected"); + Assert.IsEmpty(await bed.App.Database.Incidents.ListOpenAsync(ct)); + await bed.StopAsync(); + } + } + + [TestMethod] + [Timeout(60_000, CooperativeCancellation = true)] + public async Task TheConnectionLeaseEndsSoonAfterTheBrowserWindowWithoutHoFinito() + { + var ct = TestContext.CancellationToken; + await using var bed = await DesktopTestBed.StartAsync(); + await bed.App.Running.WaitAsync(TimeSpan.FromSeconds(20), ct); + var browser = bed.Browser!; + var connection = bed.App.Connection!; + connection.DrivingGrace = TimeSpan.FromMilliseconds(500); + await LoginAsync(bed); + + // «Usa il browser»: the window comes to the front, Alberto is driving. + using (var begin = await bed.SendAsync(HttpMethod.Post, "/api/connection/begin", """{"openLogin":false}""")) + { + Assert.AreEqual(HttpStatusCode.NoContent, begin.StatusCode); + } + + Assert.IsTrue(browser.UserIsDriving); + Assert.IsTrue(bed.App.Engine!.Services.Runtime.UserIsDriving); + + // While the window is in front the lease holds, however long he takes. + await Task.Delay(TimeSpan.FromSeconds(1.5), ct); + Assert.IsTrue(browser.UserIsDriving, "the window is in front: Alberto is still driving"); + + // He closes the window with its X (WebView2Host.Done: the window's own lease ends), no «Ho finito». + int Navigations() => browser.FakeCdp.Methods.Count(m => m == "Page.navigate"); + var navigations = Navigations(); + await browser.HideFromUserAsync(ct); + await DesktopTestBed.WaitUntilAsync(() => !browser.UserIsDriving, TimeSpan.FromSeconds(10), "la fine della guida dopo la chiusura della finestra"); + Assert.IsFalse(bed.App.Engine.Services.Runtime.UserIsDriving, "the engine may work again"); + + // The engine puts back to rest whatever he left open (§6.1). + await DesktopTestBed.WaitUntilAsync(() => Navigations() > navigations, TimeSpan.FromSeconds(10), "la pagina di riposo"); + Assert.AreEqual("about:blank", browser.FakeCdp.Url); + + // A late «Annulla» from a page left open does nothing to the page, which is the engine's again. + navigations = Navigations(); + using (var cancel = await bed.SendAsync(HttpMethod.Post, "/api/connection/cancel")) + { + Assert.AreEqual(HttpStatusCode.NoContent, cancel.StatusCode); + } + + Assert.AreEqual(navigations, Navigations()); + Assert.IsFalse(browser.UserIsDriving); + } + + /// «Accedi a Instagram», Alberto logs in, «Ho finito». Returns the message of «Ho finito». + private static async Task LoginAsync(DesktopTestBed bed) + { + using (var begin = await bed.SendAsync(HttpMethod.Post, "/api/connection/begin", """{"openLogin":true}""")) + { + Assert.AreEqual(HttpStatusCode.NoContent, begin.StatusCode); + } + + bed.Browser!.FakeCdp.LoggedIn = true; + var finish = await bed.JsonAsync(HttpMethod.Post, "/api/connection/finish"); + Assert.IsTrue(finish.GetProperty("connected").GetBoolean(), finish.GetProperty("message").GetString()); + return finish.GetProperty("message").GetString()!; + } +} diff --git a/tests/Febe.Tests/Desktop/Support/FakeDesktopShell.cs b/tests/Febe.Tests/Desktop/Support/FakeDesktopShell.cs index e155f56..293a5f0 100644 --- a/tests/Febe.Tests/Desktop/Support/FakeDesktopShell.cs +++ b/tests/Febe.Tests/Desktop/Support/FakeDesktopShell.cs @@ -202,15 +202,28 @@ internal sealed class FakeBrowser : IFebeBrowser } } -/// A CDP session answering like a page: frame tree, navigation, the session cookie (name only). +/// +/// A CDP session answering like a page: frame tree, navigation (with its Page.frameNavigated event, as the +/// collection pipeline hears it), the session cookie (name only). +/// internal sealed class FakeCdp : ICdpSession { + private readonly Lock _gate = new(); + private readonly Dictionary>> _handlers = new(StringComparer.Ordinal); + public bool LoggedIn { get; set; } public string Url { get; private set; } = "about:blank"; public ConcurrentQueue Methods { get; } = new(); + /// The main frame moved to by itself (a redirect of the site), not by a command. + public void Navigated(string url) + { + Url = url; + Raise("Page.frameNavigated", new JsonObject { ["frame"] = new JsonObject { ["id"] = "F1", ["url"] = url } }); + } + public Task SendAsync(string method, object? parameters = null, CancellationToken ct = default) { CdpCommandPolicy.EnsureAllowed(method); @@ -225,18 +238,57 @@ internal sealed class FakeCdp : ICdpSession return Task.FromResult(JsonDocument.Parse(result.ToJsonString()).RootElement.Clone()); } - public IDisposable On(string eventName, Action handler) => new Nothing(); + public IDisposable On(string eventName, Action handler) + { + lock (_gate) + { + if (!_handlers.TryGetValue(eventName, out var list)) + { + _handlers[eventName] = list = []; + } + + list.Add(handler); + } + + return new Removal(() => + { + lock (_gate) + { + _handlers[eventName].Remove(handler); + } + }); + } private JsonObject Navigate(object? parameters) { - Url = (parameters as JsonObject)?["url"]?.GetValue() ?? Url; + var url = (parameters as JsonObject)?["url"]?.GetValue(); + if (url is not null) + { + Navigated(url); + } + return new JsonObject { ["frameId"] = "F1" }; } - private sealed class Nothing : IDisposable + private void Raise(string eventName, JsonObject parameters) { - public void Dispose() + Action[] handlers; + lock (_gate) { + handlers = _handlers.TryGetValue(eventName, out var list) ? [.. list] : []; + } + + var element = JsonDocument.Parse(parameters.ToJsonString()).RootElement.Clone(); + foreach (var handler in handlers) + { + handler(element); } } + + private sealed class Removal(Action remove) : IDisposable + { + private Action? _remove = remove; + + public void Dispose() => Interlocked.Exchange(ref _remove, null)?.Invoke(); + } } diff --git a/tests/Febe.Tests/Engine/EngineHostTests.cs b/tests/Febe.Tests/Engine/EngineHostTests.cs index b7abe54..79a9e70 100644 --- a/tests/Febe.Tests/Engine/EngineHostTests.cs +++ b/tests/Febe.Tests/Engine/EngineHostTests.cs @@ -470,4 +470,141 @@ public sealed class EngineHostTests Assert.AreEqual(CheckNowStatus.Refused, result.Status); StringAssert.Contains(result.Message, "tetto giornaliero"); } + + [TestMethod] + public async Task WhenAlbertoLetsGoOfTheBrowserThePageGoesBackToRestUnlessAVerificationKeepsIt() + { + var driving = false; + await using var bed = await EngineTestBed.CreateAsync(Morning, userIsDriving: () => driving); + await bed.AddAccountAsync("uno.demo", followed: true); + await bed.AddAccountAsync("due.demo", followed: false, Frequency.High); + var runner = new ScriptedRunner(bed.Governor, bed.Clock); + EngineHost? host = null; + int? restsWhenTaken = null; + + // He takes the browser in the middle of a recipe (a story viewer may be open): the session ends and leaves the + // page to him. + runner.Before = r => + { + if (restsWhenTaken is null && r.Kind != RecipeKind.FollowingSweep) + { + restsWhenTaken = runner.Rests; + driving = true; + host!.NotifyUserDrivingChanged(); + } + + return Task.CompletedTask; + }; + host = bed.Start(runner); + await bed.RunUntilAsync(EngineTestBed.Local(2026, 10, 14, 12, 0)); + Assert.IsNotNull(restsWhenTaken, "Alberto took the browser during a session."); + Assert.AreEqual(restsWhenTaken, runner.Rests, "While he drives the page is his."); + + // He lets go during a pause: nothing starts, but nothing of what was open stays on the site either (§6.1, §6.3). + await host.PauseAsync(); + driving = false; + host.NotifyUserDrivingChanged(); + await bed.RunForAsync(TimeSpan.FromSeconds(1)); + Assert.AreEqual(restsWhenTaken + 1, runner.Rests, "Back to rest as soon as he lets go."); + + // After a verification the page stays as it is until «Riprendi» (§7.6), also when he lets go. + bed.Breaker.Report(new Signal(SignalLevel.Challenge, "challenge-url", "https://sito.prova/challenge", bed.Clock.Now)); + await bed.Breaker.FlushAsync(); + driving = true; + host.NotifyUserDrivingChanged(); + await bed.RunForAsync(TimeSpan.FromMinutes(5)); + driving = false; + host.NotifyUserDrivingChanged(); + await bed.RunForAsync(TimeSpan.FromMinutes(5)); + Assert.AreEqual(restsWhenTaken + 1, runner.Rests, "The verification page is left as it is."); + } + + [TestMethod] + public async Task ChangingTheAccountsDuringARecipeDoesNotBringItsNextCheckForward() + { + await using var bed = await EngineTestBed.CreateAsync(Morning); + var watched = await bed.AddAccountAsync("uno.demo", followed: false, Frequency.Low, types: ContentTypes.PostPhotos | ContentTypes.PostVideos); + await bed.AddAccountAsync("due.demo", followed: false, Frequency.Low, types: ContentTypes.PostPhotos | ContentTypes.PostVideos); + var runner = new ScriptedRunner(bed.Governor, bed.Clock); + EngineHost? host = null; + DateTimeOffset? checkedAt = null; + + // While the profile check of uno.demo runs (its task is «Running»), Alberto saves the settings of an account. + runner.Before = async r => + { + if (checkedAt is null && r.Kind == RecipeKind.ProfileCheck && r.AccountId == watched.Id) + { + checkedAt = bed.Clock.Now; + await host!.NotifyAccountsChangedAsync(); + } + }; + host = bed.Start(runner); + await bed.RunUntilAsync(Morning.AddDays(1)); + + Assert.IsNotNull(checkedAt); + var visits = runner.Runs + .Where(r => r.Request.Kind == RecipeKind.ProfileCheck && r.Request.AccountId == watched.Id && r.Status == RecipeStatus.Completed) + .Select(r => r.At) + .ToList(); + + // «Bassa», not followed: about every 12 hours, never sooner than 0.6 × 12 h. + for (var i = 1; i < visits.Count; i++) + { + Assert.IsTrue(visits[i] - visits[i - 1] >= TimeSpan.FromHours(7), $"Visit after {visits[i] - visits[i - 1]}: the interval of the frequency holds."); + } + + var pending = (await bed.Db.Tasks.ListPendingAsync(1000)) + .Where(t => t.Kind == EngineTaskKind.ProfileCheck && t.AccountId == watched.Id) + .ToList(); + Assert.HasCount(1, pending, "One planned check, not a second one from the queue sync."); + Assert.IsTrue(pending[0].DueAt >= visits[^1] + TimeSpan.FromHours(7), $"Next check at {pending[0].DueAt:O}, after {visits[^1]:O}."); + } + + [TestMethod] + public async Task HighlightCollectionsAreLookedAtOncePerIntervalAndNoLongerOnceGone() + { + await using var bed = await EngineTestBed.CreateAsync(Morning); + var account = await bed.AddAccountAsync("uno.demo", followed: true, Frequency.High); + await bed.Db.Highlights.UpsertAsync(new Highlight { AccountId = account.Id, InstagramId = "17900000001", Title = "Viaggi", DiscoveredAt = Morning }); + var food = await bed.Db.Highlights.UpsertAsync(new Highlight { AccountId = account.Id, InstagramId = "17900000002", Title = "Cucina", Position = 1, DiscoveredAt = Morning }); + var noStories = await bed.AddAccountAsync("due.demo", followed: true, Frequency.High, types: ContentTypes.PostPhotos); + await bed.Db.Highlights.UpsertAsync(new Highlight { AccountId = noStories.Id, InstagramId = "17900000003", Title = "Altro", DiscoveredAt = Morning }); + var runner = new ScriptedRunner(bed.Governor, bed.Clock); + + // Like the real recipe: the collection is marked as looked at. + runner.Before = async r => + { + if (r.Kind == RecipeKind.Highlight && await bed.Db.Highlights.FindAsync(account.Id, r.HighlightId!) is { } highlight) + { + await bed.Db.Highlights.UpsertAsync(highlight with { LastCheckedAt = bed.Clock.Now }); + } + }; + bed.Start(runner); + await bed.RunUntilAsync(Morning.AddDays(3)); + + List Looks(string id) => [.. runner.Runs.Where(r => r.Request.Kind == RecipeKind.Highlight && r.Request.HighlightId == id)]; + foreach (var id in new[] { "17900000001", "17900000002" }) + { + var looks = Looks(id); + Assert.IsNotEmpty(looks, $"Collection {id} of an account that wants «Storie in evidenza» is looked at."); + Assert.IsTrue(looks.All(l => l.Request.AccountId == account.Id)); + for (var i = 1; i < looks.Count; i++) + { + // «Alta»: every 24 hours or so, never sooner than 0.6 × 24 h. + Assert.IsTrue(looks[i].At - looks[i - 1].At >= TimeSpan.FromHours(14), $"Look after {looks[i].At - looks[i - 1].At}."); + } + } + + Assert.IsEmpty(Looks("17900000003"), "«Storie in evidenza» off: not looked at."); + var all = runner.Runs.Where(r => r.Request.Kind == RecipeKind.Highlight).ToList(); + Assert.AreEqual(all.Count, all.Select(r => r.SessionId).Distinct().Count(), "One collection per account and session."); + + // A collection that left the profile is no longer looked at; the other one still is. + await bed.Db.Highlights.MarkRemovedAsync(food.Id, bed.Clock.Now); + var foodLooks = Looks("17900000002").Count; + var travelLooks = Looks("17900000001").Count; + await bed.RunUntilAsync(Morning.AddDays(6)); + Assert.HasCount(foodLooks, Looks("17900000002")); + Assert.IsTrue(Looks("17900000001").Count > travelLooks); + } } diff --git a/tests/Febe.Tests/Engine/Support/ScriptedRunner.cs b/tests/Febe.Tests/Engine/Support/ScriptedRunner.cs index 43f620a..2fba9e4 100644 --- a/tests/Febe.Tests/Engine/Support/ScriptedRunner.cs +++ b/tests/Febe.Tests/Engine/Support/ScriptedRunner.cs @@ -22,6 +22,12 @@ internal sealed class ScriptedRunner(IGovernor governor, IClock clock) : IRecipe /// Called after the counted action was granted (e.g. to report a signal). public Action? AfterGrant { get; set; } + /// + /// Awaited when a recipe starts, while its task is running (e.g. what the real recipe writes, or a command of + /// Alberto arriving meanwhile). + /// + public Func? Before { get; set; } + /// Accounts the stories bar flags in every sweep. public IReadOnlyList FlaggedStories { get; set; } = []; @@ -43,6 +49,11 @@ internal sealed class ScriptedRunner(IGovernor governor, IClock clock) : IRecipe RecipeOutcome outcome; try { + if (Before is { } before) + { + await before(request); + } + outcome = Script?.Invoke(request) ?? await DefaultAsync(request, ct); } catch (OperationCanceledException) diff --git a/tests/Febe.Tests/Engine/VirtualClockTests.cs b/tests/Febe.Tests/Engine/VirtualClockTests.cs index dcf1512..4174a68 100644 --- a/tests/Febe.Tests/Engine/VirtualClockTests.cs +++ b/tests/Febe.Tests/Engine/VirtualClockTests.cs @@ -81,6 +81,71 @@ public sealed class VirtualClockTests await Assert.ThrowsAsync(() => clock.RunUntilAsync(Start.AddHours(1), CancellationToken.None, actor)); } + [TestMethod] + public async Task ATimerCancelledFromThePoolNeverEndsTheRunEarly() + { + // As EngineHost.OnBreakerChanged does: a pool thread cancels the actor's pending timer (here as soon as it is + // registered, so that it often lands between the driver's look at the actors and its decision). + for (var i = 0; i < 20_000; i++) + { + var clock = new VirtualClock(Start); + using var session = new CancellationTokenSource(); + using var end = new CancellationTokenSource(); + var oneMinuteLater = false; + var stop = 0; + Task? canceller = null; + async Task Actor() + { + canceller = Task.Run(() => + { + while (clock.PendingTimers == 0 && Volatile.Read(ref stop) == 0) + { + Thread.SpinWait(20); + } + + session.Cancel(); + }); + try + { + await clock.Delay(TimeSpan.FromSeconds(5), session.Token); + } + catch (OperationCanceledException) + { + } + + await clock.Delay(TimeSpan.FromMinutes(1), CancellationToken.None); + oneMinuteLater = true; + await clock.Delay(TimeSpan.FromDays(10), end.Token); + } + + var actor = Actor(); + bool reached; + DateTimeOffset at; + try + { + await clock.RunUntilAsync(Start.AddHours(1), CancellationToken.None, actor); + reached = Volatile.Read(ref oneMinuteLater); + at = clock.Now; + } + finally + { + // Lets the actor end in every case (also when the driver left it behind), so nothing keeps running. + Volatile.Write(ref stop, 1); + await canceller!; + await end.CancelAsync(); + for (var spin = 0; !actor.IsCompleted && spin < 1000; spin++) + { + clock.AdvanceTo(clock.Now.AddDays(1)); + await Task.WhenAny(actor, Task.Delay(1)); + } + } + + Assert.IsTrue(reached, $"Run {i}: the driver returned while the actor was running, and skipped its timer."); + Assert.AreEqual(Start.AddHours(1), at); + Assert.IsTrue(actor.IsCanceled, $"Run {i}: the actor ends on its last timer, cancelled here."); + } + } + [TestMethod] public async Task AutoAdvanceMovesTimeAtOnceAndRoundsToMilliseconds() { diff --git a/tests/Febe.Tests/Server/RemoteViewSocketTests.cs b/tests/Febe.Tests/Server/RemoteViewSocketTests.cs index e0bb645..e0af551 100644 --- a/tests/Febe.Tests/Server/RemoteViewSocketTests.cs +++ b/tests/Febe.Tests/Server/RemoteViewSocketTests.cs @@ -129,6 +129,39 @@ public sealed class RemoteViewSocketTests Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode); } + [TestMethod] + public void TheServerPingsThePageAndGivesUpOnOneThatStopsAnswering() + { + // With an interval alone ASP.NET Core sends unsolicited pongs and never notices a page that vanished. + var accept = RemoteViewSocket.AcceptContext(); + Assert.AreEqual(RemoteViewSocket.KeepAliveInterval, accept.KeepAliveInterval); + Assert.IsNotNull(accept.KeepAliveTimeout, "a ping must have a deadline"); + Assert.IsTrue(accept.KeepAliveTimeout > TimeSpan.Zero && accept.KeepAliveTimeout <= TimeSpan.FromMinutes(1), $"{accept.KeepAliveTimeout}"); + Assert.IsFalse(accept.DangerousEnableCompression); + } + + [TestMethod] + [Timeout(30_000, CooperativeCancellation = true)] + public async Task AViewWhosePageVanishedEndsWhenItsPingGoesUnanswered() + { + // The same keep-alive as the server, with short times: the page's machine went to sleep (it never answers). + using var listener = new System.Net.Sockets.TcpListener(IPAddress.Loopback, 0); + listener.Start(); + using var page = new System.Net.Sockets.TcpClient(); + await page.ConnectAsync(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndpoint).Port, TestContext.CancellationToken); + using var accepted = await listener.AcceptTcpClientAsync(TestContext.CancellationToken); + using var socket = WebSocket.CreateFromStream(accepted.GetStream(), new WebSocketCreationOptions + { + IsServer = true, + KeepAliveInterval = TimeSpan.FromMilliseconds(200), + KeepAliveTimeout = TimeSpan.FromMilliseconds(300), + }); + var view = new FakeRemoteViewConnection(); + var run = RemoteViewSocket.RunAsync(socket, view, CancellationToken.None); + Assert.AreSame(run, await Task.WhenAny(run, Task.Delay(TimeSpan.FromSeconds(10), TestContext.CancellationToken)), "the view ends by itself"); + await run; + } + [TestMethod] public void KeysGetTheVirtualCodesChromiumNeeds() { diff --git a/tests/Febe.Tests/Server/ServerEndToEndTests.cs b/tests/Febe.Tests/Server/ServerEndToEndTests.cs index bcfa65d..fb69719 100644 --- a/tests/Febe.Tests/Server/ServerEndToEndTests.cs +++ b/tests/Febe.Tests/Server/ServerEndToEndTests.cs @@ -240,6 +240,62 @@ public sealed partial class ServerEndToEndTests Assert.IsTrue(Febe.Browser.Hosting.LoopbackPortCheck.IsLoopbackOnly(bed.Options.DebugPort, out _)); } + [TestMethod] + [Timeout(120_000, CooperativeCancellation = true)] + public async Task TwoViewsOpenedAtTheSameMomentLeaveOneViewWithItsFramesAndOneLease() + { + var ct = TestContext.CancellationToken; + await using var bed = await ServerTestBed.StartAsync(); + var server = bed.Server; + await server.Running.WaitAsync(TimeSpan.FromSeconds(60), ct); + var host = server.RemoteView!; + var gate = server.Browser!.UserDriving; + for (var round = 0; round < 5; round++) + { + // From the rest page: where the browser starts, and where the engine puts it once nobody is at the browser. + await ServerTestBed.WaitUntilAsync( + async () => await Febe.Browser.Cdp.CdpPageExtensions.GetMainFrameUrlAsync(server.Browser.Cdp, ct) == "about:blank", + TimeSpan.FromSeconds(20), + "la pagina di riposo"); + + // Two tabs restored together, or the phone and the PC at once: the newest wins, the other is ended. + var views = await Task.WhenAll(Task.Run(() => host.OpenAsync(ct), ct), Task.Run(() => host.OpenAsync(ct), ct)); + var open = views.Where(v => v.Ended is null).ToList(); + Assert.HasCount(1, open, $"Round {round}: one view stays open."); + Assert.AreEqual(RemoteViewEnd.Replaced, views.Single(v => v.Ended is not null).Ended); + Assert.AreEqual(1, gate.Leases, $"Round {round}: only the open view holds the browser."); + + // The page of the replaced view closes its socket: the open view still gets its frames. + await views.Single(v => v.Ended is not null).DisposeAsync(); + await Febe.Browser.Cdp.CdpPageExtensions.NavigateAsync(server.Browser.Cdp, $"{bed.Site.SiteUrl}/?giro={round}", ct); + Assert.IsTrue(await FrameArrivesAsync(open[0], ct), $"Round {round}: frames go on after the other view closed."); + + await open[0].DisposeAsync(); + Assert.AreEqual(0, gate.Leases, $"Round {round}: no view, no lease."); + } + } + + private static async Task FrameArrivesAsync(IRemoteViewConnection view, CancellationToken ct) + { + using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct); + timeout.CancelAfter(TimeSpan.FromSeconds(15)); + try + { + await foreach (var output in view.ReadAsync(timeout.Token)) + { + if (output is RemoteViewFrame) + { + return true; + } + } + } + catch (OperationCanceledException) when (!ct.IsCancellationRequested) + { + } + + return false; + } + private static async Task WaitRunningAsync(Febe.Server.FebeServer server) { for (var i = 0; i < 40 && !server.Engine!.Services.Runtime.IsRunning; i++)