/// <summary>
/// Constructs a web request to create a new block blob or page blob, or to update the content
/// of an existing block blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The properties to set for the blob.</param>
/// <param name="blobType">The type of the blob.</param>
/// <param name="pageBlobSize">For a page blob, the size of the blob. This parameter is ignored
/// for block blobs.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage Put(Uri uri, int? timeout, BlobProperties properties, BlobType blobType, long pageBlobSize, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
if (blobType == BlobType.Unspecified)
{
throw new InvalidOperationException(SR.UndefinedBlobType);
}
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, null /* builder */, content, operationContext);
if (properties.CacheControl != null)
{
request.Headers.CacheControl = CacheControlHeaderValue.Parse(properties.CacheControl);
}
if (content != null)
{
if (properties.ContentType != null)
{
content.Headers.ContentType = MediaTypeHeaderValue.Parse(properties.ContentType);
}
if (properties.ContentMD5 != null)
{
content.Headers.ContentMD5 = Convert.FromBase64String(properties.ContentMD5);
}
if (properties.ContentLanguage != null)
{
content.Headers.ContentLanguage.Add(properties.ContentLanguage);
}
if (properties.ContentEncoding != null)
{
content.Headers.ContentEncoding.Add(properties.ContentEncoding);
}
if (properties.ContentDisposition != null)
{
content.Headers.ContentDisposition = ContentDispositionHeaderValue.Parse(properties.ContentDisposition);
}
}
if (blobType == BlobType.PageBlob)
{
request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.PageBlob);
request.Headers.Add(Constants.HeaderConstants.BlobContentLengthHeader, pageBlobSize.ToString(NumberFormatInfo.InvariantInfo));
properties.Length = pageBlobSize;
}
else if (blobType == BlobType.BlockBlob)
{
request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.BlockBlob);
}
else
{
request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.AppendBlob);
}
request.ApplyAccessCondition(accessCondition);
return request;
}
/// <summary>
/// Constructs a web request to create a new block blob or page blob, or to update the content
/// of an existing block blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The properties to set for the blob.</param>
/// <param name="blobType">The type of the blob.</param>
/// <param name="leaseId">The lease ID, if the blob has an active lease.</param>
/// <param name="pageBlobSize">For a page blob, the size of the blob. This parameter is ignored
/// for block blobs.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpWebRequest Put(Uri uri, int timeout, BlobProperties properties, BlobType blobType, string leaseId, long pageBlobSize)
{
if (blobType == BlobType.Unspecified)
{
throw new InvalidOperationException(SR.UndefinedBlobType);
}
HttpWebRequest request = CreateWebRequest(uri, timeout, null);
request.Method = "PUT";
if (properties.CacheControl != null)
{
request.Headers.Add(HttpRequestHeader.CacheControl, properties.CacheControl);
}
if (properties.ContentType != null)
{
// Setting it using Headers is an exception
request.ContentType = properties.ContentType;
}
if (properties.ContentMD5 != null)
{
request.Headers.Add(HttpRequestHeader.ContentMd5, properties.ContentMD5);
}
if (properties.ContentLanguage != null)
{
request.Headers.Add(HttpRequestHeader.ContentLanguage, properties.ContentLanguage);
}
if (properties.ContentEncoding != null)
{
request.Headers.Add(HttpRequestHeader.ContentEncoding, properties.ContentEncoding);
}
if (blobType == BlobType.PageBlob)
{
request.ContentLength = 0;
request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.PageBlob);
request.Headers.Add(Constants.HeaderConstants.Size, pageBlobSize.ToString(NumberFormatInfo.InvariantInfo));
properties.Length = pageBlobSize;
}
else
{
request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.BlockBlob);
}
Request.AddLeaseId(request, leaseId);
return request;
}
/// <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
/// </summary>
/// <param name="blobName"></param>
/// <param name="properties"></param>
/// <returns></returns>
protected async Task SetBlobPropertiesAsync(string blobName, BlobProperties properties)
{
Contract.Requires <ArgumentNullException>(!string.IsNullOrWhiteSpace(blobName), "blobName cannot be null or empty");
ThrowWhenCloudBlobClientDoesNotExist();
var blob = await Container.GetBlobReferenceFromServerAsync(blobName);
await blob.FetchAttributesAsync();
// 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;
await blob.SetPropertiesAsync();
}
public static BlobProperties CollectBlobMetadata(UploadedFile file, string fileNameOnly, string userName)
{
// Create metadata to be associated with the blob
NameValueCollection metadata = new NameValueCollection();
string desc = file.FormValues["fileDescription"];
metadata["FileDescription"] = string.IsNullOrEmpty(desc) ? "{empty}" : desc;
metadata["Submitter"] = userName;
BlobProperties properties = new BlobProperties(fileNameOnly);
properties.Metadata = metadata;
//This will always be .wmv because we just encoded it
properties.ContentType = "video/x-ms-wmv";
return(properties);
}
public async Task <ITriggerData> BindAsync(object value, ValueBindingContext context)
{
ConversionResult <BlobBaseClient> conversionResult = await _converter.TryConvertAsync(value, context.CancellationToken).ConfigureAwait(false);
if (!conversionResult.Succeeded)
{
throw new InvalidOperationException("Unable to convert trigger to IStorageBlob.");
}
BlobBaseClient blobClient = conversionResult.Result;
BlobProperties blobProperties = await blobClient.FetchPropertiesOrNullIfNotExistAsync(cancellationToken : context.CancellationToken).ConfigureAwait(false);
IReadOnlyDictionary <string, object> bindingData = CreateBindingData(blobClient, blobProperties);
return(new TriggerData(bindingData));
}
public static bool PutPropertiesValidator(BlobProperties properties)
{
if (properties.BlobType == BlobType.Unspecified)
{
return(false);
}
if ((properties.BlobType == BlobType.PageBlob) &&
(properties.Length % 512 != 0) &&
(properties.Length > 0))
{
return(false);
}
return(true);
}
public void SaveImage(string id, string contentType, byte[] data)
{
BlobProperties properties = new BlobProperties(string.Format(CultureInfo.InvariantCulture, "image_{0}", id));
NameValueCollection metadata = new NameValueCollection();
metadata["Id"] = id;
metadata["Filename"] = "userimage";
metadata["ImageName"] = "userimage";
metadata["Description"] = "userimage";
metadata["Tags"] = "userimage";
properties.Metadata = metadata;
properties.ContentType = contentType;
BlobContents imageBlob = new BlobContents(data);
container.CreateBlob(properties, imageBlob, true);
}
public void SetUp()
{
_calculationResultsRepository = Substitute.For <ICalculationResultsRepository>();
_blobClient = Substitute.For <IBlobClient>();
_csvUtils = Substitute.For <ICsvUtils>();
_transformation = Substitute.For <IProviderResultsToCsvRowsTransformation>();
_cloudBlob = Substitute.For <ICloudBlob>();
_fileSystemAccess = Substitute.For <IFileSystemAccess>();
_fileSystemCacheSettings = Substitute.For <IFileSystemCacheSettings>();
_jobManagement = Substitute.For <IJobManagement>();
_calcsApiClient = Substitute.For <ICalculationsApiClient>();
_specsApiClient = Substitute.For <ISpecificationsApiClient>();
_service = new ProviderResultsCsvGeneratorService(Substitute.For <ILogger>(),
_blobClient,
_calcsApiClient,
_specsApiClient,
_calculationResultsRepository,
new ResiliencePolicies
{
BlobClient = Policy.NoOpAsync(),
CalculationsApiClient = Policy.NoOpAsync(),
SpecificationsApiClient = Policy.NoOpAsync(),
ResultsRepository = Policy.NoOpAsync()
},
_csvUtils,
_transformation,
_fileSystemAccess,
_fileSystemCacheSettings,
_jobManagement);
_message = new Message();
_rootPath = NewRandomString();
_fileSystemCacheSettings.Path
.Returns(_rootPath);
_fileSystemAccess
.Append(Arg.Any <string>(), Arg.Any <Stream>())
.Returns(Task.CompletedTask);
_blobProperties = new BlobProperties();
_cloudBlob
.Properties
.Returns(_blobProperties);
}
public async Task IncludesEtagInConditions()
{
MemoryStream stream = new MemoryStream();
MockDataSource dataSource = new MockDataSource(100);
Mock <BlobBaseClient> blockClient = new Mock <BlobBaseClient>(MockBehavior.Strict, new Uri("http://mock"), new BlobClientOptions());
blockClient.SetupGet(c => c.ClientDiagnostics).CallBase();
BlobProperties properties = new BlobProperties()
{
ContentLength = 100,
ETag = s_etag
};
SetupDownload(blockClient, dataSource);
PartitionedDownloader downloader = new PartitionedDownloader(
blockClient.Object,
new StorageTransferOptions()
{
MaximumTransferLength = 10,
InitialTransferLength = 10
});
Response result = await InvokeDownloadToAsync(downloader, stream);
Assert.AreEqual(dataSource.Requests.Count, 10);
AssertContent(100, stream);
Assert.NotNull(result);
bool first = true;
foreach ((HttpRange Range, BlobRequestConditions Conditions)request in dataSource.Requests)
{
Assert.AreEqual(s_conditions.LeaseId, request.Conditions.LeaseId);
Assert.AreEqual(s_conditions.IfModifiedSince, request.Conditions.IfModifiedSince);
Assert.AreEqual(s_conditions.IfUnmodifiedSince, request.Conditions.IfUnmodifiedSince);
Assert.AreEqual(s_conditions.IfNoneMatch, request.Conditions.IfNoneMatch);
if (first)
{
first = false;
}
else
{
Assert.AreEqual(s_etag, request.Conditions.IfMatch);
}
}
}
public async Task InitializeAsync(WebJobsTestEnvironment testEnvironment)
{
RandomNameResolver nameResolver = new RandomNameResolver();
CacheMock = CreateMockFunctionDataCache();
CacheMock
.Setup(c => c.IsEnabled)
.Returns(true);
IFunctionDataCache cache = CacheMock.Object;
Host = new HostBuilder()
.ConfigureDefaultTestHost <CacheableBlobsEndToEndTests>(b =>
{
b.AddAzureStorageBlobs().AddAzureStorageQueues();
b.AddAzureStorageCoreServices();
})
.ConfigureServices(services =>
{
services.AddSingleton <INameResolver>(nameResolver)
.AddSingleton(cache);
})
.Build();
JobHost = Host.GetJobHost();
BlobServiceClient = new BlobServiceClient(testEnvironment.PrimaryStorageAccountConnectionString);
BlobContainer = BlobServiceClient.GetBlobContainerClient(nameResolver.ResolveInString(ContainerName));
Assert.False(await BlobContainer.ExistsAsync());
await BlobContainer.CreateAsync();
OutputBlobContainer = BlobServiceClient.GetBlobContainerClient(nameResolver.ResolveInString(OutputContainerName));
await Host.StartAsync();
// Upload some test blobs
BlockBlobClient blob = BlobContainer.GetBlockBlobClient(InputBlobName);
await blob.UploadTextAsync(TestData);
// Get information about the uploaded blob
BlobProperties blobProperties = await blob.GetPropertiesAsync();
string blobId = blob.Uri.ToString();
string blobVersion = blobProperties.ETag.ToString();
_expectedBlobCacheKey = new FunctionDataCacheKey(blobId, blobVersion);
}
private void ListBlobsStr(string containerName, string blobPrefix, string delimiter, int maxResults, ref string marker, IList <string> tn, string basePath)
{
IList <object> blobList = new List <object>(ListBlobs(containerName, blobPrefix, delimiter, maxResults, ref marker));
foreach (object o in blobList)
{
if (o is BlobProperties)
{
BlobProperties bp = (BlobProperties)o;
string[] structureArr = bp.Name.Split(char.Parse(delimiter));
if (structureArr != null && structureArr.Length > 0)
{
if (tn != null)
{
tn.Add(basePath + delimiter + (structureArr[structureArr.Length - 1]));
}
}
}
else if (o is string)
{
string bPrefix = (string)o;
string[] structureArr = bPrefix.Split(char.Parse(delimiter));
if (structureArr != null && structureArr.Length > 0)
{
string node = string.Empty;
string t1 = null;
if (structureArr.Length > 1)
{
node = structureArr[structureArr.Length - 2];
t1 = node;
}
else
{
node = structureArr[0];
t1 = node;
}
ListBlobsStr(containerName, bPrefix, delimiter, maxResults, ref marker, tn, t1);
}
}
}
}
public static HttpWebRequest PutBlobRequest(BlobContext context, string containerName, string blobName,
BlobProperties properties, BlobType blobType, byte[] content, long pageBlobSize, AccessCondition accessCondition)
{
bool valid = BlobTests.ContainerNameValidator(containerName) &&
BlobTests.BlobNameValidator(blobName) &&
BlobTests.PutPropertiesValidator(properties) &&
BlobTestUtils.ContentValidator(content);
bool fatal = !BlobTests.PutPropertiesValidator(properties);
Uri uri = BlobTests.ConstructPutUri(context.Address, containerName, blobName);
HttpWebRequest request = null;
OperationContext opContext = new OperationContext();
try
{
request = BlobHttpWebRequestFactory.Put(uri, context.Timeout, properties, blobType, pageBlobSize, accessCondition, opContext);
if (fatal)
{
Assert.Fail();
}
}
catch (InvalidOperationException)
{
if (valid)
{
Assert.Fail();
}
}
if (valid)
{
Assert.IsNotNull(request);
Assert.IsNotNull(request.Method);
Assert.AreEqual("PUT", request.Method);
BlobTestUtils.VersionHeader(request, false);
BlobTestUtils.ContentTypeHeader(request, null);
BlobTestUtils.ContentDispositionHeader(request, properties.ContentDisposition);
BlobTestUtils.ContentEncodingHeader(request, properties.ContentEncoding);
BlobTestUtils.ContentLanguageHeader(request, null);
BlobTestUtils.ContentMd5Header(request, null);
BlobTestUtils.CacheControlHeader(request, null);
BlobTestUtils.BlobTypeHeader(request, properties.BlobType);
BlobTestUtils.BlobSizeHeader(request, (properties.BlobType == BlobType.PageBlob) ? properties.Length : (long?)null);
}
return(request);
}
private BlobInfo ConvertBlobToBlobInfo(BlobClient blob, BlobProperties props)
{
var absoluteUrl = blob.Uri;
var relativeUrl = UrlHelperExtensions.Combine(GetContainerNameFromUrl(blob.Uri.ToString()), EscapeUri(blob.Name));
var fileName = Path.GetFileName(Uri.UnescapeDataString(blob.Name));
var contentType = MimeTypeResolver.ResolveContentType(fileName);
return(new BlobInfo
{
Url = absoluteUrl.ToString(),
Name = fileName,
ContentType = contentType,
Size = props.ContentLength,
ModifiedDate = props.LastModified.DateTime,
RelativeUrl = relativeUrl
});
}
// *********************************************************
// Create a new Blob in a Specific Blob Container
// *********************************************************
public void CreateBlob(string ContainerName, string FileName,
string BlobEndPoint, string Account, string SharedKey)
{
StorageAccountInfo AccountInfo =
new StorageAccountInfo(new Uri(BlobEndPoint), null, Account, SharedKey);
var blobStore = BlobStorage.Create(AccountInfo);
var container = blobStore.GetBlobContainer(ContainerName);
BlobProperties props = new BlobProperties(System.IO.Path.GetFileName(FileName));
BlobContents blobContents =
new BlobContents(new System.IO.FileStream(FileName, FileMode.Open));
container.CreateBlob(props, blobContents, true);
}
public async Task BlobProtocolPutGetBlockListCloudOwnerSync()
{
string blockId1 = Convert.ToBase64String(new byte[] { 99, 100, 101 });
string blockId2 = Convert.ToBase64String(new byte[] { 102, 103, 104 });
// use a unique name since temp blocks from previous runs can exist
string blobName = "blob2" + DateTime.UtcNow.Ticks;
BlobProperties blobProperties = new BlobProperties();
List <PutBlockListItem> blocks = new List <PutBlockListItem>();
PutBlockListItem block1 = new PutBlockListItem(blockId1, BlockSearchMode.Uncommitted);
blocks.Add(block1);
PutBlockListItem block2 = new PutBlockListItem(blockId2, BlockSearchMode.Uncommitted);
blocks.Add(block2);
try
{
await cloudOwnerSync.PutBlockScenarioTest(cloudSetup.ContainerName, blobName, blockId1, cloudSetup.LeaseId, cloudSetup.Content, null);
await cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.All, cloudSetup.LeaseId, null, blockId1);
await cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.Uncommitted, cloudSetup.LeaseId, null, blockId1);
await cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.Committed, cloudSetup.LeaseId, null);
await cloudOwnerSync.PutBlockScenarioTest(cloudSetup.ContainerName, blobName, blockId2, cloudSetup.LeaseId, cloudSetup.Content, null);
await cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.All, cloudSetup.LeaseId, null, blockId1, blockId2);
await cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.Uncommitted, cloudSetup.LeaseId, null, blockId1, blockId2);
await cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.Committed, cloudSetup.LeaseId, null);
await cloudOwnerSync.PutBlockListScenarioTest(cloudSetup.ContainerName, blobName, blocks, blobProperties, cloudSetup.LeaseId, null);
await cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.All, cloudSetup.LeaseId, null, blockId1, blockId2);
await cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.Uncommitted, cloudSetup.LeaseId, null);
await cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.Committed, cloudSetup.LeaseId, null, blockId1, blockId2);
}
finally
{
await cloudOwnerSync.DeleteBlob(cloudSetup.ContainerName, blobName);
}
}
// Called by AzureBlobSyncProvider.InsertItem.
internal SyncedBlobAttributes InsertFile(FileData fileData, string relativePath, Stream dataStream)
{
if (fileData.Name.Length > MaxFileNameLength)
{
throw new ApplicationException("Name Too Long");
}
string path = fileData.RelativePath.ToLower();
path = path.Replace(@"\", "/");
CloudBlob blob = Container.GetBlobReference(path);
BlobProperties blobProperties = blob.Properties;
DateTime uninitTime = blobProperties.LastModifiedUtc;
SetupMetadata(blob.Metadata, fileData, relativePath);
blobProperties.ContentType = LookupMimeType(Path.GetExtension(fileData.Name));
if (fileData.IsDirectory)
{
// Directories have no stream
dataStream = new MemoryStream();
}
// Specify an optimistic concurrency check to prevent races with other endpoints syncing at the same time.
BlobRequestOptions opts = new BlobRequestOptions();
opts.AccessCondition = AccessCondition.IfNotModifiedSince(uninitTime);
try
{
blob.UploadFromStream(dataStream, opts);
}
catch (StorageException e)
{
if (e.ErrorCode == StorageErrorCode.BlobAlreadyExists || e.ErrorCode == StorageErrorCode.ConditionFailed)
{
throw new ApplicationException("Concurrency Violation", e);
}
throw;
}
blobProperties = blob.Properties;
SyncedBlobAttributes attributes = new SyncedBlobAttributes(blob.Uri.ToString(), blobProperties.LastModifiedUtc);
return(attributes);
}
static async Task SetMetadataAsync()
{
string p_key = "ApplicationType";
string p_Value = "IDM";
BlobContainerClient containerClient = client.GetBlobContainerClient(containerName);
BlobClient blob = containerClient.GetBlobClient(filename);
BlobProperties props = blob.GetProperties();
props.Metadata.Add(p_key, p_Value);
IDictionary <string, string> dictObj = new Dictionary <string, string>();
dictObj.Add(p_key, p_Value);
await blob.SetMetadataAsync(dictObj);
Console.WriteLine("\nMetadata set");
}
public static bool PutBlob(WindowsAzureStorageHelper storageHelper, string containerName, string blobName, string fileName, byte[] fileContents, bool overwrite, NameValueCollection metadata)
{
BlobProperties blobProperties = new BlobProperties(blobName);
blobProperties.ContentType = WindowsAzureStorageHelper.GetContentTypeFromExtension(Path.GetExtension(fileName));
blobProperties.Metadata = metadata;
BlobContents blobContents = null;
bool ret = false;
blobContents = new BlobContents(fileContents);
ret = storageHelper.CreateBlob(containerName, blobProperties, blobContents, overwrite);
return(ret);
}
internal bool UploadStream(string blobName, Stream output, bool overwrite)
{
BlobContainer container = GetContainer();
try
{
output.Position = 0; //Rewind to start
Log.Write(EventKind.Information, "Uploading contents of blob {0}", ContainerUrl + _PathSeparator + blobName);
BlobProperties properties = new BlobProperties(blobName);
return(container.CreateBlob(properties, new BlobContents(output), overwrite));
}
catch (StorageException se)
{
Log.Write(EventKind.Error, "Error uploading blob {0}: {1}", ContainerUrl + _PathSeparator + blobName, se.Message);
throw;
}
}
public async Task HandleAsync_ShouldReturnFalseAndLogEvents_WhenPublishingThrows()
{
// Arrange
var blobUri = new Uri(_expectedInboxUrl);
JObject operationContext = JObject.Parse("{\"something\": \"something value\"}");
var topicEndpointUri = new Uri("https://www.topichost.com");
var testEvent = new EventGridEvent
{
EventTime = DateTime.UtcNow,
EventType = CustomEventTypes.RequestBlobCopy,
DataVersion = "1.0",
Data = JsonConvert.SerializeObject(new RequestBlobCopyDTO {
SourceUri = blobUri, DestinationUri = blobUri, OperationContext = JObject.FromObject(operationContext)
})
};
var blobBaseClient = new BlobBaseClient(blobUri);
var blobProperties = new BlobProperties();
// Arrange Mocks
Mock.Get(_settingsProvider)
.Setup(x => x.GetAppSettingsValue(Publishing.TopicOutboundEndpointSettingName))
.Returns(topicEndpointUri.ToString());
Mock.Get(_storageService)
.Setup(x => x.GetBlobMetadataAsync(blobUri, It.IsAny <StorageClientProviderContext>()))
.ReturnsAsync(new JObject());
Mock.Get(_eventGridPublisher)
.Setup(x => x.PublishEventToTopic(It.IsAny <EventGridEvent>()))
.ThrowsAsync(new InvalidOperationException());
// Act
var handleAsyncResult = await _handler.HandleAsync(testEvent).ConfigureAwait(true);
// Assert
handleAsyncResult.ShouldBe(false);
Mock.Get(_logger).Verify(x =>
x.LogExceptionObject(LogEventIds.FailedCriticallyToPublishEvent,
It.IsAny <Exception>(), It.IsAny <object>()),
Times.AtLeastOnce,
"An exception should be logged when the publishing fails");
Mock.Get(_logger).Verify(x =>
x.LogEventObject(LogEventIds.FailedToAcknowledge,
It.IsAny <object>()),
Times.Once,
"An exception should be logged when the acknowledgement fails");
}
public static HttpWebRequest PutBlobRequest(BlobContext context, string containerName, string blobName,
BlobProperties properties, BlobType blobType, byte[] content, long pageBlobSize, AccessCondition accessCondition)
{
bool valid = BlobTests.ContainerNameValidator(containerName) &&
BlobTests.BlobNameValidator(blobName) &&
BlobTests.PutPropertiesValidator(properties) &&
BlobTestUtils.ContentValidator(content);
bool fatal = !BlobTests.PutPropertiesValidator(properties);
Uri uri = BlobTests.ConstructPutUri(context.Address, containerName, blobName);
HttpWebRequest request = null;
OperationContext opContext = new OperationContext();
try
{
request = BlobHttpWebRequestFactory.Put(uri, context.Timeout, properties, blobType, pageBlobSize, accessCondition, opContext);
if (fatal)
{
Assert.Fail();
}
}
catch (InvalidOperationException)
{
if (valid)
{
Assert.Fail();
}
}
if (valid)
{
Assert.IsNotNull(request);
Assert.IsNotNull(request.Method);
Assert.AreEqual("PUT", request.Method);
BlobTestUtils.VersionHeader(request, false);
BlobTestUtils.ContentTypeHeader(request, null);
BlobTestUtils.ContentDispositionHeader(request, properties.ContentDisposition);
BlobTestUtils.ContentEncodingHeader(request, properties.ContentEncoding);
BlobTestUtils.ContentLanguageHeader(request, null);
BlobTestUtils.ContentMd5Header(request, null);
BlobTestUtils.CacheControlHeader(request, null);
BlobTestUtils.BlobTypeHeader(request, properties.BlobType);
BlobTestUtils.BlobSizeHeader(request, (properties.BlobType == BlobType.PageBlob) ? properties.Length : (long?)null);
}
return request;
}
/// <inheritdoc />
public async Task <bool> WritePolicyAsync(string filepath, Stream fileStream)
{
try
{
BlobClient blockBlob = CreateBlobClient(filepath);
await blockBlob.UploadAsync(fileStream, true);
BlobProperties properties = await blockBlob.GetPropertiesAsync();
return(properties.ContentLength > 0);
}
catch (Exception ex)
{
_logger.LogError($"Failed to save policy file {filepath}. " + ex);
throw;
}
}
public async Task <IDictionary <string, string> > GetBlobMetadataAsync(string blobUrl)
{
var blobUriBuilder = new BlobUriBuilder(
new Uri(blobUrl));
var blobContainerClient = _blobServiceClient
.GetBlobContainerClient(blobUriBuilder.BlobContainerName);
var blobClient = blobContainerClient.GetBlobClient(blobUriBuilder.BlobName);
BlobDownloadInfo blobDownloadInfo = await blobClient.DownloadAsync();
BlobProperties blobProperties = await blobClient
.GetPropertiesAsync()
.ConfigureAwait(false);
return(blobProperties.Metadata);
}
private static async Task SetBlobPropertiesAsync(string blobName)
{
var blobClient = new BlobClient(_connectionString, _blobContainerName, blobName);
BlobProperties blobProperties = await blobClient.GetPropertiesAsync();
var blobHttpHeaders = new BlobHttpHeaders
{
ContentLanguage = "en-us",
CacheControl = blobProperties.CacheControl,
ContentDisposition = blobProperties.ContentDisposition,
ContentEncoding = blobProperties.ContentEncoding,
ContentHash = blobProperties.ContentHash
};
await blobClient.SetHttpHeadersAsync(blobHttpHeaders);
}
private PutObjectRequest CreateUpload(string containerName, string blobName, Stream source,
BlobProperties properties, bool closeStream)
{
var putRequest = new PutObjectRequest()
{
BucketName = _bucket,
Key = GenerateKeyName(containerName, blobName),
InputStream = source,
ContentType = properties?.ContentType,
CannedACL = GetCannedACL(properties),
AutoCloseStream = closeStream,
ServerSideEncryptionMethod = _serverSideEncryptionMethod
};
putRequest.Headers.ContentDisposition = properties?.ContentDisposition;
putRequest.Metadata.AddMetadata(properties?.Metadata);
return(putRequest);
}
public async Task Ctor_AzureSasCredential()
{
// Arrange
await using DisposingContainer test = await GetTestContainerAsync();
string sas = GetContainerSas(test.Container.Name, BlobContainerSasPermissions.All).ToString();
var client = test.Container.GetBlobClient(GetNewBlobName());
await client.UploadAsync(new MemoryStream());
Uri blobUri = client.Uri;
// Act
var sasClient = InstrumentClient(new BlobClient(blobUri, new AzureSasCredential(sas), GetOptions()));
BlobProperties blobProperties = await sasClient.GetPropertiesAsync();
// Assert
Assert.IsNotNull(blobProperties);
}
/// <summary>
/// Constructs a web request to create or update a blob by committing a block list.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The properties to set for the blob.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request for performing the operation.</returns>
public static HttpRequestMessage PutBlockList(Uri uri, int?timeout, BlobProperties properties, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "blocklist");
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext);
request.AddOptionalHeader(Constants.HeaderConstants.CacheControlHeader, properties.CacheControl);
request.AddOptionalHeader(Constants.HeaderConstants.ContentTypeHeader, properties.ContentType);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentMD5Header, properties.ContentMD5);
request.AddOptionalHeader(Constants.HeaderConstants.ContentLanguageHeader, properties.ContentLanguage);
request.AddOptionalHeader(Constants.HeaderConstants.ContentEncodingHeader, properties.ContentEncoding);
request.ApplyAccessCondition(accessCondition);
return(request);
}
public static Blob ToBlob(string containerName, string path, BlobProperties properties)
{
string GetFullName(string name) => containerName == null
? name
: StoragePath.Combine(containerName, name);
var blob = new Blob(GetFullName(path), BlobItemKind.File);
blob.MD5 = properties.ContentHash.ToHexString();
blob.Size = properties.ContentLength;
blob.LastModificationTime = properties.LastModified;
AddProperties(blob, properties);
blob.Metadata.MergeRange(properties.Metadata);
return(blob);
}
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);
}
private static async Task CopyBlob()
{
blobClient = containerClient.GetBlobClient(fileName);
if (await blobClient.ExistsAsync())
{
BlobLeaseClient leaseClient = blobClient.GetBlobLeaseClient();
// Specifying -1 for the lease interval creates an infinite lease.
await leaseClient.AcquireAsync(TimeSpan.FromSeconds(-1));
// Get the source blob's properties and display the lease state.
BlobProperties sourceProperties = await blobClient.GetPropertiesAsync();
Console.WriteLine($"Lease state: {sourceProperties.LeaseState}");
// Get a BlobClient representing the destination blob with a unique name.
BlobClient destBlob = containerClient.GetBlobClient(Guid.NewGuid() + "-" + blobClient.Name);
// Start the copy operation.
await destBlob.StartCopyFromUriAsync(blobClient.Uri);
// Get the destination blob's properties and display the copy status.
BlobProperties destProperties = await destBlob.GetPropertiesAsync();
Console.WriteLine($"Copy status: {destProperties.CopyStatus}");
Console.WriteLine($"Copy progress: {destProperties.CopyProgress}");
Console.WriteLine($"Completion time: {destProperties.CopyCompletedOn}");
Console.WriteLine($"Total bytes: {destProperties.ContentLength}");
// Update the source blob's properties.
sourceProperties = await blobClient.GetPropertiesAsync();
if (sourceProperties.LeaseState == LeaseState.Leased)
{
// Break the lease on the source blob.
await leaseClient.BreakAsync();
// Update the source blob's properties to check the lease state.
sourceProperties = await blobClient.GetPropertiesAsync();
Console.WriteLine($"Lease state: {sourceProperties.LeaseState}");
}
}
}
/// <summary>
/// Gets the blob's properties from the response.
/// </summary>
/// <param name="response">The web response.</param>
/// <returns>The blob's properties.</returns>
public static BlobProperties GetProperties(HttpWebResponse response)
{
BlobProperties properties = new BlobProperties();
properties.LastModified = response.LastModified.ToUniversalTime();
properties.ContentEncoding = response.Headers[HttpResponseHeader.ContentEncoding];
properties.ContentLanguage = response.Headers[HttpResponseHeader.ContentLanguage];
properties.ContentMD5 = response.Headers[HttpResponseHeader.ContentMd5];
properties.ContentType = response.Headers[HttpResponseHeader.ContentType];
properties.CacheControl = response.Headers[HttpResponseHeader.CacheControl];
properties.ETag = HttpResponseParsers.GetETag(response);
string blobType = response.Headers[Constants.HeaderConstants.BlobType];
// Get blob type
if (!string.IsNullOrEmpty(blobType))
{
properties.BlobType = (BlobType)Enum.Parse(typeof(BlobType), blobType, true);
}
// Get lease properties
properties.LeaseStatus = GetLeaseStatus(response);
properties.LeaseState = GetLeaseState(response);
properties.LeaseDuration = GetLeaseDuration(response);
// Get the content length. Prioritize range and x-ms over content length for the special cases.
string rangeHeader = response.Headers[HttpResponseHeader.ContentRange];
string contentLengthHeader = response.Headers[Constants.HeaderConstants.ContentLengthHeader];
if (!string.IsNullOrEmpty(rangeHeader))
{
properties.Length = long.Parse(rangeHeader.Split('/')[1]);
}
else if (!string.IsNullOrEmpty(contentLengthHeader))
{
properties.Length = long.Parse(contentLengthHeader);
}
else
{
properties.Length = response.ContentLength;
}
return(properties);
}
/// <summary>
/// Constructs a web request to create or update a blob by committing a block list.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The properties to set for the blob.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param>
/// <returns>A web request for performing the operation.</returns>
public static HttpWebRequest PutBlockList(Uri uri, int?timeout, BlobProperties properties, AccessCondition accessCondition, OperationContext operationContext)
{
CommonUtility.AssertNotNull("properties", properties);
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "blocklist");
HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, operationContext);
request.AddOptionalHeader(Constants.HeaderConstants.CacheControlHeader, properties.CacheControl);
request.AddOptionalHeader(Constants.HeaderConstants.ContentTypeHeader, properties.ContentType);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentMD5Header, properties.ContentMD5);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentLanguageHeader, properties.ContentLanguage);
request.AddOptionalHeader(Constants.HeaderConstants.ContentEncodingHeader, properties.ContentEncoding);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Gets the blob's properties from the response.
/// </summary>
/// <param name="response">The web response.</param>
/// <returns>The blob's properties.</returns>
public static BlobProperties GetProperties(HttpWebResponse response)
{
BlobProperties properties = new BlobProperties();
properties.LastModified = response.LastModified.ToUniversalTime();
properties.ContentEncoding = response.Headers[HttpResponseHeader.ContentEncoding];
properties.ContentLanguage = response.Headers[HttpResponseHeader.ContentLanguage];
properties.ContentMD5 = response.Headers[HttpResponseHeader.ContentMd5];
properties.ContentType = response.Headers[HttpResponseHeader.ContentType];
properties.CacheControl = response.Headers[HttpResponseHeader.CacheControl];
properties.ETag = HttpResponseParsers.GetETag(response);
string blobType = response.Headers[Constants.HeaderConstants.BlobType];
// Get blob type
if (!string.IsNullOrEmpty(blobType))
{
properties.BlobType = (BlobType)Enum.Parse(typeof(BlobType), blobType, true);
}
// Get lease properties
properties.LeaseStatus = GetLeaseStatus(response);
properties.LeaseState = GetLeaseState(response);
properties.LeaseDuration = GetLeaseDuration(response);
// Get the content length. Prioritize range and x-ms over content length for the special cases.
string rangeHeader = response.Headers[HttpResponseHeader.ContentRange];
string contentLengthHeader = response.Headers[Constants.HeaderConstants.ContentLengthHeader];
if (!string.IsNullOrEmpty(rangeHeader))
{
properties.Length = long.Parse(rangeHeader.Split('/')[1]);
}
else if (!string.IsNullOrEmpty(contentLengthHeader))
{
properties.Length = long.Parse(contentLengthHeader);
}
else
{
properties.Length = response.ContentLength;
}
return properties;
}
public static async Task <bool> IsFileIdenticalToBlobAsync(this BlobClient client, string file)
{
BlobProperties properties = await client.GetPropertiesAsync();
if (properties.ContentHash != null)
{
var localMD5 = CalculateMD5(file);
var blobMD5 = Convert.ToBase64String(properties.ContentHash);
return(blobMD5.Equals(localMD5, StringComparison.OrdinalIgnoreCase));
}
int bytesPerMegabyte = 1 * 1024 * 1024;
using Stream localFileStream = File.OpenRead(file);
byte[] localBuffer = new byte[bytesPerMegabyte];
byte[] remoteBuffer = new byte[bytesPerMegabyte];
int localBytesRead = 0;
do
{
long start = localFileStream.Position;
localBytesRead = await localFileStream.ReadAsync(localBuffer, 0, bytesPerMegabyte);
var range = new HttpRange(start, localBytesRead);
BlobDownloadInfo download = await client.DownloadAsync(range).ConfigureAwait(false);
if (download.ContentLength != localBytesRead)
{
return(false);
}
using (var stream = new MemoryStream(remoteBuffer, true))
{
await download.Content.CopyToAsync(stream).ConfigureAwait(false);
}
if (!remoteBuffer.SequenceEqual(localBuffer))
{
return(false);
}
}while (localBytesRead > 0);
return(true);
}
public async void Test_Blob_ContentDisposition_Updated_Async()
{
var container = GetRandomContainerName();
var blobName = GenerateRandomName();
var filename = "testname.jpg";
var contentType = "image/jpg";
var newContentType = "image/png";
var data = GenerateRandomBlobStream();
await CreateNewObjectAsync(container, blobName, data, false, contentType);
var newProps = new BlobProperties
{
ContentType = newContentType,
Security = BlobSecurity.Public,
}.WithContentDispositionFilename(filename);
await _provider.UpdateBlobPropertiesAsync(container, blobName, newProps);
var meta = await _client.GetObjectMetadataAsync(Bucket, container + "/" + blobName);
Assert.Equal(newProps.ContentDisposition, meta.Headers.ContentDisposition);
}
public void GetBlobScenarioTest(string containerName, string blobName, BlobProperties properties, string leaseId,
byte[] content, HttpStatusCode? expectedError)
{
HttpWebRequest request = BlobTests.GetBlobRequest(BlobContext, containerName, blobName, AccessCondition.GenerateLeaseCondition(leaseId));
Assert.IsTrue(request != null, "Failed to create HttpWebRequest");
if (BlobContext.Credentials != null)
{
BlobTests.SignRequest(request, BlobContext);
}
HttpWebResponse response = BlobTestUtils.GetResponse(request, BlobContext);
try
{
BlobTests.GetBlobResponse(response, BlobContext, properties, content, expectedError);
}
finally
{
response.Close();
}
}
/// <summary>
/// Constructs a web request to set system properties for a blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The blob's properties.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpWebRequest SetProperties(Uri uri, int? timeout, BlobProperties properties, AccessCondition accessCondition, OperationContext operationContext)
{
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "properties");
HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, operationContext);
request.ContentLength = 0;
request.AddOptionalHeader(Constants.HeaderConstants.CacheControlHeader, properties.CacheControl);
request.AddOptionalHeader(Constants.HeaderConstants.ContentEncodingHeader, properties.ContentEncoding);
request.AddOptionalHeader(Constants.HeaderConstants.ContentLanguageHeader, properties.ContentLanguage);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentMD5Header, properties.ContentMD5);
request.AddOptionalHeader(Constants.HeaderConstants.ContentTypeHeader, properties.ContentType);
request.ApplyAccessCondition(accessCondition);
return request;
}
/// <summary>
/// Constructs a web request to create or update a blob by committing a block list.
/// </summary>
/// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
/// <param name="timeout">An integer specifying the server timeout interval.</param>
/// <param name="properties">A <see cref="BlobProperties"/> object specifying the properties to set for the blob.</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
/// <param name="useVersionHeader">A boolean value indicating whether to set the <i>x-ms-version</i> HTTP header.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
/// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
public static HttpWebRequest PutBlockList(Uri uri, int? timeout, BlobProperties properties, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
{
CommonUtility.AssertNotNull("properties", properties);
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "blocklist");
HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext);
if (properties != null)
{
request.AddOptionalHeader(Constants.HeaderConstants.BlobCacheControlHeader, properties.CacheControl);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentTypeHeader, properties.ContentType);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentMD5Header, properties.ContentMD5);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentLanguageHeader, properties.ContentLanguage);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentEncodingHeader, properties.ContentEncoding);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentDispositionRequestHeader, properties.ContentDisposition);
}
request.ApplyAccessCondition(accessCondition);
return request;
}
/// <summary>
/// Constructs a web request to create or update a blob by committing a block list.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The properties to set for the blob.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request for performing the operation.</returns>
public static HttpRequestMessage PutBlockList(Uri uri, int? timeout, BlobProperties properties, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "blocklist");
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext);
request.AddOptionalHeader(Constants.HeaderConstants.CacheControlHeader, properties.CacheControl);
request.AddOptionalHeader(Constants.HeaderConstants.ContentTypeHeader, properties.ContentType);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentMD5Header, properties.ContentMD5);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentLanguageHeader, properties.ContentLanguage);
request.AddOptionalHeader(Constants.HeaderConstants.ContentEncodingHeader, properties.ContentEncoding);
request.ApplyAccessCondition(accessCondition);
return request;
}
/// <summary>
/// Constructs a web request to create or update a blob by committing a block list.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The properties to set for the blob.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request for performing the operation.</returns>
public static StorageRequestMessage PutBlockList(Uri uri, int? timeout, BlobProperties properties, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials)
{
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "blocklist");
StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials);
if (properties != null)
{
request.AddOptionalHeader(Constants.HeaderConstants.BlobCacheControlHeader, properties.CacheControl);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentTypeHeader, properties.ContentType);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentMD5Header, properties.ContentMD5);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentLanguageHeader, properties.ContentLanguage);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentEncodingHeader, properties.ContentEncoding);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentDispositionRequestHeader, properties.ContentDisposition);
}
request.ApplyAccessCondition(accessCondition);
return request;
}
private PutObjectRequest CreateUpload(string containerName, string blobName, Stream source, BlobProperties properties, bool closeStream)
{
var putRequest = new PutObjectRequest()
{
BucketName = _bucket,
Key = GenerateKeyName(containerName, blobName),
InputStream = source,
ContentType = properties?.ContentType,
CannedACL = GetCannedACL(properties),
AutoCloseStream = closeStream,
};
putRequest.Headers.ContentDisposition = properties?.ContentDisposition;
putRequest.Metadata.AddMetadata(properties?.Metadata);
return putRequest;
}
public void PutBlobScenarioTest(string containerName, string blobName, BlobProperties properties, BlobType blobType, byte[] content, HttpStatusCode? expectedError)
{
HttpWebRequest request = BlobTests.PutBlobRequest(BlobContext, containerName, blobName, properties, blobType, content, content.Length, null);
Assert.IsTrue(request != null, "Failed to create HttpWebRequest");
request.ContentLength = content.Length;
if (BlobContext.Credentials != null)
{
BlobTests.SignRequest(request, BlobContext);
}
BlobTestUtils.SetRequest(request, BlobContext, content);
HttpWebResponse response = BlobTestUtils.GetResponse(request, BlobContext);
try
{
BlobTests.PutBlobResponse(response, BlobContext, expectedError);
}
finally
{
response.Close();
}
}
public void BlobProtocolPutPageBlobCloudAnonAsync()
{
BlobProperties properties = new BlobProperties() { BlobType = BlobType.PageBlob };
cloudAnonAsync.PutBlobScenarioTest(cloudSetup.ContainerName, Guid.NewGuid().ToString(),
properties, BlobType.PageBlob, new byte[0], HttpStatusCode.NotFound);
}
public void BlobProtocolPutBlockBlobCloudAnonAsync()
{
byte[] content = new byte[6000];
random.NextBytes(content);
BlobProperties properties = new BlobProperties() { BlobType = BlobType.BlockBlob };
cloudAnonAsync.PutBlobScenarioTest(cloudSetup.ContainerName, Guid.NewGuid().ToString(),
properties, BlobType.BlockBlob, content, HttpStatusCode.NotFound);
}
//******************************
//* *
//* BlobViewProperties_Click *
//* *
//******************************
// Display blob properties for selected blob.
private void BlobViewProperties_Click(object sender, RoutedEventArgs e)
{
// Validate a single blob has been selected.
if (ContainerListView.SelectedItems.Count != 1)
{
MessageBox.Show("In order to view or modify a blob's properties, please select one blob then click the View toolbar button", "Single Selection Requireed");
return;
}
String blobName = (ContainerListView.SelectedItems[0] as BlobItem).Name;
BlobProperties dlg = new BlobProperties();
CloudBlobContainer container = blobClient.GetContainerReference(SelectedBlobContainer);
ICloudBlob blob = container.GetBlobReferenceFromServer(blobName);
if (blob.BlobType == BlobType.BlockBlob)
{
//CloudBlockBlob blockBlob = container.GetBlockBlobReference(blobName);
CloudBlockBlob blockBlob = container.GetBlobReferenceFromServer(blobName) as CloudBlockBlob;
Microsoft.WindowsAzure.Storage.Blob.BlobProperties props = blockBlob.Properties;
dlg.ShowBlockBlob(blockBlob);
}
else if (blob.BlobType == BlobType.PageBlob)
{
CloudPageBlob pageBlob = container.GetBlobReferenceFromServer(blobName) as CloudPageBlob;
Microsoft.WindowsAzure.Storage.Blob.BlobProperties props = pageBlob.Properties;
dlg.ShowPageBlob(pageBlob);
}
if (dlg.ShowDialog().Value)
{
if (dlg.IsBlobChanged)
{
ShowBlobContainer(SelectedBlobContainer);
}
}
}
/// <summary>
/// Constructs a web request to create a new block blob or page blob, or to update the content
/// of an existing block blob.
/// </summary>
/// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
/// <param name="timeout">An integer specifying the server timeout interval.</param>
/// <param name="properties">A <see cref="BlobProperties"/> object.</param>
/// <param name="blobType">A <see cref="BlobType"/> enumeration value.</param>
/// <param name="pageBlobSize">For a page blob, the size of the blob. This parameter is ignored
/// for block blobs.</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
/// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
public static HttpWebRequest Put(Uri uri, int? timeout, BlobProperties properties, BlobType blobType, long pageBlobSize, AccessCondition accessCondition, OperationContext operationContext)
{
return BlobHttpWebRequestFactory.Put(uri, timeout, properties, blobType, pageBlobSize, accessCondition, true /* useVersionHeader */, operationContext);
}
public void BlobProtocolPutGetBlockListCloudOwnerSync()
{
string blockId1 = Convert.ToBase64String(new byte[] { 99, 100, 101 });
string blockId2 = Convert.ToBase64String(new byte[] { 102, 103, 104 });
// use a unique name since temp blocks from previous runs can exist
string blobName = "blob2" + DateTime.UtcNow.Ticks;
BlobProperties blobProperties = new BlobProperties();
List<PutBlockListItem> blocks = new List<PutBlockListItem>();
PutBlockListItem block1 = new PutBlockListItem(blockId1, BlockSearchMode.Uncommitted);
blocks.Add(block1);
PutBlockListItem block2 = new PutBlockListItem(blockId2, BlockSearchMode.Uncommitted);
blocks.Add(block2);
try
{
cloudOwnerSync.PutBlockScenarioTest(cloudSetup.ContainerName, blobName, blockId1, cloudSetup.LeaseId, cloudSetup.Content, null);
cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.All, cloudSetup.LeaseId, null, blockId1);
cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.Uncommitted, cloudSetup.LeaseId, null, blockId1);
cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.Committed, cloudSetup.LeaseId, null);
cloudOwnerSync.PutBlockScenarioTest(cloudSetup.ContainerName, blobName, blockId2, cloudSetup.LeaseId, cloudSetup.Content, null);
cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.All, cloudSetup.LeaseId, null, blockId1, blockId2);
cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.Uncommitted, cloudSetup.LeaseId, null, blockId1, blockId2);
cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.Committed, cloudSetup.LeaseId, null);
cloudOwnerSync.PutBlockListScenarioTest(cloudSetup.ContainerName, blobName, blocks, blobProperties, cloudSetup.LeaseId, null);
cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.All, cloudSetup.LeaseId, null, blockId1, blockId2);
cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.Uncommitted, cloudSetup.LeaseId, null);
cloudOwnerSync.GetBlockListScenarioTest(cloudSetup.ContainerName, blobName, BlockListingFilter.Committed, cloudSetup.LeaseId, null, blockId1, blockId2);
}
finally
{
cloudOwnerSync.DeleteBlob(cloudSetup.ContainerName, blobName);
}
}
/// <summary>
/// Gets the blob's properties from the response.
/// </summary>
/// <param name="response">The web response.</param>
/// <returns>The blob's properties.</returns>
public static BlobProperties GetProperties(HttpWebResponse response)
{
CommonUtility.AssertNotNull("response", response);
BlobProperties properties = new BlobProperties();
properties.ETag = HttpResponseParsers.GetETag(response);
#if WINDOWS_PHONE
properties.LastModified = HttpResponseParsers.GetLastModified(response);
properties.ContentLanguage = response.Headers[Constants.HeaderConstants.ContentLanguageHeader];
#else
properties.LastModified = response.LastModified.ToUniversalTime();
properties.ContentLanguage = response.Headers[HttpResponseHeader.ContentLanguage];
#endif
properties.ContentDisposition = response.Headers[Constants.HeaderConstants.ContentDispositionResponseHeader];
properties.ContentEncoding = response.Headers[HttpResponseHeader.ContentEncoding];
properties.ContentMD5 = response.Headers[HttpResponseHeader.ContentMd5];
properties.ContentType = response.Headers[HttpResponseHeader.ContentType];
properties.CacheControl = response.Headers[HttpResponseHeader.CacheControl];
// Get blob type
string blobType = response.Headers[Constants.HeaderConstants.BlobType];
if (!string.IsNullOrEmpty(blobType))
{
properties.BlobType = (BlobType)Enum.Parse(typeof(BlobType), blobType, true);
}
// Get lease properties
properties.LeaseStatus = GetLeaseStatus(response);
properties.LeaseState = GetLeaseState(response);
properties.LeaseDuration = GetLeaseDuration(response);
// Get the content length. Prioritize range and x-ms over content length for the special cases.
string rangeHeader = response.Headers[HttpResponseHeader.ContentRange];
string contentLengthHeader = response.Headers[Constants.HeaderConstants.ContentLengthHeader];
string blobContentLengthHeader = response.Headers[Constants.HeaderConstants.BlobContentLengthHeader];
if (!string.IsNullOrEmpty(rangeHeader))
{
properties.Length = long.Parse(rangeHeader.Split('/')[1], CultureInfo.InvariantCulture);
}
else if (!string.IsNullOrEmpty(blobContentLengthHeader))
{
properties.Length = long.Parse(blobContentLengthHeader, CultureInfo.InvariantCulture);
}
else if (!string.IsNullOrEmpty(contentLengthHeader))
{
// On Windows Phone, ContentLength property is not always same as Content-Length header,
// so we try to parse the header first.
properties.Length = long.Parse(contentLengthHeader, CultureInfo.InvariantCulture);
}
else
{
properties.Length = response.ContentLength;
}
// Get sequence number
string sequenceNumber = response.Headers[Constants.HeaderConstants.BlobSequenceNumber];
if (!string.IsNullOrEmpty(sequenceNumber))
{
properties.PageBlobSequenceNumber = long.Parse(sequenceNumber, CultureInfo.InvariantCulture);
}
return properties;
}
public void CreateBlob(string containerName, string blobName, bool isPublic)
{
Properties = new BlobProperties() { BlobType = BlobType.BlockBlob };
HttpWebRequest request = BlobTests.PutBlobRequest(BlobContext, containerName, blobName, Properties, BlobType.BlockBlob, Content, 0, null);
Assert.IsTrue(request != null, "Failed to create HttpWebRequest");
request.ContentLength = Content.Length;
request.Timeout = 30000;
if (BlobContext.Credentials != null)
{
BlobTests.SignRequest(request, BlobContext);
}
Stream stream = request.GetRequestStream();
stream.Write(Content, 0, Content.Length);
stream.Flush();
stream.Close();
HttpWebResponse response = BlobTestUtils.GetResponse(request, BlobContext);
HttpStatusCode statusCode = response.StatusCode;
string statusDescription = response.StatusDescription;
response.Close();
if (statusCode != HttpStatusCode.Created)
{
Assert.Fail(string.Format("Failed to create blob: {0}, Status: {1}, Status Description: {2}", containerName, statusCode, statusDescription));
}
}
/// <summary>
/// Constructs a web request to set system properties for a blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The blob's properties.</param>
/// <param name="leaseId">The lease ID, if the blob has an active lease.</param>
/// <param name="newBlobSize">The new blob size, if the blob is a page blob. Set this parameter to <c>null</c> to keep the existing blob size.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpWebRequest SetProperties(Uri uri, int timeout, BlobProperties properties, string leaseId, long? newBlobSize)
{
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "properties");
HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
request.ContentLength = 0;
request.Method = "PUT";
Request.AddLeaseId(request, leaseId);
if (newBlobSize.HasValue)
{
request.Headers.Add(Constants.HeaderConstants.Size, newBlobSize.Value.ToString(NumberFormatInfo.InvariantInfo));
properties.Length = newBlobSize.Value;
}
Request.AddOptionalHeader(request, Constants.HeaderConstants.CacheControlHeader, properties.CacheControl);
Request.AddOptionalHeader(request, Constants.HeaderConstants.ContentEncodingHeader, properties.ContentEncoding);
Request.AddOptionalHeader(request, Constants.HeaderConstants.ContentLanguageHeader, properties.ContentLanguage);
Request.AddOptionalHeader(request, Constants.HeaderConstants.BlobContentMD5Header, properties.ContentMD5);
Request.AddOptionalHeader(request, Constants.HeaderConstants.ContentTypeHeader, properties.ContentType);
return request;
}
public void ClearPageRangeScenarioTest(string containerName, string blobName, HttpStatusCode? expectedError)
{
// 1. Create Sparse Page Blob
int blobSize = 128 * 1024;
BlobProperties properties = new BlobProperties() { BlobType = BlobType.PageBlob };
Uri uri = BlobTests.ConstructPutUri(BlobContext.Address, containerName, blobName);
OperationContext opContext = new OperationContext();
HttpWebRequest webRequest = BlobHttpWebRequestFactory.Put(uri, BlobContext.Timeout, properties, BlobType.PageBlob, blobSize, null, opContext);
BlobTests.SignRequest(webRequest, BlobContext);
using (HttpWebResponse response = webRequest.GetResponse() as HttpWebResponse)
{
BlobTests.PutBlobResponse(response, BlobContext, expectedError);
}
// 2. Now upload some page ranges
for (int m = 0; m * 512 * 4 < blobSize; m++)
{
int startOffset = 512 * 4 * m;
int length = 512;
PageRange range = new PageRange(startOffset, startOffset + length - 1);
opContext = new OperationContext();
HttpWebRequest pageRequest = BlobHttpWebRequestFactory.PutPage(uri, BlobContext.Timeout, range, PageWrite.Update, null, opContext);
pageRequest.ContentLength = 512;
BlobTests.SignRequest(pageRequest, BlobContext);
Stream outStream = pageRequest.GetRequestStream();
for (int n = 0; n < 512; n++)
{
outStream.WriteByte((byte)m);
}
outStream.Close();
using (HttpWebResponse pageResponse = pageRequest.GetResponse() as HttpWebResponse)
{
}
}
// 3. Now do a Get Page Ranges
List<PageRange> pageRanges = new List<PageRange>();
opContext = new OperationContext();
HttpWebRequest pageRangeRequest = BlobHttpWebRequestFactory.GetPageRanges(uri, BlobContext.Timeout, null, null, null, null, opContext);
BlobTests.SignRequest(pageRangeRequest, BlobContext);
using (HttpWebResponse pageRangeResponse = pageRangeRequest.GetResponse() as HttpWebResponse)
{
GetPageRangesResponse getPageRangesResponse = new GetPageRangesResponse(pageRangeResponse.GetResponseStream());
pageRanges.AddRange(getPageRangesResponse.PageRanges.ToList());
}
// 4. Now Clear some pages
bool skipFlag = false;
foreach (PageRange pRange in pageRanges)
{
skipFlag = !skipFlag;
if (skipFlag)
{
continue;
}
opContext = new OperationContext();
HttpWebRequest clearPageRequest = BlobHttpWebRequestFactory.PutPage(uri, BlobContext.Timeout, pRange, PageWrite.Clear, null, opContext);
clearPageRequest.ContentLength = 0;
BlobTests.SignRequest(clearPageRequest, BlobContext);
using (HttpWebResponse clearResponse = clearPageRequest.GetResponse() as HttpWebResponse)
{
}
}
// 5. Get New Page ranges and verify
List<PageRange> newPageRanges = new List<PageRange>();
opContext = new OperationContext();
HttpWebRequest newPageRangeRequest = BlobHttpWebRequestFactory.GetPageRanges(uri, BlobContext.Timeout, null, null, null, null, opContext);
BlobTests.SignRequest(newPageRangeRequest, BlobContext);
using (HttpWebResponse newPageRangeResponse = newPageRangeRequest.GetResponse() as HttpWebResponse)
{
GetPageRangesResponse getNewPageRangesResponse = new GetPageRangesResponse(newPageRangeResponse.GetResponseStream());
newPageRanges.AddRange(getNewPageRangesResponse.PageRanges.ToList());
}
Assert.AreEqual(pageRanges.Count(), newPageRanges.Count() * 2);
for (int l = 0; l < newPageRanges.Count(); l++)
{
Assert.AreEqual(pageRanges[2 * l].StartOffset, newPageRanges[l].StartOffset);
Assert.AreEqual(pageRanges[2 * l].EndOffset, newPageRanges[l].EndOffset);
}
}
/// <summary>
/// Constructs a web request to create a new block blob or page blob, or to update the content
/// of an existing block blob.
/// </summary>
/// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
/// <param name="timeout">An integer specifying the server timeout interval.</param>
/// <param name="properties">A <see cref="BlobProperties"/> object.</param>
/// <param name="blobType">A <see cref="BlobType"/> enumeration value.</param>
/// <param name="pageBlobSize">For a page blob, the size of the blob. This parameter is ignored
/// for block blobs.</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
/// <param name="useVersionHeader">A boolean value indicating whether to set the <i>x-ms-version</i> HTTP header.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
/// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
public static HttpWebRequest Put(Uri uri, int? timeout, BlobProperties properties, BlobType blobType, long pageBlobSize, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
{
CommonUtility.AssertNotNull("properties", properties);
if (blobType == BlobType.Unspecified)
{
throw new InvalidOperationException(SR.UndefinedBlobType);
}
HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, null /* builder */, useVersionHeader, operationContext);
if (properties.CacheControl != null)
{
request.Headers[HttpRequestHeader.CacheControl] = properties.CacheControl;
}
if (properties.ContentType != null)
{
// Setting it using Headers is an exception
request.ContentType = properties.ContentType;
}
if (properties.ContentMD5 != null)
{
request.Headers[HttpRequestHeader.ContentMd5] = properties.ContentMD5;
}
if (properties.ContentLanguage != null)
{
request.Headers[HttpRequestHeader.ContentLanguage] = properties.ContentLanguage;
}
if (properties.ContentEncoding != null)
{
request.Headers[HttpRequestHeader.ContentEncoding] = properties.ContentEncoding;
}
if (properties.ContentDisposition != null)
{
request.Headers[Constants.HeaderConstants.BlobContentDispositionRequestHeader] = properties.ContentDisposition;
}
if (blobType == BlobType.PageBlob)
{
request.Headers[Constants.HeaderConstants.BlobType] = Constants.HeaderConstants.PageBlob;
request.Headers[Constants.HeaderConstants.BlobContentLengthHeader] = pageBlobSize.ToString(NumberFormatInfo.InvariantInfo);
properties.Length = pageBlobSize;
}
else if (blobType == BlobType.BlockBlob)
{
request.Headers[Constants.HeaderConstants.BlobType] = Constants.HeaderConstants.BlockBlob;
}
else
{
request.Headers[Constants.HeaderConstants.BlobType] = Constants.HeaderConstants.AppendBlob;
}
request.ApplyAccessCondition(accessCondition);
return request;
}
public void PutBlockListScenarioTest(string containerName, string blobName, List<PutBlockListItem> blocks, BlobProperties blobProperties, string leaseId, HttpStatusCode? expectedError)
{
HttpWebRequest request = BlobTests.PutBlockListRequest(BlobContext, containerName, blobName, blobProperties, AccessCondition.GenerateLeaseCondition(leaseId));
Assert.IsTrue(request != null, "Failed to create HttpWebRequest");
byte[] content;
using (MemoryStream stream = new MemoryStream())
{
BlobRequest.WriteBlockListBody(blocks, stream);
stream.Seek(0, SeekOrigin.Begin);
content = new byte[stream.Length];
stream.Read(content, 0, content.Length);
}
request.ContentLength = content.Length;
if (BlobContext.Credentials != null)
{
BlobTests.SignRequest(request, BlobContext);
}
BlobTestUtils.SetRequest(request, BlobContext, content);
HttpWebResponse response = BlobTestUtils.GetResponse(request, BlobContext);
try
{
BlobTests.PutBlockListResponse(response, BlobContext, expectedError);
}
finally
{
response.Close();
}
}
public static void GetBlobResponse(HttpWebResponse response, BlobContext context, BlobProperties properties, byte[] content, HttpStatusCode? expectedError)
{
Assert.IsNotNull(response);
if (expectedError == null)
{
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
BlobTestUtils.LastModifiedHeader(response);
BlobTestUtils.ContentLengthHeader(response, content.Length);
BlobTestUtils.ETagHeader(response);
BlobTestUtils.RequestIdHeader(response);
BlobTestUtils.Contents(response, content);
}
else
{
Assert.AreEqual(expectedError, response.StatusCode, response.StatusDescription);
}
response.Close();
}
/// <summary>
/// Constructs a web request to create or update a blob by committing a block list.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The properties to set for the blob.</param>
/// <param name="leaseId">The lease ID, if the blob has an active lease.</param>
/// <returns>A web request for performing the operation.</returns>
public static HttpWebRequest PutBlockList(
Uri uri,
int timeout,
BlobProperties properties,
string leaseId)
{
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "blocklist");
HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
request.Method = "PUT";
Request.AddLeaseId(request, leaseId);
Request.AddOptionalHeader(request, Constants.HeaderConstants.CacheControlHeader, properties.CacheControl);
Request.AddOptionalHeader(request, Constants.HeaderConstants.ContentTypeHeader, properties.ContentType);
Request.AddOptionalHeader(request, Constants.HeaderConstants.BlobContentMD5Header, properties.ContentMD5);
Request.AddOptionalHeader(request, Constants.HeaderConstants.ContentLanguageHeader, properties.ContentLanguage);
Request.AddOptionalHeader(request, Constants.HeaderConstants.ContentEncodingHeader, properties.ContentEncoding);
return request;
}
public static HttpWebRequest PutBlockListRequest(BlobContext context, string containerName, string blobName, BlobProperties blobProperties, AccessCondition accessCondition)
{
Uri uri = BlobTests.ConstructPutUri(context.Address, containerName, blobName);
HttpWebRequest request = null;
OperationContext opContext = new OperationContext();
request = BlobHttpWebRequestFactory.PutBlockList(uri, context.Timeout, blobProperties, accessCondition, opContext);
Assert.IsNotNull(request);
Assert.IsNotNull(request.Method);
Assert.AreEqual("PUT", request.Method);
BlobTestUtils.VersionHeader(request, false);
BlobTestUtils.ContentLanguageHeader(request, null);
BlobTestUtils.ContentMd5Header(request, null);
return request;
}
/// <summary>
/// Gets the blob's properties from the response.
/// </summary>
/// <param name="response">The web response.</param>
/// <returns>The blob's properties.</returns>
public static BlobProperties GetProperties(HttpResponseMessage response)
{
BlobProperties properties = new BlobProperties();
if (response.Content != null)
{
properties.LastModified = response.Content.Headers.LastModified;
properties.ContentEncoding = HttpWebUtility.CombineHttpHeaderValues(response.Content.Headers.ContentEncoding);
properties.ContentLanguage = HttpWebUtility.CombineHttpHeaderValues(response.Content.Headers.ContentLanguage);
if (response.Content.Headers.ContentDisposition != null)
{
properties.ContentDisposition = response.Content.Headers.ContentDisposition.ToString();
}
if (response.Content.Headers.ContentMD5 != null)
{
properties.ContentMD5 = Convert.ToBase64String(response.Content.Headers.ContentMD5);
}
if (response.Content.Headers.ContentType != null)
{
properties.ContentType = response.Content.Headers.ContentType.ToString();
}
// Get the content length. Prioritize range and x-ms over content length for the special cases.
string contentLengthHeader = response.Headers.GetHeaderSingleValueOrDefault(Constants.HeaderConstants.BlobContentLengthHeader);
if ((response.Content.Headers.ContentRange != null) &&
response.Content.Headers.ContentRange.HasLength)
{
properties.Length = response.Content.Headers.ContentRange.Length.Value;
}
else if (!string.IsNullOrEmpty(contentLengthHeader))
{
properties.Length = long.Parse(contentLengthHeader);
}
else if (response.Content.Headers.ContentLength.HasValue)
{
properties.Length = response.Content.Headers.ContentLength.Value;
}
}
if (response.Headers.CacheControl != null)
{
properties.CacheControl = response.Headers.CacheControl.ToString();
}
if (response.Headers.ETag != null)
{
properties.ETag = response.Headers.ETag.ToString();
}
// Get blob type
string blobType = response.Headers.GetHeaderSingleValueOrDefault(Constants.HeaderConstants.BlobType);
if (!string.IsNullOrEmpty(blobType))
{
properties.BlobType = (BlobType)Enum.Parse(typeof(BlobType), blobType, true);
}
// Get lease properties
properties.LeaseStatus = GetLeaseStatus(response);
properties.LeaseState = GetLeaseState(response);
properties.LeaseDuration = GetLeaseDuration(response);
// Get sequence number
string sequenceNumber = response.Headers.GetHeaderSingleValueOrDefault(Constants.HeaderConstants.BlobSequenceNumber);
if (!string.IsNullOrEmpty(sequenceNumber))
{
properties.PageBlobSequenceNumber = long.Parse(sequenceNumber);
}
return properties;
}
/// <summary>
/// Constructs a web request to create a new block blob or page blob, or to update the content
/// of an existing block blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The properties to set for the blob.</param>
/// <param name="blobType">The type of the blob.</param>
/// <param name="pageBlobSize">For a page blob, the size of the blob. This parameter is ignored
/// for block blobs.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpWebRequest Put(Uri uri, int? timeout, BlobProperties properties, BlobType blobType, long pageBlobSize, AccessCondition accessCondition, OperationContext operationContext)
{
if (blobType == BlobType.Unspecified)
{
throw new InvalidOperationException(SR.UndefinedBlobType);
}
HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, null /* builder */, operationContext);
if (properties.CacheControl != null)
{
request.Headers.Add(HttpRequestHeader.CacheControl, properties.CacheControl);
}
if (properties.ContentType != null)
{
// Setting it using Headers is an exception
request.ContentType = properties.ContentType;
}
if (properties.ContentMD5 != null)
{
request.Headers.Add(HttpRequestHeader.ContentMd5, properties.ContentMD5);
}
if (properties.ContentLanguage != null)
{
request.Headers.Add(HttpRequestHeader.ContentLanguage, properties.ContentLanguage);
}
if (properties.ContentEncoding != null)
{
request.Headers.Add(HttpRequestHeader.ContentEncoding, properties.ContentEncoding);
}
if (blobType == BlobType.PageBlob)
{
request.ContentLength = 0;
request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.PageBlob);
request.Headers.Add(Constants.HeaderConstants.Size, pageBlobSize.ToString(NumberFormatInfo.InvariantInfo));
properties.Length = pageBlobSize;
}
else
{
request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.BlockBlob);
}
request.ApplyAccessCondition(accessCondition);
return request;
}
/// <summary>
/// Constructs a web request to create or update a blob by committing a block list.
/// </summary>
/// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
/// <param name="timeout">An integer specifying the server timeout interval.</param>
/// <param name="properties">A <see cref="BlobProperties"/> object specifying the properties to set for the blob.</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
/// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
public static HttpWebRequest PutBlockList(Uri uri, int? timeout, BlobProperties properties, AccessCondition accessCondition, OperationContext operationContext)
{
return BlobHttpWebRequestFactory.PutBlockList(uri, timeout, properties, accessCondition, true /* useVersionHeader */, operationContext);
}
public static bool PutPropertiesValidator(BlobProperties properties)
{
if (properties.BlobType == BlobType.Unspecified)
{
return false;
}
if ((properties.BlobType == BlobType.PageBlob) &&
(properties.Length % 512 != 0) &&
(properties.Length > 0))
{
return false;
}
return true;
}
