CloudMessage TryParseCloudMessage(ArraySegment <byte> buffer)
{
try
{
var transportCloudMessage = _cloudMessageSerializer.Unpack <TransportCloudMessage>(buffer);
if (transportCloudMessage.PayloadIsCompressed == true)
{
transportCloudMessage.Payload = _cloudMessageSerializer.Decompress(transportCloudMessage.Payload);
}
return(new CloudMessage
{
Type = transportCloudMessage.Type,
CorrelationId = transportCloudMessage.CorrelationId,
Payload = transportCloudMessage.Payload,
Properties = transportCloudMessage.Properties
});
}
catch (Exception exception)
{
Interlocked.Increment(ref _malformedMessagesReceived);
_logger.LogWarning(exception, "Error while parsing cloud message.");
return(null);
}
}
private async Task <CloudMessage> InvokeHttpRequestAsync(CloudMessage requestMessage, CancellationToken cancellationToken)
{
try
{
var requestContent = _cloudMessageSerializer.Unpack <HttpRequestCloudMessageContent>(requestMessage.Payload);
using (var httpRequestMessage = new HttpRequestMessage())
{
httpRequestMessage.Method = new HttpMethod(requestContent.Method);
httpRequestMessage.RequestUri = new Uri(requestContent.Uri, UriKind.Relative);
if (requestContent.Content?.Any() == true)
{
httpRequestMessage.Content = new ByteArrayContent(requestContent.Content);
}
if (requestContent.Headers?.Any() == true)
{
foreach (var(key, value) in requestContent.Headers)
{
if (!httpRequestMessage.Headers.TryAddWithoutValidation(key, value))
{
httpRequestMessage.Content.Headers.TryAddWithoutValidation(key, value);
}
}
}
using (var httpResponse = await _httpClient.SendAsync(httpRequestMessage, cancellationToken).ConfigureAwait(false))
{
return(await _cloudMessageFactory.Create(httpResponse, requestMessage.CorrelationId).ConfigureAwait(false));
}
}
}
catch (Exception exception)
{
return(_cloudMessageFactory.Create(exception));
}
}
public async Task TryDispatchHttpRequestAsync(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
try
{
(string username, string password) = ParseBasicAuthenticationHeader(httpContext.Request);
if (username != null)
{
await _authorizationService.AuthorizeUser(httpContext, username, password).ConfigureAwait(false);
}
var channelIdentifier = await _authorizationService.GetChannelIdentifier(httpContext).ConfigureAwait(false);
if (channelIdentifier == null)
{
httpContext.Response.Redirect("/Cloud/Account/Login");
return;
}
var requestMessage = await _cloudMessageFactory.Create(httpContext.Request).ConfigureAwait(false);
var responseMessage = await Invoke(channelIdentifier, requestMessage, httpContext.RequestAborted).ConfigureAwait(false);
var responseContent = _cloudMessageSerializer.Unpack <HttpResponseCloudMessageContent>(responseMessage.Payload);
await PatchHttpResponseWithResponseFromDevice(httpContext.Response, responseContent).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
}
catch (Exception exception)
{
DefaultExceptionFilter.HandleException(exception, httpContext);
}
}