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; using Febe.Web.Api; using Febe.Web.Connection; using Febe.Web.Engine; namespace Febe.App; /// /// The link to Instagram over the real browser, the same in both shells (spec §4.1, §10.3, PROTOCOLLO.md). «Collegato» /// means that the session cookie exists in the browser profile: only its existence is checked /// (Network.getCookies, names only), never its value. Opening the login page is Alberto's action, not the /// engine's (rule 7, last sentence): it happens only while he holds the «driving» lease and the engine is still. /// On Windows the browser is the window «Browser di Febe»: «Accedi» and «Portalo in primo piano» bring it to the front, /// «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); /// How often the cookie is looked at in the background (outside sessions it is the only way to notice). public static readonly TimeSpan BackgroundCheck = TimeSpan.FromSeconds(30); private readonly IFebeBrowser _browser; private readonly IFebeStorage _storage; private readonly BrowserUseTracker _tracker; private readonly IClock _clock; private readonly FebeLog _log; private readonly string _loginUrl; private readonly SessionCookieOptions _cookie; private readonly SemaphoreSlim _commands = new(1, 1); 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) { _browser = browser ?? throw new ArgumentNullException(nameof(browser)); _storage = storage ?? throw new ArgumentNullException(nameof(storage)); _tracker = tracker ?? throw new ArgumentNullException(nameof(tracker)); _clock = clock ?? throw new ArgumentNullException(nameof(clock)); _log = log ?? throw new ArgumentNullException(nameof(log)); _loginUrl = loginUrl ?? throw new ArgumentNullException(nameof(loginUrl)); _cookie = cookie ?? throw new ArgumentNullException(nameof(cookie)); } /// /// Whether the browser holds the session, from the last check (null before the first one). The engine reads it /// on every turn (): it never waits for the browser. /// public bool? IsConnected { get { lock (_gate) { return _connected; } } } /// /// Hook for the readers (hypothesis H10): when the data of the page tell which account is connected, the composition /// marks it as «Tu» (); the status shows that account. Raised after every change of the /// connection, so that whoever learns the account can look again. /// 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)); public async Task GetStatusAsync(CancellationToken ct) { var driving = _browser.UserIsDriving; if (!_browser.IsAvailable) { return new ConnectionStatus(ConnectionState.BrowserUnavailable, null, null, driving, null); } var breaker = _engine?.Services.Breaker.State.Status; var state = breaker is BreakerStatus.Challenge or BreakerStatus.Disconnected ? ConnectionState.VerificationRequired : await CheckAsync(force: false, mayReport: true, ct).ConfigureAwait(false) == true ? ConnectionState.Connected : ConnectionState.NotConnected; Account? mine = null; if (state != ConnectionState.NotConnected) { mine = await _storage.Accounts.GetMineAsync(ct).ConfigureAwait(false); } return new ConnectionStatus(state, mine?.Username, mine?.DisplayName, driving, await CurrentUrlAsync(ct).ConfigureAwait(false)); } public async Task BeginUserDrivingAsync(bool openLogin, CancellationToken ct) { EnsureBrowser(); await _commands.WaitAsync(ct).ConfigureAwait(false); try { lock (_gate) { 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); if (openLogin) { // The engine ends its session when the lease starts; wait for it before taking the page. A search step // in progress (issue #37) stops at its next check of the lease: the login page waits for its turn. await WaitForSessionEndAsync(ct).ConfigureAwait(false); using var turn = await TakePageAsync(ct).ConfigureAwait(false); var result = await _browser.Cdp.NavigateAsync(_loginUrl, ct).ConfigureAwait(false); _log.Info("collegamento", result.Succeeded ? "Alberto usa il browser: pagina di accesso aperta." : "Alberto usa il browser: la pagina di accesso non si è aperta (errore di rete del browser)."); } else { _log.Info("collegamento", "Alberto usa il browser."); } // Windows: the window «Browser di Febe» comes to the front (Docker: nothing, the remote view shows it). await ShowQuietlyAsync(ct).ConfigureAwait(false); } finally { _commands.Release(); } } public async Task FinishAsync(CancellationToken ct) { await _commands.WaitAsync(ct).ConfigureAwait(false); try { if (!_browser.IsAvailable) { ReleaseLease(); 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."); } // 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 RestIfAlbertosAsync().ConfigureAwait(false); await HideQuietlyAsync().ConfigureAwait(false); ReleaseLease(); var stopped = _engine?.Services.Breaker.State.Status is BreakerStatus.Challenge or BreakerStatus.Disconnected; string message; if (!connected) { message = "Febe non trova la sessione di Instagram nel browser: l'accesso non sembra completato. Riprova con «Accedi a Instagram» e premi «Ho finito» solo dopo aver visto la tua pagina iniziale."; } else if (stopped) { message = "Collegato. Febe è ancora fermo per la verifica o la disconnessione: premi «Riprendi» quando vuoi che ricominci."; } else if (first) { message = "Collegato a Instagram. Febe comincia fra qualche minuto, con calma: nei primi giorni i tetti sono ridotti (avvio graduale)."; } else { message = "Collegato a Instagram. Febe riprende da solo alla prossima sessione."; } _log.Info("collegamento", connected ? "«Ho finito»: sessione presente nel browser." : "«Ho finito»: sessione assente nel browser."); return new FinishResult(connected, message); } finally { _commands.Release(); } } public async Task CancelAsync(CancellationToken ct) { await _commands.WaitAsync(ct).ConfigureAwait(false); try { if (_browser.IsAvailable) { await RestIfAlbertosAsync().ConfigureAwait(false); await HideQuietlyAsync().ConfigureAwait(false); } ReleaseLease(); _log.Info("collegamento", "«Annulla»: il browser torna a riposo."); } finally { _commands.Release(); } } public async Task DisconnectAsync(CancellationToken ct) { await _commands.WaitAsync(ct).ConfigureAwait(false); 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) { await engine.StopAsync().ConfigureAwait(false); } // Windows: the browser window goes out of view and WebView2 closes before its folder is deleted. await HideQuietlyAsync().ConfigureAwait(false); Exception? failure = null; try { await _browser.RestartWithEmptyProfileAsync(ct).ConfigureAwait(false); SetConnected(false); } catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) { // A file of the profile stayed (Windows: a process of the browser held it). The engine starts again // anyway; whether the session is still there is checked again, never assumed. failure = ex; await RefreshAsync(CancellationToken.None).ConfigureAwait(false); } if (engine is not null) { if (failure is null) { await engine.Services.Events.WriteAsync( EventSeverity.Info, "collegamento.scollegato", "Scollegato da te: il profilo del browser con la sessione di Instagram è stato cancellato.", ct: CancellationToken.None).ConfigureAwait(false); } await engine.StartAsync(CancellationToken.None).ConfigureAwait(false); } if (failure is not null) { _log.Warn("collegamento", "«Scollega»: il profilo del browser non si è potuto cancellare del tutto.", failure); throw new BadRequestException("«Scollega» non è riuscito del tutto: " + failure.Message); } _log.Info("collegamento", "«Scollega»: motore fermo, profilo del browser cancellato, browser ripartito vuoto."); } finally { ReleaseLease(); hold.Dispose(); _commands.Release(); } } /// /// 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. 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) { if (!_browser.IsAvailable) { return IsConnected; } var connected = await CheckAsync(force: true, mayReport: true, ct).ConfigureAwait(false); if (connected == true) { await MarkConnectedAsync(ct).ConfigureAwait(false); } return connected; } /// The background check of the cookie, every , until cancelled. public async Task RunAsync(CancellationToken ct) { while (!ct.IsCancellationRequested) { try { await _clock.Delay(BackgroundCheck, ct).ConfigureAwait(false); if (!_browser.UserIsDriving) { await RefreshAsync(ct).ConfigureAwait(false); } } catch (OperationCanceledException) when (ct.IsCancellationRequested) { return; } catch (Exception ex) when (ex is CdpDisconnectedException or BrowserUnavailableException or CdpCommandException or TimeoutException or IOException) { // The browser is restarting: the next turn looks again. } } } public ValueTask DisposeAsync() { ReleaseLease(); _commands.Dispose(); return ValueTask.CompletedTask; } private async Task CheckAsync(bool force, bool mayReport, CancellationToken ct) { lock (_gate) { if (!force && _connected is not null && _clock.Now - _checkedAt < CookieCacheLifetime) { return _connected; } } bool has; try { has = await SessionCookieProbe.HasSessionCookieAsync(_browser.Cdp, _cookie, ct).ConfigureAwait(false); } catch (Exception ex) when (ex is CdpDisconnectedException or BrowserUnavailableException or CdpCommandException or TimeoutException) { return IsConnected; } 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; } /// Records the state of the cookie; returns the one before (null before the first check). private bool? SetConnected(bool connected) { bool? previous; lock (_gate) { previous = _connected; _connected = connected; _checkedAt = _clock.Now; } if (previous != connected) { _log.Info("collegamento", connected ? "Sessione presente nel browser: collegato." : "Nessuna sessione nel browser: non collegato."); // Wakes the engine: it looks again whether it can work (it only cancels a session if Alberto is driving). _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. private async Task MarkConnectedAsync(CancellationToken ct) { if (await _storage.Settings.GetInt64Async(FirstConnectionKey, ct).ConfigureAwait(false) is not null) { return false; } var now = _clock.Now; await _storage.Settings.SetAsync(FirstConnectionKey, now.ToUnixTimeMilliseconds().ToString(CultureInfo.InvariantCulture), ct).ConfigureAwait(false); if (_engine is { } engine) { await engine.Services.NotifyFirstConnectionAsync(ct).ConfigureAwait(false); await engine.Services.Events.WriteAsync( EventSeverity.Info, "collegamento.primo", "Primo collegamento a Instagram: comincia l'avvio graduale.", ct: ct).ConfigureAwait(false); } _log.Info("collegamento", "Primo collegamento: comincia l'avvio graduale."); return true; } private async Task WaitForSessionEndAsync(CancellationToken ct) { if (_engine is not { } engine) { return; } var deadline = _clock.Now + TimeSpan.FromSeconds(15); while (engine.Services.Runtime.CurrentSession is not null && _clock.Now < deadline) { await _clock.Delay(TimeSpan.FromMilliseconds(100), ct).ConfigureAwait(false); } } /// /// The page turn for Alberto's login page, so that no step of the profile search runs under it; after 15 seconds /// the page is taken anyway (Alberto asked for it), and null comes back. /// private async Task TakePageAsync(CancellationToken ct) { if (_engine is not { } engine) { return null; } using var limit = CancellationTokenSource.CreateLinkedTokenSource(ct); limit.CancelAfter(TimeSpan.FromSeconds(15)); try { return await engine.Services.PageTurns.TakeAsync(PageUser.Engine, limit.Token).ConfigureAwait(false); } catch (OperationCanceledException) when (!ct.IsCancellationRequested) { return null; } } private async Task CurrentUrlAsync(CancellationToken ct) { try { var url = await _browser.Cdp.GetMainFrameUrlAsync(ct).ConfigureAwait(false); return Addresses.WithoutQuery(url); } catch (Exception ex) when (ex is CdpDisconnectedException or BrowserUnavailableException or CdpCommandException or TimeoutException or KeyNotFoundException or InvalidOperationException) { return null; } } /// /// 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 { await _browser.RestAsync(CancellationToken.None).ConfigureAwait(false); } catch (Exception ex) when (ex is CdpDisconnectedException or BrowserUnavailableException or CdpCommandException or TimeoutException) { // The browser is restarting: it starts on the rest page anyway. } } private async Task ShowQuietlyAsync(CancellationToken ct) { try { await _browser.ShowToUserAsync(ct).ConfigureAwait(false); } catch (Exception ex) when (ex is InvalidOperationException or TimeoutException or IOException) { _log.Warn("collegamento", "La finestra del browser non è venuta in primo piano.", ex); } } private async Task HideQuietlyAsync() { try { await _browser.HideFromUserAsync(CancellationToken.None).ConfigureAwait(false); } catch (Exception ex) when (ex is InvalidOperationException or TimeoutException or IOException) { _log.Warn("collegamento", "La finestra del browser non si è nascosta.", ex); } } /// 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() { if (!_browser.IsAvailable) { throw new BadRequestException(_browser.LastError is { } error ? "Il browser di Febe non è in funzione: " + error : "Il browser di Febe si sta avviando: riprova fra qualche secondo."); } } }