9787587143

Committed 01 Jul 2024 04:10AM UTC coverage: 83.202% (+0.05%) from 83.155%

Build # 9787587143

Build Type

push

github

Committed by

web-flow

Commit Message

Make restart logic progressive and other small fixes (#1129)

* Fix the version setting when pushing to nuget

* Added progressive retry timeouts for disconnections

* Removed the debug log

* Fixed the tests

* small typo

* Fix review: Use TimeSpan in ProgressiveTimeout constructor

Run Details

886 of 1219 branches covered (72.68%)

Branch coverage included in aggregate %.

28 of 29 new or added lines in 4 files covered. (96.55%)

1 existing line in 1 file now uncovered.

3344 of 3865 relevant lines covered (86.52%)

82.56 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.33

/src/Runtime/NetDaemon.Runtime/Internal/NetDaemonRuntime.cs

using System.Reactive.Linq;
using System.Reflection;
using NetDaemon.AppModel;
using NetDaemon.HassModel;

namespace NetDaemon.Runtime.Internal;

internal class NetDaemonRuntime(IHomeAssistantRunner homeAssistantRunner,
        IOptions<HomeAssistantSettings> settings,
        IOptions<AppConfigurationLocationSetting> locationSettings,
        IServiceProvider serviceProvider,
        ILogger<NetDaemonRuntime> logger,
        ICacheManager cacheManager)
    : IRuntime
{
    private const string Version = "local build";
    private const int TimeoutInSeconds = 5;

    private readonly HomeAssistantSettings _haSettings = settings.Value;

    private IAppModelContext? _applicationModelContext;
    private CancellationToken? _stoppingToken;
    private CancellationTokenSource? _runnerCancellationSource;

    public bool IsConnected;

    // These internals are used primarily for testing purposes
    internal IReadOnlyCollection<IApplication> ApplicationInstances =>
        _applicationModelContext?.Applications ?? [];

    private readonly TaskCompletionSource _startedAndConnected = new();

    private Task _runnerTask = Task.CompletedTask;

    public async Task StartAsync(CancellationToken stoppingToken)
    {
        logger.LogInformation("Starting NetDaemon runtime version {Version}.", Version);

        _stoppingToken = stoppingToken;

        homeAssistantRunner.OnConnect
            .Select(async c => await OnHomeAssistantClientConnected(c, stoppingToken).ConfigureAwait(false))
            .Subscribe();
        homeAssistantRunner.OnDisconnect
            .Select(async s => await OnHomeAssistantClientDisconnected(s).ConfigureAwait(false))
            .Subscribe();
        try
        {
            _runnerCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(stoppingToken);

            _runnerTask = homeAssistantRunner.RunAsync(
                _haSettings.Host,
                _haSettings.Port,
                _haSettings.Ssl,
                _haSettings.Token,
                _haSettings.WebsocketPath,
                TimeSpan.FromSeconds(TimeoutInSeconds),
                _runnerCancellationSource.Token);

            // make sure we cancel the task if the stoppingToken is cancelled
            stoppingToken.Register(() =>
            {
                _startedAndConnected.TrySetCanceled();
            });
            // Make sure we only return after the connection is made and initialization is ready
            await _startedAndConnected.Task;
        }
        catch (OperationCanceledException)
        {
            // Ignore and just stop
        }
    }

    private async Task OnHomeAssistantClientConnected(
        IHomeAssistantConnection haConnection,
        CancellationToken cancelToken)
    {
        try
        {
            logger.LogInformation("Successfully connected to Home Assistant");

            if (_applicationModelContext is not null)
            {
                // Something wrong with unloading and disposing apps on restart of HA, we need to prevent apps loading multiple times
                logger.LogWarning("Applications were not successfully disposed during restart, skippin loading apps again");
                return;
            }

            IsConnected = true;

            await cacheManager.InitializeAsync(cancelToken).ConfigureAwait(false);

            await LoadNewAppContextAsync(haConnection, cancelToken);

            _startedAndConnected.TrySetResult();
        }
        catch (Exception ex)
        {
            if (!_startedAndConnected.Task.IsCompleted)
            {
                // This means this was the first time we connected and StartAsync is still awaiting _startedAndConnected
                // By setting the exception on the task it will propagate up.
                _startedAndConnected.SetException(ex);
            }
            else
            {
                // There is none waiting for this event handler to finish so we need to Log the exception here
                logger.LogCritical(ex, "Error re-initializing after reconnect to Home Assistant");
            }
        }
    }

    private async Task LoadNewAppContextAsync(IHomeAssistantConnection haConnection, CancellationToken cancelToken)
    {
        var appModel = serviceProvider.GetService<IAppModel>();
        if (appModel == null) return;

        // this logging is a bit weird in this class
        if (!string.IsNullOrEmpty(locationSettings.Value.ApplicationConfigurationFolder))
            logger.LogDebug("Loading applications from folder {Path}",
                Path.GetFullPath(locationSettings.Value.ApplicationConfigurationFolder));
        else
            logger.LogDebug("Loading applications with no configuration folder");

        _applicationModelContext = await appModel.LoadNewApplicationContext(CancellationToken.None).ConfigureAwait(false);

        // Handle state change for apps if registered
        var appStateHandler = serviceProvider.GetService<IHandleHomeAssistantAppStateUpdates>();
        if (appStateHandler == null) return;

        await appStateHandler.InitializeAsync(haConnection, _applicationModelContext);
    }

    private async Task OnHomeAssistantClientDisconnected(DisconnectReason reason)
    {
        if (_stoppingToken?.IsCancellationRequested == true || reason == DisconnectReason.Client)
        {
            logger.LogInformation("HassClient disconnected cause of user stopping");
        }
        else
        {
            var reasonString = reason switch
            {
                DisconnectReason.Remote => "home assistant closed the connection",
                DisconnectReason.Error => "unknown error, set loglevel to debug to view details",
                DisconnectReason.Unauthorized => "token not authorized",
                DisconnectReason.NotReady => "home assistant not ready yet",
                _ => "unknown error"
            };
            logger.LogInformation("Home Assistant disconnected due to {Reason}",
                reasonString );
        }

        try
        {
            await DisposeApplicationsAsync().ConfigureAwait(false);
        }
        catch (Exception e)
        {
            logger.LogError(e, "Error disposing applications");
        }
        IsConnected = false;

        if (reason == DisconnectReason.Unauthorized)
        {
            // We will exit the runtime if the token is unauthorized to avoid hammering the server
            _startedAndConnected.SetResult();
        }
    }

    private async Task DisposeApplicationsAsync()
    {
        if (_applicationModelContext is not null)
        {
            await _applicationModelContext.DisposeAsync();

            _applicationModelContext = null;
        }
    }

    private bool _isDisposed;
    public async ValueTask DisposeAsync()
    {
        if (_isDisposed) return;
        _isDisposed = true;

        await DisposeApplicationsAsync().ConfigureAwait(false);
        if (_runnerCancellationSource is not null)
            await _runnerCancellationSource.CancelAsync();
        try
        {
            await _runnerTask.ConfigureAwait(false);
        }
        catch (OperationCanceledException) { }
        _runnerCancellationSource?.Dispose();
    }
}

1	using System.Reactive.Linq;
2	using System.Reflection;
3	using NetDaemon.AppModel;
4	using NetDaemon.HassModel;
5
6	namespace NetDaemon.Runtime.Internal;
7
8	internal class NetDaemonRuntime(IHomeAssistantRunner homeAssistantRunner,	18✔
9	IOptions<HomeAssistantSettings> settings,	18✔
10	IOptions<AppConfigurationLocationSetting> locationSettings,	18✔
11	IServiceProvider serviceProvider,	18✔
12	ILogger<NetDaemonRuntime> logger,	18✔
13	ICacheManager cacheManager)	18✔
14	: IRuntime
15	{
16	private const string Version = "local build";
17	private const int TimeoutInSeconds = 5;
18
19	private readonly HomeAssistantSettings _haSettings = settings.Value;	18✔
20
21	private IAppModelContext? _applicationModelContext;
22	private CancellationToken? _stoppingToken;
23	private CancellationTokenSource? _runnerCancellationSource;
24
25	public bool IsConnected;
26
27	// These internals are used primarily for testing purposes
28	internal IReadOnlyCollection<IApplication> ApplicationInstances =>
29	_applicationModelContext?.Applications ?? [];	1!
30
31	private readonly TaskCompletionSource _startedAndConnected = new();	18✔
32
33	private Task _runnerTask = Task.CompletedTask;	18✔
34
35	public async Task StartAsync(CancellationToken stoppingToken)
36	{
37	logger.LogInformation("Starting NetDaemon runtime version {Version}.", Version);	18✔
38
39	_stoppingToken = stoppingToken;	18✔
40
41	homeAssistantRunner.OnConnect	18✔
42	.Select(async c => await OnHomeAssistantClientConnected(c, stoppingToken).ConfigureAwait(false))	19✔
43	.Subscribe();	18✔
44	homeAssistantRunner.OnDisconnect	18✔
45	.Select(async s => await OnHomeAssistantClientDisconnected(s).ConfigureAwait(false))	13✔
46	.Subscribe();	18✔
47	try
48	{
49	_runnerCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(stoppingToken);	18✔
50
51	_runnerTask = homeAssistantRunner.RunAsync(	18✔
52	_haSettings.Host,	18✔
53	_haSettings.Port,	18✔
54	_haSettings.Ssl,	18✔
55	_haSettings.Token,	18✔
56	_haSettings.WebsocketPath,	18✔
57	TimeSpan.FromSeconds(TimeoutInSeconds),	18✔
58	_runnerCancellationSource.Token);	18✔
59
60	// make sure we cancel the task if the stoppingToken is cancelled
61	stoppingToken.Register(() =>	18✔
62	{	18✔
63	_startedAndConnected.TrySetCanceled();	×
64	});	18✔
65	// Make sure we only return after the connection is made and initialization is ready
66	await _startedAndConnected.Task;	18✔
67	}	16✔
UNCOV 68	catch (OperationCanceledException)	×
69	{
70	// Ignore and just stop
71	}	×
72	}	16✔
73
74	private async Task OnHomeAssistantClientConnected(
75	IHomeAssistantConnection haConnection,
76	CancellationToken cancelToken)
77	{
78	try
79	{
80	logger.LogInformation("Successfully connected to Home Assistant");	19✔
81
82	if (_applicationModelContext is not null)	19!
83	{
84	// Something wrong with unloading and disposing apps on restart of HA, we need to prevent apps loading multiple times
85	logger.LogWarning("Applications were not successfully disposed during restart, skippin loading apps again");	×
86	return;	×
87	}
88
89	IsConnected = true;	19✔
90
91	await cacheManager.InitializeAsync(cancelToken).ConfigureAwait(false);	19✔
92
93	await LoadNewAppContextAsync(haConnection, cancelToken);	17✔
94
95	_startedAndConnected.TrySetResult();	17✔
96	}	17✔
97	catch (Exception ex)	2✔
98	{
99	if (!_startedAndConnected.Task.IsCompleted)	2✔
100	{
101	// This means this was the first time we connected and StartAsync is still awaiting _startedAndConnected
102	// By setting the exception on the task it will propagate up.
103	_startedAndConnected.SetException(ex);	1✔
104	}
105	else
106	{
107	// There is none waiting for this event handler to finish so we need to Log the exception here
108	logger.LogCritical(ex, "Error re-initializing after reconnect to Home Assistant");	1✔
109	}
110	}	2✔
111	}	19✔
112
113	private async Task LoadNewAppContextAsync(IHomeAssistantConnection haConnection, CancellationToken cancelToken)
114	{
115	var appModel = serviceProvider.GetService<IAppModel>();	17✔
116	if (appModel == null) return;	17!
117
118	// this logging is a bit weird in this class
119	if (!string.IsNullOrEmpty(locationSettings.Value.ApplicationConfigurationFolder))	17✔
120	logger.LogDebug("Loading applications from folder {Path}",	13✔
121	Path.GetFullPath(locationSettings.Value.ApplicationConfigurationFolder));	13✔
122	else
123	logger.LogDebug("Loading applications with no configuration folder");	4✔
124
125	_applicationModelContext = await appModel.LoadNewApplicationContext(CancellationToken.None).ConfigureAwait(false);	17✔
126
127	// Handle state change for apps if registered
128	var appStateHandler = serviceProvider.GetService<IHandleHomeAssistantAppStateUpdates>();	17✔
129	if (appStateHandler == null) return;	26✔
130
131	await appStateHandler.InitializeAsync(haConnection, _applicationModelContext);	8✔
132	}	17✔
133
134	private async Task OnHomeAssistantClientDisconnected(DisconnectReason reason)
135	{
136	if (_stoppingToken?.IsCancellationRequested == true \|\| reason == DisconnectReason.Client)	13!
137	{
138	logger.LogInformation("HassClient disconnected cause of user stopping");	4✔
139	}
140	else
141	{
142	var reasonString = reason switch	9!
143	{	9✔
144	DisconnectReason.Remote => "home assistant closed the connection",	8✔
145	DisconnectReason.Error => "unknown error, set loglevel to debug to view details",	×
146	DisconnectReason.Unauthorized => "token not authorized",	×
147	DisconnectReason.NotReady => "home assistant not ready yet",	1✔
148	_ => "unknown error"	×
149	};	9✔
150	logger.LogInformation("Home Assistant disconnected due to {Reason}",	9✔
151	reasonString );	9✔
152	}
153
154	try
155	{
156	await DisposeApplicationsAsync().ConfigureAwait(false);	13✔
157	}	13✔
158	catch (Exception e)	×
159	{
160	logger.LogError(e, "Error disposing applications");	×
161	}	×
162	IsConnected = false;	13✔
163
164	if (reason == DisconnectReason.Unauthorized)	13!
165	{
166	// We will exit the runtime if the token is unauthorized to avoid hammering the server
NEW 167	_startedAndConnected.SetResult();	×
168	}
169	}	13✔
170
171	private async Task DisposeApplicationsAsync()
172	{
173	if (_applicationModelContext is not null)	22✔
174	{
175	await _applicationModelContext.DisposeAsync();	11✔
176
177	_applicationModelContext = null;	11✔
178	}
179	}	22✔
180
181	private bool _isDisposed;
182	public async ValueTask DisposeAsync()
183	{
184	if (_isDisposed) return;	13✔
185	_isDisposed = true;	9✔
186
187	await DisposeApplicationsAsync().ConfigureAwait(false);	9✔
188	if (_runnerCancellationSource is not null)	9✔
189	await _runnerCancellationSource.CancelAsync();	9✔
190	try
191	{
192	await _runnerTask.ConfigureAwait(false);	9✔
193	}	6✔
194	catch (OperationCanceledException) { }	6✔
195	_runnerCancellationSource?.Dispose();	9!
196	}	11✔
197	}

net-daemon / netdaemon / 9787587143

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous