public void DisposeContext<TSource>(OicContext oicContext, Exception exception)
{
var oicContextFactory = GetContextFactory<TSource>();
//if (exception == null)
//{
// var diagnoticsEnabled = _diagnosticSource.IsEnabled(_debugEndRequestTag);
// var currentTimestamp = (diagnoticsEnabled) ? Stopwatch.GetTimestamp() : 0;
// if (diagnoticsEnabled)
// _diagnosticSource.Write(_debugEndRequestTag, new { oicContext = oicContext, timestamp = currentTimestamp });
//}
//else
if(exception != null)
_logger.LogError(exception, "Exception occured during handling request in application stack");
//{
// var diagnoticsEnabled = _diagnosticSource.IsEnabled(_debugUnhandledExceptionTag);
// var currentTimestamp = diagnoticsEnabled ? Stopwatch.GetTimestamp() : 0;
// if (diagnoticsEnabled)
// _diagnosticSource.Write(_debugUnhandledExceptionTag, new { oicContext = oicContext, timestamp = currentTimestamp, exception = exception });
//}
oicContextFactory.DisposeContext(oicContext);
}
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 ResourceRepositoryContext(OicContext context, ResourceRepositoryOptions options, IOicResourceRepository resourceProvider)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
_options = options ?? throw new ArgumentNullException(nameof(options));
_resourceProvider = resourceProvider ?? throw new ArgumentNullException(nameof(resourceProvider));
// Since request path is a segment, ensure it is surrounded with slashes.
_requestPath = _options.RequestPath ?? "/";
if (!_requestPath.EndsWith("/"))
{
_requestPath += "/";
}
if (!_requestPath.StartsWith("/"))
{
_requestPath = "/" + _requestPath;
}
}
public async Task Invoke(OicContext oicContext)
{
Debug.Assert(oicContext != null);
// All done if RequestServices is set
if (oicContext.RequestServices != null)
{
await _next.Invoke(oicContext);
return;
}
var replacementFeature = new RequestServicesFeature(_scopeFactory);
try
{
oicContext.RequestServices = replacementFeature.RequestServices;
await _next.Invoke(oicContext);
}
finally
{
replacementFeature.Dispose();
}
}
public async Task Invoke(OicContext context)
{
var resourceContext = new ResourceRepositoryContext(context, _options, _resourceRepository);
if (!resourceContext.ValidatePath())
{
await _next(context);
return;
}
OicResponse result;
var request = resourceContext.GetSubRequest();
IOicResource requestResource = null;
if (request.ContentType != OicMessageContentType.None)
{
if (request.Content == null)
{
context.Response = OicResponseUtility.CreateMessage(OicResponseCode.BadRequest, "Content type provided with no content");
return;
}
var r = _oicConfiguration.Serialiser.Deserialise(request.Content, request.ContentType);
if (r is OicResourceList list)
{
// TODO: verify grabbing the first resource is okay and enumeration is not needed.
requestResource = list.First();
}
else
{
requestResource = r as IOicResource;
}
}
if (request.Operation == OicRequestOperation.Get)
{
result = await _resourceRepository.RetrieveAsync(request);
}
else if (request.Operation == OicRequestOperation.Post)
{
result = await _resourceRepository.CreateOrUpdateAsync(request, requestResource);
}
else if (request.Operation == OicRequestOperation.Put)
{
result = await _resourceRepository.CreateAsync(request, requestResource);
}
else if (request.Operation == OicRequestOperation.Delete)
{
result = await _resourceRepository.DeleteAsync(request);
}
else
{
result = OicResponseUtility.CreateMessage(OicResponseCode.BadRequest, "Bad request");
}
if (result.ResposeCode == OicResponseCode.NotFound)
{
await _next(context);
return;
}
context.Response = result;
}
public void DisposeContext(OicContext context)
{
// TODO: Do we need to ensure response is sent?
}
public Task ProcessRequestAsync(OicContext oicContext)
{
return _application(oicContext);
}
