public override async Task <CoapMessage> GetAsync(CoapMessage request, ICoapConnectionInformation connectionInformation)
{
Console.WriteLine($"Got request: {request}");
if (connectionInformation is CoapDtlsConnectionInformation dtlsConnectionInformation)
{
// this is a dtls connection
// here, we know the server must be our ExamplePskDtlsServer so we can just cast it and call the GetIdentity method.
var server = (ExamplePskDtlsServer)dtlsConnectionInformation.TlsServer;
var identity = server.GetIdentity();
return(new CoapMessage
{
Code = CoapMessageCode.Content,
Options = { new ContentFormat(ContentFormatType.TextPlain) },
Payload = Encoding.UTF8.GetBytes($"Hello {identity}!")
});
}
else
{
// this is not a dtls connection
// this will never be called in this example, but you could use a resource for both CoAP and CoAPS and decide here.
return(new CoapMessage
{
Code = CoapMessageCode.Content,
Options = { new ContentFormat(ContentFormatType.TextPlain) },
Payload = Encoding.UTF8.GetBytes($"Hello World!")
});
}
}
protected override async Task <CoapMessage> HandleRequestAsync(ICoapConnectionInformation connectionInformation, CoapMessage message)
{
var resource = Resources.FirstOrDefault(r =>
Uri.Compare(
new Uri(BaseUri, r.Metadata.UriReference),
new Uri(BaseUri, message.GetUri()),
UriComponents.Path,
UriFormat.SafeUnescaped,
UriPathComparison) == 0);
if (resource == null)
{
return(CoapMessage.Create(CoapMessageCode.NotFound,
$"Resouce {message.GetUri()} was not found"));
}
// ReSharper disable once SwitchStatementMissingSomeCases
switch (message.Code)
{
case CoapMessageCode.Get:
return(await resource.GetAsync(message));
case CoapMessageCode.Post:
return(await resource.PostAsync(message));
case CoapMessageCode.Put:
return(await resource.PutAsync(message));
case CoapMessageCode.Delete:
return(await resource.DeleteAsync(message));
}
throw new InvalidOperationException();
}
private async Task ProcessRequestAsync(ICoapConnectionInformation connection, byte[] payload)
{
try
{
await _coapHandler.ProcessRequestAsync(connection, payload);
}
catch (Exception ex)
{
_logger?.LogError(CoapUdpLoggingEvents.TransportRequestsLoop, ex, "Unexpected exception was thrown");
throw;
}
}
protected override async Task <CoapMessage> HandleRequestAsync(ICoapConnectionInformation connectionInformation, CoapMessage message)
{
_logger.LogDebug($"New request! {message}");
var response = OicResponseUtility.CreateMessage(OicResponseCode.NotFound, "Not found");
OicContext context = null;
Exception exception = null;
if (_options.UseCoreLink && message.GetUri().AbsolutePath.Equals("/.well-known/core", StringComparison.Ordinal))
{
return(GenerateCoreLinkResource(message));
}
try
{
// Create the OiCContext
context = _application.CreateContext(new OicCoapContext(connectionInformation, message));
await _application.ProcessRequestAsync(context);
if (context.Response.ResposeCode != default(OicResponseCode))
{
response = context.Response;
}
else
{
// This should only occur during development.
var errorMessage = $"{context.GetType()}.{nameof(context.Response)}.{nameof(context.Response.ResposeCode)} was not set!";
_logger.LogError(errorMessage);
response = OicResponseUtility
.CreateMessage(OicResponseCode.InternalServerError, errorMessage);
}
}
catch (Exception ex)
{
exception = ex;
// TODO: Do we want to restrict error messages to developers/logging only?
response = OicResponseUtility.FromException(ex);
}
finally
{
_application.DisposeContext <OicCoapContext>(context, exception);
}
_logger.LogDebug($"Responding with {response}");
return(response.ToCoapMessage());
}
public virtual Task <CoapMessage> DeleteAsync(CoapMessage request, ICoapConnectionInformation connectionInformation) => DeleteAsync(request);
public async Task ProcessRequestAsync(ICoapConnectionInformation connection, byte[] payload)
{
CoapMessage result = null;
var message = new CoapMessage();
try
{
_logger?.LogDebug(CoapLoggingEvents.HandlerProcessRequest, "Deserialising payload");
message.FromBytes(payload);
//TODO: check if message is multicast, ignore Confirmable requests and delay response
if (!message.Code.IsRequest())
{
// TODO: send CoapMessageCode.Reset or ignore them, i dunno
throw new NotImplementedException("TODO: Send CoapMessageCode.Reset or ignore them");
}
_logger?.LogDebug(CoapLoggingEvents.HandlerProcessRequest, "Handling request");
result = await HandleRequestAsync(connection, message);
}
catch (Exception ex)
{
_logger?.LogError(CoapLoggingEvents.HandlerProcessRequest, ex, "Failed to handle incomming message");
if (ex is CoapException || ex is NotImplementedException)
{
result = CoapMessage.FromException(ex);
}
else
{
result = CoapMessage.Create(CoapMessageCode.InternalServerError,
"An unexpected error occured", CoapMessageType.Reset);
throw;
}
}
finally
{
Debug.Assert(result != null);
if (message.Type == CoapMessageType.Confirmable)
{
if (result.Type != CoapMessageType.Reset)
{
result.Type = CoapMessageType.Acknowledgement;
}
// TODO: create unit tests to ensure message.Id and message.Token are set when exceptions are thrown
result.Id = message.Id;
}
else
{
result.Id = GetNextMessageId();
_logger?.LogDebug(CoapLoggingEvents.HandlerProcessRequest, $"Setting message id to {result.Id}");
}
result.Token = message.Token;
_logger?.LogDebug(CoapLoggingEvents.HandlerProcessRequest, $"Sending");
await connection.LocalEndpoint.SendAsync(
new CoapPacket
{
Endpoint = connection.RemoteEndpoint,
Payload = result.ToBytes()
}, CancellationToken.None);
}
}
protected virtual CoapMessage HandleRequest(ICoapConnectionInformation connectionInformation, CoapMessage message)
{
return(CoapMessage.Create(CoapMessageCode.NotFound, $"Resouce {message.GetUri()} was not found"));
}
protected virtual Task <CoapMessage> HandleRequestAsync(ICoapConnectionInformation connectionInformation, CoapMessage message) => Task.FromResult(HandleRequest(connectionInformation, message));
