Refactor live control client a good bit

Author: LucHeart

SDK.CSharp.Example/Http/LiveControlDemo.cs

@@ -0,0 +1,65 @@
+using Microsoft.Extensions.Logging;
+using OpenShock.SDK.CSharp;
+using OpenShock.SDK.CSharp.Live;
+using OpenShock.SDK.CSharp.Models;
+
+namespace SDK.CSharp.Example.Http;
+
+public sealed class LiveControlDemo : IExample
+{
+    private readonly ExampleConfig _config;
+    private readonly ILogger<OpenShockLiveControlClient> _liveControlLogger;
+
+    public LiveControlDemo(ExampleConfig config, ILogger<OpenShockLiveControlClient> liveControlLogger)
+    {
+        _config = config;
+        _liveControlLogger = liveControlLogger;
+    }
+
+
+    public async Task Start()
+    {
+        var apiClient = new OpenShockApiClient(new ApiClientOptions
+        {
+            Token = _config.ApiToken
+        });
+        
+        if(!_config.Hub.HasValue) 
+        {
+            Console.WriteLine("No hub configured, skipping live control demo.");
+            return;
+        }
+
+        var gateway = await apiClient.GetDeviceGateway(_config.Hub.Value);
+        
+       gateway.Switch(success => {},
+           found =>
+           {
+               Console.WriteLine($"Hub with ID {_config.Hub.Value} not found.");
+           },
+           offline =>
+           {
+               Console.WriteLine($"Hub with ID {_config.Hub.Value} is not online.");
+           },
+           unauthenticated =>
+           {
+               Console.WriteLine($"not authenticated");
+           });
+       
+       if(!gateway.IsT0) throw new Exception("Failed to get gateway for hub " + _config.Hub.Value);
+        
+        var liveControlClient = new OpenShockLiveControlClient(gateway.AsT0.Value.Gateway, _config.Hub.Value, _config.ApiToken, _liveControlLogger);
+
+        await liveControlClient.InitializeAsync();
+
+        while (true)
+        {
+            Console.Write("\rHold down enter to continue to send vibrates%   ");
+            Console.ReadLine();
+            foreach (var configShocker in _config.Shockers)
+            {
+                liveControlClient.IntakeFrame(configShocker, ControlType.Vibrate, 50);
+            }
+        }
+    }
+}

SDK.CSharp.Example/SDK.CSharp.Example.csproj

@@ -15,7 +15,7 @@
 
     <ItemGroup>
       <PackageReference Include="Microsoft.Extensions.Hosting" Version="9.0.5" />
-      <PackageReference Include="Serilog" Version="4.2.0" />
+      <PackageReference Include="Serilog" Version="4.3.0" />
       <PackageReference Include="Serilog.Extensions.Hosting" Version="9.0.0" />
       <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
     </ItemGroup>

SDK.CSharp.Live/OpenShockLiveControlClient.cs

@@ -112,12 +112,12 @@ private ValueTask QueueMessage(BaseRequest<LiveRequestType> data) =>
 
     public IAsyncUpdatable<WebsocketConnectionState> State => _state;
 
-    private async Task MessageLoop()
+    private async Task MessageLoop(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var msg in _channel.Reader.ReadAllAsync(_linked.Token))
-                await JsonWebSocketUtils.SendFullMessage(msg, _clientWebSocket!, _linked.Token, JsonSerializerOptions);
+            await foreach (var msg in _channel.Reader.ReadAllAsync(cancellationToken))
+                await JsonWebSocketUtils.SendFullMessage(msg, _clientWebSocket!, cancellationToken, JsonSerializerOptions);
         }
         catch (OperationCanceledException)
         {
@@ -128,11 +128,11 @@ private async Task MessageLoop()
         }
     }
 
-    public struct Shutdown;
+    public readonly struct Shutdown;
 
-    public struct Reconnecting;
+    public  readonly struct Reconnecting;
 
-    private async Task<OneOf<Success, NotFound, Shutdown, Reconnecting>> ConnectAsync()
+    private async Task<OneOf<Success, Shutdown, Reconnecting>> ConnectAsync()
     {
         if (_dispose.IsCancellationRequested)
         {
@@ -141,13 +141,21 @@ private async Task<OneOf<Success, NotFound, Shutdown, Reconnecting>> ConnectAsyn
         }
 
         _state.Value = WebsocketConnectionState.Connecting;
+        
 #if NETSTANDARD2_1
         _currentConnectionClose?.Cancel();
 #else
         if (_currentConnectionClose != null) await _currentConnectionClose.CancelAsync();
 #endif
+        
         _currentConnectionClose = new CancellationTokenSource();
+        
+        if (_linked != _dispose)
+        {
+            _linked.Dispose();
+        }
         _linked = CancellationTokenSource.CreateLinkedTokenSource(_dispose.Token, _currentConnectionClose.Token);
+        var cancellationToken = _linked.Token;
 
         _clientWebSocket?.Abort();
         _clientWebSocket?.Dispose();
@@ -160,32 +168,18 @@ private async Task<OneOf<Success, NotFound, Shutdown, Reconnecting>> ConnectAsyn
         _logger.LogInformation("Connecting to websocket....");
         try
         {
-            await _clientWebSocket.ConnectAsync(new Uri($"wss://{Gateway}/1/ws/live/{DeviceId}"), _linked.Token);
+            await _clientWebSocket.ConnectAsync(new Uri($"wss://{Gateway}/1/ws/live/{DeviceId}"), cancellationToken);
 
             _logger.LogInformation("Connected to websocket");
             _state.Value = WebsocketConnectionState.Connected;
 
 #pragma warning disable CS4014
-            Run(ReceiveLoop, _linked.Token);
-            Run(MessageLoop, _linked.Token);
+            Run(ReceiveLoop(cancellationToken), cancellationToken);
+            Run(MessageLoop(cancellationToken), cancellationToken);
 #pragma warning restore CS4014
 
             return new Success();
         }
-        catch (WebSocketException e)
-        {
-            if (e.Message.Contains("404"))
-            {
-                _logger.LogError("Device not found, shutting down");
-                _dispose.Dispose();
-#pragma warning disable CS4014
-                Run(async () => await _onDispose.InvokeAsyncParallel());
-#pragma warning restore CS4014
-                return new NotFound();
-            }
-
-            _logger.LogError(e, "Error while connecting, retrying in 3 seconds");
-        }
         catch (Exception e)
         {
             _logger.LogError(e, "Error while connecting, retrying in 3 seconds");
@@ -229,9 +223,9 @@ private string GetUserAgent()
     }
 
 
-    private async Task ReceiveLoop()
+    private async Task ReceiveLoop(CancellationToken cancellationToken)
     {
-        while (!_linked.Token.IsCancellationRequested)
+        while (!cancellationToken.IsCancellationRequested)
         {
             try
             {
@@ -244,7 +238,7 @@ private async Task ReceiveLoop()
                 var message =
                     await JsonWebSocketUtils
                         .ReceiveFullMessageAsyncNonAlloc<LiveControlModels.BaseResponse<LiveResponseType>>(
-                            _clientWebSocket, _linked.Token, JsonSerializerOptions);
+                            _clientWebSocket, cancellationToken, JsonSerializerOptions);
 
                 if (message.IsT2)
                 {
@@ -257,7 +251,7 @@ await JsonWebSocketUtils
                     try
                     {
                         await _clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Normal close",
-                            _linked.Token);
+                            cancellationToken);
                     }
                     catch (OperationCanceledException e)
                     {

SDK.CSharp.Tests/SDK.CSharp.Tests.csproj

@@ -12,7 +12,7 @@
           <PrivateAssets>all</PrivateAssets>
           <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
-        <PackageReference Include="TUnit" Version="0.19.148" />
+        <PackageReference Include="TUnit" Version="0.23.0" />
     </ItemGroup>
 
     <ItemGroup>

SDK.CSharp/IOpenShockApiClient.cs

@@ -22,8 +22,7 @@ public Task<OneOf<Success<ImmutableArray<ResponseDeviceWithShockers>>, Unauthent
     /// <param name="deviceId"></param>
     /// <param name="cancellationToken"></param>
     /// <returns></returns>
-    public Task<OneOf<Success<LcgResponse>, NotFound, DeviceOffline, DeviceNotConnectedToGateway, UnauthenticatedError>>
-        GetDeviceGateway(Guid deviceId, CancellationToken cancellationToken = default);
+    public Task<OneOf<Success<LcgResponse>, NotFound, DeviceOffline, UnauthenticatedError>> GetDeviceGateway(Guid deviceId, CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Gets the root for the API, this has some useful information and can be used to check if the API is reachable
@@ -66,5 +65,4 @@ public Task<OneOf<Success<bool>, NotFound>> PauseShocker(Guid shockerId, bool pa
 }
 
 public struct DeviceOffline;
-public struct DeviceNotConnectedToGateway;
 

SDK.CSharp/OpenShockApiClient.cs

@@ -73,7 +73,7 @@ await ownShockersResponse.Content
 
     /// <inheritdoc />
     public async
-        Task<OneOf<Success<LcgResponse>, NotFound, DeviceOffline, DeviceNotConnectedToGateway, UnauthenticatedError>>
+        Task<OneOf<Success<LcgResponse>, NotFound, DeviceOffline, UnauthenticatedError>>
         GetDeviceGateway(Guid deviceId, CancellationToken cancellationToken = default)
     {
         using var gatewayResponse =
@@ -98,7 +98,6 @@ await gatewayResponse.Content.ReadAsJsonAsync<ProblemDetails>(cancellationToken,
         {
             "Device.NotFound" => new NotFound(),
             "Device.NotOnline" => new DeviceOffline(),
-            "Device.NotConnectedToGateway" => new DeviceNotConnectedToGateway(),
             _ => throw new OpenShockApiError($"Unknown problem type [{problem.Type}]", gatewayResponse.StatusCode)
         };
     }