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