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++)