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