public static async Task FormatHttpContentAsync(StringBuilder sb, HttpContent content)
{
if (content.Headers != null)
{
foreach (var header in content.Headers)
{
sb.AppendLine(string.Format("{0} : {1}", header.Key, header.Value.First()));
}
}
await content.LoadIntoBufferAsync().ConfigureAwait(false);
bool isMultipart = content.IsMimeMultipartContent();
if (isMultipart)
{
//TODO: for some reason it hangs when trying to read the multi-part. might have something to do with UI thread :(
//MultipartMemoryStreamProvider provider = await content.ReadAsMultipartAsync();
//TODO: for now format just the first part. We will need to figure out what to do with the remain
//parts so that it doesnt break viewer
//content = provider.Contents.First() as StreamContent;
}
var sw = new StringWriter(sb);
var writer = new JsonTextWriter(sw)
{
Formatting = Formatting.Indented,
Indentation = 4,
IndentChar = ' '
};
string contentBody = await content.ReadAsStringAsync().ConfigureAwait(false);
try
{
var jsonSerializer = new JsonSerializer();
var reader = new JsonTextReader(new StringReader(contentBody));
object obj = jsonSerializer.Deserialize(reader);
if (obj != null)
{
jsonSerializer.Serialize(writer, obj);
}
else
{
sb.AppendLine(contentBody);
}
}
catch (Exception ex)
{
sb.AppendLine(contentBody);
Logger.Instance.Warning("JsonWriter failed with ex: " + ex.ToString());
}
finally
{
writer.Close();
sw.Close();
}
}
private static async Task BufferRequestBodyAsync(IOwinRequest owinRequest, HttpContent content)
{
await content.LoadIntoBufferAsync();
// We need to replace the request body with a buffered stream so that other
// components can read the stream
owinRequest.Body = await content.ReadAsStreamAsync();
}
private static async Task BufferRequestBodyAsync(IDictionary <string, object> environment, HttpContent content)
{
await content.LoadIntoBufferAsync();
// We need to replace the request body with a buffered stream so that other
// components can read the stream
environment[OwinConstants.RequestBodyKey] = await content.ReadAsStreamAsync();
}
protected override BodyWriter OnCreateBufferedCopy(int maxBufferSize)
{
HttpContent content = this.httpResponseMessage.Content;
if (content != null)
{
content.LoadIntoBufferAsync(maxBufferSize).Wait();
}
return(base.OnCreateBufferedCopy(maxBufferSize));
}
public static async Task <Func <Stream> > WriteToStream(HttpContent content, Stream outputStream,
int maxBufferSize = int.MaxValue)
{
await content.LoadIntoBufferAsync(maxBufferSize);
await content.CopyToAsync(outputStream);
outputStream.Position = 0;
return(() => outputStream);
}
protected static float GetContentSize(HttpContent content)
{
// get content size
float contentLength = 0.0f;
if (content != null)
{
content.LoadIntoBufferAsync().Wait();
contentLength = content.Headers.ContentLength.HasValue ?
content.Headers.ContentLength.Value / 1024.0f : 0.0f;
}
return(contentLength);
}
public static async Task <HttpContent> Clone(this HttpContent source)
{
if (source == null)
{
return(null);
}
await source.LoadIntoBufferAsync();
var destination = new ByteArrayContent(await source.ReadAsByteArrayAsync());
CopyHeadersFrom(destination.Headers, source.Headers);
return(destination);
}
private static async Task WriteContentHeadersAndBody(StringWriter sw, HttpContent content)
{
if (content != null)
{
await content.LoadIntoBufferAsync();
WriteHeaders(sw, content.Headers);
sw.WriteLine();
sw.Write(await content.ReadAsStringAsync());
sw.WriteLine();
}
else
{
sw.WriteLine();
}
}
private async Task<StreamContent> GetBufferedStreamContentAsync(HttpContent httpContent)
{
await httpContent.LoadIntoBufferAsync();
var buffer = new MemoryStream();
await httpContent.CopyToAsync(buffer);
buffer.Position = 0;
StreamContent streamContent = new StreamContent(buffer);
foreach (var header in httpContent.Headers)
{
streamContent.Headers.TryAddWithoutValidation(header.Key, header.Value);
}
return streamContent;
}
/// <summary>
/// Gets the payload size as a human readable string.
/// </summary>
/// <param name="content">The content.</param>
/// <returns>The payload size as a human readable string.</returns>
public static string SizeAsHumanReadableString(this HttpContent content)
{
if (content.Headers.ContentLength.HasValue)
{
return(content.Headers.ContentLength.Value.SizeAsHumanReadableString(LongExtensions.SIType.Byte));
}
var tcs = new TaskCompletionSource <byte[]>();
Task.Run(async() =>
{
await content.LoadIntoBufferAsync();
tcs.SetResult(await content.ReadAsByteArrayAsync());
}).ConfigureAwait(false);
return(tcs.Task.Result.SizeAsHumanReadableString());
}
/// <summary>
/// Deserializes the request content which is assumed to be json into a object of <typeparamref name="T"/>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="content"></param>
/// <returns></returns>
public async Task <T> Deserialize <T>(HttpContent content)
{
await content.LoadIntoBufferAsync().ConfigureAwait(false);
if (_knownJsonPrimitives.ContainsKey(typeof(T)))
{
var str = await content.ReadAsStringAsync().ConfigureAwait(false);
return((T)_knownJsonPrimitives[typeof(T)](str));
}
else
{
using (var stream = await content.ReadAsStreamAsync().ConfigureAwait(false))
{
return(await System.Text.Json.JsonSerializer.DeserializeAsync <T>(stream, _options).ConfigureAwait(false));
}
}
}
private async Task <string> TryGetContentAsString(HttpContent content, bool silentlyIgnoreExceptions, CancellationToken cancellationToken)
{
if (content == null)
{
return(null);
}
try
{
await content.LoadIntoBufferAsync();
return(await content.ReadAsStringAsync().ConfigureAwait(false));
}
catch (Exception e)
{
if (!silentlyIgnoreExceptions)
{
throw new FulcrumAssertionFailedException("Expected to be able to read an HttpContent.", e);
}
}
return(null);
}
/// <inheritdoc />
public Task LoadIntoBufferAsync()
{
return(_content.LoadIntoBufferAsync());
}
/// <summary>
/// Deserializes the request content which is assumed to be MessagePack into a object of <typeparamref name="T"/>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="content"></param>
/// <returns></returns>
public async Task <T> Deserialize <T>(HttpContent content)
{
await content.LoadIntoBufferAsync().ConfigureAwait(false);
return(await MessagePack.MessagePackSerializer.DeserializeAsync <T>(await content.ReadAsStreamAsync().ConfigureAwait(false), ContractlessStandardResolver.Instance));
}