Websocket - Add events (OnConnect / OnDisconnect)

Substrate.NetApi.Test/Extrinsic/EraTest.cs

@@ -39,10 +39,21 @@ public void EraEncodeDecodeTest()
  }
 
  [Test]
- public void EraBeginTest()
+ [TestCase(64u, 49u, 1587u, 1585u)]
+ [TestCase(64u, 45u, 21604404u, 21604397u)]
+ public void EraBeginTest(ulong period, ulong phase, ulong currentBlock, ulong expectedBlock)
  {
- var era = new Era(64, 49, false);
- Assert.AreEqual(1585, era.EraStart(1587));
+ var era = new Era(period, phase, false);
+ Assert.AreEqual(expectedBlock, era.EraStart(currentBlock));
+ }
+
+ [Test]
+ [TestCase(64u, 49u, 1587u, 1649u)]
+ [TestCase(64u, 45u, 21604404u, 21604461u)]
+ public void EraEndTest(ulong period, ulong phase, ulong currentBlock, ulong expectedBlock)
+ {
+ var era = new Era(period, phase, false);
+ Assert.AreEqual(expectedBlock, era.EraEnd(currentBlock));
  }
 
  [Test]

Substrate.NetApi.Test/Substrate.NetApi.Test.csproj

@@ -7,6 +7,7 @@
  </PropertyGroup>
 
  <ItemGroup>
+ <PackageReference Include="NSubstitute" Version="5.1.0" />
  <PackageReference Include="nunit" Version="3.13.3" />
  <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
  <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />

Substrate.NetApi.TestNode/ClientTests.cs

@@ -0,0 +1,96 @@
+using NUnit.Framework;
+using Substrate.NetApi.Model.Extrinsics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Sockets;
+using System.Net.WebSockets;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Substrate.NetApi.TestNode
+{
+ public class ClientTests
+ {
+ private SubstrateClient _client;
+
+ [SetUp]
+ public void Setup()
+ {
+ _client = new SubstrateClient(new Uri("ws://rpc-parachain.bajun.network"), ChargeTransactionPayment.Default());
+ }
+
+ [TearDown]
+ public async Task TeardownAsync()
+ {
+ await _client.CloseAsync();
+ }
+
+ [Test]
+ public async Task Connect_ShouldConnectSuccessfullyAsync()
+ {
+ Assert.That(_client.IsConnected, Is.False);
+
+ await _client.ConnectAsync();
+ Assert.That(_client.IsConnected, Is.True);
+ }
+
+ [Test]
+ public async Task Connect_ShouldDisconnectSuccessfullyAsync()
+ {
+ await _client.ConnectAsync();
+ Assert.That(_client.IsConnected, Is.True);
+
+ await _client.CloseAsync();
+ Assert.That(_client.IsConnected, Is.False);
+ }
+
+ [Test]
+ public async Task Connect_ShouldTriggerEventAsync()
+ {
+ var onConnectionSetTriggered = new TaskCompletionSource<bool>();
+ _client.ConnectionSet += (sender, e) => onConnectionSetTriggered.SetResult(true);
+
+ await _client.ConnectAsync();
+
+ await Task.WhenAny(onConnectionSetTriggered.Task, Task.Delay(TimeSpan.FromMinutes(1)));
+ Assert.That(onConnectionSetTriggered.Task.IsCompleted, Is.True);
+ }
+
+ [Test]
+ public async Task OnConnectionLost_ShouldThrowDisconnectedEventAsync()
+ {
+ var onConnectionLostTriggered = new TaskCompletionSource<bool>();
+ _client.ConnectionLost += (sender, e) => onConnectionLostTriggered.SetResult(true);
+
+ await _client.ConnectAsync();
+ await _client.CloseAsync();
+
+ await Task.WhenAny(onConnectionLostTriggered.Task, Task.Delay(TimeSpan.FromMinutes(1)));
+ Assert.That(onConnectionLostTriggered.Task.IsCompleted, Is.True);
+ }
+
+ [Test]
+ public async Task ManuallyDisconnect_ShouldNotTryToReconnectAsync()
+ {
+ await _client.ConnectAsync();
+ await _client.CloseAsync();
+
+ Assert.That(_client.IsConnected, Is.False);
+ }
+
+ [Test]
+ public async Task Disconnect_ShouldTryToReconnectAsync()
+ {
+ var onReconnectedTriggered = new TaskCompletionSource<(bool, int)>();
+ _client.OnReconnected += (sender, e) => onReconnectedTriggered.SetResult((true, e));
+
+ await _client.ConnectAsync();
+ await _client._socket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
+
+ await Task.WhenAny(onReconnectedTriggered.Task, Task.Delay(TimeSpan.FromMinutes(1)));
+ Assert.That(_client.IsConnected, Is.True);
+ }
+ }
+}

Substrate.NetApi/Model/Extrinsics/Era.cs

@@ -31,6 +31,13 @@ public class Era : IEncodable
  /// <returns></returns>
  public ulong EraStart(ulong currentBlockNumber) => IsImmortal ? 0 : (Math.Max(currentBlockNumber, Phase) - Phase) / Period * Period + Phase;
 
+ /// <summary>
+ /// Era End
+ /// </summary>
+ /// <param name="currentBlockNumber"></param>
+ /// <returns></returns>
+ public ulong EraEnd(ulong currentBlockNumber) => EraStart(currentBlockNumber) + Period;
+
  /// <summary>
  /// Initializes a new instance of the <see cref="Era"/> class.
  /// </summary>

Substrate.NetApi/SubstrateClient.cs

@@ -23,6 +23,7 @@
 using Substrate.NetApi.Model.Types.Metadata.V14;
 
 [assembly: InternalsVisibleTo("Substrate.NetApi.Test")]
+[assembly: InternalsVisibleTo("Substrate.NetApi.TestNode")]
 
 namespace Substrate.NetApi
 {
@@ -62,10 +63,29 @@ public class SubstrateClient : IDisposable
  /// </summary>
  private JsonRpc _jsonRpc;
 
+ /// <summary> The socket. </summary>
+ internal ClientWebSocket _socket;
+
+ /// <summary>
+ /// The "ping" to check the connection status
+ /// </summary>
+ private int _connectionCheckDelay = 500;
+
  /// <summary>
- /// The socket
+ /// The connexion lost event trigger when the websocket change state to disconnected
  /// </summary>
- private ClientWebSocket _socket;
+ public event EventHandler ConnectionLost;
+
+ /// <summary>
+ /// Event triggered when the connection is set
+ /// </summary>
+ public event EventHandler ConnectionSet;
+
+ /// <summary>
+ /// Event triggered when the connection is reconnected
+ /// </summary>
+
+ public event EventHandler<int> OnReconnected;
 
  /// <summary>
  /// Bypass Remote Certificate Validation. Useful when testing with self-signed SSL certificates.
@@ -185,6 +205,30 @@ public bool SetJsonRPCTraceLevel(SourceLevels sourceLevels)
  return true;
  }
 
+ /// <summary>
+ /// Raises the event when the connection to the server is lost.
+ /// </summary>
+ protected virtual void OnConnectionLost()
+ {
+ ConnectionLost?.Invoke(this, EventArgs.Empty);
+ }
+
+ /// <summary>
+ /// Raises the event when the connection to the server is set.
+ /// </summary>
+ protected virtual void OnConnectionSet()
+ {
+ ConnectionSet?.Invoke(this, EventArgs.Empty);
+ }
+
+ /// <summary>
+ /// Raises the event when reconnected
+ /// </summary>
+ protected virtual void OnReconnectedSet(int nbTry)
+ {
+ OnReconnected?.Invoke(this, nbTry);
+ }
+
  /// <summary>
  /// Asynchronously connects to the node.
  /// </summary>
@@ -259,14 +303,18 @@ public async Task ConnectAsync(bool useMetaData, bool standardSubstrate, int max
 #if NETSTANDARD2_0
  throw new NotSupportedException("Bypass remote certification validation not supported in NETStandard2.0");
 #elif NETSTANDARD2_1_OR_GREATER
- _socket.Options.RemoteCertificateValidationCallback = (sender, certificate, chain, errors) => true;
+ _socket.Options.RemoteCertificateValidationCallback = (sender, certificate, chain, errors) => true; 
 #endif
  }
  }
 
  _connectTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
  var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token, _connectTokenSource.Token);
  await _socket.ConnectAsync(_uri, linkedTokenSource.Token);
+
+ // Triger the event
+ OnConnectionSet();
+
  linkedTokenSource.Dispose();
  _connectTokenSource.Dispose();
  _connectTokenSource = null;
@@ -333,6 +381,9 @@ public async Task ConnectAsync(bool useMetaData, bool standardSubstrate, int max
  private void OnJsonRpcDisconnected(object sender, JsonRpcDisconnectedEventArgs e)
  {
  Logger.Error(e.Exception, $"JsonRpc disconnected: {e.Reason}");
+ OnConnectionLost();
+
+ if (_jsonRpc == null || _jsonRpc.IsDisposed) return;
 
  // Attempt to reconnect asynchronously
  _ = Task.Run(async () =>
@@ -368,6 +419,8 @@ await ConnectAsync(
  );
 
  Logger.Information("Reconnected successfully.");
+
+ OnReconnectedSet(retry);
  }
  catch (Exception ex)
  {
@@ -563,14 +616,15 @@ public async Task CloseAsync(CancellationToken token)
  {
  _connectTokenSource?.Cancel();
 
- await Task.Run(() =>
+ await Task.Run(async () =>
  {
  // cancel remaining request tokens
  foreach (var key in _requestTokenSourceDict.Keys) key?.Cancel();
  _requestTokenSourceDict.Clear();
 
  if (_socket != null && _socket.State == WebSocketState.Open)
  {
+ await _socket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
  _jsonRpc?.Dispose();
  Logger.Debug("Client closed.");
  }
@@ -629,4 +683,4 @@ public void Dispose()
 
  #endregion IDisposable Support
  }
-}
+}