/// <summary> /// Get the reference of a cloud block blob. /// </summary> /// <param name="cloudBlobContainer">The container to get the blob reference from</param> /// <param name="blobName">Name of the desired blob</param> /// <param name="directoryName">Name of the virtual directory</param> /// <param name="path">Path of the virtual directory / blob</param> /// <returns></returns> public static CloudBlockBlob GetCloudBlockBlobReference(this CloudBlobContainer cloudBlobContainer, string blobName, string directoryName = null, string[] path = null) { #region validation if (cloudBlobContainer == null) { throw new ArgumentNullException(nameof(cloudBlobContainer)); } if (string.IsNullOrEmpty(blobName)) { throw new ArgumentNullException(blobName); } #endregion string fullBlobPath; if (string.IsNullOrEmpty(directoryName)) { fullBlobPath = BlobUtilities.GetPath(blobName, path); } else { string fullDirectoryPath = BlobUtilities.GetPath(directoryName, path); fullBlobPath = BlobUtilities.GetPath(blobName, fullDirectoryPath); } return(cloudBlobContainer.GetBlockBlobReference(fullBlobPath)); }
/// <exception cref="ArgumentOutOfRangeException">Range specified by <paramref name="start"/> and <paramref name="byteCount"/> falls outside of the bounds of the buffer content.</exception> /// <exception cref="InvalidOperationException">Content is not available, the builder has been linked with another one.</exception> public byte[] ToArray(int start, int byteCount) { BlobUtilities.ValidateRange(Count, start, byteCount); var result = new byte[byteCount]; int chunkStartPosition = 0; int resultOffset = 0; foreach (var chunk in GetChunks()) { int chunkEndPosition = chunkStartPosition + chunk.Length; if (chunkEndPosition > start) { int bytesToCopy = Math.Min(chunk.Length, result.Length - resultOffset); if (bytesToCopy == 0) { break; } Array.Copy(chunk._buffer, Math.Max(start - chunkStartPosition, 0), result, resultOffset, bytesToCopy); resultOffset += bytesToCopy; } chunkStartPosition = chunkEndPosition; } Debug.Assert(resultOffset == result.Length); return(result); }
/// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException">Range specified by <paramref name="start"/> and <paramref name="byteCount"/> falls outside of the bounds of the <paramref name="buffer"/>.</exception> /// <exception cref="InvalidOperationException">Builder is not writable, it has been linked with another one.</exception> public unsafe void WriteBytes(byte[] buffer, int start, int byteCount) { if (buffer == null) { throw new ArgumentNullException(nameof(buffer)); } BlobUtilities.ValidateRange(buffer.Length, start, byteCount); if (!IsHead) { ThrowHeadRequired(); } // an empty array has no element pointer: if (buffer.Length == 0) { return; } fixed(byte *ptr = buffer) { WriteBytesUnchecked(ptr + start, byteCount); } }
/// <summary> /// Returns the content of the entire memory block. /// </summary> /// <remarks> /// Does not check bounds. /// /// Only creates a copy of the data if they are not represented by a managed byte array, /// or if the specified range doesn't span the entire block. /// </remarks> public unsafe virtual ImmutableArray <byte> GetContentUnchecked(int start, int length) { var result = BlobUtilities.ReadImmutableBytes(Pointer + start, length); GC.KeepAlive(this); return(result); }
/// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException">Range specified by <paramref name="start"/> and <paramref name="byteCount"/> falls outside of the bounds of the <paramref name="buffer"/>.</exception> /// <exception cref="InvalidOperationException">Builder is not writable, it has been linked with another one.</exception> public unsafe void WriteBytes(byte[] buffer, int start, int byteCount) { if (buffer == null) { Throw.ArgumentNull(nameof(buffer)); } BlobUtilities.ValidateRange(buffer.Length, start, byteCount, nameof(byteCount)); if (!IsHead) { Throw.InvalidOperationBuilderAlreadyLinked(); } // an empty array has no element pointer: if (buffer.Length == 0) { return; } fixed(byte *ptr = &buffer[0]) { WriteBytesUnchecked(ptr + start, byteCount); } }
/// <exception cref="ArgumentOutOfRangeException">Range specified by <paramref name="start"/> and <paramref name="byteCount"/> falls outside of the bounds of the buffer content.</exception> public byte[] ToArray(int start, int byteCount) { BlobUtilities.ValidateRange(Length, start, byteCount, nameof(byteCount)); var result = new byte[byteCount]; Array.Copy(_buffer, _start + start, result, 0, byteCount); return result; }
private int ComputeSizeOfDebugDirectoryData() { // The debug directory data is only needed if this.EmitPdb. return((!EmitPdb) ? 0 : 4 + // 4B signature "RSDS" 16 + // GUID sizeof(uint) + // Age Math.Max(BlobUtilities.GetUTF8ByteCount(PdbPathOpt) + 1, MinPdbPath)); }
/// <exception cref="ArgumentOutOfRangeException">Range specified by <paramref name="start"/> and <paramref name="byteCount"/> falls outside of the bounds of the buffer content.</exception> public byte[] ToArray(int start, int byteCount) { BlobUtilities.ValidateRange(Length, start, byteCount); var result = new byte[byteCount]; Buffer.BlockCopy(_buffer, _start + start, result, 0, byteCount); return(result); }
public async Task ComputeNodeUploadLogs() { Func <Task> test = async() => { using (BatchClient batchCli = TestUtilities.OpenBatchClientFromEnvironmentAsync().Result) { const string containerName = "computenodelogscontainer"; // Generate a storage container URL StagingStorageAccount storageAccount = TestUtilities.GetStorageCredentialsFromEnvironment(); BlobServiceClient blobClient = BlobUtilities.GetBlobServiceClient(storageAccount); BlobContainerClient containerClient = BlobUtilities.GetBlobContainerClient(containerName, blobClient, storageAccount); try { containerClient.CreateIfNotExists(); string sasUri = BlobUtilities.GetWriteableSasUri(containerClient, storageAccount); var blobs = containerClient.GetAllBlobs(); // Ensure that there are no items in the container to begin with Assert.Empty(blobs); var startTime = DateTime.UtcNow.Subtract(TimeSpan.FromMinutes(5)); var node = batchCli.PoolOperations.ListComputeNodes(this.poolFixture.PoolId).First(); var result = batchCli.PoolOperations.UploadComputeNodeBatchServiceLogs( this.poolFixture.PoolId, node.Id, sasUri, startTime); Assert.NotEqual(0, result.NumberOfFilesUploaded); Assert.NotEmpty(result.VirtualDirectoryName); // Allow up to 2m for files to get uploaded DateTime timeoutAt = DateTime.UtcNow.AddMinutes(2); while (DateTime.UtcNow < timeoutAt) { blobs = containerClient.GetAllBlobs(); if (blobs.Any()) { break; } } Assert.NotEmpty(blobs); } finally { await containerClient.DeleteIfExistsAsync(); } } }; await SynchronizationContextHelper.RunTestAsync(test, TestTimeout); }
/// <exception cref="ImageFormatLimitationException">The remaining space on the heap is too small to fit the string.</exception> public UserStringHandle ReserveUserString(int length, out Blob fixup) { int offset = GetNewUserStringHeapOffset(length); int encodedLength = BlobUtilities.GetUserStringByteLength(length); fixup = _userStringWriter.ReserveBytes(BlobWriterImpl.GetCompressedIntegerSize(encodedLength) + encodedLength); new BlobWriter(fixup).WriteBytes(0, fixup.Length); return(MetadataTokens.UserStringHandle(offset)); }
private static async Task CopyBlobAsync(BlobContainerClient container, BlobContainerClient destContainer, JPOFileInfo info, ILogger log) { try { // Get the name of the first blob in the container to use as the source. string blobName = info.fileName; // Create a BlobClient representing the source blob to copy. BlobClient sourceBlob = container.GetBlobClient(blobName); // Ensure that the source blob exists. if (await sourceBlob.ExistsAsync()) { // Lease the source blob for the copy operation to prevent another client from modifying it. BlobLeaseClient lease = sourceBlob.GetBlobLeaseClient(); // Specifying -1 for the lease interval creates an infinite lease. //await lease.AcquireAsync(TimeSpan.FromSeconds(100)); // Get the source blob's properties and display the lease state. BlobProperties sourceProperties = await sourceBlob.GetPropertiesAsync(); log.LoggerInfo($"Lease state: {sourceProperties.LeaseState}", info); Uri blob_sas_uri = BlobUtilities.GetServiceSASUriForBlob(sourceBlob, container.Name, null); // Get a BlobClient representing the destination blob BlobClient destBlob = destContainer.GetBlobClient(blobName);//destContainer.GetBlobClient(blob_sas_uri.ToString()); // Start the copy operation. await destBlob.StartCopyFromUriAsync(blob_sas_uri); // Get the destination blob's properties and display the copy status. BlobProperties destProperties = await destBlob.GetPropertiesAsync(); // Update the source blob's properties. sourceProperties = await sourceBlob.GetPropertiesAsync(); if (sourceProperties.LeaseState == LeaseState.Leased) { // Break the lease on the source blob. await lease.BreakAsync(); // Update the source blob's properties to check the lease state. sourceProperties = await sourceBlob.GetPropertiesAsync(); } } } catch (RequestFailedException ex) { log.LoggerError($"RequestFailedException: {ex.Message}", ex?.StackTrace, info); Console.WriteLine(ex.Message); Console.ReadLine(); throw; } }
private static unsafe byte[] ReadBuffer(byte *buffer, int bufferSize) { byte *p = buffer + bufferSize - 1; while (p >= buffer && *p == 0xfe) { p--; } return(BlobUtilities.ReadBytes(buffer, (int)(p + 1 - buffer))); }
public async Task <IActionResult> Get(string documentId) { var file = await BlobUtilities.DownloadFileFromBlob(documentId); if (file == null) { return(new NotFoundResult()); } return(File(file, "application/pdf", documentId)); }
/// <summary> /// Writes string in User String (#US) heap format (see ECMA-335-II 24.2.4 #US and #Blob heaps): /// </summary> /// <remarks> /// The string is UTF16 encoded and prefixed by the its size in bytes. /// /// This final byte holds the value 1 if and only if any UTF16 character within the string has any bit set in its top byte, /// or its low byte is any of the following: 0x01-0x08, 0x0E-0x1F, 0x27, 0x2D, 0x7F. Otherwise, it holds 0. /// The 1 signifies Unicode characters that require handling beyond that normally provided for 8-bit encoding sets. /// </remarks> /// <exception cref="InvalidOperationException">Builder is not writable, it has been linked with another one.</exception> public void WriteUserString(string value) { if (value is null) { Throw.ArgumentNull(nameof(value)); } WriteCompressedInteger(BlobUtilities.GetUserStringByteLength(value.Length)); WriteUTF16(value); WriteByte(BlobUtilities.GetUserStringTrailingByte(value)); }
/// <summary> /// Writes string in User String (#US) heap format (see ECMA-335-II 24.2.4 #US and #Blob heaps): /// </summary> /// <remarks> /// The string is UTF16 encoded and prefixed by the its size in bytes. /// /// This final byte holds the value 1 if and only if any UTF16 character within the string has any bit set in its top byte, /// or its low byte is any of the following: 0x01–0x08, 0x0E–0x1F, 0x27, 0x2D, 0x7F. Otherwise, it holds 0. /// The 1 signifies Unicode characters that require handling beyond that normally provided for 8-bit encoding sets. /// </remarks> /// <exception cref="InvalidOperationException">Builder is not writable, it has been linked with another one.</exception> public void WriteUserString(string value) { if (value == null) { throw new ArgumentNullException(nameof(value)); } WriteCompressedInteger(BlobUtilities.GetUserStringByteLength(value.Length)); WriteUTF16(value); WriteByte(BlobUtilities.GetUserStringTrailingByte(value)); }
private void TestGetUTF8ByteCount(int expectedCount, string expectedRemainder, string str, int charCount, int byteLimit) { fixed(char *ptr = str) { char *remainderPtr; Assert.Equal(expectedCount, BlobUtilities.GetUTF8ByteCount(ptr, charCount, byteLimit, out remainderPtr)); string remainder = new string(remainderPtr); Assert.Equal(expectedRemainder, remainder); } }
/// <summary> /// Reserves space on the User String heap for a string of specified length. /// </summary> /// <param name="length">The number of characters to reserve.</param> /// <param name="reservedUserString"> /// <see cref="Blob"/> representing the entire User String blob (including its length and terminal character). /// Use <see cref="BlobWriter.WriteUserString(string)"/> to fill in the content. /// </param> /// <returns> /// Handle to the reserved User String. /// May be used in <see cref="InstructionEncoder.LoadString(UserStringHandle)"/>. /// </returns> /// <exception cref="ImageFormatLimitationException">The remaining space on the heap is too small to fit the string.</exception> /// <exception cref="ArgumentOutOfRangeException"><paramref name="length"/> is negative.</exception> public UserStringHandle ReserveUserString(int length, out Blob reservedUserString) { if (length < 0) { Throw.ArgumentOutOfRange(nameof(length)); } var handle = GetNewUserStringHandle(); int encodedLength = BlobUtilities.GetUserStringByteLength(length); reservedUserString = _userStringBuilder.ReserveBytes(BlobWriterImpl.GetCompressedIntegerSize(encodedLength) + encodedLength); return(handle); }
/// <summary> /// Returns a cloud blob directory reference at a specified location /// </summary> /// <param name="cloudBlobContainer">Container reference to get the directory reference from</param> /// <param name="path">Path to the cloud blob directory</param> /// <returns>Cloud blob directory reference at the desired location</returns> public static CloudBlobDirectory GetCloudBlobDirectoryReference(this CloudBlobContainer cloudBlobContainer, string[] path = null) { #region validation if (cloudBlobContainer == null) { throw new ArgumentNullException(nameof(cloudBlobContainer)); } #endregion string fullPath = BlobUtilities.GetPath(path); return(cloudBlobContainer.GetDirectoryReference(fullPath)); }
/// <summary> /// Create a container if doesn't exist, setting permission with policy, and return assosciated SAS signature /// </summary> /// <param name="account">Storage account</param> /// <param name="Key">Storage account key</param> /// <param name="blobUri">Blob endpoint URI</param> /// <param name="containerName">Name of the container to be created</param> /// <param name="policy">Name for the policy</param> /// <param name="start">Start time of the policy</param> /// <param name="end">Expire time of the policy</param> /// <param name="permissions">Blob access permissions</param> /// <returns>the SAS for the container, in full URI format.</returns>. private static async Task <string> CreateContainerWithPolicySASIfNotExistAsync(string account, string key, Uri blobUri, string containerName, string policy, DateTime start, DateTime end, string permissions) { // 1. form the credentail and initial client StagingStorageAccount stagingCredentials = new StagingStorageAccount(account, key, blobUri.ToString()); StorageSharedKeyCredential shardKeyCredentials = new StorageSharedKeyCredential(account, key); BlobContainerClient containerClient = BlobUtilities.GetBlobContainerClient(containerName, stagingCredentials); // 2. create container if it doesn't exist containerClient.CreateIfNotExists(); // 3. validate policy, create/overwrite if doesn't match BlobSignedIdentifier identifier = new BlobSignedIdentifier { Id = policy, AccessPolicy = new BlobAccessPolicy { Permissions = permissions, StartsOn = start, ExpiresOn = end, }, }; var accessPolicy = (await containerClient.GetAccessPolicyAsync()).Value; bool policyFound = accessPolicy.SignedIdentifiers.Any(i => i == identifier); if (policyFound == false) { await containerClient.SetAccessPolicyAsync(PublicAccessType.BlobContainer, permissions : new List <BlobSignedIdentifier> { identifier }); } BlobSasBuilder sasBuilder = new BlobSasBuilder { BlobContainerName = containerName, StartsOn = start, ExpiresOn = end, }; sasBuilder.SetPermissions(permissions); BlobUriBuilder builder = new BlobUriBuilder(containerClient.Uri) { Sas = sasBuilder.ToSasQueryParameters(shardKeyCredentials) }; string fullSas = builder.ToString(); return(fullSas); }
private void WriteUTF8(string str, int start, int length, bool allowUnpairedSurrogates, bool prependSize) { fixed (char* strPtr = str) { char* charPtr = strPtr + start; int byteCount = BlobUtilities.GetUTF8ByteCount(charPtr, length); if (prependSize) { WriteCompressedInteger(byteCount); } int startOffset = Advance(byteCount); _buffer.WriteUTF8(startOffset, charPtr, length, byteCount, allowUnpairedSurrogates); } }
/// <summary> /// Stage a single file. /// </summary> private async static Task StageOneFileAsync(FileToStage stageThisFile, SequentialFileStagingArtifact seqArtifacts) { StagingStorageAccount storecreds = stageThisFile.StagingStorageAccount; string containerName = seqArtifacts.BlobContainerCreated; // TODO: this flattens all files to the top of the compute node/task relative file directory. solve the hiearchy problem (virt dirs?) string blobName = Path.GetFileName(stageThisFile.LocalFileToStage); BlobContainerClient blobContainerClient = BlobUtilities.GetBlobContainerClient(containerName, storecreds); BlockBlobClient blobClient = blobContainerClient.GetBlockBlobClient(blobName); bool doesBlobExist = await blobClient.ExistsAsync(); bool mustUploadBlob = true; // we do not re-upload blobs if they have already been uploaded if (doesBlobExist) // if the blob exists, compare { FileInfo fi = new FileInfo(stageThisFile.LocalFileToStage); var properties = await blobClient.GetPropertiesAsync(); var length = properties.Value.ContentLength; // since we don't have a hash of the contents... we check length if (length == fi.Length) { mustUploadBlob = false; } } if (mustUploadBlob) { using FileStream stream = new FileStream(stageThisFile.LocalFileToStage, FileMode.Open); // upload the file Task uploadTask = blobClient.UploadAsync(stream); await uploadTask.ConfigureAwait(continueOnCapturedContext : false); } // get the SAS for the blob string blobSAS = ConstructBlobSource(seqArtifacts.DefaultContainerSAS, blobName); string nodeFileName = stageThisFile.NodeFileName; // create a new ResourceFile and populate it. This file is now staged! stageThisFile.StagedFiles = new ResourceFile[] { ResourceFile.FromUrl(blobSAS, nodeFileName) }; }
public void MoveDirectoryTest(string directoryName, string[] sourcePath, string[] targetPath) { // Arrange string relativeAddress = BlobUtilities.GetPath(directoryName, sourcePath); CloudBlobDirectory sourceCloudBlobDirectory = _cloudBlobContainer.GetDirectoryReference(relativeAddress); int expectedChildCount = TaskUtilities .ExecuteSync( sourceCloudBlobDirectory.ListBlobsSegmentedAsync( useFlatBlobListing: true, blobListingDetails: BlobListingDetails.None, maxResults: null, currentToken: new BlobContinuationToken(), options: new BlobRequestOptions(), operationContext: new OperationContext() ) ) .Results.Count(); // Act _fileContainer.MoveDirectory(directoryName, sourcePath, targetPath); string path = BlobUtilities.GetPath(directoryName, targetPath); CloudBlobDirectory targetCloudBlobDirectory = _cloudBlobContainer.GetDirectoryReference(path); int actualChildCount = TaskUtilities .ExecuteSync( targetCloudBlobDirectory.ListBlobsSegmentedAsync( useFlatBlobListing: true, blobListingDetails: BlobListingDetails.None, maxResults: null, currentToken: new BlobContinuationToken(), options: new BlobRequestOptions(), operationContext: new OperationContext() ) ) .Results.Count(); // Assert Assert.IsFalse(_fileContainer.ExistsDirectory(directoryName, sourcePath)); Assert.AreEqual(expectedChildCount, actualChildCount); }
public void GetSharedAccessSignature_WithBlob_Returns_The_Correct_Token() { // Arrange var dummyContainer = new CloudBlobContainer( new Uri("http://test-storage.org"), new StorageCredentials("fakeaccount", Convert.ToBase64String(Encoding.Unicode.GetBytes("fakekeyval")), "fakekeyname")); var blobUtilities = new BlobUtilities(); var permissions = SharedAccessBlobPermissions.Read; var expiryTime = DateTimeOffset.UtcNow.AddDays(1); // Act var result = blobUtilities.GetSharedAccessSignature(dummyContainer, "blob", expiryTime, permissions); // Assert Assert.That(result, Is.Not.Null); }
/// <summary> /// Fills in stringIndexMap with data from stringIndex and write to stringWriter. /// Releases stringIndex as the stringTable is sealed after this point. /// </summary> private static ImmutableArray <int> SerializeStringHeap( BlobBuilder heapBuilder, Dictionary <string, StringHandle> strings, int stringHeapStartOffset) { // Sort by suffix and remove stringIndex var sorted = new List <KeyValuePair <string, StringHandle> >(strings); sorted.Sort(SuffixSort.Instance); // Create VirtIdx to Idx map and add entry for empty string int totalCount = sorted.Count + 1; var stringVirtualIndexToHeapOffsetMap = ImmutableArray.CreateBuilder <int>(totalCount); stringVirtualIndexToHeapOffsetMap.Count = totalCount; stringVirtualIndexToHeapOffsetMap[0] = 0; heapBuilder.WriteByte(0); // Find strings that can be folded string prev = string.Empty; foreach (KeyValuePair <string, StringHandle> entry in sorted) { int position = stringHeapStartOffset + heapBuilder.Count; // It is important to use ordinal comparison otherwise we'll use the current culture! if (prev.EndsWith(entry.Key, StringComparison.Ordinal) && !BlobUtilities.IsLowSurrogateChar(entry.Key[0])) { // Map over the tail of prev string. Watch for null-terminator of prev string. stringVirtualIndexToHeapOffsetMap[entry.Value.GetWriterVirtualIndex()] = position - (BlobUtilities.GetUTF8ByteCount(entry.Key) + 1); } else { stringVirtualIndexToHeapOffsetMap[entry.Value.GetWriterVirtualIndex()] = position; heapBuilder.WriteUTF8(entry.Key, allowUnpairedSurrogates: false); heapBuilder.WriteByte(0); } prev = entry.Key; } return(stringVirtualIndexToHeapOffsetMap.MoveToImmutable()); }
/// <summary> /// Creates a builder of a metadata root. /// </summary> /// <param name="tablesAndHeaps"> /// Builder populated with metadata entities stored in tables and values stored in heaps. /// The entities and values will be enumerated when serializing the metadata root. /// </param> /// <param name="metadataVersion"> /// The version string written to the metadata header. The default value is "v4.0.30319". /// </param> /// <exception cref="ArgumentNullException"><paramref name="tablesAndHeaps"/> is null.</exception> /// <exception cref="ArgumentException"><paramref name="metadataVersion"/> is too long (the number of bytes when UTF8-encoded must be less than 255).</exception> public MetadataRootBuilder(MetadataBuilder tablesAndHeaps, string metadataVersion = null) { if (tablesAndHeaps == null) { Throw.ArgumentNull(nameof(tablesAndHeaps)); } Debug.Assert(BlobUtilities.GetUTF8ByteCount(DefaultMetadataVersionString) == DefaultMetadataVersionString.Length); int metadataVersionByteCount = metadataVersion != null?BlobUtilities.GetUTF8ByteCount(metadataVersion) : DefaultMetadataVersionString.Length; if (metadataVersionByteCount > MetadataSizes.MaxMetadataVersionByteCount) { Throw.InvalidArgument(SR.MetadataVersionTooLong, nameof(metadataVersion)); } _tablesAndHeaps = tablesAndHeaps; MetadataVersion = metadataVersion ?? DefaultMetadataVersionString; _serializedMetadata = tablesAndHeaps.GetSerializedMetadata(EmptyRowCounts, metadataVersionByteCount, isStandaloneDebugMetadata: false); }
/// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException">Range specified by <paramref name="start"/> and <paramref name="byteCount"/> falls outside of the bounds of the <paramref name="buffer"/>.</exception> public unsafe void WriteBytes(byte[] buffer, int start, int byteCount) { if (buffer == null) { Throw.ArgumentNull(nameof(buffer)); } BlobUtilities.ValidateRange(buffer.Length, start, byteCount, nameof(byteCount)); // an empty array has no element pointer: if (buffer.Length == 0) { return; } fixed (byte* ptr = &buffer[0]) { WriteBytes(ptr + start, byteCount); } }
internal unsafe void WriteUTF8(string str, int start, int length, bool allowUnpairedSurrogates, bool prependSize) { Debug.Assert(start >= 0); Debug.Assert(length >= 0); Debug.Assert(start + length <= str.Length); if (!IsHead) { Throw.InvalidOperationBuilderAlreadyLinked(); } fixed(char *strPtr = str) { char *currentPtr = strPtr + start; char *nextPtr; // the max size of compressed int is 4B: int byteLimit = FreeBytes - (prependSize ? sizeof(uint) : 0); int bytesToCurrent = BlobUtilities.GetUTF8ByteCount(currentPtr, length, byteLimit, out nextPtr); int charsToCurrent = (int)(nextPtr - currentPtr); int charsToNext = length - charsToCurrent; int bytesToNext = BlobUtilities.GetUTF8ByteCount(nextPtr, charsToNext); if (prependSize) { WriteCompressedInteger(bytesToCurrent + bytesToNext); } _buffer.WriteUTF8(Length, currentPtr, charsToCurrent, bytesToCurrent, allowUnpairedSurrogates); AddLength(bytesToCurrent); if (bytesToNext > 0) { Expand(bytesToNext); _buffer.WriteUTF8(0, nextPtr, charsToNext, bytesToNext, allowUnpairedSurrogates); AddLength(bytesToNext); } } }
/// <summary> /// Creates a builder of a Portable PDB image. /// </summary> /// <param name="tablesAndHeaps"> /// Builder populated with debug metadata entities stored in tables and values stored in heaps. /// The entities and values will be enumerated when serializing the Portable PDB image. /// </param> /// <param name="typeSystemRowCounts"> /// Row counts of all tables that the associated type-system metadata contain. /// Each slot in the array corresponds to a table (<see cref="TableIndex"/>). /// The length of the array must be equal to <see cref="MetadataTokens.TableCount"/>. /// </param> /// <param name="entryPoint"> /// Entry point method definition handle. /// </param> /// <param name="idProvider"> /// Function calculating id of content represented as a sequence of blobs. /// If not specified a default function that ignores the content and returns current time-based content id is used /// (<see cref="BlobContentId.GetTimeBasedProvider()"/>). /// You must specify a deterministic function to produce a deterministic Portable PDB image. /// </param> /// <exception cref="ArgumentNullException"><paramref name="tablesAndHeaps"/> or <paramref name="typeSystemRowCounts"/> is null.</exception> public PortablePdbBuilder( MetadataBuilder tablesAndHeaps, ImmutableArray <int> typeSystemRowCounts, MethodDefinitionHandle entryPoint, Func <IEnumerable <Blob>, BlobContentId>?idProvider = null) { if (tablesAndHeaps == null) { Throw.ArgumentNull(nameof(tablesAndHeaps)); } ValidateTypeSystemRowCounts(typeSystemRowCounts); _builder = tablesAndHeaps; _entryPoint = entryPoint; Debug.Assert(BlobUtilities.GetUTF8ByteCount(MetadataVersion) == MetadataVersion.Length); _serializedMetadata = tablesAndHeaps.GetSerializedMetadata(typeSystemRowCounts, MetadataVersion.Length, isStandaloneDebugMetadata: true); IdProvider = idProvider ?? BlobContentId.GetTimeBasedProvider(); }
/// <summary> /// Fills in stringIndexMap with data from stringIndex and write to stringWriter. /// Releases stringIndex as the stringTable is sealed after this point. /// </summary> private void SerializeStringHeap() { // Sort by suffix and remove stringIndex var sorted = new List <KeyValuePair <string, StringHandle> >(_strings); sorted.Sort(new SuffixSort()); _strings = null; _stringWriter = new BlobBuilder(1024); // Create VirtIdx to Idx map and add entry for empty string _stringIndexToResolvedOffsetMap = new int[sorted.Count + 1]; _stringIndexToResolvedOffsetMap[0] = 0; _stringWriter.WriteByte(0); // Find strings that can be folded string prev = string.Empty; foreach (KeyValuePair <string, StringHandle> entry in sorted) { int position = _stringHeapStartOffset + _stringWriter.Position; // It is important to use ordinal comparison otherwise we'll use the current culture! if (prev.EndsWith(entry.Key, StringComparison.Ordinal) && !BlobUtilities.IsLowSurrogateChar(entry.Key[0])) { // Map over the tail of prev string. Watch for null-terminator of prev string. _stringIndexToResolvedOffsetMap[MetadataTokens.GetHeapOffset(entry.Value)] = position - (BlobUtilities.GetUTF8ByteCount(entry.Key) + 1); } else { _stringIndexToResolvedOffsetMap[MetadataTokens.GetHeapOffset(entry.Value)] = position; _stringWriter.WriteUTF8(entry.Key, allowUnpairedSurrogates: false); _stringWriter.WriteByte(0); } prev = entry.Key; } }
private async Task <bool> SaveToAzureBlob(BlobDetails blobDetails) { MemoryStream ms = null; IFormFile file = null; try { if (CloudStorageAccount.TryParse(_azureBlobConfig.Value.ConnectionString, out CloudStorageAccount storageAccount)) { CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); CloudBlobContainer container = BlobUtilities.GetBlobContainer(blobClient, blobDetails.Type, _azureBlobConfig); CloudBlockBlob blockBlob = container.GetBlockBlobReference(BlobUtilities.GenerateUniqueAadhaarImageName(blobDetails.CustomerID, blobDetails.Type)); using (ms = new MemoryStream()) { file = blobDetails.BlobFile; file.CopyTo(ms); var fileBytes = ms.ToArray(); await blockBlob.UploadFromByteArrayAsync(fileBytes, 0, fileBytes.Length); } return(true); } else { return(false); } } catch { return(false); } //finally //{ // await ms.DisposeAsync(); //} }