internal async Task SetBlobTag(long taskId, IStorageBlobManagement localChannel, CloudBlobContainer container, string blobName) { if (!NameUtil.IsValidBlobName(blobName)) { throw new ArgumentException(String.Format(Resources.InvalidBlobName, blobName)); } ValidatePipelineCloudBlobContainer(container); BlobContainerClient track2container = AzureStorageContainer.GetTrack2BlobContainerClient(container, this.Channel.StorageContext, ClientOptions); BlobBaseClient blobClient = Util.GetTrack2BlobClient(track2container, blobName, localChannel.StorageContext, null, false, null, ClientOptions); await SetBlobTag(taskId, localChannel, blobClient, true).ConfigureAwait(false); }
public async Task BlobTrigger_IfBoundToCloudBlob_Binds() { // Arrange var container = CreateContainer(blobServiceClient, ContainerName); var blob = container.GetBlockBlobClient(BlobName); await blob.UploadTextAsync("ignore"); // Act BlobBaseClient result = await RunTriggerAsync <BlobBaseClient>(typeof(BindToCloudBlobProgram), (s) => BindToCloudBlobProgram.TaskSource = s); // Assert Assert.AreEqual(blob.Uri, result.Uri); }
private void CopyBlobSync(IStorageBlobManagement destChannel, BlobBaseClient srcBlobBaseClient, string destContainerName, string destBlobName) { NameUtil.ValidateContainerName(destContainerName); if (string.IsNullOrEmpty(destBlobName)) { destBlobName = srcBlobBaseClient.Name; } else { NameUtil.ValidateBlobName(destBlobName); } BlobBaseClient destBlob = this.GetDestBlob(destChannel, destContainerName, destBlobName, Util.GetBlobType(srcBlobBaseClient)); this.CopyBlobSync(destChannel, srcBlobBaseClient, destBlob); }
public async Task HandleAsync_ShouldReturnFalseAndLogEvent_WhenSetMetadataThrows() { // Arrange var blobUri = new Uri(_expectedInboxUrl); var appInsightsUri = new Uri("https://www.appinsights.com"); JObject operationContext = JsonHelpers.JsonToJObject("{\"something\": \"something value\"}"); var metadataData = new Dictionary <string, string> { { "key1", "value1" }, { "key2", "value2" } }; var topicEndpointUri = new Uri("https://www.topichost.com"); var testEvent = new EventGridEvent { EventTime = DateTime.UtcNow, EventType = CustomEventTypes.RequestCreateMetadata, DataVersion = "1.0", Data = JsonConvert.SerializeObject(new RequestBlobMetadataCreateDTO { BlobUri = blobUri, BlobMetadata = JObject.FromObject(metadataData), 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.SetBlobMetadataAsync(blobUri, metadataData, It.IsAny <StorageClientProviderContext>())) .ThrowsAsync(new ArgumentException("Something's wrong")); Mock.Get(_logger) .Setup(x => x.LogExceptionObject( out appInsightsUri, LogEventIds.GridwichUnhandledException, It.IsAny <Exception>(), It.IsAny <object>())); // Act var handleAsyncResult = await _handler.HandleAsync(testEvent).ConfigureAwait(true); // Assert handleAsyncResult.ShouldBe(false); Mock.Get(_logger).Verify(x => x.LogExceptionObject(out appInsightsUri, LogEventIds.GridwichUnhandledException, It.IsAny <Exception>(), It.IsAny <object>()), Times.Once, "An exception should be logged when the work fails"); }
public PartitionedDownloader( BlobBaseClient client, StorageTransferOptions transferOptions = default, DownloadTransactionalHashingOptions hashingOptions = default) { _client = client; // Set _maxWorkerCount if (transferOptions.MaximumConcurrency.HasValue && transferOptions.MaximumConcurrency > 0) { _maxWorkerCount = transferOptions.MaximumConcurrency.Value; } else { _maxWorkerCount = Constants.Blob.Block.DefaultConcurrentTransfersCount; } // Set _rangeSize if (transferOptions.MaximumTransferSize.HasValue && transferOptions.MaximumTransferSize.Value > 0) { _rangeSize = Math.Min(transferOptions.MaximumTransferSize.Value, Constants.Blob.Block.MaxDownloadBytes); } else { _rangeSize = Constants.DefaultBufferSize; } // Set _initialRangeSize if (transferOptions.InitialTransferSize.HasValue && transferOptions.InitialTransferSize.Value > 0) { _initialRangeSize = transferOptions.InitialTransferSize.Value; } else { _initialRangeSize = Constants.Blob.Block.DefaultInitalDownloadRangeSize; } // the caller to this stream cannot defer validation, as they cannot access a returned hash if (!(hashingOptions?.Validate ?? true)) { throw Errors.CannotDeferTransactionalHashVerification(); } _hashingOptions = hashingOptions; }
public T Convert(BlobBaseClient input) { if (input == null) { return(default(T)); } T blob = input as T; if (blob == null) { throw new InvalidOperationException($"The blob is not an {typeof(T).Name}."); } return(blob); }
public async Task SetImmutibilityPolicyAsync_Mutable() { // Arrange BlobBaseClient blob = InstrumentClient(_containerClient.GetBlobClient(GetNewBlobName())); BlobImmutabilityPolicy immutabilityPolicy = new BlobImmutabilityPolicy { ExpiresOn = Recording.UtcNow.AddSeconds(5), PolicyMode = BlobImmutabilityPolicyMode.Mutable }; // Act await TestHelper.AssertExpectedExceptionAsync <ArgumentException>( blob.SetImmutabilityPolicyAsync(immutabilityPolicy), e => Assert.AreEqual("PolicyMode must be Locked or Unlocked", e.Message)); }
public async Task SetImmutibilityPolicyAsync_Error() { // Arrange BlobBaseClient blob = InstrumentClient(_containerClient.GetBlobClient(GetNewBlobName())); BlobImmutabilityPolicy immutabilityPolicy = new BlobImmutabilityPolicy { ExpiresOn = Recording.UtcNow.AddSeconds(5), PolicyMode = BlobImmutabilityPolicyMode.Locked }; // Act await TestHelper.AssertExpectedExceptionAsync <RequestFailedException>( blob.SetImmutabilityPolicyAsync(immutabilityPolicy), e => Assert.AreEqual(BlobErrorCode.BlobNotFound.ToString(), e.ErrorCode)); }
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 BlobBaseClient."); } 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 async Task SetImmutibilityPolicyAsync_InvalidRequestConditions(string invalidCondition) { // Arrange BlobBaseClient blobBaseClient = new BlobBaseClient(new Uri("https://www.doesntmatter.com"), GetOptions()); BlobImmutabilityPolicy immutabilityPolicy = new BlobImmutabilityPolicy { ExpiresOn = Recording.UtcNow.AddMinutes(5), PolicyMode = BlobImmutabilityPolicyMode.Unlocked }; BlobRequestConditions conditions = new BlobRequestConditions(); switch (invalidCondition) { case nameof(BlobRequestConditions.IfMatch): conditions.IfMatch = new ETag(); break; case nameof(BlobRequestConditions.IfModifiedSince): conditions.IfModifiedSince = Recording.UtcNow.AddMinutes(5); break; case nameof(BlobRequestConditions.IfNoneMatch): conditions.IfNoneMatch = new ETag(); break; case nameof(BlobRequestConditions.LeaseId): conditions.LeaseId = string.Empty; break; case nameof(BlobRequestConditions.TagConditions): conditions.TagConditions = string.Empty; break; } // Act await TestHelper.AssertExpectedExceptionAsync <ArgumentException>( blobBaseClient.SetImmutabilityPolicyAsync( immutabilityPolicy, conditions), e => { Assert.IsTrue(e.Message.Contains($"SetImmutabilityPolicy does not support the {invalidCondition} condition(s).")); Assert.IsTrue(e.Message.Contains("conditions")); }); }
/// <summary> /// Make sure the pipeline blob is valid and already existing /// </summary> /// <param name="blob">CloudBlob object</param> internal void ValidatePipelineCloudBlobTrack2(BlobBaseClient blob) { if (null == blob) { throw new ArgumentException(String.Format(Resources.ObjectCannotBeNull, typeof(CloudBlob).Name)); } if (!NameUtil.IsValidBlobName(blob.Name)) { throw new ArgumentException(String.Format(Resources.InvalidBlobName, blob.Name)); } if (!NameUtil.IsValidContainerName(blob.BlobContainerName)) { throw new ArgumentException(String.Format(Resources.InvalidContainerName, blob.BlobContainerName)); } }
public PartitionedDownloader( BlobBaseClient client, StorageTransferOptions transferOptions = default, long?initialTransferLength = null) { _client = client; _maxWorkerCount = transferOptions.MaximumConcurrency ?? Constants.Blob.Block.DefaultConcurrentTransfersCount; _initialRangeSize = initialTransferLength ?? ((long?)transferOptions.MaximumTransferLength) ?? Constants.DefaultBufferSize; _rangeSize = Math.Min( Constants.Blob.Block.MaxDownloadBytes, transferOptions.MaximumTransferLength ?? Constants.DefaultBufferSize); }
/// <summary> /// Create a mock sleeve, properly set up so that the two main getter's work. /// </summary> private static IStorageBlobClientSleeve MockSleeve(BlobBaseClient client, StorageClientProviderContext context) { Mock.Get(client) .SetupGet(x => x.AccountName) .Returns(@"ut"); var sleeve = Mock.Of <IStorageBlobClientSleeve>(); Mock.Get(sleeve) .SetupGet(x => x.Client) .Returns(client); Mock.Get(sleeve) .SetupGet(x => x.Context) .Returns(context); return(sleeve); }
private void StartCopyBlob(IStorageBlobManagement destChannel, BlobBaseClient srcCloudBlob, BlobBaseClient destCloudBlob) { global::Azure.Storage.Blobs.Models.BlobType srcBlobType = Util.GetBlobType(srcCloudBlob, true).Value; if (srcCloudBlob is BlobClient) { srcCloudBlob = Util.GetTrack2BlobClientWithType(srcCloudBlob, Channel.StorageContext, srcBlobType); } if (destCloudBlob is BlobClient) { destCloudBlob = Util.GetTrack2BlobClientWithType(destCloudBlob, destChannel.StorageContext, srcBlobType); } ValidateBlobTier(Util.convertBlobType_Track2ToTrack1(srcBlobType), pageBlobTier, standardBlobTier, rehydratePriority); Func <long, Task> taskGenerator = (taskId) => StartCopyAsync(taskId, destChannel, srcCloudBlob, destCloudBlob); RunTask(taskGenerator); }
public async Task SetLegalHoldAsync() { // Arrange await using DisposingImmutableStorageWithVersioningContainer vlwContainer = await GetTestVersionLevelWormContainer(TestConfigOAuth); BlobBaseClient blob = await GetNewBlobClient(vlwContainer.Container); // Act Response <BlobLegalHoldResult> response = await blob.SetLegalHoldAsync(true); // Assert Assert.IsTrue(response.Value.HasLegalHold); // Validate that we are correctly deserializing Get Properties response. // Act Response <BlobProperties> propertiesResponse = await blob.GetPropertiesAsync(); // Assert Assert.IsTrue(propertiesResponse.Value.HasLegalHold); // Validate we are correctly deserializing Blob Items. // Act List <BlobItem> blobItems = new List <BlobItem>(); await foreach (BlobItem blobItem in vlwContainer.Container.GetBlobsAsync(traits: BlobTraits.LegalHold)) { blobItems.Add(blobItem); } // Assert Assert.AreEqual(1, blobItems.Count); Assert.IsTrue(blobItems[0].Properties.HasLegalHold); // Validate we are correctly deserialzing Get Blob response. // Act Response <BlobDownloadInfo> downloadResponse = await blob.DownloadAsync(); // Assert Assert.IsTrue(downloadResponse.Value.Details.HasLegalHold); // Act response = await blob.SetLegalHoldAsync(false); // Assert Assert.IsFalse(response.Value.HasLegalHold); }
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 async Task SetImmutibilityPolicyAsync_Mutable() { // Arrange await using DisposingImmutableStorageWithVersioningContainer vlwContainer = await GetTestVersionLevelWormContainer(TestConfigOAuth); BlobBaseClient blob = InstrumentClient(vlwContainer.Container.GetBlobClient(GetNewBlobName())); BlobImmutabilityPolicy immutabilityPolicy = new BlobImmutabilityPolicy { ExpiresOn = Recording.UtcNow.AddSeconds(5), PolicyMode = BlobImmutabilityPolicyMode.Mutable }; // Act await TestHelper.AssertExpectedExceptionAsync <ArgumentException>( blob.SetImmutabilityPolicyAsync(immutabilityPolicy), e => Assert.AreEqual("PolicyMode must be Locked or Unlocked", e.Message)); }
public async Task SetImmutibilityPolicyAsync_Error() { // Arrange await using DisposingImmutableStorageWithVersioningContainer vlwContainer = await GetTestVersionLevelWormContainer(TestConfigOAuth); BlobBaseClient blob = InstrumentClient(vlwContainer.Container.GetBlobClient(GetNewBlobName())); BlobImmutabilityPolicy immutabilityPolicy = new BlobImmutabilityPolicy { ExpiresOn = Recording.UtcNow.AddSeconds(5), PolicyMode = BlobImmutabilityPolicyMode.Locked }; // Act await TestHelper.AssertExpectedExceptionAsync <RequestFailedException>( blob.SetImmutabilityPolicyAsync(immutabilityPolicy), e => Assert.AreEqual(BlobErrorCode.BlobNotFound.ToString(), e.ErrorCode)); }
public async Task SetLegalHoldAsync() { // Arrange BlobBaseClient blob = await GetNewBlobClient(_containerClient); // Act Response <BlobLegalHoldResult> response = await blob.SetLegalHoldAsync(true); // Assert Assert.IsTrue(response.Value.HasLegalHold); // Validate that we are correctly deserializing Get Properties response. // Act Response <BlobProperties> propertiesResponse = await blob.GetPropertiesAsync(); // Assert Assert.IsTrue(propertiesResponse.Value.HasLegalHold); // Validate we are correctly deserializing Blob Items. // Act List <BlobItem> blobItems = new List <BlobItem>(); await foreach (BlobItem blobItem in _containerClient.GetBlobsAsync(traits: BlobTraits.LegalHold, prefix: blob.Name)) { blobItems.Add(blobItem); } // Assert Assert.AreEqual(1, blobItems.Count); Assert.IsTrue(blobItems[0].Properties.HasLegalHold); // Validate we are correctly deserialzing Get Blob response. // Act Response <BlobDownloadInfo> downloadResponse = await blob.DownloadAsync(); // Assert Assert.IsTrue(downloadResponse.Value.Details.HasLegalHold); // Act response = await blob.SetLegalHoldAsync(false); // Assert Assert.IsFalse(response.Value.HasLegalHold); }
public async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req, ILogger log) { // Try to get the blobUri from the request parameters: string blobUri = req?.Query["blobUri"]; blobUri ??= HttpUtility.UrlDecode(blobUri); // Replace with the blobUri from the body, if it exists: using (var sr = new StreamReader(req?.Body)) { string requestBody = await sr.ReadToEndAsync().ConfigureAwait(false); dynamic data = JsonConvert.DeserializeObject(requestBody); blobUri ??= data?.blobUri; } // If we have a blobUri, try to get the ContentLength: long contentLength = -1; try { if (Uri.TryCreate(blobUri, UriKind.Absolute, out Uri requestedUri)) { var blobBaseClient = new BlobBaseClient(requestedUri, _tokenCredential); var props = await blobBaseClient.GetPropertiesAsync().ConfigureAwait(false); contentLength = props.Value.ContentLength; } } catch (Azure.RequestFailedException e) when(e.ErrorCode == "AuthorizationPermissionMismatch") { return(new BadRequestObjectResult(new { error = $"BlobBaseClient.GetPropertiesAsync requires the identity principal to have role 'Storage Blob Data Reader' on resource (file, container, resource-group, or subscription).\n\n\nException.Message:\n\n{e.Message}" })); } catch (Exception e) { return(new BadRequestObjectResult(new { error = $"Exception.Message:\n{e.Message}\n\nInnerException.Message:\n{e.InnerException?.Message}" })); } log.LogInformation($"BlobUri: {blobUri}, ContentLength: {contentLength}"); return(new OkObjectResult(contentLength)); }
/// <summary> /// Create a mock sleeve, properly set up so that the two main getter's work. /// </summary> private static IStorageBlobClientSleeve MockSleeve(BlobBaseClient client, StorageClientProviderContext context) { Mock.Get(client) .SetupGet(x => x.AccountName) .Returns(@"ut"); var serviceClient = new BlobServiceClient(new Uri($@"https://{client.AccountName}.blob.core.windows.net")); var sleeve = Mock.Of <IStorageBlobClientSleeve>(); Mock.Get(sleeve) .SetupGet(x => x.Client) .Returns(client); Mock.Get(sleeve) .SetupGet(x => x.Context) .Returns(context); return(sleeve); }
/// <summary> /// Creates a BlobClientSleeve (BlobBaseClient + Context). Called when one does not exist yet. /// </summary> /// <param name="blobUri">The target Uri.</param> /// <param name="ctx">The context.</param> /// <returns> /// A BlobBaseClient object. /// </returns> internal StorageBlobClientSleeve CreateBlobClientSleeveForUri(Uri blobUri, StorageClientProviderContext ctx) { BlobBaseClient blobBaseClient; BlobUriBuilder blobUriBuilder; var contextCopy = new StorageClientProviderContext(ctx); var blobClientOptions = new BlobClientOptions(); try { blobUriBuilder = new BlobUriBuilder(blobUri); var clientRequestIdPolicy = new BlobClientPipelinePolicy(contextCopy); blobClientOptions.AddPolicy(clientRequestIdPolicy, HttpPipelinePosition.PerCall); blobBaseClient = new BlobBaseClient(blobUri, _identity, blobClientOptions); } catch (Exception e) { _log.LogExceptionObject(LogEventIds.BlobBaseClientProviderFailedToCreateBlobBaseClient, e, blobUri); throw; } try { // BlobUriBuilder SDK class will just give null for Accountname if URL is malformed, so let flow upwards _ = StringHelpers.NullIfNullOrWhiteSpace(blobUriBuilder.AccountName) ?? throw new UriFormatException($@"Malformed Azure Storage URL: {blobUri}"); var accountUri = StorageHelpers.BuildStorageAccountUri(blobUriBuilder.AccountName, buildForBlobService: true); var newSleeve = new StorageBlobClientSleeve(blobBaseClient, new BlobServiceClient(accountUri, _identity, blobClientOptions), contextCopy); return(newSleeve); } catch (UriFormatException uriex) { _log.LogExceptionObject(LogEventIds.BlobBaseClientProviderUriMissingAccountName, uriex, blobUri); throw new ArgumentException(LogEventIds.BlobBaseClientProviderUriMissingAccountName.Name, nameof(blobUri), uriex); } catch (ArgumentException aex) { _log.LogExceptionObject(LogEventIds.BlobBaseClientProviderUriMissingAccountName, aex, blobUri); throw; } }
private async Task <IEnumerable <T> > ConvertBlobs(IAsyncEnumerable <BlobItem> blobItems, BlobContainerClient blobContainerClient) { var list = new List <T>(); await foreach (var blobItem in blobItems.ConfigureAwait(false)) { BlobBaseClient src = null; switch (blobItem.Properties.BlobType) { case BlobType.Block: if (typeof(T) == typeof(BlobClient)) { // BlobClient is simplified version of BlockBlobClient, i.e. upload results in creation of block blob. src = blobContainerClient.GetBlobClient(blobItem.Name); } else { src = blobContainerClient.GetBlockBlobClient(blobItem.Name); } break; case BlobType.Append: src = blobContainerClient.GetAppendBlobClient(blobItem.Name); break; case BlobType.Page: src = blobContainerClient.GetPageBlobClient(blobItem.Name); break; default: throw new InvalidOperationException($"Unexpected blob type {blobItem.Properties.BlobType}"); } var funcCtx = new FunctionBindingContext(Guid.Empty, CancellationToken.None); var valueCtx = new ValueBindingContext(funcCtx, CancellationToken.None); var converted = await _converter(src, null, valueCtx).ConfigureAwait(false); list.Add(converted); } return(list); }
public void TestUploadToWrongBlobType([Values("block", "page", "append")] string actualType) { var blobName = Guid.NewGuid().ToString(); var createFunctions = new Dictionary <string, Action> { ["block"] = () => new BlockBlobClient(AzureCredentials.ConnectionString, AzureCredentials.DefaultBlobContainerName, blobName).Upload(Stream.Null), ["page"] = () => new PageBlobClient(AzureCredentials.ConnectionString, AzureCredentials.DefaultBlobContainerName, blobName).CreateIfNotExists(size: 0), ["append"] = () => new AppendBlobClient(AzureCredentials.ConnectionString, AzureCredentials.DefaultBlobContainerName, blobName).CreateIfNotExists() }; // right now append blobs aren't fully supported, so we can't fully test this if (actualType == "append") { Assert.Throws <RequestFailedException>(() => createFunctions[actualType]()) .ErrorCode.ShouldEqual("FeatureNotSupportedByEmulator"); return; } else { createFunctions.Remove("append"); // to prevent it from failing below } var baseClient = new BlobBaseClient(AzureCredentials.ConnectionString, AzureCredentials.DefaultBlobContainerName, blobName); Assert.IsFalse(baseClient.Exists()); createFunctions[actualType](); Assert.IsTrue(baseClient.Exists()); foreach (var kvp in createFunctions) { if (kvp.Key == actualType) { Assert.DoesNotThrow(() => kvp.Value()); } else { Assert.Throws <RequestFailedException>(() => kvp.Value()) .ErrorCode.ShouldEqual("InvalidBlobType"); } } }
/// <summary> /// Azure storage blob constructor /// </summary> /// <param name="blob">ICloud blob object</param> public AzureStorageBlob(BlobBaseClient track2BlobClient, AzureStorageContext storageContext, BlobClientOptions options = null, BlobItem listBlobItem = null) { if (listBlobItem == null) { SetProperties(track2BlobClient, storageContext, track2BlobClient.GetProperties().Value, options); return; } this.privateBlobBaseClient = track2BlobClient; Name = track2BlobClient.Name; this.Context = storageContext; privateClientOptions = options; ICloudBlob = GetTrack1Blob(track2BlobClient, storageContext.StorageAccount.Credentials, listBlobItem.Properties.BlobType); if (!(ICloudBlob is InvalidCloudBlob)) { BlobType = ICloudBlob.BlobType; SnapshotTime = ICloudBlob.SnapshotTime; } else { BlobType = Util.convertBlobType_Track2ToTrack1(listBlobItem.Properties.BlobType); if (listBlobItem.Snapshot != null) { SnapshotTime = DateTimeOffset.Parse(listBlobItem.Snapshot); } } // Set the AzureStorageBlob Properties Length = listBlobItem.Properties.ContentLength is null ? 0 : listBlobItem.Properties.ContentLength.Value; IsDeleted = listBlobItem.Deleted; RemainingDaysBeforePermanentDelete = listBlobItem.Properties.RemainingRetentionDays; ContentType = listBlobItem.Properties.ContentType; LastModified = listBlobItem.Properties.LastModified; VersionId = listBlobItem.VersionId; IsLatestVersion = listBlobItem.IsLatestVersion; AccessTier = listBlobItem.Properties.AccessTier is null? null: listBlobItem.Properties.AccessTier.ToString(); if (listBlobItem.Tags != null) { Tags = listBlobItem.Tags.ToHashtable(); TagCount = listBlobItem.Tags.Count; } }
/// <summary> /// get blob content /// </summary> /// <param name="blob">source BlobBaseClient object</param> /// <param name="fileName">destination file path</param> /// <param name="isValidBlob">whether the source container validated</param> /// <returns>the downloaded AzureStorageBlob object</returns> internal void GetBlobContent(BlobBaseClient blob, string fileName, bool isValidBlob = false) { if (null == blob) { throw new ArgumentNullException(typeof(CloudBlob).Name, String.Format(Resources.ObjectCannotBeNull, typeof(CloudBlob).Name)); } if (!isValidBlob) { ValidatePipelineCloudBlobTrack2(blob); } //skip download the snapshot except the CloudBlob pipeline DateTimeOffset?snapshotTime = Util.GetSnapshotTimeFromBlobUri(blob.Uri); if (snapshotTime != null && ParameterSetName != BlobParameterSet) { WriteWarning(String.Format(Resources.SkipDownloadSnapshot, blob.Name, snapshotTime)); return; } string filePath = GetFullReceiveFilePath(fileName, blob.Name, snapshotTime); if (!isValidBlob) { ValidatePipelineCloudBlobTrack2(blob); } //create the destination directory if not exists. String dirPath = Path.GetDirectoryName(filePath); if (!Directory.Exists(dirPath)) { Directory.CreateDirectory(dirPath); } IStorageBlobManagement localChannel = Channel; Func <long, Task> taskGenerator = (taskId) => DownloadBlob(taskId, localChannel, blob, filePath); RunTask(taskGenerator); }
private IReadOnlyDictionary <string, object> CreateBindingData(BlobBaseClient value, BlobProperties blobProperties) { var bindingData = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase); bindingData.Add("BlobTrigger", value.GetBlobPath()); bindingData.Add("Uri", value.Uri); bindingData.Add("Properties", blobProperties); bindingData.Add("Metadata", blobProperties.Metadata); IReadOnlyDictionary <string, object> bindingDataFromPath = _path.CreateBindingData(value.ToBlobPath()); if (bindingDataFromPath != null) { foreach (KeyValuePair <string, object> item in bindingDataFromPath) { // In case of conflict, binding data from the value type overrides the built-in binding data above. bindingData[item.Key] = item.Value; } } return(bindingData); }
/// <inheritdoc/> public async Task <BlobDownloadInfo> DownloadHttpRangeAsync(Uri blobUri, HttpRange httpRange = default) { _ = blobUri ?? throw new ArgumentNullException(nameof(blobUri)); var blobBaseClient = new BlobBaseClient(blobUri, _tokenCredential); // Note: when the httpRange struct is omitted it defaults to 'default' which downloads the entire blob. BlobDownloadInfo blobDownloadInfo; try { blobDownloadInfo = (await blobBaseClient.DownloadAsync(httpRange).ConfigureAwait(false)).Value; } catch (Exception e) { var message = $"Could not download the HTTP range for {blobUri}."; _log.LogError(message, e); throw new Exception(message, e); } return(blobDownloadInfo); }
private void CopyBlobSync(IStorageBlobManagement destChannel, BlobBaseClient srcCloudBlob, BlobBaseClient destCloudBlob) { Track2Models.BlobType srcBlobType = Util.GetBlobType(srcCloudBlob, true).Value; if (srcBlobType != Track2Models.BlobType.Block) { throw new ArgumentException(string.Format("The cmdlet currently only support souce blob and destination blob are both block blob. The source blob type is {0}.", srcBlobType)); } if (srcCloudBlob is BlobClient) { srcCloudBlob = Util.GetTrack2BlobClientWithType(srcCloudBlob, Channel.StorageContext, srcBlobType, ClientOptions); } if (destCloudBlob is BlobClient) { destCloudBlob = Util.GetTrack2BlobClientWithType(destCloudBlob, destChannel.StorageContext, srcBlobType, ClientOptions); } Func <long, Task> taskGenerator = (taskId) => CopyFromUri(taskId, destChannel, srcCloudBlob.GenerateUriWithCredentials(Channel.StorageContext), destCloudBlob); RunTask(taskGenerator); }
public async Task SetImmutibilityPolicyAsync_SetLegalHold_AccoutnSas(AccountSasPermissions sasPermissions) { // Arrange await using DisposingImmutableStorageWithVersioningContainer vlwContainer = await GetTestVersionLevelWormContainer(TestConfigOAuth); BlobBaseClient blob = await GetNewBlobClient(vlwContainer.Container, GetNewBlobName()); BlobServiceClient sharedKeyServiceClient = InstrumentClient( GetServiceClient_OAuthAccount_SharedKey()); Uri serviceSasUri = sharedKeyServiceClient.GenerateAccountSasUri( sasPermissions, Recording.UtcNow.AddDays(1), AccountSasResourceTypes.All); BlobBaseClient sasBlobClient = InstrumentClient(new BlobServiceClient(serviceSasUri, GetOptions()) .GetBlobContainerClient(vlwContainer.Container.Name) .GetBlobBaseClient(blob.Name)); BlobImmutabilityPolicy immutabilityPolicy = new BlobImmutabilityPolicy { ExpiresOn = Recording.UtcNow.AddMinutes(5), PolicyMode = BlobImmutabilityPolicyMode.Unlocked }; // The service rounds Immutability Policy Expiry to the nearest second. DateTimeOffset expectedImmutabilityPolicyExpiry = RoundToNearestSecond(immutabilityPolicy.ExpiresOn.Value); // Act Response <BlobImmutabilityPolicy> response = await sasBlobClient.SetImmutabilityPolicyAsync( immutabilityPolicy : immutabilityPolicy); // Assert Assert.AreEqual(expectedImmutabilityPolicyExpiry, response.Value.ExpiresOn); Assert.AreEqual(immutabilityPolicy.PolicyMode, response.Value.PolicyMode); // Act Response <BlobLegalHoldResult> legalHoldResponse = await sasBlobClient.SetLegalHoldAsync(hasLegalHold : false); // Assert Assert.IsFalse(legalHoldResponse.Value.HasLegalHold); }