public void ValidateTag(string tag, bool isValid)
{
var ev = new Event {
Type = Event.KnownTypes.Error, Date = DateTimeOffset.Now
};
ev.Tags.Add(tag);
var result = _validator.Validate(ev);
Assert.Equal(isValid, result.IsValid);
}
public async Task <CoapMessage> PutAsync(CoapMessage message)
{
CoapUri uri = new CoapUri(message.ResourceUri.ToString());
ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable;
//EventValidator.Validate(false, resourceUriString, Channel, graphManager, context).Validated
//if (!await adapter.CanSubscribeAsync(uri.Resource, channel.IsEncrypted))
if (EventValidator.Validate(false, uri.Resource, channel, graphManager).Validated)
{
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token));
}
if (coapObserved.ContainsKey(uri.Resource) || coapUnobserved.Contains(uri.Resource))
{
//resource previously subscribed
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.NotAcceptable, message.Token));
}
//this point the resource is not being observed, so we can
// #1 subscribe to it
// #2 add to unobserved resources (means not coap observed)
SubscriptionMetadata metadata = new SubscriptionMetadata()
{
IsEphemeral = true,
Identity = session.Identity,
Indexes = session.Indexes
};
string subscriptionUriString = await adapter.SubscribeAsync(uri.Resource, metadata);
coapUnobserved.Add(uri.Resource);
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Created, message.Token));
}
public async Task <CoapMessage> ObserveAsync(CoapMessage message)
{
if (!message.Observe.HasValue)
{
//RST because GET needs to be observe/unobserve
await logger?.LogWarningAsync($"CoAP observe received without Observe flag and will return RST for {session.Identity}");
await logger?.LogDebugAsync($"Returning RST because GET needs to be observe/unobserve for {session.Identity}");
return(new CoapResponse(message.MessageId, ResponseMessageType.Reset, ResponseCodeType.EmptyMessage));
}
CoapUri uri = new CoapUri(message.ResourceUri.ToString());
ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable;
ValidatorResult result = EventValidator.Validate(false, uri.Resource, channel, graphManager);
if (!result.Validated)
{
await logger?.LogErrorAsync($"{result.ErrorMessage} for {session.Identity}");
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token));
}
if (!message.Observe.Value)
{
//unsubscribe
await logger?.LogInformationAsync($"CoAP unobserve '{message.ResourceUri.ToString()}' for {session.Identity}.");
await adapter.UnsubscribeAsync(uri.Resource);
await logger?.LogDebugAsync($"CoAP unsubscribed '{message.ResourceUri.ToString()} for {session.Identity}'.");
coapObserved.Remove(uri.Resource);
}
else
{
//subscribe
SubscriptionMetadata metadata = new SubscriptionMetadata()
{
IsEphemeral = true,
Identity = session.Identity,
Indexes = session.Indexes
};
await logger?.LogInformationAsync($"CoAP subscribed '{message.ResourceUri.ToString()}' for {session.Identity}");
string subscriptionUriString = await adapter.SubscribeAsync(uri.Resource, metadata);
if (!coapObserved.ContainsKey(uri.Resource)) //add resource to observed list
{
coapObserved.Add(uri.Resource, message.Token);
await logger?.LogDebugAsync("Key added to observable resource.");
}
}
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Valid, message.Token));
}
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);
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;
}
}
public async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req, ILogger log)
{
var newEvent = JsonConvert.DeserializeObject <Event>(await req.ReadAsStringAsync());
var validator = new EventValidator();
var validatorResults = validator.Validate(newEvent);
if (!validatorResults.IsValid)
{
return(new BadRequestObjectResult(validatorResults.Errors));
}
await newEvent.SaveAsync(Repository);
return(new JsonResult(newEvent));
}
public Notification <bool> CreateEvent(Event ev)
{
ev.SetId(GetMaxId() + 1);
EventValidator validator = new EventValidator(ev);
bool valid = validator.Validate();
Notification <bool> notifier = new Notification <bool>();
if (!valid)
{
foreach (var error in validator.GetErrors())
{
notifier.AddError(error);
}
notifier.SetResult(false);
}
else
{
notifier.SetResult(eventRepo.Create(ev));
}
return(notifier);
}
private void Session_OnUnsubscribe(object sender, MqttMessageEventArgs args)
{
try
{
UnsubscribeMessage msg = (UnsubscribeMessage)args.Message;
foreach (var item in msg.Topics)
{
MqttUri uri = new MqttUri(item.ToLowerInvariant());
if (EventValidator.Validate(false, uri.Resource, Channel, graphManager, context).Validated)
{
adapter.UnsubscribeAsync(uri.Resource).GetAwaiter();
logger?.LogInformationAsync($"MQTT adapter unsubscribed {uri.ToString()}");
}
}
}
catch (Exception ex)
{
logger?.LogErrorAsync(ex, $"MQTT adapter Session_OnUnsubscribe error on channel '{Channel.Id}'.").GetAwaiter();
OnError?.Invoke(this, new ProtocolAdapterErrorEventArgs(Channel.Id, ex));
}
}
private List <string> Session_OnSubscribe(object sender, MqttMessageEventArgs args)
{
List <string> list = new List <string>();
try
{
SubscribeMessage message = args.Message as SubscribeMessage;
SubscriptionMetadata metadata = new SubscriptionMetadata
{
Identity = session.Identity,
Indexes = session.Indexes,
IsEphemeral = true
};
foreach (var item in message.Topics)
{
MqttUri uri = new MqttUri(item.Key);
string resourceUriString = uri.Resource;
if (EventValidator.Validate(false, resourceUriString, Channel, graphManager, context).Validated)
{
Task <string> subTask = Subscribe(resourceUriString, metadata);
string subscriptionUriString = subTask.Result;
list.Add(resourceUriString);
}
}
}
catch (Exception ex)
{
logger?.LogErrorAsync(ex, $"MQTT adapter Session_OnSubscribe error on channel '{Channel.Id}'.")
.GetAwaiter();
OnError?.Invoke(this, new ProtocolAdapterErrorEventArgs(Channel.Id, ex));
}
return(list);
}
public void ForValidEvent_DoesNotThrowException()
{
FluentActions.Invoking(() => validator.Validate(command))
.Should().NotThrow();
}