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));
}
public async Task <CoapMessage> ObserveAsync(CoapMessage message)
{
if (!message.Observe.HasValue)
{
//RST because GET needs to be observe/unobserve
Trace.TraceWarning("{0} - CoAP observe received without Observe flag set on channel '{1}', returning RST", DateTime.UtcNow.ToString("yyyy-MM-ddTHH-MM-ss.fffff"), channel.Id);
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;
if (!await adapter.CanSubscribeAsync(uri.Resource, channel.IsEncrypted))
{
//not authorized
Trace.TraceWarning("{0} - CoAP observe not authorized on channel '{1}'", DateTime.UtcNow.ToString("yyyy-MM-ddTHH-MM-ss.fffff"), channel.Id);
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token));
}
if (!message.Observe.Value)
{
//unsubscribe
Trace.TraceWarning("{0} - CoAP observe with value on channel '{1}', unsubscribing.", DateTime.UtcNow.ToString("yyyy-MM-ddTHH-MM-ss.fffff"), channel.Id);
await adapter.UnsubscribeAsync(uri.Resource);
coapObserved.Remove(uri.Resource);
}
else
{
//subscribe
SubscriptionMetadata metadata = new SubscriptionMetadata()
{
IsEphemeral = true,
Identity = session.Identity,
Indexes = session.Indexes
};
string subscriptionUriString = await adapter.SubscribeAsync(uri.Resource, metadata);
if (!coapObserved.ContainsKey(uri.Resource)) //add resource to observed list
{
coapObserved.Add(uri.Resource, message.Token);
}
}
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Valid, message.Token));
}
private void Channel_OnOpen(object sender, ChannelOpenEventArgs e)
{
if (!Channel.IsAuthenticated)
{
OnError?.Invoke(this,
new ProtocolAdapterErrorEventArgs(Channel.Id,
new SecurityException("Not authenticated on WSN channel")));
Channel.CloseAsync().Ignore();
return;
}
adapter = new OrleansAdapter(identity, "WebSocket", "WSN", graphManager);
adapter.OnObserve += Adapter_OnObserve;
if (subscriptions != null)
{
foreach (var sub in subscriptions)
{
SubscriptionMetadata metadata = new SubscriptionMetadata
{
Identity = identity,
Indexes = localIndexes,
IsEphemeral = true
};
adapter.SubscribeAsync(resource, metadata).GetAwaiter();
}
}
}
private Task <string> Subscribe(string resourceUriString, SubscriptionMetadata metadata)
{
TaskCompletionSource <string> tcs = new TaskCompletionSource <string>();
Task t = Task.Factory.StartNew(async() =>
{
try
{
string id = await adapter.SubscribeAsync(resourceUriString, metadata);
tcs.SetResult(id);
}
catch (Exception ex)
{
logger.LogError(ex, $"MQTT adapter Subscribe error on channel '{Channel.Id}'.");
tcs.SetException(ex);
}
});
return(tcs.Task);
}
private async Task SubscribeAsync(string resourceUriString, string identity, List <KeyValuePair <string, string> > indexes)
{
if (await adapter.CanSubscribeAsync(resourceUriString, Channel.IsEncrypted))
{
SubscriptionMetadata metadata = new SubscriptionMetadata()
{
Identity = identity,
Indexes = indexes,
IsEphemeral = true
};
string subscriptionUriString = await adapter.SubscribeAsync(resourceUriString, metadata);
//await Log.LogInfoAsync("Identity {0} subscribed to resource {1} with subscription URI {2}", identity, resourceUriString, subscriptionUriString);
}
else
{
//await Log.LogErrorAsync("REST protocol cannot subscribe identity {0} to resource {1}", identity, resourceUriString);
}
}
private void Channel_OnOpen(object sender, ChannelOpenEventArgs e)
{
if (!Channel.IsAuthenticated)
{
OnError?.Invoke(this, new ProtocolAdapterErrorEventArgs(Channel.Id, new SecurityException("Not authenticated on WSN channel")));
Channel.CloseAsync().Ignore(); //shutdown channel immediately
return;
}
//string uriString = HttpUtility.HtmlDecode(UriHelper.GetEncodedUrl(context.Request));
//MessageUri uri = new MessageUri(uriString);
//IdentityDecoder decoder = new IdentityDecoder(config.ClientIdentityNameClaimType, context, config.GetClientIndexes());
//identity = decoder.Id;
////resource = uri.Resource;
////indexes = uri.Indexes == null ? null : new List<KeyValuePair<string, string>>(uri.Indexes);
//var localIndexes = decoder.Indexes;
adapter = new OrleansAdapter(identity, "WebSocket", "WSN", graphManager);
adapter.OnObserve += Adapter_OnObserve;
if (subscriptions != null)
{
foreach (var sub in subscriptions)
{
//subscribe
SubscriptionMetadata metadata = new SubscriptionMetadata()
{
Identity = identity,
Indexes = localIndexes,
IsEphemeral = true
};
adapter.SubscribeAsync(resource, metadata).GetAwaiter();
//SubscribeAsync(sub, metadata).GetAwaiter();
}
}
}
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));
}
}
