private static async Task WriteGZipCompressedDynamicResponse(byte[] input, HttpResponse response)
{
response.ContentLength = input.Length;
response.Headers[ContentEncoding] = GZip;
await using var gz = new GZipStream(response.Body, CompressionLevel.Fastest);
await gz.WriteAsync(input, 0, input.Length);
}
/// <summary>
/// Get the compressed(or not) output data according to request.
/// </summary>
/// <param name="context">The http context.</param>
/// <param name="data">The data to output.</param>
/// <param name="cancellationToken">The cancellation token which will cancel this method.</param>
/// <returns>The compressed or not output data.</returns>
private async Task <byte[]> GetOutputDataAsync(IJsonRpcHttpContext context, byte[] data, CancellationToken cancellationToken = default)
{
var outputData = data;
var acceptEncoding = context.GetRequestHeader("Accept-Encoding");
if (acceptEncoding != null && acceptEncoding.Contains("gzip"))
{
context.SetResponseHeader("Content-Encoding", "gzip");
await using var memoryStream = new MemoryStream();
await using var outputStream = new GZipStream(memoryStream, CompressionMode.Compress);
await outputStream.WriteAsync(outputData, cancellationToken).ConfigureAwait(false);
await outputStream.FlushAsync(cancellationToken).ConfigureAwait(false);
outputData = memoryStream.ToArray();
}
else if (acceptEncoding != null && acceptEncoding.Contains("deflate"))
{
context.SetResponseHeader("Content-Encoding", "deflate");
await using var memoryStream = new MemoryStream();
await using var outputStream = new DeflateStream(memoryStream, CompressionMode.Compress);
await outputStream.WriteAsync(outputData, cancellationToken).ConfigureAwait(false);
await outputStream.FlushAsync(cancellationToken).ConfigureAwait(false);
outputData = memoryStream.ToArray();
}
return(outputData);
}
private async Task <HttpResponseMessage> HttpHandler(HttpRequestMessage httpRequestMessage)
{
Assert.Equal(HttpMethod.Get, httpRequestMessage.Method);
var queryParams = HttpUtility.ParseQueryString(httpRequestMessage.RequestUri.Query);
var fileParam = queryParams["file"];
if (!string.IsNullOrWhiteSpace(fileParam))
{
var fileHash = Hash.Parse(fileParam);
if (!OnlineFiles.TryGetValue(fileHash, out var fileData))
{
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}
Downloads.Add(fileHash);
using (var responseStream = new MemoryStream())
using (var gzipStream = new GZipStream(responseStream, CompressionLevel.Fastest))
{
var data = Encoding.ASCII.GetBytes(fileData);
await gzipStream.WriteAsync(data, 0, data.Length);
gzipStream.Close();
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ByteArrayContent(responseStream.ToArray())
});
}
}
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
public async Task AddFileAsync(string name, Stream input, CancellationToken cancellationToken)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
using (var data = new MemoryStream())
{
using (var zip = new GZipStream(data, CompressionMode.Compress, true))
{
var buffer = new byte[64 * 1024];
int readBytes;
while ((readBytes = await input.ReadAsync(buffer, 0, buffer.Length, cancellationToken)) != 0)
{
await zip.WriteAsync(buffer, 0, readBytes, cancellationToken);
}
}
this.Data.Add(data.ToArray());
this.Header.Add(name, (int)data.Length);
}
}
private static async Task <byte[]> CompressAsync(byte[] data)
{
using (var stream = new MemoryStream())
try
{
using (GZipStream zipStream = new GZipStream(stream, CompressionLevel.Fastest, true))
try
{
await zipStream.WriteAsync(data, 0, data.Length);
}
finally
{
zipStream.Close();
}
var result = new byte[stream.Length];
stream.Position = 0;
stream.Read(result, 0, result.Length);
return(result);
}
finally
{
stream.Close();
}
}
public static async Task SaveAsync(SolutionConfiguration configuration, Stream stream)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
// ReSharper disable once MethodHasAsyncOverload
// var json = JsonConvert.SerializeObject(configuration, Formatting.None);
var json = JsonSerializer.Serialize(configuration);
var data = Encoding.UTF8.GetBytes(json);
using (var ms = new MemoryStream())
{
using (var zip = new GZipStream(ms, CompressionLevel.Optimal))
await zip.WriteAsync(data, 0, data.Length);
data = ms.ToArray();
}
await stream.WriteAsync(BitConverter.GetBytes(data.Length), 0, 4);
await stream.WriteAsync(data, 0, data.Length);
}
public void FileAsync_Compress_Decompress_Async()
{
var filename = FileTool.GetTempFileName();
using (var fs = FileAsync.OpenWrite(filename))
using (var gzip = new GZipStream(fs, CompressionMode.Compress)) {
gzip.WriteAsync(PlainBytes, 0, PlainBytes.Length).Wait();
}
var fi = new FileInfo(filename);
Assert.IsTrue(fi.Exists);
Assert.IsTrue(PlainBytes.Length > fi.Length);
using (var fs = FileAsync.OpenRead(filename))
using (var gzip = new GZipStream(fs, CompressionMode.Decompress, true)) {
var output = With.TryFunctionAsync(() => gzip.ReadAllBytesAsync().Result);
Assert.AreEqual(PlainBytes.Length, output.Length);
Assert.AreEqual(PlainBytes, output);
}
fi = new FileInfo(filename);
fi.Delete();
}
public async ValueTask <ArraySegment <byte> > CompressAsync(ReadOnlyMemory <byte> inputData)
{
Guard.AgainstEmpty(inputData, nameof(inputData));
var compressedStream = RecyclableManager.GetStream(nameof(RecyclableGzipProvider));
using (var gzipStream = new GZipStream(compressedStream, CompressionLevel, true))
{
await gzipStream
.WriteAsync(inputData)
.ConfigureAwait(false);
}
if (compressedStream.TryGetBuffer(out var buffer))
{
return(buffer);
}
else
{
using (compressedStream) // dispose stream after allocation.
{
return(compressedStream.ToArray());
}
}
}
private static async Task ResponseBase(HttpListenerRequest request, HttpListenerResponse response, byte[] content, HttpStatusCode statusCode = HttpStatusCode.OK)
{
if ((request == null) || (response == null) || (content == null) || (content.Length == 0))
{
ASF.ArchiLogger.LogNullError(nameof(request) + " || " + nameof(response) + " || " + nameof(content));
return;
}
try {
if (response.StatusCode != (ushort)statusCode)
{
response.StatusCode = (ushort)statusCode;
}
response.AddHeader("Access-Control-Allow-Origin", "*");
response.AddHeader("Date", DateTime.UtcNow.ToString("R"));
if (CompressableContentTypes.Contains(response.ContentType))
{
string acceptEncoding = request.Headers["Accept-Encoding"];
if (!string.IsNullOrEmpty(acceptEncoding))
{
if (acceptEncoding.Contains("gzip"))
{
response.AddHeader("Content-Encoding", "gzip");
using (MemoryStream ms = new MemoryStream()) {
using (GZipStream stream = new GZipStream(ms, CompressionMode.Compress)) {
await stream.WriteAsync(content, 0, content.Length).ConfigureAwait(false);
}
content = ms.ToArray();
}
}
else if (acceptEncoding.Contains("deflate"))
{
response.AddHeader("Content-Encoding", "deflate");
using (MemoryStream ms = new MemoryStream()) {
using (DeflateStream stream = new DeflateStream(ms, CompressionMode.Compress)) {
await stream.WriteAsync(content, 0, content.Length).ConfigureAwait(false);
}
content = ms.ToArray();
}
}
}
}
response.ContentLength64 = content.Length;
await response.OutputStream.WriteAsync(content, 0, content.Length).ConfigureAwait(false);
} catch (HttpListenerException e) {
ASF.ArchiLogger.LogGenericDebuggingException(e);
} catch (ObjectDisposedException e) {
ASF.ArchiLogger.LogGenericDebuggingException(e);
} catch (Exception e) {
ASF.ArchiLogger.LogGenericException(e);
await ResponseStatusCode(request, response, HttpStatusCode.ServiceUnavailable).ConfigureAwait(false);
}
}
/// <summary>
/// Compress a JSON string with base-64 encoded gzip compressed string.
/// </summary>
/// <param name="json">The JSON to write.</param>
/// <param name="stream">The stream.</param>
public static async Task WriteAsync(string json, Stream stream)
{
byte[] data = Encoding.UTF8.GetBytes(json);
using (GZipStream gzip = new GZipStream(stream, CompressionMode.Compress))
{
await gzip.WriteAsync(data, 0, data.Length);
}
}
private static async Task <byte[]> CompressMessageAsync(byte[] messageBytes)
{
using var outputStream = new MemoryStream();
using (var gzipStream = new GZipStream(outputStream, CompressionMode.Compress))
{
await gzipStream.WriteAsync(messageBytes, 0, messageBytes.Length);
}
return(outputStream.ToArray());
}
public static async Task <byte[]> CompressGZipAsync([NotNull] this byte[] bytes)
{
using var memoryStream = new MemoryStream();
using (var zipStream = new GZipStream(memoryStream, CompressionMode.Compress))
{
await zipStream.WriteAsync(bytes);
}
return(memoryStream.ToArray());
}
public async Task <byte[]> EncodeAsync(byte[] rawMessage, CancellationToken cancellationToken)
{
await using var compressedStream = new MemoryStream();
//use using with explicit scope to close/flush the GZipStream before using the outputstream
await using (var zipStream = new GZipStream(compressedStream, CompressionMode.Compress))
{
await zipStream.WriteAsync(rawMessage, cancellationToken);
}
return(compressedStream.ToArray());
}
public static async Task <ChunkBytes> Compress(ChunkBytes data)
{
using (MemoryStream memStream = new MemoryStream())
{
using (GZipStream gzipStream = new GZipStream(memStream, CompressionLevel.Optimal, leaveOpen: true))
await gzipStream.WriteAsync(data.Bytes, 0, data.Length);
var chunkBytes = new ChunkBytes(memStream.ToArray());
return(chunkBytes);
}
}
public async Task <byte[]> CompactaGzip(byte[] dados)
{
using (MemoryStream memory = new MemoryStream())
{
using (GZipStream gzip = new GZipStream(memory, CompressionMode.Compress, true))
{
await gzip.WriteAsync(dados, 0, dados.Length).ConfigureAwait(false);
}
return(memory.ToArray());
}
}
public override async Task ProcessRequestAsync(HttpContext context)
{
try
{
HttpContext.Current = context;
var clientScriptReference = new ClientScriptReference();
var version = clientScriptReference.GetContentHash(context.Request.Url.AbsolutePath);
if (string.Equals(context.Request.Headers["If-None-Match"], version))
{
context.Response.StatusCode = (int)HttpStatusCode.NotModified;
}
else
{
context.Response.Charset = Encoding.UTF8.WebName;
context.Response.ContentType = new ContentType("application/x-javascript")
{
CharSet = Encoding.UTF8.WebName
}.ToString();
// cache
context.Response.Cache.SetVaryByCustom("*");
context.Response.Cache.SetAllowResponseInBrowserHistory(true);
context.Response.Cache.SetETag(version);
context.Response.Cache.SetCacheability(HttpCacheability.Public);
// body
var content = Encoding.UTF8.GetBytes(await clientScriptReference.GetContentAsync(context));
using (var inputStream = new MemoryStream())
{
if (ClientSettings.GZipEnabled)
{
using (var zip = new GZipStream(inputStream, CompressionMode.Compress, true))
{
await zip.WriteAsync(content, 0, content.Length);
zip.Flush();
}
context.Response.Headers["Content-Encoding"] = "gzip";
}
else
{
await inputStream.WriteAsync(content, 0, content.Length);
}
inputStream.Position = 0;
inputStream.CopyTo(context.Response.OutputStream);
}
}
}
catch (Exception e)
{
LogManager.GetLogger("ASC").Error("ClientScriptHandler", e);
}
}
public static async Task <byte[]> CompressSource(string source)
{
using var dbStream = new MemoryStream();
using (var blobStream = new GZipStream(dbStream, CompressionLevel.Fastest, true))
{
await blobStream.WriteAsync(Encoding.UTF8.GetBytes(source));
}
dbStream.Seek(0, SeekOrigin.Begin);
return(dbStream.ToArray());
}
public static async Task <byte[]> Compress(byte[] data)
{
using (MemoryStream memStream = new MemoryStream())
{
using (GZipStream gzipStream = new GZipStream(memStream, CompressionLevel.Optimal))
{
await gzipStream.WriteAsync(data, 0, data.Length);
}
return(memStream.ToArray());
}
}
public async Task <byte[]> CompressAsync(byte[] input)
{
using (MemoryStream memory = new MemoryStream())
{
using (GZipStream gzip = new GZipStream(memory, CompressionMode.Compress, true))
{
await gzip.WriteAsync(input, 0, input.Length);
}
return(memory.ToArray());
}
}
/// <summary>
/// Compresses binary data using gzip.
/// </summary>
/// <param name="data">
/// The binary data to compress.
/// </param>
/// <returns>
/// A byte array containing the compressed data.
/// </returns>
public static async Task <byte[]> CompressAsync(byte[] data)
{
Contract.Requires <ArgumentNullException>(data != null);
using (var outputStream = new MemoryStream())
using (var gzip = new GZipStream(outputStream, CompressionMode.Compress))
{
await gzip.WriteAsync(data, 0, data.Length);
return(outputStream.ToArray());
}
}
public async Task <byte[]> CompressAsync(ReadOnlyMemory <byte> data)
{
using var compressedStream = new MemoryStream();
using (var gzipStream = new GZipStream(compressedStream, CompressionMode.Compress))
{
await gzipStream
.WriteAsync(data)
.ConfigureAwait(false);
}
return(compressedStream.ToArray());
}
private async Task <ChunkBytes> Compress(ChunkBytes data)
{
var result = await Pool.GetAsync();
using (MemoryStream memStream = new MemoryStream(result.Bytes))
{
using (GZipStream gzipStream = new GZipStream(memStream, CompressionLevel.Optimal, leaveOpen: true))
await gzipStream.WriteAsync(data.Bytes, 0, data.Length);
result.Length = (int)memStream.Position;
}
return(result);
}
public async Task <byte[]> Compress(byte[] responseBody)
{
using (var ms = new MemoryStream())
{
using (var zip = new GZipStream(ms, CompressionMode.Compress, true))
{
await zip.WriteAsync(responseBody, 0, responseBody.Length);
}
return(ms.ToArray());
}
}
//Compress the input string and then save as Base64 format
public async static Task <string> CompressString(string str)
{
using (MemoryStream outputStream = new MemoryStream())
{
var data = UTF8Encoding.UTF8.GetBytes(str);
var compressStream = new GZipStream(outputStream, CompressionMode.Compress);
await compressStream.WriteAsync(data, 0, data.Length);
compressStream.Flush();
compressStream.Close();
return(Convert.ToBase64String(outputStream.ToArray()));
}
}
public static async Task <byte[]> CompressWithGzipAsync(byte[] input)
{
byte[] output = null;
using (var compressedStream = new MemoryStream())
{
using (var gzipStream = new GZipStream(compressedStream, CompressionMode.Compress))
{
await gzipStream.WriteAsync(input, 0, input.Length).ConfigureAwait(false);
}
output = compressedStream.ToArray();
}
return(output);
}
/// <summary>
/// 压缩
/// </summary>
/// <param name="buffer">字节流</param>
public static async Task <byte[]> CompressAsync(byte[] buffer)
{
if (buffer == null)
{
return(null);
}
using (var ms = new MemoryStream())
{
using (var zip = new GZipStream(ms, CompressionMode.Compress, true))
await zip.WriteAsync(buffer, 0, buffer.Length);
return(ms.ToArray());
}
}
private async static Task <byte[]> compress(byte[] raw)
{
using (MemoryStream memory = new MemoryStream())
{
using (GZipStream gzip = new GZipStream(memory, CompressionMode.Compress, true))
{
await gzip.WriteAsync(raw, 0, raw.Length);
}
await memory.FlushAsync();
return(memory.ToArray());
}
}
private static async Task <byte[]> CompressDataAsync(byte[] data)
{
using (var targetStream = new MemoryStream())
{
using (var stream = new GZipStream(targetStream, CompressionMode.Compress))
{
await stream.WriteAsync(data, 0, data.Length);
}
// Don't return earlier, or else the GZipStream isn't closed and we get corrupted data
return(targetStream.ToArray());
}
}
private async Task <HttpResponseMessage> sendRequest(HttpMethod method, string path, string body)
{
HttpRequestMessage request = null;
try
{
var pathAndQuery = path.Split(new char[] { '?' });
UriBuilder uriBuilder = new UriBuilder(clientSchema, hostname, hostPort, basePath + pathAndQuery[0]);
if (pathAndQuery.Length > 1)
{
uriBuilder.Query = pathAndQuery[1];
}
request = new HttpRequestMessage(method, uriBuilder.Uri);
request.Headers.Add("Authorization", credentialHandler.GetAuthenticationToken());
request.Headers.Add("X-MNUBO-SDK", this.version);
if (!string.IsNullOrEmpty(body))
{
if (compressionEnabled)
{
var data = Encoding.UTF8.GetBytes(body);
var stream = new MemoryStream();
using (var gz = new GZipStream(stream, CompressionMode.Compress))
{
await gz.WriteAsync(data, 0, data.Length);
}
var compressed = stream.ToArray();
stream.Dispose();
request.Content = new ByteArrayContent(compressed);
request.Content.Headers.ContentEncoding.Add("gzip");
}
else
{
request.Content = new StringContent(body, Encoding.UTF8);
}
request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
}
return(await client.SendAsync(request));
}
finally
{
if (request != null)
{
request.Dispose();
}
}
}
private static async Task BaseResponse(this HttpListenerContext context, byte[] response, HttpStatusCode statusCode = HttpStatusCode.OK)
{
if ((context == null) || (response == null) || (response.Length == 0))
{
ASF.ArchiLogger.LogNullError(nameof(context) + " || " + nameof(response));
return;
}
try {
if (context.Response.StatusCode != (ushort)statusCode)
{
context.Response.StatusCode = (ushort)statusCode;
}
context.Response.AppendHeader("Access-Control-Allow-Origin", "null");
string acceptEncoding = context.Request.Headers["Accept-Encoding"];
if (!string.IsNullOrEmpty(acceptEncoding))
{
if (acceptEncoding.Contains("gzip"))
{
context.Response.AddHeader("Content-Encoding", "gzip");
using (MemoryStream ms = new MemoryStream()) {
using (GZipStream stream = new GZipStream(ms, CompressionMode.Compress)) {
await stream.WriteAsync(response, 0, response.Length).ConfigureAwait(false);
}
response = ms.ToArray();
}
}
else if (acceptEncoding.Contains("deflate"))
{
context.Response.AddHeader("Content-Encoding", "deflate");
using (MemoryStream ms = new MemoryStream()) {
using (DeflateStream stream = new DeflateStream(ms, CompressionMode.Compress)) {
await stream.WriteAsync(response, 0, response.Length).ConfigureAwait(false);
}
response = ms.ToArray();
}
}
}
context.Response.ContentLength64 = response.Length;
await context.Response.OutputStream.WriteAsync(response, 0, response.Length).ConfigureAwait(false);
} catch (Exception e) {
ASF.ArchiLogger.LogGenericDebugException(e);
}
}