9138272824

Committed 18 May 2024 07:31AM UTC coverage: 82.878% (+1.5%) from 81.415%

Build # 9138272824

Build Type

push

github

Committed by

web-flow

Commit Message

Adds support for input number helpers (#1096)

* Adds support for input number helpers

This commit introduces new methods for handling InputNumberHelpers in
the HomeAssistantConnectionHelpersExtensions class. These methods
include CreateInputNumberHelperAsync, DeleteInputNumberHelperAsync, and
ListInputNumberHelpersAsync. This enhancement provides more granular
control over InputNumberHelpers in Home Assistant.

* Added namespace

* remove the coverage.info files

* add more coverage files to gitignore

* Include coverlet for msbuild that was missing

Run Details

864 of 1189 branches covered (72.67%)

Branch coverage included in aggregate %.

49 of 49 new or added lines in 3 files covered. (100.0%)

5 existing lines in 1 file now uncovered.

3231 of 3752 relevant lines covered (86.11%)

81.57 hits per line

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

84.27

/src/Client/NetDaemon.HassClient/Internal/HomeAssistantRunner.cs

using NetDaemon.Client.Exceptions;

namespace NetDaemon.Client.Internal;

internal class HomeAssistantRunner(IHomeAssistantClient client,
    ILogger<IHomeAssistantRunner> logger) : IHomeAssistantRunner
{
    // The internal token source will make sure we
    // always cancel operations on dispose
    private readonly CancellationTokenSource _internalTokenSource = new();
    private readonly Subject<IHomeAssistantConnection> _onConnectSubject = new();

    private readonly Subject<DisconnectReason> _onDisconnectSubject = new();


    private Task? _runTask;

    public IObservable<IHomeAssistantConnection> OnConnect => _onConnectSubject;
    public IObservable<DisconnectReason> OnDisconnect => _onDisconnectSubject;
    public IHomeAssistantConnection? CurrentConnection { get; internal set; }

    public Task RunAsync(string host, int port, bool ssl, string token, TimeSpan timeout,
        CancellationToken cancelToken)
    {
        return RunAsync(host, port, ssl, token, HomeAssistantSettings.DefaultWebSocketPath, timeout, cancelToken);
    }
    public Task RunAsync(string host, int port, bool ssl, string token, string websocketPath, TimeSpan timeout, CancellationToken cancelToken)
    {
        _runTask = InternalRunAsync(host, port, ssl, token, websocketPath, timeout, cancelToken);
        return _runTask;
    }

    private bool _isDisposed;
    public async ValueTask DisposeAsync()
    {
        if (_isDisposed)
            return;
        await _internalTokenSource.CancelAsync();

        if (_runTask?.IsCompleted == false)
            try
            {
                await Task.WhenAny(
                    _runTask,
                    Task.Delay(5000)
                ).ConfigureAwait(false);
            }
            catch
            {
                // Ignore errors
            }

        _onConnectSubject.Dispose();
        _onDisconnectSubject.Dispose();
        _internalTokenSource.Dispose();
        _isDisposed = true;
    }

    private async Task InternalRunAsync(string host, int port, bool ssl, string token, string websocketPath, TimeSpan timeout,
        CancellationToken cancelToken)
    {
        var combinedToken = CancellationTokenSource.CreateLinkedTokenSource(_internalTokenSource.Token, cancelToken);
        while (!combinedToken.IsCancellationRequested)
        {
            try
            {
                CurrentConnection = await client.ConnectAsync(host, port, ssl, token, websocketPath, combinedToken.Token)
                    .ConfigureAwait(false);
                // Start the event processing before publish the connection
                var eventsTask = CurrentConnection.WaitForConnectionToCloseAsync(combinedToken.Token);
                _onConnectSubject.OnNext(CurrentConnection);
                await eventsTask.ConfigureAwait(false);
            }
            catch (HomeAssistantConnectionException de) when (de.Reason == DisconnectReason.Unauthorized)
            {
                logger.LogError("User token unauthorized! Will not retry connecting...");
                await DisposeConnectionAsync();
                _onDisconnectSubject.OnNext(DisconnectReason.Unauthorized);
                return;
            }
            catch (HomeAssistantConnectionException de) when (de.Reason == DisconnectReason.NotReady)
            {
                logger.LogInformation("Home Assistant is not ready yet!");
                await DisposeConnectionAsync();
                _onDisconnectSubject.OnNext(DisconnectReason.NotReady);
            }
            catch (OperationCanceledException)
            {
                await DisposeConnectionAsync();
                if (_internalTokenSource.IsCancellationRequested)
                {
                    // We have internal cancellation due to dispose
                    // just return without any further due
                    return;
                }

                _onDisconnectSubject.OnNext(cancelToken.IsCancellationRequested
                    ? DisconnectReason.Client
                    : DisconnectReason.Remote);
            }
            catch (Exception e)
            {
                // In most cases this is just normal when client fails to connect so we log as debug
                logger.LogDebug(e, "Unhandled exception connecting to Home Assistant!");
                await DisposeConnectionAsync();
                _onDisconnectSubject.OnNext(DisconnectReason.Error);
            }

            await DisposeConnectionAsync();

            if (combinedToken.IsCancellationRequested)
                return; // If we are cancelled we should not retry

            logger.LogInformation("Client connection failed, retrying in {Seconds} seconds...", timeout.TotalSeconds);
            await Task.Delay(timeout, combinedToken.Token).ConfigureAwait(false);
        }
    }

    private async Task DisposeConnectionAsync()
    {
        if (CurrentConnection is not null)
        {
            // Just try to dispose the connection silently
            try
            {
                await CurrentConnection.DisposeAsync().ConfigureAwait(false);
            }
            finally
            {
                CurrentConnection = null;
            }
        }
    }
}

1	using NetDaemon.Client.Exceptions;
2
3	namespace NetDaemon.Client.Internal;
4
5	internal class HomeAssistantRunner(IHomeAssistantClient client,	16✔
6	ILogger<IHomeAssistantRunner> logger) : IHomeAssistantRunner	16✔
7	{
8	// The internal token source will make sure we
9	// always cancel operations on dispose
10	private readonly CancellationTokenSource _internalTokenSource = new();	16✔
11	private readonly Subject<IHomeAssistantConnection> _onConnectSubject = new();	16✔
12
13	private readonly Subject<DisconnectReason> _onDisconnectSubject = new();	16✔
14
15
16	private Task? _runTask;
17
18	public IObservable<IHomeAssistantConnection> OnConnect => _onConnectSubject;	9✔
19	public IObservable<DisconnectReason> OnDisconnect => _onDisconnectSubject;	13✔
20	public IHomeAssistantConnection? CurrentConnection { get; internal set; }	258✔
21
22	public Task RunAsync(string host, int port, bool ssl, string token, TimeSpan timeout,
23	CancellationToken cancelToken)
24	{
25	return RunAsync(host, port, ssl, token, HomeAssistantSettings.DefaultWebSocketPath, timeout, cancelToken);	×
26	}
27	public Task RunAsync(string host, int port, bool ssl, string token, string websocketPath, TimeSpan timeout, CancellationToken cancelToken)
28	{
29	_runTask = InternalRunAsync(host, port, ssl, token, websocketPath, timeout, cancelToken);	15✔
30	return _runTask;	15✔
31	}
32
33	private bool _isDisposed;
34	public async ValueTask DisposeAsync()
35	{
36	if (_isDisposed)	7!
37	return;	×
38	await _internalTokenSource.CancelAsync();	7✔
39
40	if (_runTask?.IsCompleted == false)	7!
41	try
42	{
UNCOV 43	await Task.WhenAny(	×
UNCOV 44	_runTask,	×
UNCOV 45	Task.Delay(5000)	×
UNCOV 46	).ConfigureAwait(false);	×
UNCOV 47	}	×
48	catch	×
49	{
50	// Ignore errors
51	}	×
52
53	_onConnectSubject.Dispose();	7✔
54	_onDisconnectSubject.Dispose();	7✔
55	_internalTokenSource.Dispose();	7✔
56	_isDisposed = true;	7✔
57	}	7✔
58
59	private async Task InternalRunAsync(string host, int port, bool ssl, string token, string websocketPath, TimeSpan timeout,
60	CancellationToken cancelToken)
61	{
62	var combinedToken = CancellationTokenSource.CreateLinkedTokenSource(_internalTokenSource.Token, cancelToken);	15✔
63	while (!combinedToken.IsCancellationRequested)	16!
64	{
65	try
66	{
67	CurrentConnection = await client.ConnectAsync(host, port, ssl, token, websocketPath, combinedToken.Token)	16✔
68	.ConfigureAwait(false);	16✔
69	// Start the event processing before publish the connection
70	var eventsTask = CurrentConnection.WaitForConnectionToCloseAsync(combinedToken.Token);	11✔
71	_onConnectSubject.OnNext(CurrentConnection);	11✔
72	await eventsTask.ConfigureAwait(false);	11✔
73	}	×
74	catch (HomeAssistantConnectionException de) when (de.Reason == DisconnectReason.Unauthorized)	3✔
75	{
76	logger.LogError("User token unauthorized! Will not retry connecting...");	1✔
77	await DisposeConnectionAsync();	1✔
78	_onDisconnectSubject.OnNext(DisconnectReason.Unauthorized);	1✔
79	return;	1✔
80	}
81	catch (HomeAssistantConnectionException de) when (de.Reason == DisconnectReason.NotReady)	2✔
82	{
83	logger.LogInformation("Home Assistant is not ready yet!");	2✔
84	await DisposeConnectionAsync();	2✔
85	_onDisconnectSubject.OnNext(DisconnectReason.NotReady);	2✔
86	}	2✔
87	catch (OperationCanceledException)	12✔
88	{
89	await DisposeConnectionAsync();	12✔
90	if (_internalTokenSource.IsCancellationRequested)	12✔
91	{
92	// We have internal cancellation due to dispose
93	// just return without any further due
94	return;	1✔
95	}
96
97	_onDisconnectSubject.OnNext(cancelToken.IsCancellationRequested	11✔
98	? DisconnectReason.Client	11✔
99	: DisconnectReason.Remote);	11✔
100	}	11✔
101	catch (Exception e)	1✔
102	{
103	// In most cases this is just normal when client fails to connect so we log as debug
104	logger.LogDebug(e, "Unhandled exception connecting to Home Assistant!");	1✔
105	await DisposeConnectionAsync();	1✔
106	_onDisconnectSubject.OnNext(DisconnectReason.Error);	1✔
107	}
108
109	await DisposeConnectionAsync();	14✔
110
111	if (combinedToken.IsCancellationRequested)	14✔
112	return; // If we are cancelled we should not retry	2✔
113
114	logger.LogInformation("Client connection failed, retrying in {Seconds} seconds...", timeout.TotalSeconds);	12✔
115	await Task.Delay(timeout, combinedToken.Token).ConfigureAwait(false);	12✔
116	}
117	}	4✔
118
119	private async Task DisposeConnectionAsync()
120	{
121	if (CurrentConnection is not null)	30✔
122	{
123	// Just try to dispose the connection silently
124	try
125	{
126	await CurrentConnection.DisposeAsync().ConfigureAwait(false);	11✔
127	}	11✔
128	finally
129	{
130	CurrentConnection = null;	11✔
131	}
132	}
133	}	30✔
134	}

net-daemon / netdaemon / 9138272824

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