private async Task PublishAsync(PublishMessage message)
{
MessageAuditRecord record = null;
EventMetadata metadata = null;
try
{
MqttUri mqttUri = new MqttUri(message.Topic);
metadata = await graphManager.GetPiSystemMetadataAsync(mqttUri.Resource);
if (EventValidator.Validate(true, metadata, Channel, graphManager, context).Validated)
{
EventMessage msg = new EventMessage(mqttUri.ContentType, mqttUri.Resource, ProtocolType.MQTT,
message.Encode(), DateTime.UtcNow, metadata.Audit);
if (!string.IsNullOrEmpty(mqttUri.CacheKey))
{
msg.CacheKey = mqttUri.CacheKey;
}
if (mqttUri.Indexes != null)
{
List <KeyValuePair <string, string> > list = GetIndexes(mqttUri);
await adapter.PublishAsync(msg, list);
}
else
{
await adapter.PublishAsync(msg);
}
}
else
{
if (metadata.Audit)
{
record = new MessageAuditRecord("XXXXXXXXXXXX", session.Identity, Channel.TypeId, "MQTT",
message.Payload.Length, MessageDirectionType.In, false, DateTime.UtcNow,
"Not authorized, missing resource metadata, or channel encryption requirements");
}
throw new SecurityException(string.Format("'{0}' not authorized to publish to '{1}'",
session.Identity, metadata.ResourceUriString));
}
}
catch (Exception ex)
{
await logger?.LogErrorAsync(ex, $"MQTT adapter PublishAsync error on channel '{Channel.Id}'.");
OnError?.Invoke(this, new ProtocolAdapterErrorEventArgs(Channel.Id, ex));
}
finally
{
if (metadata != null && metadata.Audit && record != null)
{
await messageAuditor?.WriteAuditRecordAsync(record);
}
}
}
public async Task <CoapMessage> PostAsync(CoapMessage message)
{
try
{
CoapUri uri = new CoapUri(message.ResourceUri.ToString());
ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable;
EventMetadata metadata = await GraphManager.GetPiSystemMetadataAsync(uri.Resource);
if (!await adapter.CanPublishAsync(metadata, channel.IsEncrypted))
{
if (metadata.Audit)
{
await auditor?.WriteAuditRecordAsync(new MessageAuditRecord("XXXXXXXXXXXX", session.Identity, this.channel.TypeId, "COAP", message.Payload.Length, MessageDirectionType.In, false, DateTime.UtcNow, "Not authorized, missing resource metadata, or channel encryption requirements"));
}
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token));
}
string contentType = message.ContentType.HasValue ? message.ContentType.Value.ConvertToContentType() : "application/octet-stream";
EventMessage msg = new EventMessage(contentType, uri.Resource, ProtocolType.COAP, message.Encode(), DateTime.UtcNow, metadata.Audit);
if (!string.IsNullOrEmpty(uri.CacheKey))
{
msg.CacheKey = uri.CacheKey;
}
if (uri.Indexes == null)
{
await adapter.PublishAsync(msg);
}
else
{
List <KeyValuePair <string, string> > indexes = new List <KeyValuePair <string, string> >(uri.Indexes);
Task task = Retry.ExecuteAsync(async() =>
{
await adapter.PublishAsync(msg, indexes);
});
task.LogExceptions();
}
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Created, message.Token));
}
catch (Exception ex)
{
Trace.TraceError("{0} - CoAP publish error on channel '{1}'", DateTime.UtcNow.ToString("yyyy-MM-ddTHH-MM-ss.fffff"), channel.Id);
throw ex;
}
}
public async Task <CoapMessage> PostAsync(CoapMessage message)
{
try
{
CoapUri uri = new CoapUri(message.ResourceUri.ToString());
ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable;
EventMetadata metadata = await graphManager.GetPiSystemMetadataAsync(uri.Resource);
ValidatorResult result = EventValidator.Validate(true, metadata, null, graphManager);
if (!result.Validated)
{
if (metadata.Audit)
{
await auditor?.WriteAuditRecordAsync(new MessageAuditRecord("XXXXXXXXXXXX", session.Identity, this.channel.TypeId, "COAP", message.Payload.Length, MessageDirectionType.In, false, DateTime.UtcNow, "Not authorized, missing resource metadata, or channel encryption requirements")).LogExceptions(logger);
}
logger?.LogErrorAsync(result.ErrorMessage);
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token));
}
string contentType = message.ContentType.HasValue ? message.ContentType.Value.ConvertToContentType() : "application/octet-stream";
EventMessage msg = new EventMessage(contentType, uri.Resource, ProtocolType.COAP, message.Encode(), DateTime.UtcNow, metadata.Audit);
if (!string.IsNullOrEmpty(uri.CacheKey))
{
msg.CacheKey = uri.CacheKey;
}
if (uri.Indexes == null)
{
await adapter.PublishAsync(msg);
}
else
{
List <KeyValuePair <string, string> > indexes = GetIndexes(uri);
await adapter.PublishAsync(msg, indexes);
}
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Created, message.Token));
}
catch (Exception ex)
{
logger?.LogErrorAsync(ex, $"CoAP POST fault for {session.Identity}.");
throw ex;
}
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs e)
{
var metadata = graphManager.GetPiSystemMetadataAsync(resource).GetAwaiter().GetResult();
EventMessage msg = new EventMessage(contentType, resource, ProtocolType.WSN, e.Message, DateTime.UtcNow, metadata.Audit)
{
CacheKey = cacheKey
};
adapter.PublishAsync(msg, indexes).GetAwaiter();
}
private async Task PublishAsync(string identity, EventMessage message, List <KeyValuePair <string, string> > indexes = null)
{
EventMetadata metadata = await GraphManager.GetPiSystemMetadataAsync(message.ResourceUri);
if (await adapter.CanPublishAsync(metadata, Channel.IsEncrypted))
{
await adapter.PublishAsync(message, indexes);
}
else
{
if (metadata.Audit)
{
await messageAuditor?.WriteAuditRecordAsync(new MessageAuditRecord("XXXXXXXXXXXX", identity, this.Channel.TypeId, "REST", message.Message.Length, MessageDirectionType.In, false, DateTime.UtcNow, "Not authorized, missing resource metadata, or channel encryption requirements"));
}
}
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs e)
{
Exception error = null;
if (method == "POST" && string.IsNullOrEmpty(resource))
{
error = new Exception("REST adapter cannot send message without resource.");
}
if (method == "POST" && string.IsNullOrEmpty(contentType))
{
error = new Exception("REST adapter cannot send message without content-type.");
}
if (method == "POST" && (e.Message == null || e.Message.Length == 0))
{
error = new Exception("REST adapter cannot send empty message.");
}
if (method == "GET" && (subscriptions == null || subscriptions.Count() == 0))
{
error = new Exception("REST adapter cannot subscribe to '0' subscriptions.");
}
if (error != null)
{
logger?.LogWarningAsync(error.Message).GetAwaiter();
OnError?.Invoke(this, new ProtocolAdapterErrorEventArgs(channel.Id, error));
return;
}
try
{
if (method == "POST")
{
EventMessage message = new EventMessage(contentType, resource, protocolType, e.Message);
if (!string.IsNullOrEmpty(messageUri.CacheKey))
{
message.CacheKey = messageUri.CacheKey;
}
adapter.PublishAsync(message, indexes).GetAwaiter();
logger?.LogDebugAsync("REST adapter published message");
MessageAuditRecord record = new MessageAuditRecord(message.MessageId, identity, channel.TypeId, protocolType.ToString(), e.Message.Length, MessageDirectionType.In, true, DateTime.UtcNow);
messageAuditor?.WriteAuditRecordAsync(record).Ignore();
OnClose?.Invoke(this, new ProtocolAdapterCloseEventArgs(Channel.Id));
}
if (method == "GET")
{
foreach (var subscription in subscriptions)
{
SubscriptionMetadata metadata = new SubscriptionMetadata()
{
Identity = identity,
Indexes = indexes,
IsEphemeral = true
};
adapter.SubscribeAsync(subscription, metadata).GetAwaiter();
}
}
}
catch (Exception ex)
{
logger?.LogErrorAsync($"REST adapter processing error on receive - {ex.Message}");
OnError?.Invoke(this, new ProtocolAdapterErrorEventArgs(channel.Id, ex));
}
}
