private async Task DownloadArtifactToArchiveAsync(DumpArtifact dumpArtifact, ZipArchive archive, SemaphoreSlim archiveLock, CancellationToken cancelToken)
{
if (!cancelToken.IsCancellationRequested)
{
var blob = DumplingStorageClient.BlobClient.GetBlobReferenceFromServer(new Uri(dumpArtifact.Artifact.Url));
//download the compressed dump artifact to a temp file
using (var tempStream = CreateTempFile())
{
using (var compStream = CreateTempFile())
{
await blob.DownloadToStreamAsync(compStream, cancelToken);
using (var gunzipStream = new GZipStream(compStream, CompressionMode.Decompress, false))
{
await gunzipStream.CopyToAsync(tempStream);
}
await tempStream.FlushAsync();
}
tempStream.Position = 0;
await archiveLock.WaitAsync(cancelToken);
if (!cancelToken.IsCancellationRequested)
{
try
{
var entry = archive.CreateEntry(FixupLocalPath(dumpArtifact.LocalPath));
using (var entryStream = entry.Open())
{
await tempStream.CopyToAsync(entryStream);
await entryStream.FlushAsync();
}
}
finally
{
archiveLock.Release();
}
}
}
}
}
/// <summary>
/// 对流进行解压
/// </summary>
/// <param name="response"></param>
private static void UnGZip(HttpResponseMessage response)
{
bool isGzip = response.Content.Headers.ContentEncoding.Contains("gzip");
if (isGzip)
{
Stream decompressedStream = new MemoryStream();
using (var gzipStream = new GZipStream(response.Content.ReadAsStreamAsync().Result, CompressionMode.Decompress))
{
gzipStream.CopyToAsync(decompressedStream);
}
decompressedStream.Seek(0, SeekOrigin.Begin);
var originContent = response.Content;
response.Content = new StreamContent(decompressedStream);
}
}
/// <summary>
/// static|Downloads an xml file from AniDB which contains all of the titles for every anime, and their IDs,
/// and saves it to disk.
/// </summary>
/// <param name="titlesFile"></param>
/// <returns></returns>
private static async Task DownloadTitles_static(string titlesFile)
{
var client = new WebClient();
client.Headers.Add("User-Agent", Constants.UserAgent);
await AniDbSeriesProvider.RequestLimiter.Tick().ConfigureAwait(false);
await Task.Delay(Plugin.Instance.Configuration.AniDbRateLimit).ConfigureAwait(false);
using (var stream = await client.OpenReadTaskAsync(TitlesUrl))
using (var unzipped = new GZipStream(stream, CompressionMode.Decompress))
using (var writer = File.Open(titlesFile, FileMode.Create, FileAccess.Write))
{
await unzipped.CopyToAsync(writer).ConfigureAwait(false);
}
}
/// <summary>
/// Downloads an xml file from AniDB which contains all of the titles for every anime, and their IDs,
/// and saves it to disk.
/// </summary>
/// <param name="titlesFile">The destination file name.</param>
private async Task DownloadTitles(string titlesFile)
{
_logger.LogDebug("Downloading new AniDB titles file.");
var client = new WebClient();
await AniDbSeriesProvider.RequestLimiter.Tick().ConfigureAwait(false);
await Task.Delay(Plugin.Instance.Configuration.AniDB_wait_time).ConfigureAwait(false);
using (var stream = await client.OpenReadTaskAsync(TitlesUrl))
using (var unzipped = new GZipStream(stream, CompressionMode.Decompress))
using (var writer = File.Open(titlesFile, FileMode.Create, FileAccess.Write))
{
await unzipped.CopyToAsync(writer).ConfigureAwait(false);
}
}
public async Task MutateIncoming(MutateIncomingTransportMessageContext context)
{
if (!context.Headers.ContainsKey("IWasCompressed"))
{
return;
}
var memoryStream = new MemoryStream(context.Body);
using (var bigStream = new GZipStream(memoryStream, CompressionMode.Decompress))
{
var bigStreamOut = new MemoryStream();
await bigStream.CopyToAsync(bigStreamOut)
.ConfigureAwait(false);
context.Body = bigStreamOut.ToArray();
}
}
public async Task Accept(INodeVisitor visitor)
{
// Extract the file to a temporary file, and then parse that.
using (var tempFile = new TempFile())
{
// Extract to the temporary file
using (var tempStream = tempFile.OpenWrite())
using (var stream = file.Open(FileMode.Open, FileAccess.Read, FileShare.Read))
using (var gzipFile = new GZipStream(stream, CompressionMode.Decompress, false))
{
await gzipFile.CopyToAsync(tempStream);
}
// Process the extracted file
await visitor.Visit(new FileNode(tempFile.File));
}
}
public void Decompress(string compressedFile, string targetFile, ProgressBar bar)
{
bar.Value = 0;
try
{
new Task(() =>
{
if (File.Exists(compressedFile))
{
using (FileStream sourceStream = new FileStream(compressedFile, FileMode.OpenOrCreate))
{
using (FileStream targetStream = File.Create(targetFile))
{
using (GZipStream decompressionStream = new GZipStream(sourceStream, CompressionMode.Decompress))
{
new Task(() =>
{
long compressed_length = new System.IO.FileInfo(compressedFile).Length;
long target_length = new System.IO.FileInfo(targetFile).Length;
if ((target_length / 2) < compressed_length)
{
bar.Value += 100;
}
}).Start();
decompressionStream.CopyToAsync(targetStream).Wait();
MessageBox.Show("File has been decompressed!");
bar.Value = 0;
}
}
}
}
else
{
throw new Exception("Compressed file doesn't exist");
}
}).Start();
}
catch (Exception ex)
{
throw ex;
}
finally
{
}
}
private static async Task RunWithoutStreamingApiAsync(FileInfo file, int totalObjects, bool iswarmup = true)
{
long beforeMem = 0;
long afterMem = 0;
if (iswarmup)
{
beforeMem = Helpers.GetMemoryPostGc() >> 10;
}
var sw = Stopwatch.StartNew();
var byteData = File.ReadAllBytes(file.FullName);
var unzippedData = new MemoryStream();
using (var unzipper = new GZipStream(new MemoryStream(byteData), CompressionMode.Decompress, false))
{
await unzipper.CopyToAsync(unzippedData).ConfigureAwait(false);
}
var deserializedJson =
JsonConvert.DeserializeObject <List <MyTestData> >(new UTF8Encoding().GetString(unzippedData.ToArray()));
sw.Stop();
if (iswarmup)
{
afterMem = Helpers.GetMemoryPostGc() >> 10;
}
Thread.MemoryBarrier();
if (deserializedJson.Count != totalObjects)
{
throw new Exception($"Expected {totalObjects} objects. Got only {deserializedJson.Count}");
}
if (iswarmup)
{
await Console.Out.WriteLineAsync($"NonAPI Memory => Before: {beforeMem} KB, After: {afterMem} KB, " +
$"Diff: {afterMem - beforeMem} KB")
.ConfigureAwait(false);
await RunWithoutStreamingApiAsync(file, totalObjects, false).ConfigureAwait(false);
}
else
{
await Console.Out.WriteLineAsync($"NonAPI Total Time:{sw.ElapsedMilliseconds} ms")
.ConfigureAwait(false);
}
}
public async Task CompressionThresholdZeroGZipNoCompressionTest()
{
// Arrange
using (
var server =
new TestServer(
this.CreateBuilder(options =>
{
options.MinimumCompressionThreshold = 0;
options.Compressors = new List <ICompressor> {
new GZipCompressor(CompressionLevel.NoCompression)
};
})))
{
// Act
RequestBuilder request = server.CreateRequest("/");
request.AddHeader(HeaderNames.AcceptEncoding, "gzip");
HttpResponseMessage response = await request.SendAsync("PUT");
// Assert
response.EnsureSuccessStatusCode();
Stream stream = await response.Content.ReadAsStreamAsync();
string responseText;
using (var decompression = new GZipStream(stream, CompressionMode.Decompress))
{
using (var ms = new MemoryStream())
{
await decompression.CopyToAsync(ms);
responseText = Encoding.UTF8.GetString(ms.ToArray());
}
}
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, "StatusCode != OK");
Assert.AreEqual(Helpers.ResponseText, responseText, "Response Text not equal");
Assert.AreEqual(147, response.Content.Headers.ContentLength, "Content-Length != 147");
Assert.AreEqual(true, response.Content.Headers.ContentEncoding.Any(), "Content-Encoding == null");
Assert.AreEqual("gzip", response.Content.Headers.ContentEncoding.ToString(), "Content-Encoding != gzip");
Assert.AreEqual(true, response.Headers.Vary.Contains(HeaderNames.AcceptEncoding), "Vary != Accept-Encoding");
}
}
public static async Task UnzipAsync <TDataSet>(this IModelLoader <TDataSet> modelLoader, string zipFile, string saveTo, bool showProgressInConsole = false)
where TDataSet : IDataSet
{
if (!Path.IsPathRooted(saveTo))
{
saveTo = Path.Combine(AppContext.BaseDirectory, saveTo);
}
Directory.CreateDirectory(saveTo);
if (!Path.IsPathRooted(zipFile))
{
zipFile = Path.Combine(AppContext.BaseDirectory, zipFile);
}
var destFileName = Path.GetFileNameWithoutExtension(zipFile);
var destFilePath = Path.Combine(saveTo, destFileName);
if (showProgressInConsole)
{
Console.WriteLine($"Unzippinng {Path.GetFileName(zipFile)}");
}
if (File.Exists(destFilePath))
{
if (showProgressInConsole)
{
Console.WriteLine($"The file {destFileName} already exists");
}
}
using (GZipStream unzipStream = new GZipStream(File.OpenRead(zipFile), CompressionMode.Decompress))
{
using (var destStream = File.Create(destFilePath))
{
await unzipStream.CopyToAsync(destStream).ConfigureAwait(false);
await destStream.FlushAsync().ConfigureAwait(false);
destStream.Close();
}
unzipStream.Close();
}
}
public static async Task WriteFlotAppAsync(Stream output, bool decompress = false)
{
if (!decompress)
{
using (var stream = Assembly.GetAssembly(typeof(FlotWebApp)).GetManifestResourceStream("Metrics.Visualization.index.full.html.gz"))
{
await stream.CopyToAsync(output).ConfigureAwait(false);
}
}
else
{
using (var stream = Assembly.GetAssembly(typeof(FlotWebApp)).GetManifestResourceStream("Metrics.Visualization.index.full.html.gz"))
using (var gzip = new GZipStream(stream, CompressionMode.Decompress))
{
await gzip.CopyToAsync(output).ConfigureAwait(false);
}
}
}
/// <summary>
/// Gets the uncompressed string.
/// </summary>
/// <param name="input">The input byte array.</param>
/// <returns>Returns the uncompressed string.</returns>
private async Task <string> DecompressAsync(byte[] input)
{
if (input == null)
{
return(string.Empty);
}
using (MemoryStream mso = new MemoryStream())
{
using (MemoryStream ms = new MemoryStream(input))
using (GZipStream zs = new GZipStream(ms, CompressionMode.Decompress, true))
{
await zs.CopyToAsync(mso).ConfigureAwait(false);
}
return(Encoding.UTF8.GetString(mso.ToArray()));
}
}
/// <summary>
/// Returns the decompressed version of provided data.
/// </summary>
/// <returns>The decompressed data stream.</returns>
/// <exception cref="ArgumentNullException">The source or destination are null.</exception>
public static async ValueTask <TStream> DecompressAsync <TStream>(Stream source, TStream destination)
where TStream : Stream
{
if (source is null)
{
throw new ArgumentNullException(nameof(source));
}
if (destination is null)
{
throw new ArgumentNullException(nameof(destination));
}
Contract.EndContractBlock();
using var gs = new GZipStream(source, CompressionMode.Decompress);
await gs.CopyToAsync(destination).ConfigureAwait(false);
return(destination);
}
public static async Task <byte[]> GzipDecompressAsync(this byte[] bytes)
{
byte[] decompressedBytes;
using (var inputStream = new MemoryStream(bytes))
using (var outputStream = new MemoryStream())
{
//GZipStream must be disposed to ensure that all data is flushed!
using (var zipStream = new GZipStream(inputStream, CompressionMode.Decompress))
{
await zipStream.CopyToAsync(outputStream).ConfigureAwait(false);
}
decompressedBytes = outputStream.ToArray();
}
return(decompressedBytes);
}
private static async Task ReadContent(HttpWebResponse response, HttpRes res)
{
res.ResponseChartSet = response.CharacterSet;
// 不能依赖content-length
using (var mem = new MemoryStream())
{
using (var stream = response.GetResponseStream())
{
if (response.ContentEncoding?.ToLowerInvariant() == "gzip")
{
using (var gZipStream = new GZipStream(stream, CompressionMode.Decompress))
await gZipStream.CopyToAsync(mem).DonotCapture();
}
else
{
await stream.CopyToAsync(mem).DonotCapture();
}
}
switch (res.Req.ResultType)
{
case HttpResultType.String:
var charset = res.Req.ResultCharSet.IsNullOrEmpty()
? response.CharacterSet
: res.Req.ResultCharSet;
var contentEncoding = charset.IsNullOrEmpty()
? Encoding.UTF8
: Encoding.GetEncoding(charset); // GetEncoding returns a cached instance with default settings.
mem.Seek(0, SeekOrigin.Begin);
using (var sr = new StreamReader(mem, contentEncoding))
{
res.ResponseString = sr.ReadToEnd();
}
break;
case HttpResultType.Byte:
res.ResponseBytes = mem.ToArray();
break;
}
}
}
private async Task <BoolResult> StreamContentWithCompressionAsync(IAsyncStreamReader <CopyFileResponse> input, Stream output, CopyOptions?options, CancellationToken cancellationToken)
{
try
{
long chunks = 0L;
long bytes = 0L;
using (var grpcStream = new BufferedReadStream(
async() =>
{
if (await input.MoveNext(cancellationToken))
{
if (input.Current.Header is { } header)
{
var error = new ErrorResult(header.ErrorMessage ?? "Unknown error", header.Diagnostics);
error.ThrowIfFailure();
}
chunks++;
bytes += input.Current.Content.Length;
options?.UpdateTotalBytesCopied(bytes);
return(input.Current.Content);
}
else
{
return(null);
}
}))
{
using (Stream decompressedStream = new GZipStream(grpcStream, CompressionMode.Decompress, true))
{
await decompressedStream.CopyToAsync(output, _configuration.ClientBufferSizeBytes, cancellationToken);
}
}
return(BoolResult.Success);
}
catch (ResultPropagationException e)
{
return(new BoolResult(e.Result));
}
}
// load
protected override async Task <StorageContent> OnLoad(Uri resourceUri, CancellationToken cancellationToken)
{
// the Azure SDK will treat a starting / as an absolute URL,
// while we may be working in a subdirectory of a storage container
// trim the starting slash to treat it as a relative path
string name = GetName(resourceUri).TrimStart('/');
CloudBlockBlob blob = _directory.GetBlockBlobReference(name);
if (blob.Exists())
{
MemoryStream originalStream = new MemoryStream();
await blob.DownloadToStreamAsync(originalStream, cancellationToken);
originalStream.Position = 0;
MemoryStream content;
if (blob.Properties.ContentEncoding == "gzip")
{
using (var uncompressedStream = new GZipStream(originalStream, CompressionMode.Decompress))
{
content = new MemoryStream();
await uncompressedStream.CopyToAsync(content);
}
content.Position = 0;
}
else
{
content = originalStream;
}
return(new StreamStorageContent(content));
}
if (Verbose)
{
_logger.LogInformation("Can't load {BlobUri}. Blob doesn't exist", resourceUri);
}
return(null);
}
/// <summary>
/// 提取网页Byte
/// </summary>
/// <returns></returns>
private async Task <byte[]> GetByte(HttpItem HttpDataItem, HttpResponseMessage response)
{
byte[] ResponseByte = null;
try
{
ResponseByte = await response.Content.ReadAsByteArrayAsync();
}
catch (WebException ex)
{
LogHelper.Log(LogDefine.LogError, ex, $"获取http返回流异常,{HttpDataItem.URL}");
var exResponse = (HttpWebResponse)ex.Response;
if (exResponse == null)
{
return(null);
}
MemoryStream _stream = null;
try
{
using var stream = exResponse.GetResponseStream();
if (stream != null)
{
_stream = new MemoryStream();
if (exResponse.ContentEncoding.Equals("gzip", StringComparison.OrdinalIgnoreCase))
{
using var item = new GZipStream(stream, CompressionMode.Decompress);
await item.CopyToAsync(_stream, 10240);
}
else
{
await stream.CopyToAsync(_stream, 10240);
}
ResponseByte = _stream.ToArray();
}
}
catch
{
_stream?.Dispose();
}
}
return(ResponseByte);
}
public static async Task <string> UnpackByteToJsonString(byte[] buffer)
{
string jsonString;
using (var compressedStream = new MemoryStream(buffer))
{
using (var zipStream = new GZipStream((Stream)compressedStream, CompressionMode.Decompress))
{
using (var resultStream = new MemoryStream())
{
await zipStream.CopyToAsync((Stream)resultStream).ConfigureAwait(false);
jsonString = Encoding.UTF8.GetString(resultStream.ToArray());
}
}
}
return(jsonString);
}
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
if (request.Method == HttpMethod.Post)
{
bool isGzip = request.Content.Headers.ContentEncoding.Contains("gzip");
bool isDeflate = !isGzip && request.Content.Headers.ContentEncoding.Contains("deflate");
if (isGzip || isDeflate)
{
Stream decompressedStream = new MemoryStream();
if (isGzip)
{
using (var gzipStream = new GZipStream(await request.Content.ReadAsStreamAsync(),
CompressionMode.Decompress))
{
await gzipStream.CopyToAsync(decompressedStream);
}
}
else if (isDeflate)
{
using (var gzipStream = new DeflateStream(await request.Content.ReadAsStreamAsync(),
CompressionMode.Decompress))
{
await gzipStream.CopyToAsync(decompressedStream);
}
}
decompressedStream.Seek(0, SeekOrigin.Begin);
var originContent = request.Content;
request.Content = new StreamContent(decompressedStream);
foreach (var header in originContent.Headers)
{
request.Content.Headers.Add(header.Key, header.Value);
}
}
}
return(await base.SendAsync(request, cancellationToken));
}
/// <summary>
/// takes byte array and decompress it into Content
/// </summary>
public async Task Decompress()
{
if (CompressedContent != null && CompressedContent.Length != 0)
{
using (MemoryStream inStream = new MemoryStream(CompressedContent))
using (MemoryStream outStream = new MemoryStream())
{
using (GZipStream gz = new GZipStream(inStream, CompressionMode.Decompress))
{
await gz.CopyToAsync(outStream);
}
Content = Encoding.Unicode.GetString(outStream.ToArray());
}
}
else
{
Content = "";
}
}
public async Task DecompressAsync(string source, string destination)
{
using (var dt = _telemetryClient.StartOperation <DependencyTelemetry>("DotNetDecompression"))
using (var pm = new PerfMon())
using (FileStream originalFileStream = File.OpenRead(source))
using (FileStream decompressedFileStream = File.Create(destination))
using (GZipStream decompressionStream = new GZipStream(originalFileStream, CompressionMode.Decompress))
{
await decompressionStream.CopyToAsync(decompressedFileStream);
pm.Stop();
dt.Telemetry.Type = "DotNetDecompression";
dt.Telemetry.Properties.Add("source", source);
dt.Telemetry.Properties.Add("destination", destination);
dt.Telemetry.Properties.Add("run", _config.RunID);
dt.Telemetry.Properties.Add("used_cpu", pm.UsedProcessorTime.Ticks.ToString());
dt.Telemetry.Properties.Add("used_memory", pm.UsedMemory.ToString());
}
}
public static async Task <string> ReadAndDecodeAsStringAsync(this HttpContent content)
{
var autoDecode = GetDecodeResponse();
var contentEncoding = content.Headers.ContentEncoding;
if (autoDecode)
{
if (contentEncoding.Any(enc => string.Equals("gzip", enc, StringComparison.OrdinalIgnoreCase)))
{
var stream = new GZipStream(await content.ReadAsStreamAsync(), CompressionMode.Decompress);
using (var memory = new MemoryStream())
{
await stream.CopyToAsync(memory);
await memory.FlushAsync();
return(Encoding.UTF8.GetString(memory.ToArray()));
}
}
else if (contentEncoding.Any(enc => string.Equals("br", enc, StringComparison.OrdinalIgnoreCase)) ||
contentEncoding.Any(enc => string.Equals("brotli", enc, StringComparison.OrdinalIgnoreCase)))
{
var stream = new BrotliStream(await content.ReadAsStreamAsync(), CompressionMode.Decompress);
using (var memory = new MemoryStream())
{
await stream.CopyToAsync(memory);
await memory.FlushAsync();
return(Encoding.UTF8.GetString(memory.ToArray()));
}
}
}
if (contentEncoding.Any())
{
Console.WriteLine("[ Content is {0} encoding. Set ARMCLIENT_DECODE_RESPONSE=1 env to automatically decode the content ]", string.Join(", ", contentEncoding));
Console.WriteLine();
}
return(await content.ReadAsStringAsync());
}
public async Task <IActionResult> PostIngest()
{
var user = Request.Headers[Consts.MetricsKeyHeader].First();
var use_gzip = Request.Headers[Consts.CompressedBodyHeader].Any();
_logger.Log(LogLevel.Information, $"Ingesting Modlist Definition for {user}");
var modlistBytes = await Request.Body.ReadAllAsync();
_logger.LogInformation("Spawning ingestion task");
var tsk = Task.Run(async() =>
{
try
{
if (use_gzip)
{
await using var os = new MemoryStream();
await using var gZipStream =
new GZipStream(new MemoryStream(modlistBytes), CompressionMode.Decompress);
await gZipStream.CopyToAsync(os);
modlistBytes = os.ToArray();
}
var modlist = new MemoryStream(modlistBytes).FromJson <ModList>();
var file = AbsolutePath.EntryPoint.Combine("mod_list_definitions")
.Combine($"{user}_{DateTime.UtcNow.ToFileTimeUtc()}.json");
file.Parent.CreateDirectory();
await using var stream = await file.Create();
modlist.ToJson(stream);
_logger.Log(LogLevel.Information, $"Done Ingesting Modlist Definition for {user}");
}
catch (Exception ex)
{
_logger.LogError(ex, "Error ingesting uploaded modlist");
}
});
return(Accepted(0));
}
public static async Task <byte[]> DecompressAsync(byte[] data)
{
if (data == null || data.Length == 0)
{
throw new ArgumentNullException("the data cannot be null", nameof(data));
}
using (var compressedDataStream = new MemoryStream(data))
{
using (var gzipStream = new GZipStream(compressedDataStream, CompressionMode.Decompress))
{
using (var decompressedDataStream = new MemoryStream())
{
await gzipStream.CopyToAsync(decompressedDataStream);
return(decompressedDataStream.ToArray());
}
}
}
}
// Making this async since regular read/write are tested below
private static async Task DecompressAsync(MemoryStream compareStream, MemoryStream gzStream)
{
var ms = new MemoryStream();
var zip = new GZipStream(gzStream, CompressionMode.Decompress);
var GZipStream = new MemoryStream();
await zip.CopyToAsync(GZipStream);
GZipStream.Position = 0;
compareStream.Position = 0;
byte[] compareArray = compareStream.ToArray();
byte[] writtenArray = GZipStream.ToArray();
Assert.Equal(compareArray.Length, writtenArray.Length);
for (int i = 0; i < compareArray.Length; i++)
{
Assert.Equal(compareArray[i], writtenArray[i]);
}
}
public static async Task <byte[]> DecompressAsync(byte[] input)
{
using var inmem = new MemoryStream(input);
using var output = new MemoryStream();
using var gz = new GZipStream(inmem, CompressionMode.Decompress);
try
{
await gz.CopyToAsync(output);
}
catch (InvalidDataException invalidDataEx)
{
if (invalidDataEx.Message == "The archive entry was compressed using an unsupported compression method.")
{
throw new UnsupportedCompressionAlgorithmException();
}
}
return(output.ToArray());
}
/// <summary>
/// Uploads a decompressed blob.
/// </summary>
/// <param name="srcBlob"></param>
/// <param name="tgtContainer"></param>
/// <param name="tgtBlobName"></param>
/// <param name="cToken"></param>
/// <returns></returns>
private async Task UploadDecompressedSrcBlobToTgtBlobAsnyc(
CloudBlob srcBlob,
CloudBlobContainer tgtContainer,
string tgtBlobName,
CancellationToken cToken = default)
{
using (Stream blobStream = await srcBlob.OpenReadAsync(null, _options, null, cToken))
using (var compressedBloblStream = new GZipStream(blobStream, CompressionMode.Decompress, leaveOpen: true))
using (MemoryStream streamToUplaod = new MemoryStream())
{
await compressedBloblStream.CopyToAsync(streamToUplaod).ConfigureAwait(false);
compressedBloblStream.Close();
streamToUplaod.Seek(0, SeekOrigin.Begin);
var targetBlob = tgtContainer.GetBlockBlobReference(tgtBlobName);
// set the content type of the original blob
targetBlob.Properties.ContentType = srcBlob.Metadata["contenttype"].FromBase64();
await targetBlob.UploadFromStreamAsync(streamToUplaod, null, _options, null, cToken).ConfigureAwait(false);
}
}
public static async Task <string> DecompressAsync(FileInfo fileToDecompress, string newFileName = null)
{
var currentFileName = fileToDecompress.FullName;
if (string.IsNullOrEmpty(newFileName))
{
newFileName = currentFileName.Remove(currentFileName.Length - fileToDecompress.Extension.Length);
}
using (var originalFileStream = fileToDecompress.OpenRead())
using (var decompressedFileStream = File.Create(newFileName))
using (var decompressionStream = new GZipStream(originalFileStream, CompressionMode.Decompress))
{
await decompressionStream.CopyToAsync(decompressedFileStream);
//Console.WriteLine("Decompressed: {0}", fileToDecompress.Name);
}
return(newFileName);
}
/// <summary>
/// Returns a new <c>MemoryStream</c> that has decompressed data inside. The provided stream is optionally closed.
/// </summary>
/// <param name="compressedStream"></param>
/// <param name="leaveStreamOpen"></param>
/// <returns></returns>
public async ValueTask <MemoryStream> DecompressAsync(Stream compressedStream, bool leaveStreamOpen = false)
{
Guard.AgainstNullOrEmpty(compressedStream, nameof(compressedStream));
if (compressedStream.Position == compressedStream.Length)
{
compressedStream.Seek(0, SeekOrigin.Begin);
}
var uncompressedStream = RecyclableManager.GetStream(nameof(RecyclableGzipProvider), CompressionHelpers.GetGzipUncompressedLength(compressedStream));
using (var gzipStream = new GZipStream(compressedStream, CompressionMode.Decompress, leaveStreamOpen))
{
await gzipStream
.CopyToAsync(uncompressedStream)
.ConfigureAwait(false);
}
return(uncompressedStream);
}
// Making this async since regular read/write are tested below
private static async Task DecompressAsync(MemoryStream compareStream, MemoryStream gzStream)
{
var ms = new MemoryStream();
var zip = new GZipStream(gzStream, CompressionMode.Decompress);
var GZipStream = new MemoryStream();
await zip.CopyToAsync(GZipStream);
GZipStream.Position = 0;
compareStream.Position = 0;
byte[] compareArray = compareStream.ToArray();
byte[] writtenArray = GZipStream.ToArray();
Assert.Equal(compareArray.Length, writtenArray.Length);
for (int i = 0; i < compareArray.Length; i++)
{
Assert.Equal(compareArray[i], writtenArray[i]);
}
}
public void CopyToAsyncArgumentValidation()
{
using (GZipStream gs = new GZipStream(new MemoryStream(), CompressionMode.Decompress))
{
Assert.Throws<ArgumentNullException>("destination", () => { gs.CopyToAsync(null); });
Assert.Throws<ArgumentOutOfRangeException>("bufferSize", () => { gs.CopyToAsync(new MemoryStream(), 0); });
Assert.Throws<NotSupportedException>(() => { gs.CopyToAsync(new MemoryStream(new byte[1], writable: false)); });
gs.Dispose();
Assert.Throws<ObjectDisposedException>(() => { gs.CopyToAsync(new MemoryStream()); });
}
using (GZipStream gs = new GZipStream(new MemoryStream(), CompressionMode.Compress))
{
Assert.Throws<NotSupportedException>(() => { gs.CopyToAsync(new MemoryStream()); });
}
}