/// <inheritdoc cref="IMqttRepositoryGrain" />
/// <summary>
/// Proceeds the disconnection for one client identifier.
/// </summary>
/// <param name="eventArgs">The event args.</param>
/// <returns>A <see cref="Task" /> returning any asynchronous operation.</returns>
/// <seealso cref="IMqttRepositoryGrain" />
public async Task ProceedDisconnect(MqttServerClientDisconnectedEventArgs eventArgs)
{
try
{
if (eventArgs == null)
{
return;
}
// Save disconnect to the database
var eventLog = new EventLog
{
EventType = EventType.Disconnect,
EventDetails = $"Disconnected: ClientId = {eventArgs.ClientId}, DisconnectType = {eventArgs.DisconnectType}."
};
await this.eventLogRepository.InsertEventLog(eventLog);
// Handle disconnect in grain
var mqttClientGrain = this.GrainFactory.GetGrain <IMqttClientGrain>(eventArgs.ClientId);
mqttClientGrain.ProceedDisconnect(eventArgs);
}
catch (Exception ex)
{
this.logger.Error("An error occured: {ex}.", ex);
}
}
internal void Server_ClientDisconnected(IMqttServerEx server, MqttServerClientDisconnectedEventArgs args)
{
Task.Run(async() =>
{
try
{
var dev = await FoundDevice(args.ClientId);
if (dev != null)
{
using (var scope = _scopeFactor.CreateScope())
using (var _dbContext = scope.ServiceProvider.GetRequiredService <ApplicationDbContext>())
{
var devtmp = _dbContext.Device.FirstOrDefault(d => d.Id == dev.Id);
devtmp.LastActive = DateTime.Now;
devtmp.Online = false;
_dbContext.SaveChanges();
_logger.LogInformation($"Server_ClientDisconnected ClientId:{args.ClientId} DisconnectType:{args.DisconnectType} Device is {devtmp.Name }({devtmp.Id}) ");
}
}
else
{
_logger.LogWarning($"Server_ClientDisconnected ClientId:{args.ClientId} DisconnectType:{args.DisconnectType}, 未能在缓存中找到");
}
}
catch (Exception ex)
{
_logger.LogError(ex, $"Server_ClientDisconnected ClientId:{args.ClientId} DisconnectType:{args.DisconnectType},{ex.Message}");
}
});
}
public async Task Fire_Client_Disconnected_Event()
{
using (var testEnvironment = CreateTestEnvironment())
{
var server = await testEnvironment.StartServer();
MqttServerClientDisconnectedEventArgs eventArgs = null;
server.ClientDisconnectedHandler = new MqttServerClientDisconnectedHandlerDelegate(e =>
{
eventArgs = e;
});
var client = await testEnvironment.ConnectClient(o => o.WithCredentials("TheUser"));
await client.DisconnectAsync();
await LongTestDelay();
Assert.IsNotNull(eventArgs);
Assert.IsTrue(eventArgs.ClientId.StartsWith(nameof(Fire_Client_Disconnected_Event)));
Assert.IsTrue(eventArgs.Endpoint.Contains("127.0.0.1"));
Assert.AreEqual(MqttClientDisconnectType.Clean, eventArgs.DisconnectType);
}
}
internal void Server_ClientDisconnected(IMqttServerEx server, MqttServerClientDisconnectedEventArgs args)
{
try
{
if (_device.Exists(args.ClientId))
{
var _xdev = _device.Get <Device>(args.ClientId);
var dev = _xdev.Value;
using (var scope = _scopeFactor.CreateScope())
using (var _dbContext = scope.ServiceProvider.GetRequiredService <ApplicationDbContext>())
{
var devtmp = _dbContext.Device.FirstOrDefault(d => d.Id == dev.Id);
devtmp.LastActive = DateTime.Now;
_dbContext.SaveChanges();
_logger.LogInformation($"Server_ClientDisconnected ClientId:{args.ClientId} DisconnectType:{args.DisconnectType} Device is {devtmp.Name }({devtmp.Id}) ");
}
}
else
{
_logger.LogWarning($"Server_ClientDisconnected ClientId:{args.ClientId} DisconnectType:{args.DisconnectType}, 未能在缓存中找到");
}
}
catch (Exception ex)
{
_logger.LogError(ex, $"Server_ClientDisconnected ClientId:{args.ClientId} DisconnectType:{args.DisconnectType},{ex.Message}");
}
}
public async Task HandleClientDisconnectedAsync(MqttServerClientDisconnectedEventArgs eventArgs)
{
System.Console.WriteLine($"Disconnected: {eventArgs.ClientId}");
var zigbeeClientId = _zigbeeSettings.Id;
var hubClientId = _clientSettings.Id;
if (eventArgs.ClientId != zigbeeClientId && eventArgs.ClientId != hubClientId)
{
using (var scope = _serviceScopeFactory.CreateScope())
{
var mediator = scope.ServiceProvider.GetService <IMediator>();
var device = await mediator.Send(new GetMqttDeviceByIdQuery()
{
Id = eventArgs.ClientId
});
await mediator.Send(
new UpdateMqttDeviceCommand()
{
Id = device.Id, isAvailable = false, isConfirmed = device.IsConfirmed
});
await _mqttServer.PublishAsync(_brokerEvents.NewClientDisconnected, eventArgs.ClientId);
}
}
}
public async Task HandleClientDisconnectedAsync(MqttServerClientDisconnectedEventArgs eventArgs)
{
var serializedData = Utf8Json.JsonSerializer.Serialize(new { ClientId = eventArgs.ClientId });
var message = new MqttApplicationMessageBuilder().WithTopic(eventTopics.NewClientDisconnected)
.WithPayload(serializedData)
.Build();
await mqttServer.PublishAsync(message);
}
public async Task HandleClientDisconnectedAsync(MqttServerClientDisconnectedEventArgs eventArgs)
{
lbxMessage.BeginInvoke(this.updateListBoxAction, $"<Client DisConnected:ClientId:{eventArgs.ClientId}");
var s = await this.mqttServer.GetClientStatusAsync();
this.sslMessage.Text = $"總連接數：{s.Count}";
}
private Task HandleClientDisconnectedAsync(MqttServerClientDisconnectedEventArgs eventArgs)
{
EventId eventId = GetNextEventId();
_logger.LogInformation(eventId, $"Client disconnected (Id: {eventArgs.ClientId})");
return(Task.CompletedTask);
}
public Task HandleClientDisconnectedAsync(MqttServerClientDisconnectedEventArgs eventArgs)
{
client--;
if (client < 1)
{
mqtt.StopAsync();
}
return(Task.FromResult(true));
}
internal void Server_ClientDisconnected(IMqttServerEx server, MqttServerClientDisconnectedEventArgs args)
{
try
{
Devices.Remove(args.ClientId);
}
catch (Exception)
{
}
}
/// <inheritdoc cref="IMqttClientGrain" />
/// <summary>
/// Proceeds the disconnection message for one client identifier.
/// </summary>
/// <param name="eventArgs">The event args.</param>
/// <seealso cref="IMqttClientGrain" />
public void ProceedDisconnect(MqttServerClientDisconnectedEventArgs eventArgs)
{
try
{
this.users.Remove(eventArgs.ClientId);
}
catch (Exception ex)
{
this.logger.Error("An error occured: {ex}.", ex);
}
}
/// <summary>
/// Handles the disconnect event.
/// </summary>
/// <param name="eventArgs">The MQTT client unsubscribed event args.</param>
private void HandleDisconnect(MqttServerClientDisconnectedEventArgs eventArgs)
{
if (this.cancellationToken.IsCancellationRequested)
{
return;
}
var repositoryGrain = this.clusterClient.GetGrain <IMqttRepositoryGrain>(0);
repositoryGrain.ProceedDisconnect(eventArgs);
}
internal void Server_ClientDisconnected(object sender, MqttServerClientDisconnectedEventArgs e)
{
Task.Run(async() =>
{
var svr = ((IMqttServer)sender);
var lst = await svr?.GetSessionStatusAsync();
if (_sessions.ContainsKey(e.ClientId))
{
_sessions.Remove(e.ClientId);
}
});
}
public async Task HandleClientDisconnectedAsync(MqttServerClientDisconnectedEventArgs eventArgs)
{
var message = new MqttDisconnectMessage()
{
ClientId = eventArgs.ClientId,
};
if (string.Equals(message.ClientId, _configuration.GetSection("MQTT").GetSection("MqttClientEnactorName").Value) == false)
{
await _endpoint.Request <HttpStatusCode>(message).ConfigureAwait(false);
}
}
/// <summary>
/// Validates the MQTT client disconnect.
/// </summary>
/// <param name="eventArgs">The event args.</param>
/// <returns>A <see cref="Task"/> representing any asynchronous operation.</returns>
public async Task HandleClientDisconnectedAsync(MqttServerClientDisconnectedEventArgs eventArgs)
{
try
{
var repositoryGrain = clusterClient.GetGrain <IMqttRepositoryGrain>(0);
await repositoryGrain.ProceedDisconnect(eventArgs);
}
catch (Exception ex)
{
this.logger.Error("An error occurred: {@ex}.", ex);
}
}
public static void ClientDisconnectedHandler(MqttServerClientDisconnectedEventArgs args)
{
try
{
var clientID = args.ClientId;
var mqttClientDisconnectType = args.DisconnectType;
}
catch (Exception ex)
{
mqttServiceLogger.LogError(ex.Message);
}
}
public Task HandleClientDisconnectedAsync(MqttServerClientDisconnectedEventArgs context)
{
try
{
_logger.LogInformation($"Client disconnected: {context.ClientId}, Disconnect Type: {context.DisconnectType}");
}
catch (Exception exception)
{
_logger.LogError(exception, "Error while handling client disconnected event.");
}
return(Task.CompletedTask);
}
public async Task HandleClientDisconnectedAsync(MqttServerClientDisconnectedEventArgs eventArgs)
{
_logger.LogInformation($"Client: {eventArgs.ClientId} disconnected!");
var message = new MqttApplicationMessageBuilder()
.WithTopic($"clients/{eventArgs.ClientId}/disconnect")
.WithPayload(eventArgs.ClientId)
.WithExactlyOnceQoS()
.WithContentType("client_event")
.Build();
await this._mqttServer.PublishAsync(message);
}
/// <summary>
/// Fired when a client disconnects
/// </summary>
/// <param name="eventArgs">MqttServerClientDisconnectedEventArgs</param>
/// <returns>Task</returns>
public Task HandleClientDisconnectedAsync(MqttServerClientDisconnectedEventArgs eventArgs)
{
// Ignore uncategorized nodes / UI clients
if (!nodeStates.TryRemove(eventArgs.ClientId, out var state) || state == null)
{
return(Task.CompletedTask);
}
Helper.Log(new LogMessage(LogSeverity.Info, nameof(MqttService), $"Disconnected from client {eventArgs.ClientId}"));
state.IsActive = false;
Helper.SendClientStatus(mqtt, eventArgs.ClientId, state).GetAwaiter().GetResult();
Helper.SendConnectedClients(mqtt, nodeStates).GetAwaiter().GetResult();
return(Task.CompletedTask);
}
public async Task HandleClientDisconnectedAsync(MqttServerClientDisconnectedEventArgs eventArgs)
{
Debug.WriteLine($"Client disconnected {eventArgs.ClientId}");
await _mqttServer.ClearRetainedApplicationMessagesAsync();
try
{
await _restClient.DisableLightPoint(Guid.Parse(eventArgs.ClientId));
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public async Task HandleClientDisconnectedAsync(MqttServerClientDisconnectedEventArgs eventArgs)
{
var clientStatus = await mqttServer.GetClientStatusAsync();
var client = clientStatus.Where(c => c.ClientId == eventArgs.ClientId).FirstOrDefault();
if (client == null)
{
Publisher publisher;
if (publishers.Remove(eventArgs.ClientId, out publisher))
{
publisher.DeregisterAll();
}
}
GC.Collect();
GC.WaitForPendingFinalizers();
}
public Task HandleClientDisconnectedAsync(MqttServerClientDisconnectedEventArgs eventArgs)
{
try
{
var pythonEventArgs = new PythonDictionary
{
{ "client_id", eventArgs.ClientId },
{ "type", PythonConvert.Pythonfy(eventArgs.DisconnectType) }
};
_pythonScriptHostService.InvokeOptionalFunction("on_client_disconnected", pythonEventArgs);
}
catch (Exception exception)
{
_logger.LogError(exception, "Error while handling client disconnected event.");
}
return(Task.CompletedTask);
}
public async Task HandleClientDisconnectedAsync(MqttServerClientDisconnectedEventArgs eventArgs)
{
if (string.IsNullOrEmpty(eventArgs.ClientId))
{
await Task.CompletedTask;
}
var message = new MqttApplicationMessageBuilder()
.WithTopic($"disconnected/{eventArgs.ClientId}")
.WithPayload(eventArgs.ClientId)
.WithExactlyOnceQoS()
.Build();
await _mqttServer.PublishAsync(message);
_logger.LogInformation($"Device disconnected - {eventArgs.ClientId}, {eventArgs.DisconnectType} ");
await Task.CompletedTask;
}
/// <inheritdoc cref="IMqttRepositoryGrain" />
/// <summary>
/// Proceeds the disconnection for one client identifier.
/// </summary>
/// <param name="eventArgs">The event args.</param>
/// <returns>A <see cref="Task" /> returning any asynchronous operation.</returns>
/// <seealso cref="IMqttRepositoryGrain" />
public Task ProceedDisconnect(MqttServerClientDisconnectedEventArgs eventArgs)
{
if (eventArgs == null)
{
throw new ArgumentNullException(nameof(eventArgs));
}
if (string.IsNullOrWhiteSpace(eventArgs.ClientId))
{
throw new ArgumentNullException(nameof(eventArgs.ClientId));
}
// Save disconnect to the database
var eventLog = new EventLog
{
EventType = EventType.Disconnect,
EventDetails = $"Disconnected: ClientId = {eventArgs.ClientId}, DisconnectType = {eventArgs.DisconnectType}."
};
this.eventLogQueue.Enqueue(eventLog);
return(Task.CompletedTask);
}
/// <summary>
/// 客户连接断开
/// </summary>
private void MqttNetServer_ClientDisConnected(MqttServerClientDisconnectedEventArgs e)
{
string ClientId = e.ClientId;
log.LogInformation($"client [{ClientId}] disconnected");
}
public Task HandleClientDisconnectedAsync(MqttServerClientDisconnectedEventArgs eventArgs)
{
Disconnected?.Invoke(this, eventArgs);
return(null);
}
private void OnDisconnected(MqttServerClientDisconnectedEventArgs e)
{
Console.WriteLine("Client Disconnected:" + e.ClientId);
clientSession.Remove(e.ClientId);
}
/// <summary>
/// 客户连接断开
/// </summary>
/// <param name="e"></param>
private static void MqttNetServer_ClientDisConnected(MqttServerClientDisconnectedEventArgs e)
{
var ClientId = e.ClientId;
Console.WriteLine($"客户端[{ClientId}]已断开连接");
}
private static Task ClientDisconnectedHandler(MqttServerClientDisconnectedEventArgs arg)
{
//Console.WriteLine($"Client {arg.ClientId} disconnected");
return(Task.FromResult(12));
}
public Task HandleClientDisconnectedAsync(MqttServerClientDisconnectedEventArgs eventArgs)
{
_logger.LogInformation($"Client Disconnect {eventArgs.ClientId} , {eventArgs.DisconnectType}");
return(Task.CompletedTask);
}
