public override Stream ReadBlob(string keyValue)
{
var urlPath = string.Format("{0}/{1}", this.Container, KeyValueToPath(keyValue));
var requestMethod = "GET";
var storageServiceVersion = "2015-12-11";
var blobType = "BlockBlob";
var dateInRfc1123Format = DateTime.UtcNow.ToString("R", CultureInfo.InvariantCulture);
var canonicalizedHeaders = string.Format("x-ms-blob-type:{0}\nx-ms-date:{1}\nx-ms-version:{2}", blobType, dateInRfc1123Format, storageServiceVersion);
var canonicalizedResource = string.Format("/{0}/{1}", this.Account, urlPath);
var blobLength = "";
var stringToSign = string.Format("{0}\n\n\n{1}\n\n\n\n\n\n\n\n\n{2}\n{3}", requestMethod, blobLength, canonicalizedHeaders, canonicalizedResource);
var authorizationHeader = CreateAuthorizationHeaderForAzure(stringToSign);
var uri = new Uri((("https://" + this.Account)
+ (".blob.core.windows.net/" + urlPath)));
var request = ((HttpWebRequest)(WebRequest.Create(uri)));
request.Method = requestMethod;
request.Headers.Add("x-ms-blob-type", blobType);
request.Headers.Add("x-ms-date", dateInRfc1123Format);
request.Headers.Add("x-ms-version", storageServiceVersion);
request.Headers.Add("Authorization", authorizationHeader);
try
{
var stream = new TemporaryFileStream();
using (var response = ((HttpWebResponse)(request.GetResponse())))
using (var dataStream = response.GetResponseStream())
CopyData(dataStream, stream);
return(stream);
}
catch (Exception e)
{
var message = e.Message;
return(null);
}
}
/// <summary>
/// Create a stream of a given size that will not use more than maxMemory memory.
/// If the size is greater than maxMemory, a TemporaryFileStream will be used that
/// will delete the file in its Dispose method.
/// </summary>
protected async Task <Stream> CreateLimitedMemoryStream(long size, long maxMemory = Constants.MB * 100)
{
Stream stream;
if (size < maxMemory)
{
var data = GetRandomBuffer(size);
stream = new MemoryStream(data);
}
else
{
var path = Path.GetTempFileName();
stream = new TemporaryFileStream(path, FileMode.Create);
var bufferSize = 4 * Constants.KB;
while (stream.Position + bufferSize < size)
{
await stream.WriteAsync(GetRandomBuffer(bufferSize), 0, bufferSize);
}
if (stream.Position < size)
{
await stream.WriteAsync(GetRandomBuffer(size - stream.Position), 0, (int)(size - stream.Position));
}
// reset the stream
stream.Seek(0, SeekOrigin.Begin);
}
return(stream);
}
public override Stream ReadBlob(string keyValue)
{
var extendedPath = KeyValueToPath(keyValue);
var httpVerb = "GET";
var d = DateTime.UtcNow;
var canonicalizedAmzHeaders = ("x-amz-date:" + d.ToString("R", CultureInfo.InvariantCulture));
var canonicalizedResource = string.Format("/{0}/{1}", this.Bucket, extendedPath);
var stringToSign = string.Format("{0}\n\n\n\n{1}\n{2}", httpVerb, canonicalizedAmzHeaders, canonicalizedResource);
var authorization = CreateAuthorizationHeaderForS3(stringToSign);
var uri = new Uri((("http://" + this.Bucket)
+ (".s3.amazonaws.com/" + extendedPath)));
var request = ((HttpWebRequest)(WebRequest.Create(uri)));
request.Method = httpVerb;
request.Headers.Add("x-amz-date", d.ToString("R", CultureInfo.InvariantCulture));
request.Headers.Add("Authorization", authorization);
try
{
var stream = new TemporaryFileStream();
using (var response = ((HttpWebResponse)(request.GetResponse())))
using (var dataStream = response.GetResponseStream())
CopyData(dataStream, stream);
return(stream);
}
catch (Exception e)
{
var message = e.Message;
return(null);
}
}
public static void Search()
{
using (TemporaryFileStream fileStream1 =
new TemporaryFileStream(),
fileStream2 = new TemporaryFileStream())
{
// Use temporary file stream;
}
}
public static void Search()
{
using(TemporaryFileStream fileStream1 =
new TemporaryFileStream(),
fileStream2 = new TemporaryFileStream())
{
// Use temporary file stream;
}
}
public Stream DownloadFile()
{
string temp = Path.GetTempFileName();
_pendingChange.DownloadShelvedFile(temp);
var stream = new TemporaryFileStream(temp);
_contentLength = stream.Length;
return(stream);
}
public static string HashWithGit(Stream file)
{
// Write the data to a file and insert that, so that git will handle any
// EOL and encoding issues.
using (var tempStream = TemporaryFileStream.Acquire())
{
file.CopyTo(tempStream);
return(HashWithGit(tempStream.Filename));
}
}
public void TemporaryFileS_NoName()
{
var fname = string.Empty;
using (var k = new TemporaryFileStream())
{
fname = k.Name;
Assert.IsTrue(File.Exists(fname));
}
Assert.IsFalse(File.Exists(fname));
}
public void T04_InMemmoryRender_Render_Png()
{
using (var context = new InMemoryRender(GraphvizUnitTests.DIGRPAH, LayoutEngine.Dot, ImageFormat.Png, this.Container.Resolve <ILogger>()))
{
var data = context.Render();
Assert.AreEqual(8743, data.Length);
using (var image = data.ToImage())
using (var temp = new TemporaryFileStream())
{
image.Save(temp, SystemDrawingImageFormat.Png);
}
}
}
public static void Search()
{
// C# 8.0
using TemporaryFileStream fileStream1 =
new TemporaryFileStream();
// Prior to C# 8.0
using (TemporaryFileStream fileStream2 =
new TemporaryFileStream(),
fileStream3 = new TemporaryFileStream())
{
// Use temporary file stream;
}
}
public void TemporaryFileS_WithName()
{
var filePath = Path.Combine(Path.GetTempPath(), "dummy.txt");
var fname = string.Empty;
using (var k = new TemporaryFileStream(new Uri(filePath)))
{
fname = k.Name;
Assert.IsTrue(File.Exists(fname));
}
Assert.IsFalse(File.Exists(fname));
}
private async Task <Stream> AttemptDeltaDownload(string packageId, string version, FileStream basisStream)
{
try
{
var builder = new SignatureBuilder();
using (var signatureStream = new MemoryStream())
{
builder.Build(basisStream, new SignatureWriter(signatureStream));
signatureStream.Seek(0, SeekOrigin.Begin);
basisStream.Seek(0, SeekOrigin.Begin);
using (var delta = await _client.FeedClientWrapper.Create <Stream>(
UrlTemplate.Resolve(_feedRootUri + "/packages/{packageId}/{version}/download-delta", new { packageId, version }),
signatureStream,
"delta",
new Dictionary <string, string>()
))
{
var tempFile = Path.GetTempFileName();
Stream fs = null;
try
{
var deltaApplier = new DeltaApplier {
SkipHashCheck = false
};
fs = new TemporaryFileStream(tempFile, File.Open(tempFile, FileMode.OpenOrCreate, FileAccess.ReadWrite));
deltaApplier.Apply(basisStream, new BinaryDeltaReader(delta, new NullProgressReporter()), fs);
return(fs);
}
catch
{
fs?.Dispose();
throw;
}
}
}
}
catch (Exception ex)
{
_client.Log.Info("Failed delta download: " + ex.Message);
return(null);
}
}
public void FromFile()
{
STLDocument stl = null;
using (Stream stream = GetData("ASCII.stl"))
{
string tempFilePath = Path.GetTempFileName();
using (TemporaryFileStream tempStream = new TemporaryFileStream(tempFilePath))
{
stream.CopyTo(tempStream);
tempStream.Flush();
tempStream.Close();
stl = STLDocument.Open(tempFilePath);
}
}
ValidateSTL(stl);
}
/// <summary>
/// Расжимаем
/// </summary>
/// <param name="ms">MemoryStream который необходимо расжать</param>
/// <returns>Расжатый MemoryStream</returns>
public static Stream DecompressGZip(Stream ms)
{
Stream result;
if (!Environment.Is64BitProcess && ms.Length > 1024 * 50) // ??? Наверное должно хватить
{
//Если запущен под 32 битной версией IE тогда расжимаем в файл иначе OutOfMemoryException
result = new TemporaryFileStream();
}
else
{
result = new MemoryStream();
}
using (var zip = new GZipStream(ms, CompressionMode.Decompress))
{
// Read all bytes in the zip stream and return them.
zip.CopyTo(result);
}
result.Position = 0;
return(result);
}
public void Create_GivenNewDocument_FileGetsCreated()
{
TemporaryFileStream fileStream = new TemporaryFileStream(TempFileName);
Assert.IsTrue(File.Exists(fileStream.File?.FullName !));
}
private static async Task RunAddPackageAsync(PackageOperation packageOperation, CloudBlockBlob packageBlob, ILogger log, List <IndexAction <PackageDocument> > indexActions)
{
var packagesToIndex = new List <PackageDocument>();
log.LogInformation("Downloading package {packageId}@{packageVersionNormalized} for indexing...",
packageOperation.Id, packageOperation.Version);
using (var packageInputStream = await HttpClient.GetStreamAsync(packageOperation.PackageUrl))
using (var packageInputSeekableStream = TemporaryFileStream.Create())
{
await packageInputStream.CopyToAsync(packageInputSeekableStream);
packageInputSeekableStream.Position = 0;
log.LogInformation("Finished downloading package {packageId}@{packageVersionNormalized} for indexing...",
packageOperation.Id, packageOperation.Version);
using (var nugetPackage = new PackageArchiveReader(packageInputSeekableStream))
{
log.LogInformation("Analyzing package {packageId}@{packageVersionNormalized}...",
packageOperation.Id, packageOperation.Version);
// Get some metadata
var nuspecReader = nugetPackage.NuspecReader;
var packageIdentity = nuspecReader.GetIdentity();
var packageSummary = nuspecReader.GetDescription();
if (string.IsNullOrEmpty(packageSummary))
{
packageSummary = nuspecReader.GetSummary();
}
var packageToIndex = new PackageDocument(
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString(),
packageIdentity.Version.OriginalVersion,
nuspecReader.GetTitle(),
packageSummary,
nuspecReader.GetAuthors(),
nuspecReader.GetTags(),
nuspecReader.GetIconUrl(),
nuspecReader.GetLicenseUrl(),
nuspecReader.GetProjectUrl(),
packageOperation.Published,
AuxiliaryNuGetData.GetDownloadCount(packageIdentity.Id),
packageOperation.IsListed,
packageIdentity.Version.IsPrerelease);
var targetFrameworks = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var typeNames = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var frameworkSpecificGroups = nugetPackage.GetReferenceItems();
foreach (var frameworkSpecificGroup in frameworkSpecificGroups)
{
// Get some metadata
var targetFramework = frameworkSpecificGroup.TargetFramework.GetShortFolderName();
targetFrameworks.Add(targetFramework);
log.LogInformation(
"Collecting information for {packageId}@{packageVersionNormalized} and framework {targetFramework}...",
packageOperation.Id, packageOperation.Version, targetFramework);
// Collect assembly data
foreach (var item in frameworkSpecificGroup.Items)
{
var entry = nugetPackage.GetEntry(item);
var entryName = item;
log.LogInformation(
"Collecting assembly information from {entryName} for {packageId}@{packageVersionNormalized} and framework {targetFramework}...",
entryName, packageOperation.Id, packageOperation.Version, targetFramework);
using (var assemblyStream = entry.Open())
using (var assemblySeekableStream = TemporaryFileStream.Create())
{
await assemblyStream.CopyToAsync(assemblySeekableStream);
assemblySeekableStream.Position = 0;
using (var portableExecutableReader = new PEReader(assemblySeekableStream))
{
var metadataReader = portableExecutableReader.GetMetadataReader();
foreach (var typeDefinition in metadataReader.TypeDefinitions.Select(metadataReader
.GetTypeDefinition))
{
if (!typeDefinition.Attributes.HasFlag(TypeAttributes.Public))
{
continue;
}
var typeNamespace = metadataReader.GetString(typeDefinition.Namespace);
var typeName = metadataReader.GetString(typeDefinition.Name);
if (typeName.StartsWith("<") || typeName.StartsWith("__Static") ||
typeName.Contains("c__DisplayClass"))
{
continue;
}
log.LogDebug(
"{packageId}@{packageVersionNormalized}, framework {targetFramework}, entry {entryName}: adding {namespace}.{type}",
packageOperation.Id, packageOperation.Version, targetFramework, entryName, typeNamespace, typeName);
typeNames.Add($"{typeNamespace}.{typeName}");
}
}
}
log.LogInformation(
"Finished collecting assembly information from {entryName} for {packageId}@{packageVersionNormalized} and framework {targetFramework}.",
entryName, packageOperation.Id, packageOperation.Version, targetFramework);
}
log.LogInformation(
"Finished collecting information for {packageId}@{packageVersionNormalized} and framework {targetFramework}.",
packageOperation.Id, packageOperation.Version, targetFramework);
}
packageToIndex.TargetFrameworks = targetFrameworks.ToHashSet();
packageToIndex.TypeNames = typeNames.ToHashSet();
log.LogInformation("Finished analyzing package {packageId}@{packageVersionNormalized}.",
packageOperation.Id, packageOperation.Version);
// Build index
log.LogInformation(
"Creating index actions for package {packageId}@{packageVersionNormalized}...",
packageOperation.Id, packageOperation.Version);
// Add to index blob
packagesToIndex.Add(packageToIndex);
// Add to index
indexActions.Add(IndexAction.MergeOrUpload(packageToIndex));
log.LogInformation(
"Finished creating index actions for package {packageId}@{packageVersionNormalized}.",
packageOperation.Id, packageOperation.Version);
log.LogInformation("Finished analyzing package {packageId}@{packageVersionNormalized}.",
packageOperation.Id, packageOperation.Version);
}
}
log.LogInformation("Storing index blob for package {packageId}@{packageVersionNormalized}...",
packageOperation.Id, packageOperation.Version);
// Store index blob
try
{
await packageBlob.DeleteIfExistsAsync();
using (var jsonStream = await packageBlob.OpenWriteAsync())
using (var jsonWriter = new StreamWriter(jsonStream))
{
JsonSerializer.Serialize(jsonWriter, packagesToIndex);
}
log.LogInformation("Finished storing index blob for package {packageId}@{packageVersionNormalized}.",
packageOperation.Id, packageOperation.Version);
}
catch (Exception ex)
{
log.LogError(ex, "Error storing index blob for package {packageId}@{packageVersionNormalized}.",
packageOperation.Id, packageOperation.Version);
}
}
public void FromFile()
{
STLDocument stl = null;
using (Stream stream = GetData("ASCII.stl"))
{
string tempFilePath = Path.GetTempFileName();
using (TemporaryFileStream tempStream = new TemporaryFileStream(tempFilePath))
{
stream.CopyTo(tempStream);
tempStream.Flush();
tempStream.Close();
stl = STLDocument.Open(tempFilePath);
}
}
ValidateSTL(stl);
}
