private Task ProcessEvent(IEvent e, CancellationToken token)
{
// do we have an error.
if (e.Error != EventError.None)
{
return(OnErrorAsync != null?Task.Run(() => OnErrorAsync?.Invoke(new utils.EventError(e.Error, e.DateTimeUtc), token), token) : Task.FromResult(false));
}
switch (e.Action)
{
case EventAction.Added:
return(OnAddedAsync != null?Task.Run(() => OnAddedAsync?.Invoke(new FileSystemEvent(e), token), token) : Task.FromResult(false));
case EventAction.Removed:
return(OnRemovedAsync != null?Task.Run(() => OnRemovedAsync?.Invoke(new FileSystemEvent(e), token), token) : Task.FromResult(false));
case EventAction.Touched:
return(OnTouchedAsync != null?Task.Run(() => OnTouchedAsync?.Invoke(new FileSystemEvent(e), token), token) : Task.FromResult(false));
case EventAction.Renamed:
return(OnRenamedAsync != null?Task.Run(() => OnRenamedAsync?.Invoke(new RenamedFileSystemEvent(e), token), token) : Task.FromResult(false));
default:
throw new NotSupportedException($"Received an unknown Action: {e.Action:G}");
}
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
/// <param name="bypassQueue"></param>
/// <param name="serializerOptions"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="InvalidOperationException"></exception>
public async ValueTask SendAsync <T>(T data, bool bypassQueue = false,
JsonSerializerOptions serializerOptions = default)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data), "Provided data was null.");
}
if (_webSocket.State != WebSocketState.Open)
{
throw new InvalidOperationException(
$"WebSocket is not in open state. Current state: {_webSocket.State}");
}
try {
var serializedData = JsonSerializer.SerializeToUtf8Bytes(data, serializerOptions);
if (bypassQueue)
{
_messageQueue.Enqueue(serializedData);
}
else
{
await _webSocket.SendAsync(serializedData, WebSocketMessageType.Text,
true, _connectionTokenSource.Token);
}
}
catch (Exception exception) {
await OnErrorAsync.Invoke(new ErrorEventArgs(exception));
}
}
private async Task ReceiveAsync()
{
try {
var buffer = new byte[_lavaConfig.BufferSize];
var finalBuffer = default(byte[]);
var offset = 0;
do
{
var receiveResult = await _webSocket.ReceiveAsync(buffer, _cancellationToken.Token);
if (!receiveResult.EndOfMessage)
{
finalBuffer = new byte[_lavaConfig.BufferSize * 2];
buffer.CopyTo(finalBuffer, offset);
offset += receiveResult.Count;
buffer = new byte[_lavaConfig.BufferSize];
continue;
}
switch (receiveResult.MessageType)
{
case WebSocketMessageType.Text:
await OnDataAsync.Invoke(RemoveTrailingNulls(finalBuffer ?? buffer));
finalBuffer = default;
buffer = new byte[_lavaConfig.BufferSize];
offset = 0;
break;
case WebSocketMessageType.Close:
await DisconnectAsync();
break;
}
} while (_webSocket.State == WebSocketState.Open &&
!_cancellationToken.IsCancellationRequested);
}
catch (Exception exception) {
if (exception is TaskCanceledException ||
exception is OperationCanceledException ||
exception is ObjectDisposedException)
{
return;
}
await OnErrorAsync.Invoke(exception);
await RetryConnectionAsync();
}
}
/// <summary>
/// Initializes instance of <see cref="ClientWebSocket"/> and connects to server.
/// </summary>
public async Task ConnectAsync()
{
if (_webSocket.State == WebSocketState.Open)
{
throw new InvalidOperationException(
$"WebSocket is already in open state. Current state: {_webSocket.State}");
}
async Task VerifyConnectionAsync(Task task)
{
if (task.Exception != null)
{
await OnErrorAsync.Invoke(task.Exception);
await RetryConnectionAsync();
return;
}
_isConnected = true;
_connectionAttempts = 0;
_reconnectInterval = TimeSpan.Zero;
_cancellationToken = new CancellationTokenSource();
await OnOpenAsync.Invoke();
await ReceiveAsync();
}
try {
await _webSocket
.ConnectAsync(_url, CancellationToken.None)
.ContinueWith(VerifyConnectionAsync);
}
catch (Exception exception) {
if (!(exception is ObjectDisposedException))
{
return;
}
await RetryConnectionAsync();
}
}
/// <summary>
/// Closes connection to websocket server.
/// </summary>
/// <returns></returns>
public async Task DisconnectAsync(WebSocketCloseStatus closeStatus = WebSocketCloseStatus.NormalClosure,
string closeReason = "Normal closure.")
{
if (_webSocket.State != WebSocketState.Open)
{
throw new InvalidOperationException(
$"WebSocket is not in open state. Current state: {_webSocket.State}");
}
try {
await _webSocket.CloseAsync(closeStatus, closeReason, _cancellationToken.Token);
}
catch (Exception exception) {
await OnErrorAsync.Invoke(exception);
}
finally {
_isConnected = false;
_cancellationToken.Cancel(false);
await OnCloseAsync.Invoke(closeReason);
}
}
/// <summary>
/// A method to submitting a form in a modal.
/// </summary>
/// <returns>An instance of <see cref="Task"/>.</returns>
public async Task SubmitAsync()
{
try
{
await _loaderService.CreateAsync(); // Show the loader
await OnSubmitAsync.Invoke(); // Submit the form.
await DisposeAsync(); // Remove the modal.
await _loaderService.DisposeAsync(); // Remove the loader.
}
catch (Exception exception)
{
await DisposeAsync(); // Remove the modal.
await _loaderService.DisposeAsync(); // Remove the loader.
await OnErrorAsync.Invoke(exception); // Invoke the fact that there is an error.
}
}
/// <summary>
/// Used to send data to websocket server.
/// </summary>
/// <param name="value">Value of <typeparamref name="T"/></param>
/// <typeparam name="T">Type of data to set.</typeparam>
/// <exception cref="InvalidOperationException">Throws if not connected to websocket.</exception>
public async Task SendAsync <T>(T value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value), "Provided data was null.");
}
if (_webSocket.State != WebSocketState.Open)
{
throw new InvalidOperationException(
$"WebSocket is not in open state. Current state: {_webSocket.State}");
}
try {
var rawBytes = JsonSerializer.SerializeToUtf8Bytes(value, VictoriaExtensions.JsonOptions);
await _webSocket.SendAsync(rawBytes, WebSocketMessageType.Text, true, _cancellationToken.Token)
.ConfigureAwait(false);
}
catch (Exception exception) {
await OnErrorAsync.Invoke(exception);
}
}
