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