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)); } }