9308989580

Committed 30 May 2024 08:46PM UTC coverage: 82.961% (-0.07%) from 83.029%

Build # 9308989580

Build Type

Pull #1111

github

Committed by

web-flow

Commit Message

Merge 45d9e5592 into 7f6be196c

Pull Request Pull Request #1111: Support service calls with return values in codegen

Run Details

871 of 1201 branches covered (72.52%)

Branch coverage included in aggregate %.

63 of 68 new or added lines in 5 files covered. (92.65%)

6 existing lines in 2 files now uncovered.

3287 of 3811 relevant lines covered (86.25%)

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

net-daemon / netdaemon / 9308989580

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