/// <summary> /// Fills the meta. /// </summary> /// <param name="meta">The meta.</param> /// <param name="blobProperties">The BLOB properties.</param> public static void FillMeta(this BinaryStorageMetaData meta, BlobProperties blobProperties) { if (meta != null && blobProperties != null) { meta.Hash = blobProperties.ContentMD5; meta.Mime = blobProperties.ContentType; meta.Name = blobProperties.ContentDisposition.ConvertContentDispositionToName(); } }
/// <summary> /// Initializes a new instance of the <see cref="BlobProperties"/> class based on an existing instance. /// </summary> /// <param name="other">The set of properties to clone.</param> public BlobProperties(BlobProperties other) { this.BlobType = other.BlobType; this.ContentEncoding = other.ContentEncoding; this.ContentLanguage = other.ContentLanguage; this.Length = other.Length; this.ContentType = other.ContentType; this.ETag = other.ETag; this.LastModified = other.LastModified; this.LeaseStatus = other.LeaseStatus; }
/// <summary> /// Initializes a new instance of the <see cref="BlobProperties"/> class based on an existing instance. /// </summary> /// <param name="other">The set of properties to clone.</param> /// <remarks>Lease-related properties will not be cloned, because a lease associated with the base blob is not copied to the snapshot.</remarks> public BlobProperties(BlobProperties other) { CommonUtility.AssertNotNull("other", other); this.BlobType = other.BlobType; this.ContentType = other.ContentType; this.ContentEncoding = other.ContentEncoding; this.ContentLanguage = other.ContentLanguage; this.CacheControl = other.CacheControl; this.ContentMD5 = other.ContentMD5; this.Length = other.Length; this.ETag = other.ETag; this.LastModified = other.LastModified; this.PageBlobSequenceNumber = other.PageBlobSequenceNumber; }
/// <summary> /// Initializes a new instance of the <see cref="BlobProperties"/> class based on an existing instance. /// </summary> /// <param name="other">The set of properties to clone.</param> /// <remarks>Lease-related properties will not be cloned, because a lease associated with the base blob is not copied to the snapshot.</remarks> public BlobProperties(BlobProperties other) { CommonUtility.AssertNotNull("other", other); this.BlobType = other.BlobType; this.ContentType = other.ContentType; this.ContentDisposition = other.ContentDisposition; this.ContentEncoding = other.ContentEncoding; this.ContentLanguage = other.ContentLanguage; this.CacheControl = other.CacheControl; this.ContentMD5 = other.ContentMD5; this.Length = other.Length; this.ETag = other.ETag; this.LastModified = other.LastModified; this.PageBlobSequenceNumber = other.PageBlobSequenceNumber; }
/// <summary> /// Initializes a new instance of the <see cref="BlobProperties"/> class based on an existing instance. /// </summary> /// <param name="other">A <see cref="BlobProperties"/> object.</param> /// <remarks>Lease-related properties will not be cloned, because a lease associated with the base blob is not copied to the snapshot.</remarks> public BlobProperties(BlobProperties other) { CommonUtility.AssertNotNull("other", other); this.BlobType = other.BlobType; this.ContentType = other.ContentType; this.ContentDisposition = other.ContentDisposition; this.ContentEncoding = other.ContentEncoding; this.ContentLanguage = other.ContentLanguage; this.CacheControl = other.CacheControl; this.ContentMD5 = other.ContentMD5; this.Length = other.Length; this.ETag = other.ETag; this.LastModified = other.LastModified; this.PageBlobSequenceNumber = other.PageBlobSequenceNumber; this.AppendBlobCommittedBlockCount = other.AppendBlobCommittedBlockCount; this.IsServerEncrypted = other.IsServerEncrypted; }
/// <summary> /// Initializes a new instance of the BlobReadStreamBase class. /// </summary> /// <param name="blob">Blob reference to read from</param> /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed. If <c>null</c>, no condition is used.</param> /// <param name="options">A <see cref="BlobRequestOptions"/> object that specifies additional options for the request.</param> /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param> protected BlobReadStreamBase(CloudBlob blob, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext) { if (options.UseTransactionalMD5.Value) { CommonUtility.AssertInBounds("StreamMinimumReadSizeInBytes", blob.StreamMinimumReadSizeInBytes, 1, Constants.MaxRangeGetContentMD5Size); } this.blob = blob; this.blobProperties = new BlobProperties(blob.Properties); this.currentOffset = 0; this.streamMinimumReadSizeInBytes = this.blob.StreamMinimumReadSizeInBytes; this.internalBuffer = new MultiBufferMemoryStream(blob.ServiceClient.BufferManager); this.accessCondition = accessCondition; this.options = options; this.operationContext = operationContext; this.blobMD5 = (this.options.DisableContentMD5Validation.Value || string.IsNullOrEmpty(this.blobProperties.ContentMD5)) ? null : new MD5Wrapper(); this.lastException = null; }
/// <summary> /// Initializes a new instance of the BlobReadStreamBase class. /// </summary> /// <param name="blob">Blob reference to read from</param> /// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param> /// <param name="options">An object that specifies additional options for the request.</param> /// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param> protected BlobReadStreamBase(ICloudBlob blob, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext) { if (options.UseTransactionalMD5.Value) { CommonUtility.AssertInBounds("StreamMinimumReadSizeInBytes", blob.StreamMinimumReadSizeInBytes, 1, Constants.MaxRangeGetContentMD5Size); } this.blob = blob; this.blobProperties = new BlobProperties(blob.Properties); this.currentOffset = 0; this.streamMinimumReadSizeInBytes = this.blob.StreamMinimumReadSizeInBytes; this.internalBuffer = new MemoryStream(this.streamMinimumReadSizeInBytes); this.accessCondition = accessCondition; this.options = options; this.operationContext = operationContext; this.blobMD5 = (this.options.DisableContentMD5Validation.Value || string.IsNullOrEmpty(this.blobProperties.ContentMD5)) ? null : new MD5Wrapper(); this.lastException = null; }
/// <summary> /// Initializes a new instance of the <see cref="BlobProperties"/> class based on an existing instance. /// </summary> /// <param name="other">A <see cref="BlobProperties"/> object.</param> /// <remarks>Lease-related properties will not be cloned, because a lease associated with the base blob is not copied to the snapshot.</remarks> public BlobProperties(BlobProperties other) { CommonUtility.AssertNotNull("other", other); this.BlobType = other.BlobType; this.ContentType = other.ContentType; this.ContentDisposition = other.ContentDisposition; this.ContentEncoding = other.ContentEncoding; this.ContentLanguage = other.ContentLanguage; this.CacheControl = other.CacheControl; this.ContentMD5 = other.ContentMD5; this.Length = other.Length; this.ETag = other.ETag; this.LastModified = other.LastModified; this.PageBlobSequenceNumber = other.PageBlobSequenceNumber; this.AppendBlobCommittedBlockCount = other.AppendBlobCommittedBlockCount; this.IsServerEncrypted = other.IsServerEncrypted; this.IsIncrementalCopy = other.IsIncrementalCopy; }
public static void AssertAreEqual(BlobProperties prop1, BlobProperties prop2) { if (prop1 == null) { Assert.IsNull(prop2); } else { Assert.IsNotNull(prop2); Assert.AreEqual(prop1.CacheControl, prop2.CacheControl); Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding); Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage); Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5); Assert.AreEqual(prop1.ContentType, prop2.ContentType); Assert.AreEqual(prop1.ETag, prop2.ETag); Assert.AreEqual(prop1.LastModified, prop2.LastModified); Assert.AreEqual(prop1.Length, prop2.Length); } }
public static void AssertAreEqual(BlobProperties expected, BlobProperties actual) { if (expected == null) { Assert.IsNull(actual); } else { Assert.IsNotNull(actual); Assert.AreEqual(expected.CacheControl, actual.CacheControl); Assert.AreEqual(expected.ContentDisposition, actual.ContentDisposition); Assert.AreEqual(expected.ContentEncoding, actual.ContentEncoding); Assert.AreEqual(expected.ContentLanguage, actual.ContentLanguage); Assert.AreEqual(expected.ContentMD5, actual.ContentMD5); Assert.AreEqual(expected.ContentType, actual.ContentType); Assert.AreEqual(expected.ETag, actual.ETag); Assert.AreEqual(expected.LastModified, actual.LastModified); Assert.AreEqual(expected.Length, actual.Length); } }
/// <summary> /// Updates this blob with the given attributes a the end of a fetch attributes operation. /// </summary> /// <param name="attributes">The new attributes.</param> /// <param name="response">The response.</param> /// <param name="ignoreMD5">if set to <c>true</c>, blob's MD5 will not be updated.</param> /// <exception cref="System.InvalidOperationException"></exception> internal static void UpdateAfterFetchAttributes(BlobAttributes attributes, HttpWebResponse response, bool ignoreMD5) { BlobProperties properties = BlobHttpResponseParsers.GetProperties(response); // If BlobType is specified and the value returned from cloud is different, // then it's a client error and we need to throw. if (attributes.Properties.BlobType != BlobType.Unspecified && attributes.Properties.BlobType != properties.BlobType) { throw new InvalidOperationException(SR.BlobTypeMismatchExceptionMessage); } if (ignoreMD5) { properties.ContentMD5 = attributes.Properties.ContentMD5; } attributes.Properties = properties; attributes.Metadata = BlobHttpResponseParsers.GetMetadata(response); attributes.CopyState = BlobHttpResponseParsers.GetCopyAttributes(response); }
public async Task Load() { var random = new Random(); var bytes = new byte[64]; random.NextBytes(bytes); var p = new BlobProperties() { ContentType = Guid.NewGuid().ToString(), ContentMD5 = Guid.NewGuid().ToString(), }; var container = Substitute.For<IContainer>(); container.Get("file.txt").Returns(Task.FromResult(bytes)); var bi = new BlobItem(container, "/file.txt"); await bi.Load(); Assert.AreEqual(bytes, bi.Data); container.Received().Get("file.txt"); }
/// <summary> /// Downloads the BLOB by BLOB URI. /// </summary> /// <param name="blobUri">The BLOB URI.</param> /// <param name="fetchAttribute">if set to <c>true</c> [fetch attribute].</param> /// <param name="blobProperties">The BLOB properties.</param> /// <param name="metaData">The meta data.</param> /// <returns>System.Byte[].</returns> public static byte[] DownloadBlobByBlobUri(string blobUri, bool fetchAttribute, out BlobProperties blobProperties, out IDictionary<string, string> metaData) { try { blobUri.CheckEmptyString("blobUri"); var blob = new CloudBlockBlob(new Uri(blobUri)); blobProperties = blob.Properties; return DownloadBlob(blob, fetchAttribute, out metaData); } catch (Exception ex) { throw ex.Handle("UploadBlobByBlobUri", blobUri); } }
public async Task UpdateBlobPropertiesAsync(string containerName, string blobName, BlobProperties properties) { var container = _blobClient.GetContainerReference(containerName); var blob = container.GetBlockBlobReference(blobName); try { await blob.FetchAttributesAsync(null, _requestOptions, _context).ConfigureAwait(false); blob.Properties.ContentType = properties.ContentType; blob.Properties.ContentDisposition = properties.ContentDisposition; await blob.SetPropertiesAsync(null, _requestOptions, _context).ConfigureAwait(false); if (properties.Metadata != null) { blob.Metadata.SetMetadata(properties.Metadata); await blob.SetMetadataAsync(); } var perms = await container.GetPermissionsAsync(null, _requestOptions, _context).ConfigureAwait(false); // Elevate container permissions if necessary. if (properties.Security == BlobSecurity.Public && perms.PublicAccess == BlobContainerPublicAccessType.Off) { await container.SetPermissionsAsync(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }, null, _requestOptions, _context).ConfigureAwait(false); } } catch (Exception e) { if (e.IsAzureStorageException()) { throw e.Convert(); } throw; } }
public async Task SaveBlobStreamAsync(string containerName, string blobName, Stream source, BlobProperties properties = null, bool closeStream = true) { var container = _blobClient.GetContainerReference(containerName); var props = properties ?? BlobProperties.Empty; var security = props.Security == BlobSecurity.Public ? BlobContainerPublicAccessType.Blob : BlobContainerPublicAccessType.Off; try { var created = await container.CreateIfNotExistsAsync(security, _requestOptions, _context).ConfigureAwait(false); var blob = container.GetBlockBlobReference(blobName); blob.Properties.ContentType = props.ContentType; blob.Properties.ContentDisposition = props.ContentDisposition; if (props.Metadata != null) { blob.Metadata.SetMetadata(props.Metadata); } await blob.UploadFromStreamAsync(source, null, _requestOptions, _context).ConfigureAwait(false); // Hack to deal with issue https://github.com/Azure/azure-storage-net/issues/353 if (!string.IsNullOrEmpty(props.ContentDisposition)) { await blob.SetPropertiesAsync(null, _requestOptions, _context); } // Check if container permission elevation is necessary if (!created) { var perms = await container.GetPermissionsAsync(null, _requestOptions, _context).ConfigureAwait(false); if (properties != null && properties.Security == BlobSecurity.Public && perms.PublicAccess == BlobContainerPublicAccessType.Off) { await container.SetPermissionsAsync(new BlobContainerPermissions { PublicAccess = security }, null, _requestOptions, _context).ConfigureAwait(false); } } } catch (Exception e) { if (e.IsAzureStorageException()) { throw e.Convert(); } throw; } finally { if (closeStream) { source.Dispose(); } } }
public BlobProperties Properties() { ValidateFile(); if (_properties == null) { if (_blob == null) GetBlob(); _blob.FetchAttributes(); _properties = _blob.Properties; } return _properties; }
public HostedAzureBlobProperties(BlobProperties blobProperties) { _blobProperties = blobProperties; }
protected ICloudBlob StubACloudBlob(DateTimeOffset? lastModified = default(DateTimeOffset?)) { var cloudBlobProperties = new BlobProperties(); var property = typeof(BlobProperties).GetProperty("LastModified"); property.SetValue(cloudBlobProperties, lastModified, BindingFlags.NonPublic, null, null, null); var cloudBlob = MockRepository.GenerateStub<ICloudBlob>(); cloudBlob.Stub(x => x.Metadata).Return(new Dictionary<string, string>()); cloudBlob.Stub(x => x.SetMetadata()); cloudBlob.Stub(x => x.Properties).Return(cloudBlobProperties); return cloudBlob; }
public async Task CloudPageBlobCopyFromSnapshotTestAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob source = container.GetPageBlobReference("source"); string data = new string('a', 512); await UploadTextAsync(source, data, Encoding.UTF8); source.Metadata["Test"] = "value"; await source.SetMetadataAsync(); CloudPageBlob snapshot = await source.CreateSnapshotAsync(); //Modify source string newData = new string('b', 512); source.Metadata["Test"] = "newvalue"; await source.SetMetadataAsync(); source.Properties.ContentMD5 = null; await UploadTextAsync(source, newData, Encoding.UTF8); Assert.AreEqual(newData, await DownloadTextAsync(source, Encoding.UTF8), "Source is modified correctly"); Assert.AreEqual(data, await DownloadTextAsync(snapshot, Encoding.UTF8), "Modifying source blob should not modify snapshot"); await source.FetchAttributesAsync(); await snapshot.FetchAttributesAsync(); Assert.AreNotEqual(source.Metadata["Test"], snapshot.Metadata["Test"], "Source and snapshot metadata should be independent"); CloudPageBlob copy = container.GetPageBlobReference("copy"); await copy.StartCopyFromBlobAsync(TestHelper.Defiddler(snapshot)); await WaitForCopyAsync(copy); Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status); Assert.AreEqual(data, await DownloadTextAsync(copy, Encoding.UTF8), "Data inside copy of blob not similar"); await copy.FetchAttributesAsync(); BlobProperties prop1 = copy.Properties; BlobProperties prop2 = snapshot.Properties; Assert.AreEqual(prop1.CacheControl, prop2.CacheControl); Assert.AreEqual(prop1.ContentDisposition, prop2.ContentDisposition); Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding); Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage); Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5); Assert.AreEqual(prop1.ContentType, prop2.ContentType); Assert.AreEqual("value", copy.Metadata["Test"], false, "Copied metadata not same"); await copy.DeleteAsync(); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
/// <summary> /// Get blob properties /// </summary> /// <returns>Return true on success, false if not found, throw exception on error</returns> public bool GetBlobProperties(string containerName, string blobName, out BlobProperties properties) { properties = null; try { CloudBlobContainer container = _blobClient.GetContainerReference(containerName); ICloudBlob blob = container.GetBlobReferenceFromServer(blobName); blob.FetchAttributes(); properties = blob.Properties; return true; } catch (StorageException ex) { if (ex.RequestInformation.HttpStatusCode == 404) { return false; } throw; } }
private static async Task CloudBlockBlobCopyFromCloudFileImpl(Func <CloudFile, CloudBlockBlob, string> copyFunc) { CloudFileClient fileClient = GenerateCloudFileClient(); string name = GetRandomContainerName(); CloudFileShare share = fileClient.GetShareReference(name); CloudBlobContainer container = GetRandomContainerReference(); try { try { await container.CreateAsync(); await share.CreateAsync(); CloudFile source = share.GetRootDirectoryReference().GetFileReference("source"); byte[] data = GetRandomBuffer(1024); await source.UploadFromByteArrayAsync(data, 0, data.Length); source.Metadata["Test"] = "value"; source.SetMetadataAsync().Wait(); var sasToken = source.GetSharedAccessSignature(new SharedAccessFilePolicy { Permissions = SharedAccessFilePermissions.Read, SharedAccessExpiryTime = DateTime.UtcNow.AddHours(24) }); Uri fileSasUri = new Uri(source.StorageUri.PrimaryUri.ToString() + sasToken); source = new CloudFile(fileSasUri); CloudBlockBlob copy = container.GetBlockBlobReference("copy"); string copyId = copyFunc(source, copy); Assert.AreEqual(BlobType.BlockBlob, copy.BlobType); try { await WaitForCopyAsync(copy); Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status); Assert.AreEqual(source.Uri.AbsolutePath, copy.CopyState.Source.AbsolutePath); Assert.AreEqual(data.Length, copy.CopyState.TotalBytes); Assert.AreEqual(data.Length, copy.CopyState.BytesCopied); Assert.AreEqual(copyId, copy.CopyState.CopyId); Assert.IsFalse(copy.Properties.IsIncrementalCopy); Assert.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1))); } catch (NullReferenceException) { // potential null ref in the WaitForCopyTask and CopyState check implementation } OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await copy.AbortCopyAsync(copyId, null, null, opContext), opContext, "Aborting a copy operation after completion should fail", HttpStatusCode.Conflict, "NoPendingCopyOperation"); source.FetchAttributesAsync().Wait(); Assert.IsNotNull(copy.Properties.ETag); Assert.AreNotEqual(source.Properties.ETag, copy.Properties.ETag); Assert.IsTrue(copy.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1))); byte[] copyData = new byte[source.Properties.Length]; await copy.DownloadToByteArrayAsync(copyData, 0); Assert.IsTrue(data.SequenceEqual(copyData), "Data inside copy of blob not similar"); copy.FetchAttributesAsync().Wait(); BlobProperties prop1 = copy.Properties; FileProperties prop2 = source.Properties; Assert.AreEqual(prop1.CacheControl, prop2.CacheControl); Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding); Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage); Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5); Assert.AreEqual(prop1.ContentType, prop2.ContentType); Assert.AreEqual("value", copy.Metadata["Test"], false, "Copied metadata not same"); copy.DeleteIfExistsAsync().Wait(); } finally { share.DeleteIfExistsAsync().Wait(); } } finally { container.DeleteIfExistsAsync().Wait(); } }
public static void AssertAreEqual(BlobProperties expected, BlobProperties actual) { AssertAreEqual(expected, actual, true); }
public BlobProperties(BlobProperties other) { throw new System.NotImplementedException(); }
public async void Test_Blob_Created_ContentDisposition_Set_Async() { var container = GetRandomContainerName(); var blobName = GenerateRandomName(); var filename = "testFile.jpg"; var dataLength = 256; var data = GenerateRandomBlobStream(dataLength); var prop = new BlobProperties().WithContentDispositionFilename(filename); await _provider.SaveBlobStreamAsync(container, blobName, data, prop); var blob = _client.GetContainerReference(container) .GetBlockBlobReference(blobName); await blob.FetchAttributesAsync(); Assert.Equal(dataLength, blob.Properties.Length); Assert.Equal($"attachment; filename=\"{filename}\"", blob.Properties.ContentDisposition); }
public static void AssertAreEqual(BlobProperties prop1, BlobProperties prop2) { if (prop1 == null) { Assert.IsNull(prop2); } else { Assert.IsNotNull(prop2); Assert.AreEqual(prop1.CacheControl, prop2.CacheControl); Assert.AreEqual(prop1.ContentDisposition, prop2.ContentDisposition); Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding); Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage); Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5); Assert.AreEqual(prop1.ContentType, prop2.ContentType); Assert.AreEqual(prop1.ETag, prop2.ETag); Assert.AreEqual(prop1.LastModified, prop2.LastModified); Assert.AreEqual(prop1.Length, prop2.Length); } }
public void CloudBlockBlobCopyTestAPM() { CloudBlobContainer container = GetRandomContainerReference(); try { container.Create(); CloudBlockBlob source = container.GetBlockBlobReference("source"); string data = "String data"; UploadText(source, data, Encoding.UTF8); source.Metadata["Test"] = "value"; source.SetMetadata(); CloudBlockBlob copy = container.GetBlockBlobReference("copy"); using (AutoResetEvent waitHandle = new AutoResetEvent(false)) { IAsyncResult result = copy.BeginStartCopyFromBlob(TestHelper.Defiddler(source), ar => waitHandle.Set(), null); waitHandle.WaitOne(); string copyId = copy.EndStartCopyFromBlob(result); WaitForCopy(copy); Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status); Assert.AreEqual(source.Uri.AbsolutePath, copy.CopyState.Source.AbsolutePath); Assert.AreEqual(data.Length, copy.CopyState.TotalBytes); Assert.AreEqual(data.Length, copy.CopyState.BytesCopied); Assert.AreEqual(copyId, copy.CopyState.CopyId); Assert.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1))); result = copy.BeginAbortCopy(copyId, ar => waitHandle.Set(), null); waitHandle.WaitOne(); TestHelper.ExpectedException( () => copy.EndAbortCopy(result), "Aborting a copy operation after completion should fail", HttpStatusCode.Conflict, "NoPendingCopyOperation"); } source.FetchAttributes(); Assert.IsNotNull(copy.Properties.ETag); Assert.AreNotEqual(source.Properties.ETag, copy.Properties.ETag); Assert.IsTrue(copy.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1))); string copyData = DownloadText(copy, Encoding.UTF8); Assert.AreEqual(data, copyData, "Data inside copy of blob not similar"); copy.FetchAttributes(); BlobProperties prop1 = copy.Properties; BlobProperties prop2 = source.Properties; Assert.AreEqual(prop1.CacheControl, prop2.CacheControl); Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding); Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage); Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5); Assert.AreEqual(prop1.ContentType, prop2.ContentType); Assert.AreEqual("value", copy.Metadata["Test"], false, "Copied metadata not same"); copy.Delete(); } finally { container.DeleteIfExists(); } }
/// <summary> /// Downloads the BLOB by BLOB URI. /// </summary> /// <param name="blobUri">The BLOB URI.</param> /// <param name="blobProperties">The BLOB properties.</param> /// <param name="metaData">The meta data.</param> /// <returns>System.Byte[].</returns> public static byte[] DownloadBlobByBlobUri(string blobUri, out BlobProperties blobProperties, out IDictionary<string, string> metaData) { return DownloadBlobByBlobUri(blobUri, true, out blobProperties, out metaData); }
/// <summary> /// Downloads the BLOB by BLOB URI. /// </summary> /// <param name="blobUri">The BLOB URI.</param> /// <param name="blobProperties">The BLOB properties.</param> /// <returns>System.Byte[].</returns> public static byte[] DownloadBlobByBlobUri(string blobUri, out BlobProperties blobProperties) { IDictionary<string, string> metaData = null; return DownloadBlobByBlobUri(blobUri, false, out blobProperties, out metaData); }
private static void CloudBlockBlobCopy(bool sourceIsSas, bool destinationIsSas) { CloudBlobContainer container = GetRandomContainerReference(); try { container.Create(); // Create Source on server CloudBlockBlob source = container.GetBlockBlobReference("source"); string data = "String data"; UploadText(source, data, Encoding.UTF8); source.Metadata["Test"] = "value"; source.SetMetadata(); // Create Destination on server CloudBlockBlob destination = container.GetBlockBlobReference("destination"); destination.PutBlockList(new string[] { }); CloudBlockBlob copySource = source; CloudBlockBlob copyDestination = destination; if (sourceIsSas) { // Source SAS must have read permissions SharedAccessBlobPermissions permissions = SharedAccessBlobPermissions.Read; SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy() { SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5), SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30), Permissions = permissions, }; string sasToken = source.GetSharedAccessSignature(policy); // Get source StorageCredentials credentials = new StorageCredentials(sasToken); copySource = new CloudBlockBlob(credentials.TransformUri(source.Uri)); } if (destinationIsSas) { if (!sourceIsSas) { // Source container must be public if source is not SAS BlobContainerPermissions containerPermissions = new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }; container.SetPermissions(containerPermissions); } // Destination SAS must have write permissions SharedAccessBlobPermissions permissions = SharedAccessBlobPermissions.Write; SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy() { SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5), SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30), Permissions = permissions, }; string sasToken = destination.GetSharedAccessSignature(policy); // Get destination StorageCredentials credentials = new StorageCredentials(sasToken); copyDestination = new CloudBlockBlob(credentials.TransformUri(destination.Uri)); } // Start copy and wait for completion string copyId = copyDestination.StartCopyFromBlob(TestHelper.Defiddler(copySource)); WaitForCopy(destination); // Check original blob references for equality Assert.AreEqual(CopyStatus.Success, destination.CopyState.Status); Assert.AreEqual(source.Uri.AbsolutePath, destination.CopyState.Source.AbsolutePath); Assert.AreEqual(data.Length, destination.CopyState.TotalBytes); Assert.AreEqual(data.Length, destination.CopyState.BytesCopied); Assert.AreEqual(copyId, destination.CopyState.CopyId); Assert.IsTrue(destination.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1))); if (!destinationIsSas) { // Abort Copy is not supported for SAS destination TestHelper.ExpectedException( () => copyDestination.AbortCopy(copyId), "Aborting a copy operation after completion should fail", HttpStatusCode.Conflict, "NoPendingCopyOperation"); } source.FetchAttributes(); Assert.IsNotNull(destination.Properties.ETag); Assert.AreNotEqual(source.Properties.ETag, destination.Properties.ETag); Assert.IsTrue(destination.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1))); string copyData = DownloadText(destination, Encoding.UTF8); Assert.AreEqual(data, copyData, "Data inside copy of blob not equal."); destination.FetchAttributes(); BlobProperties prop1 = destination.Properties; BlobProperties prop2 = source.Properties; Assert.AreEqual(prop1.CacheControl, prop2.CacheControl); Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding); Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage); Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5); Assert.AreEqual(prop1.ContentType, prop2.ContentType); Assert.AreEqual("value", destination.Metadata["Test"], false, "Copied metadata not same"); destination.Delete(); source.Delete(); } finally { container.DeleteIfExists(); } }
public async Task CloudPageBlobCopyTestAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob source = container.GetPageBlobReference("source"); string data = new string('a', 512); await UploadTextAsync(source, data, Encoding.UTF8); source.Metadata["Test"] = "value"; await source.SetMetadataAsync(); CloudPageBlob copy = container.GetPageBlobReference("copy"); string copyId = await copy.StartCopyFromBlobAsync(TestHelper.Defiddler(source)); await WaitForCopyAsync(copy); Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status); Assert.AreEqual(source.Uri.AbsolutePath, copy.CopyState.Source.AbsolutePath); Assert.AreEqual(data.Length, copy.CopyState.TotalBytes); Assert.AreEqual(data.Length, copy.CopyState.BytesCopied); Assert.AreEqual(copyId, copy.CopyState.CopyId); Assert.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1))); OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await copy.AbortCopyAsync(copyId, null, null, opContext), opContext, "Aborting a copy operation after completion should fail", HttpStatusCode.Conflict, "NoPendingCopyOperation"); await source.FetchAttributesAsync(); Assert.IsNotNull(copy.Properties.ETag); Assert.AreNotEqual(source.Properties.ETag, copy.Properties.ETag); Assert.IsTrue(copy.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1))); string copyData = await DownloadTextAsync(copy, Encoding.UTF8); Assert.AreEqual(data, copyData, "Data inside copy of blob not similar"); await copy.FetchAttributesAsync(); BlobProperties prop1 = copy.Properties; BlobProperties prop2 = source.Properties; Assert.AreEqual(prop1.CacheControl, prop2.CacheControl); Assert.AreEqual(prop1.ContentDisposition, prop2.ContentDisposition); Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding); Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage); Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5); Assert.AreEqual(prop1.ContentType, prop2.ContentType); Assert.AreEqual("value", copy.Metadata["Test"], false, "Copied metadata not same"); await copy.DeleteAsync(); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task StoreCreateSnapshot() { var random = new Random(); var data = new byte[64]; random.NextBytes(data); var relPath = Guid.NewGuid().ToString(); var contentType = Guid.NewGuid().ToString(); var p = new BlobProperties() { ContentType = Guid.NewGuid().ToString(), ContentMD5 = Guid.NewGuid().ToString(), }; var item = Substitute.For<IStorageItem>(); item.RelativePath.Returns(relPath); item.Data.Returns(data); item.ContentType.Returns(contentType); item.LoadMD5(); item.Load(); var container = Substitute.For<IContainer>(); container.Save(relPath, data, contentType); container.Exists(relPath).Returns(Task.FromResult(true)); container.Snapshot(relPath); container.Properties(relPath).Returns(Task.FromResult(p)); var w = new BlobWriter(container, true); await w.Store(new[] { item }); var x = item.Received().RelativePath; var y = item.Received().Data; var z = item.Received().ContentType; item.Received().LoadMD5(); item.Received().Load(); container.Received().Save(relPath, data, contentType); container.Received().Exists(relPath); container.Received().Snapshot(relPath); container.Received().Properties(relPath); }
/// <summary> /// Set the properties of for the blob. Using null for a property means that the original property ofthe blob /// remain unaffected, using empty string mean to "erase" the original property value /// Note that only /// <list type="number"> /// <item>CacheControl</item> /// <item>ContentEncoding</item> /// <item>ContentLanguage</item> /// <item>ContentMD5</item> /// <item>ContentType</item> /// </list> /// </summary> /// <param name="containerName"></param> /// <param name="blobName"></param> /// <param name="properties"></param> /// <returns></returns> public bool SetBlobProperties(string containerName, string blobName, BlobProperties properties) { try { CloudBlobContainer container = _blobClient.GetContainerReference(containerName); ICloudBlob blob = container.GetBlobReferenceFromServer(blobName); blob.FetchAttributes(); //update the properties with new values if exist or use the original ones. blob.Properties.CacheControl = properties.CacheControl ?? blob.Properties.CacheControl; blob.Properties.ContentEncoding= properties.ContentEncoding ?? blob.Properties.ContentEncoding; blob.Properties.ContentLanguage= properties.ContentLanguage ?? blob.Properties.ContentLanguage; blob.Properties.ContentMD5 = properties.ContentMD5 ?? blob.Properties.ContentMD5; blob.Properties.ContentType = properties.ContentType ?? blob.Properties.ContentType; blob.SetProperties(); return true; } catch (StorageException ex) { if (ex.RequestInformation.HttpStatusCode == 404) { return false; } throw; } }