public async Task <OutboundResponse> Handle(OutboundRequest request, CancellationToken cancellationToken)
{
// TODO handle response
if (request.Payload != null)
{
await _mqttClient.PublishAsync(builder =>
builder
.WithTopic(request.Topic)
.WithMessage(request.Message)
.WithPayload(request.Payload)
.WithCorrelationData(request.CorrelationData)
.WithUserProperty("messageType", request.MessageType)
.WithUserProperty("payloadType", request.PayloadType)
.WithUserProperty("serialization", "json")
.WithUserProperty("encoding", "utf8")
, cancellationToken);
}
else
{
await _mqttClient.PublishAsync(builder =>
builder
.WithTopic(request.Topic)
.WithMessage(request.Message)
.WithUserProperty("messageType", request.MessageType)
, cancellationToken);
}
return(new OutboundResponse()
{
Success = true
});
}
public async Task PublishAsync(MqttApplicationMessage message)
{
if (clientMqtt != null)
{
await clientMqtt.PublishAsync(message);
}
}
private async void TimerCallback(object stateInfo)
{
_timersMutex.WaitOne();
try
{
var timerDetails = (TimerDetails)stateInfo;
var topic = $"mqtttimer/{timerDetails.Name}";
_logger.LogInformation($"Timer callback for {timerDetails.Name} called.");
_logger.LogInformation($"Publishing payload '{timerDetails.ResponsePayload}' to topic {topic}");
var managedMqttApplicationMessage = new ManagedMqttApplicationMessageBuilder()
.WithApplicationMessage(new MqttApplicationMessageBuilder()
.WithTopic(topic)
.WithPayload(timerDetails.ResponsePayload)
.WithAtLeastOnceQoS()
.WithRetainFlag()
.Build())
.Build();
await _mqttClient.PublishAsync(managedMqttApplicationMessage);
}
finally
{
_timersMutex.ReleaseMutex();
}
}
public async Task Handle(OutboundNotification notification, CancellationToken cancellationToken)
{
if (notification.Payload != null)
{
await _mqttClient.PublishAsync(builder =>
builder
.WithTopic(notification.Topic)
.WithMessage(notification.Message)
.WithPayload(notification.Payload)
.WithUserProperty("messageType", notification.MessageType)
.WithUserProperty("payloadType", notification.PayloadType)
.WithUserProperty("serialization", "json")
.WithUserProperty("encoding", "utf8")
, cancellationToken);
}
else
{
await _mqttClient.PublishAsync(builder =>
builder
.WithTopic(notification.Topic)
.WithMessage(notification.Message)
.WithUserProperty("messageType", notification.MessageType)
, cancellationToken);
}
}
private async void PowerOnAsync()
{
airconPowerToolStripMenuItem.Checked = true;
notifyIcon1.Icon = Properties.Resources.PowerOn;
#if DEBUG
Console.WriteLine("Power On");
#else
await mqttClient.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("cmnd/" + TB_DevID.Text + "/mode").WithPayload("cool").Build());
#endif
}
public async Task OtaUpdateDevice(string deviceFriendlyName)
{
var device = _stateService.FindDeviceById(deviceFriendlyName, out _);
var msg = new MqttApplicationMessageBuilder()
.WithTopic($"{_settings.CurrentSettings.BaseTopic}/bridge/ota_update/update")
.WithPayload(device.FriendlyName)
.Build();
await _client.PublishAsync(msg);
}
/// <summary>
/// Publish Message.
/// </summary>
/// <param name="topic">Topic.</param>
/// <param name="payload">Payload.</param>
/// <param name="retainFlag">Retain flag.</param>
/// <param name="qos">Quality of Service.</param>
/// <returns>Task.</returns>
public static async Task PublishAsync(string topic, string payload, bool retainFlag = true, int qos = 1) =>
await client.PublishAsync(new MqttApplicationMessageBuilder()
.WithTopic(topic)
.WithPayload(payload)
.WithQualityOfServiceLevel((MQTTnet.Protocol.MqttQualityOfServiceLevel)qos)
.WithRetainFlag(retainFlag)
.Build());
async void LogEventRaised(object sender, LogEventArgs e)
{
if (mqttClient == null || mqttClient.IsConnected == false)
{
return;
}
string json = JsonConvert.SerializeObject(e);
var applicationMessage = new MqttApplicationMessageBuilder()
.WithTopic("log/" + e.Assembly)
.WithPayload(json)
.WithAtLeastOnceQoS()
.WithRetainFlag(false)
.Build();
await mqttClient.PublishAsync(applicationMessage);
}
public async void Receive(Message receivedMessage)
{
_logger.Debug($"IoT Edge Message Received from Broker: {JsonConvert.SerializeObject(receivedMessage)}");
try
{
if (!receivedMessage.Properties.ContainsKey("source"))
{
_logger.Debug("IoT Edge Message received from unknown source");
return;
}
if (!_moduleConfiguration.ExpectedSources.Contains(receivedMessage.Properties["source"]))
{
_logger.Debug($"IoT Edge Message received from a non-expected source: {receivedMessage.Properties["source"]}");
return;
}
// Let's forward it along to Smart Connector.
var messageString = Encoding.ASCII.GetString(receivedMessage.Content);
_logger.Debug($"Message: {messageString}");
await _managedMqttClient.PublishAsync(_moduleConfiguration.MqttValueSendTopic, messageString, MqttQualityOfServiceLevel.AtLeastOnce, true);
}
catch (Exception ex)
{
_logger.Error(ex.ToString());
}
}
private async Task PublishMessage(IManagedMqttClient mqttClient, string topic, string payload, bool retain,
MqttQualityOfServiceLevel qos)
{
var message = new MqttApplicationMessageBuilder().WithTopic(topic)
.WithPayload(payload)
.WithRetainFlag(retain)
.WithQualityOfServiceLevel(qos)
.Build();
_logger.LogDebug("MQTT sending to {Topic}: {Message}", message.Topic, message.ConvertPayloadToString());
try
{
var publishResult = await mqttClient.PublishAsync(message, CancellationToken.None).ConfigureAwait(false);
if (publishResult.ReasonCode != MqttClientPublishReasonCode.Success)
{
throw new MqttPublishException(publishResult.ReasonString);
}
}
catch (Exception e)
{
_logger.LogError(e.Message, e);
throw new MqttPublishException(e.Message, e);
}
}
public async Task SendAsync(IMessage message)
{
if (disposedValue)
{
throw new InvalidOperationException("Client is disposed.");
}
await clientLock.WaitAsync();
try
{
if (client == null)
{
throw new InvalidOperationException($"{nameof(MqttClient)} has to be started to send messages.");
}
var mqttMessage = new MqttApplicationMessageBuilder()
.WithTopic(message.Topic)
.WithPayload(JsonConvert.SerializeObject(message))
//.WithExactlyOnceQoS() // Fails with exception and disconnect!
.Build();
await client.PublishAsync(mqttMessage);
}
finally
{
clientLock.Release();
}
}
public void PublishMessage(RawMessage message)
{
string topic = message.Topic;
Log.Debug("publish message topic = " + topic);
if (string.IsNullOrEmpty(topic))
{
Log.Error("publish message is null");
return;
}
var appMsg = new MqttApplicationMessage();
appMsg.Payload = Encoding.UTF8.GetBytes(message.Payload);
appMsg.Topic = topic;
appMsg.QualityOfServiceLevel = clientConf.Qos;
appMsg.Retain = false;
// 上行响应
client.PublishAsync(appMsg).Wait();
Log.Debug($"publish msg : publishing message is " + message.Payload);
}
// FIXME?(AFL): kinda ugly signature
public void SendRequest(TRequest request, TimeSpan?requestTimeout, string destinationClientID = null, bool retained = false)
{
requestTimeout = requestTimeout ?? TimeSpan.FromSeconds(20);
var wrappedRequest = _requestSerializer.SerializeMessage(request);
wrappedRequest.Source = _client.Options.ClientOptions.ClientId;;
wrappedRequest.Destination = destinationClientID;
var payload = _requestSerializer.SerializeWrapper(wrappedRequest);
var packedMessage = new MqttApplicationMessageBuilder()
.WithTopic(RequestTopic)
.WithPayload(payload)
.WithQualityOfServiceLevel(_qosLevel)
.WithRetainFlag(retained)
.Build();
try
{
_client.PublishAsync(packedMessage, _cancellationToken.Token).Wait();
}
catch (Exception e)
{
Log.Error($"Failed to publish response message on topic \"{ResponseTopic}\". Exception: {e}");
throw;
}
}
public async void PublishMessage(string topic, string message)
{
MqttApplicationMessageBuilder messageBuilder = new MqttApplicationMessageBuilder()
.WithTopic(topic)
.WithPayload(message);
await client.PublishAsync(messageBuilder.Build(), CancellationToken.None);
}
public void MQTTPublishMessage(string topic, byte[] payload)
{
topic = topic.Replace("//", "/");
var message = new MqttApplicationMessageBuilder()
.WithTopic(topic)
.WithPayload(payload)
.WithExactlyOnceQoS()
.WithRetainFlag()
.Build();
Debug.Log("newClient publishes message: " + topic);
client.PublishAsync(message);
currentlyProcessingMessages.Add(message.GetHashCode());
}
private async Task SendAsync(PacketContainer container, IRoutingInformation routingInfos)
{
await _client.PublishAsync(builder => builder
.WithPayload(_serializer.Serialize(container))
.WithTopic(routingInfos.OutgoingTopic)
.WithExactlyOnceQoS());
}
public async Task PublishMessage(TMessage message, bool retained = false)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var payload = _serializer.Serialize(message);
var packedMessage = new MqttApplicationMessageBuilder()
.WithTopic(Topic)
.WithPayload(payload)
.WithQualityOfServiceLevel(_qosLevel)
.WithRetainFlag(retained)
.Build();
try
{
await _client.PublishAsync(packedMessage, _cancellationToken.Token);
}
catch (Exception e)
{
Log.Error($"Failed to publish message on topic \"{Topic}\". Exception: {e}");
throw;
}
}
public void Stop()
{
Policy
.HandleResult <MqttClientPublishResult>(r => r.ReasonCode == MqttClientPublishReasonCode.UnspecifiedError)
.WaitAndRetry(5, retryAttempt => TimeSpan.FromSeconds(2),
(exception, timespan) => _logger.LogWarning("Error sending offline message. Retrying..."))
.Execute(() =>
{
var message = _mqttClient.PublishAsync(_lwtMessage);
message.Wait();
return(message.Result);
});
_mqttClient.StopAsync().Wait();
_logger.LogDebug("Stopped client");
_mqttClient.Dispose();
}
/// <summary>
/// Publish a message on to the MQTT broker.
/// </summary>
/// <param name="message">The message to publish.</param>
public async Task PublishAsync(MqttApplicationMessage message)
{
if (_managedMqttClient == null)
{
throw new MqttConnectionException("Connection not open, please use StartAsync first!");
}
await _managedMqttClient.PublishAsync(message).ConfigureAwait(false);
}
async void MQTTPublish()
{
try
{
string json = @"{
'Name': 'Bad Boys',
'ReleaseDate': '1995-4-7T00:00:00',
'Genres': [
'Action',
'Comedy'
]
}";
string test = @"{
'updateId': 5,
'nodeId': 'ns=2;s=cnc362.cnc362.Cycle_Counter_Shift_SL',
'name':'Cycle_Counter_Shift_SL',
'plexus_Customer_No':'310507',
'pcn': 'Avilla',
'workcenter_Key': '61314',
'workcenter_Code': 'Honda Civic cnc 359 362',
'cnc': '362',
'value': 0,
'transDate': '2020-06-29 00:00:00'
}";
Node node = new Node();
Console.WriteLine("node.updateId {0}",node.updateId);
Console.WriteLine("node.nodeId {0}", node.nodeId);
Console.WriteLine("node.name {0}", node.name);
// https://stackoverflow.com/questions/7574606/left-function-in-c-sharp/7574645
node.value = partCounter;
string json2 = JsonConvert.SerializeObject(node);
Console.WriteLine("json2=> {0}", json2);
var payload = Encoding.UTF8.GetBytes(json2);
// var payload = Encoding.UTF8.GetBytes(partCounter);
var message = new MqttApplicationMessageBuilder().WithTopic("presence").WithPayload(payload).WithQualityOfServiceLevel(MqttQualityOfServiceLevel.AtLeastOnce).WithRetainFlag().Build();
if (managedMqttClientPublisher != null)
{
await managedMqttClientPublisher.PublishAsync(message);
Console.WriteLine("Published Message=>{0}", message);
}
else
{
throw new Exception("MQTTPublish => Not connected to MQTT server");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private async Task OnMessageReceived(MqttApplicationMessageReceivedEventArgs arg)
{
var messageTypeString = arg.ApplicationMessage
.UserProperties?
.FirstOrDefault(p => p.Name == "messageType")?
.Value;
var responseTypeString = arg.ApplicationMessage
.UserProperties?
.FirstOrDefault(p => p.Name == "responseType")?
.Value;
// Only if there is a responseType specifed do we do request/response processing
// Otherwise we treat it as a notification.
// Notification
if (responseTypeString == null)
{
var messageType = MessageTypeMapper(messageTypeString);
Type[] typeArgs = { messageType };
var generic = typeof(InboundNotification <>);
var constructedType = generic.MakeGenericType(typeArgs);
var notifyObject = Activator.CreateInstance(constructedType);
var inboundNotification = notifyObject as IInboundNotification;
inboundNotification.RawMessage = arg.ApplicationMessage;
inboundNotification.PropertyBag["messageType"] = messageTypeString;
await _mediator.Publish(notifyObject);
}
// Request/Response
else
{
var messageType = MessageTypeMapper(messageTypeString);
Type[] typeArgs = { messageType };
var generic = typeof(InboundRequest <>);
var constructedType = generic.MakeGenericType(typeArgs);
var requestObject = Activator.CreateInstance(constructedType);
var inboundRequest = requestObject as IInboundRequest;
inboundRequest.RawMessage = arg.ApplicationMessage;
inboundRequest.PropertyBag["messageType"] = messageTypeString;
inboundRequest.PropertyBag["responseType"] = responseTypeString;
inboundRequest.ResponseTopic = arg.ApplicationMessage.ResponseTopic;
inboundRequest.CorrelationData = arg.ApplicationMessage.CorrelationData;
var response = await _mediator.Send(requestObject) as InboundResponse;
arg.ProcessingFailed = !response.Success;
await Task.Run(async() => await _mqttClient.PublishAsync(builder =>
builder
.WithTopic(response.Topic)
.WithPayload(response.Payload)
.WithCorrelationData(response.CorrelationData)
.WithUserProperty("messageType", response.MessageType)
.WithUserProperty("payloadType", response.PayloadType)));
}
}
private void SendMessage(int siteId, string type, string valueName, string value)
{
var message = new MqttApplicationMessageBuilder()
.WithTopic($"solaredge/state/{siteId}/{type.ToLowerInvariant()}/{valueName.ToLowerInvariant()}")
.WithPayload(value)
.Build();
_managedMqttClient.PublishAsync(message).Wait();
}
public async Task PublishAsync(string topic, string payload)
{
var applicationMessage = new MqttApplicationMessageBuilder().WithTopic(topic)
.WithPayload(payload)
.Build();
var manegedApplicationMessage = new ManagedMqttApplicationMessageBuilder().WithApplicationMessage(applicationMessage)
.Build();
await _mqttClient.PublishAsync(manegedApplicationMessage);
}
public async Task SendMessageAsync(string topic, string message)
{
var msg = new MqttApplicationMessageBuilder()
.WithTopic(topic)
.WithPayload(message)
.Build();
await _mqttClient.PublishAsync(msg);
}
private async Task CountAsync()
{
await Semaphore.WaitAsync().ConfigureAwait(false);
try
{
using var scope = _scopeFactory.CreateScope();
var dbContext = scope.ServiceProvider.GetRequiredService <ApplicationDbContext>();
if (executionCount >= 100)
{
executionCount = 0;
}
var count = Interlocked.Increment(ref executionCount);
_logger.LogInformation("[MQTT] Counter is working. Count: {Count}", count);
var counters = dbContext.Counters.ToList();
counters.Add(new Common.Counter
{
NodeId = _serviceSettings.NodeId,
Count = count,
LocalRecordTime = DateTime.Now
});
if (_client.IsConnected)
{
var message = new MqttApplicationMessageBuilder()
.WithTopic("/count")
.WithPayload(JsonSerializer.Serialize(counters.AsEnumerable()))
.WithAtLeastOnceQoS()
.Build();
await _client.PublishAsync(message, CancellationToken.None);
if (dbContext.Counters.Any())
{
_logger.LogTrace("[MQTT] succeeded. going to delete localDb records");
dbContext.Counters.RemoveRange(dbContext.Counters);
await dbContext.SaveChangesAsync();
}
}
else
{
await dbContext.Counters.AddAsync(new Common.Counter
{
NodeId = _serviceSettings.NodeId,
Count = count,
LocalRecordTime = DateTime.Now
});
await dbContext.SaveChangesAsync();
_logger.LogWarning("[MQTT] failed. Recorded to localDb: {Count}", count);
}
}
finally
{
Semaphore.Release();
}
}
public static Task SendJsonAsync(this IManagedMqttClient mqttClient, string topic, JToken doc, CancellationToken token = default)
{
return(mqttClient.PublishAsync(new MqttApplicationMessage
{
Topic = topic,
Retain = true,
QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce,
Payload = ConvertJson(doc)
}, token));
}
public async Task Publish(string topic, string payload)
{
_logger.LogInformation($"Publishing Topic: {topic} Payload: {payload}");
await _mqttClient.PublishAsync(new MqttApplicationMessageBuilder()
.WithTopic(topic)
.WithPayload(payload)
.WithQualityOfServiceLevel(MqttQualityOfServiceLevel.ExactlyOnce)
.WithRetainFlag()
.Build());
}
public async Task PublishAsync(string topic, string payload, bool retainFlag = false, int qos = 2)
{
_logger.LogInformation("she efe pami ni");
await _client.PublishAsync(new MqttApplicationMessageBuilder()
.WithTopic (topic)
.WithPayload (payload)
.WithQualityOfServiceLevel ((MQTTnet.Protocol.MqttQualityOfServiceLevel)qos)
.WithRetainFlag (retainFlag)
.Build());
}
private async Task PublishAsync(String topic, String value)
{
var message = new MqttApplicationMessageBuilder()
.WithTopic(topic)
.WithPayload(value)
.WithExactlyOnceQoS()
// .WithRetainFlag()
.Build();
await MqttClient.PublishAsync(message);
}
private async Task SetLastSeen()
{
var msg = new MqttApplicationMessageBuilder()
.WithTopic($"{_settings.CurrentSettings.BaseTopic}/bridge/config/last_seen")
.WithPayload("epoch")
.Build();
await _client.PublishAsync(msg);
}
