public async Task SetPropertiesAsync_StaticWebsite()
{
// Arrange
BlobServiceClient service = GetServiceClient_SharedKey();
BlobServiceProperties properties = await service.GetPropertiesAsync();
BlobStaticWebsite originalBlobStaticWebsite = properties.StaticWebsite;
string errorDocument404Path = "error/404.html";
string defaultIndexDocumentPath = "index.html";
properties.StaticWebsite = new BlobStaticWebsite
{
Enabled = true,
ErrorDocument404Path = errorDocument404Path,
DefaultIndexDocumentPath = defaultIndexDocumentPath
};
// Act
await service.SetPropertiesAsync(properties);
// Assert
properties = await service.GetPropertiesAsync();
Assert.IsTrue(properties.StaticWebsite.Enabled);
Assert.AreEqual(errorDocument404Path, properties.StaticWebsite.ErrorDocument404Path);
Assert.AreEqual(defaultIndexDocumentPath, properties.StaticWebsite.DefaultIndexDocumentPath);
// Cleanup
properties.StaticWebsite = originalBlobStaticWebsite;
await service.SetPropertiesAsync(properties);
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
var blobServiceClient = new BlobServiceClient(_connectionString);
var serviceProperties = await blobServiceClient.GetPropertiesAsync(cancellationToken);
if (!string.IsNullOrEmpty(_containerName))
{
var containerClient = blobServiceClient.GetBlobContainerClient(_containerName);
if (!await containerClient.ExistsAsync(cancellationToken))
{
return(new HealthCheckResult(context.Registration.FailureStatus, description: $"Container '{_containerName}' not exists"));
}
await containerClient.GetPropertiesAsync(cancellationToken : cancellationToken);
}
return(HealthCheckResult.Healthy());
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
public async Task SharedKeyAuthAsync()
{
// Get a Storage account name, shared key, and endpoint Uri.
//
// You can obtain both from the Azure Portal by clicking Access
// Keys under Settings in the Portal Storage account blade.
//
// You can also get access to your account keys from the Azure CLI
// with:
//
// az storage account keys list --account-name <account_name> --resource-group <resource_group>
//
string accountName = StorageAccountName;
string accountKey = StorageAccountKey;
Uri serviceUri = StorageAccountBlobUri;
// Create a SharedKeyCredential that we can use to authenticate
StorageSharedKeyCredential credential = new StorageSharedKeyCredential(accountName, accountKey);
// Create a client that can authenticate with a connection string
BlobServiceClient service = new BlobServiceClient(serviceUri, credential);
// Make a service request to verify we've successfully authenticated
await service.GetPropertiesAsync();
}
public async Task DisableSoftDelete()
{
BlobServiceClient service = GetServiceClient_SharedKey();
Response <BlobServiceProperties> properties = await service.GetPropertiesAsync();
properties.Value.DeleteRetentionPolicy = new BlobRetentionPolicy
{
Enabled = false
};
await service.SetPropertiesAsync(properties);
do
{
await Delay(250);
properties = await service.GetPropertiesAsync();
} while (properties.Value.DeleteRetentionPolicy.Enabled);
}
public async Task EnableSoftDelete()
{
BlobServiceClient service = BlobsClientBuilder.GetServiceClient_SharedKey();
Response <BlobServiceProperties> properties = await service.GetPropertiesAsync();
properties.Value.DeleteRetentionPolicy = new BlobRetentionPolicy()
{
Enabled = true,
Days = 2
};
await service.SetPropertiesAsync(properties);
do
{
await Delay(250);
properties = await service.GetPropertiesAsync();
} while (!properties.Value.DeleteRetentionPolicy.Enabled);
}
public async Task GetPropertiesAsync()
{
// Arrange
BlobServiceClient service = GetServiceClient_SharedKey();
// Act
Response <BlobServiceProperties> response = await service.GetPropertiesAsync();
// Assert
Assert.IsNotNull(response.Value.DeleteRetentionPolicy);
}
/// <summary>
/// Determines whether Azure Blob is ready
/// </summary>
public async Task <Status> IsReadyAsync(CancellationToken cancellationToken)
{
BlobServiceClient blobServiceClient = new BlobServiceClient(_connectionString);
Azure.Response <BlobServiceProperties> serviceProperties =
await blobServiceClient.GetPropertiesAsync(cancellationToken);
return(new Status
{
IsReady = serviceProperties != null,
Message = $"Service version: {serviceProperties.Value.DefaultServiceVersion}."
});
}
public async Task GetPropertiesAsync_Error()
{
// Arrange
BlobServiceClient service = InstrumentClient(
new BlobServiceClient(
GetServiceClient_SharedKey().Uri,
GetOptions()));
// Act
await TestHelper.AssertExpectedExceptionAsync <RequestFailedException>(
service.GetPropertiesAsync(),
e => { });
}
private async Task VerifyServiceAvailable(BlobServiceClient client)
{
try
{
var propertiesResponse = await client.GetPropertiesAsync();
Assert.True(true);
}
catch (Exception e)
{
Assert.False(true, $"Could not establish connection to BlobService. {e}");
}
}
public async Task SharedAccessSignatureAuthAsync()
{
// Create a service level SAS that only allows reading from service
// level APIs
AccountSasBuilder sas = new AccountSasBuilder
{
// Allow access to blobs
Services = new AccountSasServices()
{
Blobs = true
}.ToString(),
// Allow access to the service level APIs
ResourceTypes = new AccountSasResourceTypes()
{
Service = true
}.ToString(),
// Allow read access
Permissions = new AccountSasPermissions()
{
Read = true
}.ToString(),
// Access expires in 1 hour!
ExpiryTime = DateTimeOffset.UtcNow.AddHours(1)
};
// Create a SharedKeyCredential that we can use to sign the SAS token
StorageSharedKeyCredential credential = new StorageSharedKeyCredential(StorageAccountName, StorageAccountKey);
// Build a SAS URI
UriBuilder sasUri = new UriBuilder(StorageAccountBlobUri);
sasUri.Query = sas.ToSasQueryParameters(credential).ToString();
// Create a client that can authenticate with the SAS URI
BlobServiceClient service = new BlobServiceClient(sasUri.Uri);
// Make a service request to verify we've succesfully authenticated
await service.GetPropertiesAsync();
// Try to create a new container (which is beyond our
// delegated permission)
StorageRequestFailedException ex =
Assert.ThrowsAsync <StorageRequestFailedException>(
async() => await service.CreateBlobContainerAsync(Randomize("sample-container")));
Assert.AreEqual(403, ex.Status);
}
private async Task <bool> DoesOAuthWorkAsync()
{
TestContext.Error.WriteLine($"Blob Probing OAuth {Process.GetCurrentProcess().Id}");
try
{
for (int i = 0; i < 10; i++)
{
BlobServiceClient serviceClient = new BlobServiceClient(
new Uri(TestConfigurations.DefaultTargetOAuthTenant.BlobServiceEndpoint),
GetOAuthCredential(TestConfigurations.DefaultTargetOAuthTenant));
await serviceClient.GetPropertiesAsync();
var containerName = Guid.NewGuid().ToString();
var containerClient = serviceClient.GetBlobContainerClient(containerName);
await containerClient.CreateIfNotExistsAsync();
try
{
await containerClient.GetPropertiesAsync();
var blobName = Guid.NewGuid().ToString();
var blobClient = containerClient.GetAppendBlobClient(blobName);
await blobClient.CreateIfNotExistsAsync();
await blobClient.GetPropertiesAsync();
var userDelegationKey = await serviceClient.GetUserDelegationKeyAsync(startsOn : null, expiresOn : DateTimeOffset.UtcNow.AddHours(1));
var sasBuilder = new BlobSasBuilder(BlobSasPermissions.All, DateTimeOffset.UtcNow.AddHours(1))
{
BlobContainerName = containerName,
BlobName = blobName,
};
var sas = sasBuilder.ToSasQueryParameters(userDelegationKey.Value, serviceClient.AccountName).ToString();
await new BlobBaseClient(blobClient.Uri, new AzureSasCredential(sas)).GetPropertiesAsync();
}
finally
{
await containerClient.DeleteIfExistsAsync();
}
}
} catch (RequestFailedException e) when(e.Status == 403 && e.ErrorCode == "AuthorizationPermissionMismatch")
{
TestContext.Error.WriteLine($"Blob Probing OAuth - not ready {Process.GetCurrentProcess().Id}");
return(false);
}
TestContext.Error.WriteLine($"Blob Probing OAuth - ready {Process.GetCurrentProcess().Id}");
return(true);
}
public void AddsTimeoutToQuery()
{
// Arrange
var client = new BlobServiceClient(_endpoint, _credentials, _clientOptions);
// Act
using (StorageExtensions.CreateServiceTimeoutScope(ServerTimeout))
{
Assert.ThrowsAsync <RequestFailedException>(async() => await client.GetPropertiesAsync());
}
// Assert
StringAssert.Contains($"timeout={ServerTimeoutSeconds}", _transport.SingleRequest.Uri.ToString());
}
public async Task SetPropertiesAsync()
{
// Arrange
BlobServiceClient service = GetServiceClient_SharedKey();
BlobServiceProperties properties = await service.GetPropertiesAsync();
BlobCorsRule[] originalCors = properties.Cors.ToArray();
properties.Cors =
new[]
{
new BlobCorsRule
{
MaxAgeInSeconds = 1000,
AllowedHeaders = "x-ms-meta-data*,x-ms-meta-target*,x-ms-meta-abc",
AllowedMethods = "PUT,GET",
AllowedOrigins = "*",
ExposedHeaders = "x-ms-meta-*"
}
};
// Act
await service.SetPropertiesAsync(properties);
// Assert
properties = await service.GetPropertiesAsync();
Assert.AreEqual(1, properties.Cors.Count());
Assert.IsTrue(properties.Cors[0].MaxAgeInSeconds == 1000);
// Cleanup
properties.Cors = originalCors;
await service.SetPropertiesAsync(properties);
properties = await service.GetPropertiesAsync();
Assert.AreEqual(originalCors.Count(), properties.Cors.Count());
}
public async Task SetPropertiesAsync_Error()
{
// Arrange
BlobServiceClient service = GetServiceClient_SharedKey();
BlobServiceProperties properties = (await service.GetPropertiesAsync()).Value;
BlobServiceClient invalidService = InstrumentClient(
new BlobServiceClient(
GetServiceClient_SharedKey().Uri,
GetOptions()));
// Act
await TestHelper.AssertExpectedExceptionAsync <RequestFailedException>(
invalidService.SetPropertiesAsync(properties),
e => { });
}
public void Ctor_With_Sas_Does_Not_Reorder_Services()
{
// Arrange
var uri = new Uri("http://127.0.0.1/accountName?sv=2015-04-05&ss=bqtf&srt=sco&st=2021-03-29T02%3A25%3A53Z&se=2021-06-09T02%3A40%3A53Z&sp=crwdlaup&sig=XXXXX");
var transport = new MockTransport(r => new MockResponse(404));
var clientOptions = new BlobClientOptions()
{
Transport = transport
};
// Act
var client = new BlobServiceClient(uri, clientOptions);
Assert.ThrowsAsync <RequestFailedException>(async() => await client.GetPropertiesAsync());
// Act
StringAssert.Contains("ss=bqtf", transport.SingleRequest.Uri.ToString());
}
public async Task ConnectionStringAsync()
{
// Get a connection string to our Azure Storage account. You can
// obtain your connection string from the Azure Portal (click
// Access Keys under Settings in the Portal Storage account blade)
// or using the Azure CLI with:
//
// az storage account show-connection-string --name <account_name> --resource-group <resource_group>
//
// And you can provide the connection string to your application
// using an environment variable.
string connectionString = ConnectionString;
// Create a client that can authenticate with a connection string
BlobServiceClient service = new BlobServiceClient(connectionString);
// Make a service request to verify we've successfully authenticated
await service.GetPropertiesAsync();
}
public async Task ActiveDirectoryAuthAsync()
{
// Create a token credential that can use our Azure Active
// Directory application to authenticate with Azure Storage
TokenCredential credential =
new ClientSecretCredential(
ActiveDirectoryTenantId,
ActiveDirectoryApplicationId,
ActiveDirectoryApplicationSecret,
new TokenCredentialOptions()
{
AuthorityHost = ActiveDirectoryAuthEndpoint
});
// Create a client that can authenticate using our token credential
BlobServiceClient service = new BlobServiceClient(ActiveDirectoryBlobUri, credential);
// Make a service request to verify we've successfully authenticated
await service.GetPropertiesAsync();
}
public static async Task EnableLoggingAsync(BlobServiceClient blobClient, CancellationToken cancellationToken)
{
BlobServiceProperties serviceProperties = await blobClient.GetPropertiesAsync(cancellationToken).ConfigureAwait(false);
// Merge write onto it.
BlobAnalyticsLogging loggingProperties = serviceProperties.Logging;
if (!loggingProperties.Write)
{
// First activating. Be sure to set a retention policy if there isn't one.
loggingProperties.Write = true;
loggingProperties.RetentionPolicy = new BlobRetentionPolicy()
{
Enabled = true,
Days = 7,
};
// Leave metrics untouched
await blobClient.SetPropertiesAsync(serviceProperties, cancellationToken).ConfigureAwait(false);
}
}
public async Task <string> UploadFile(string containerName, string fileName, IFormFile file, bool overwrite = true)
{
// Create the container if not exists and return a container client object
BlobContainerClient containerClient = new BlobContainerClient(_connectionString, containerName);
BlobServiceClient serviceClient = new BlobServiceClient(_connectionString);
var props = (await serviceClient.GetPropertiesAsync()).Value;
props.DefaultServiceVersion = "2019-07-07";
await serviceClient.SetPropertiesAsync(props);
await containerClient.CreateIfNotExistsAsync(PublicAccessType.Blob);
// Get a reference to a blob
BlobClient blobClient = containerClient.GetBlobClient(fileName);
if (!overwrite)
{
string newFileName;
int count = 1;
while (await blobClient.ExistsAsync())
{
newFileName = $"{Path.GetFileNameWithoutExtension(fileName)}-{count++}{Path.GetExtension(fileName)}";
blobClient = containerClient.GetBlobClient(newFileName);
}
}
// Open the file and upload its data
var headers = new BlobHttpHeaders
{
ContentType = file.ContentType,
ContentDisposition = file.ContentDisposition
};
await using var uploadFileStream = file.OpenReadStream();
await blobClient.UploadAsync(uploadFileStream, headers);
return(blobClient.Uri.AbsoluteUri);
}
private async Task <bool> DoesOAuthWorkAsync()
{
TestContext.Error.WriteLine("Blob Probing OAuth");
try
{
BlobServiceClient serviceClient = new BlobServiceClient(
new Uri(TestConfigurations.DefaultTargetOAuthTenant.BlobServiceEndpoint),
GetOAuthCredential(TestConfigurations.DefaultTargetOAuthTenant));
await serviceClient.GetPropertiesAsync();
var containerName = Guid.NewGuid().ToString();
var containerClient = serviceClient.GetBlobContainerClient(containerName);
await containerClient.CreateIfNotExistsAsync();
try
{
await containerClient.GetPropertiesAsync();
var blobName = Guid.NewGuid().ToString();
var blobClient = containerClient.GetAppendBlobClient(blobName);
await blobClient.CreateIfNotExistsAsync();
await blobClient.GetPropertiesAsync();
}
finally
{
await containerClient.DeleteIfExistsAsync();
}
} catch (RequestFailedException e) when(e.Status == 403 && e.ErrorCode == "AuthorizationPermissionMismatch")
{
TestContext.Error.WriteLine("Blob Probing OAuth - not ready");
return(false);
}
TestContext.Error.WriteLine("Blob Probing OAuth - ready");
return(true);
}
private async Task <bool> DoesOAuthWorkAsync()
{
TestContext.Error.WriteLine($"Datalake Probing OAuth {Process.GetCurrentProcess().Id}");
try
{
for (int i = 0; i < 10; i++)
{
// Check flat account. For some reason we observe failures if that one doesn't work before we start datalake run.
{
BlobServiceClient serviceClient = new BlobServiceClient(
new Uri(TestConfigurations.DefaultTargetOAuthTenant.BlobServiceEndpoint),
GetOAuthCredential(TestConfigurations.DefaultTargetOAuthTenant));
await serviceClient.GetPropertiesAsync();
var containerName = Guid.NewGuid().ToString();
var containerClient = serviceClient.GetBlobContainerClient(containerName);
await containerClient.CreateIfNotExistsAsync();
try
{
await containerClient.GetPropertiesAsync();
var blobName = Guid.NewGuid().ToString();
var blobClient = containerClient.GetAppendBlobClient(blobName);
await blobClient.CreateIfNotExistsAsync();
await blobClient.GetPropertiesAsync();
var userDelegationKey = await serviceClient.GetUserDelegationKeyAsync(startsOn : null, expiresOn : DateTimeOffset.UtcNow.AddHours(1));
var sasBuilder = new BlobSasBuilder(BlobSasPermissions.All, DateTimeOffset.UtcNow.AddHours(1))
{
BlobContainerName = containerName,
BlobName = blobName,
};
var sas = sasBuilder.ToSasQueryParameters(userDelegationKey.Value, serviceClient.AccountName).ToString();
await new BlobBaseClient(blobClient.Uri, new AzureSasCredential(sas)).GetPropertiesAsync();
}
finally
{
await containerClient.DeleteIfExistsAsync();
}
}
// Check hierarchical account.
{
DataLakeServiceClient serviceClient = new DataLakeServiceClient(
new Uri(TestConfigurations.DefaultTargetHierarchicalNamespaceTenant.BlobServiceEndpoint),
GetOAuthCredential(TestConfigurations.DefaultTargetHierarchicalNamespaceTenant));
await serviceClient.GetPropertiesAsync();
var fileSystemName = Guid.NewGuid().ToString();
var fileSystemClient = serviceClient.GetFileSystemClient(fileSystemName);
await fileSystemClient.CreateIfNotExistsAsync();
try
{
var directoryName = Guid.NewGuid().ToString();
var directoryClient = fileSystemClient.GetDirectoryClient(directoryName);
await directoryClient.CreateIfNotExistsAsync();
await directoryClient.GetPropertiesAsync();
var fileName = Guid.NewGuid().ToString();
var fileClient = directoryClient.GetFileClient(fileName);
await fileClient.CreateIfNotExistsAsync();
await fileClient.GetPropertiesAsync();
// call some APIs that talk to DFS endoint as well.
await fileClient.AppendAsync(new MemoryStream(new byte[] { 1 }), 0);
await fileClient.GetAccessControlAsync();
var userDelegationKey = await serviceClient.GetUserDelegationKeyAsync(startsOn : null, expiresOn : DateTimeOffset.UtcNow.AddHours(1));
var sasBuilder = new DataLakeSasBuilder(DataLakeSasPermissions.All, DateTimeOffset.UtcNow.AddHours(1))
{
FileSystemName = fileSystemName,
Path = fileClient.Path,
};
var sas = sasBuilder.ToSasQueryParameters(userDelegationKey.Value, serviceClient.AccountName).ToString();
await new DataLakeFileClient(fileClient.Uri, new AzureSasCredential(sas)).GetPropertiesAsync();
}
finally
{
await fileSystemClient.DeleteIfExistsAsync();
}
}
}
}
catch (RequestFailedException e) when(e.Status == 403 && e.ErrorCode == "AuthorizationPermissionMismatch")
{
TestContext.Error.WriteLine($"Datalake Probing OAuth - not ready {Process.GetCurrentProcess().Id}");
return(false);
}
TestContext.Error.WriteLine($"Datalake Probing OAuth - ready {Process.GetCurrentProcess().Id}");
return(true);
}
private async Task <bool> DoesOAuthWorkAsync()
{
TestContext.Error.WriteLine("Datalake Probing OAuth");
try
{
// Check flat account. For some reason we observe failures if that one doesn't work before we start datalake run.
{
BlobServiceClient serviceClient = new BlobServiceClient(
new Uri(TestConfigurations.DefaultTargetOAuthTenant.BlobServiceEndpoint),
GetOAuthCredential(TestConfigurations.DefaultTargetOAuthTenant));
await serviceClient.GetPropertiesAsync();
var containerName = Guid.NewGuid().ToString();
var containerClient = serviceClient.GetBlobContainerClient(containerName);
await containerClient.CreateIfNotExistsAsync();
try
{
await containerClient.GetPropertiesAsync();
var blobName = Guid.NewGuid().ToString();
var blobClient = containerClient.GetAppendBlobClient(blobName);
await blobClient.CreateIfNotExistsAsync();
await blobClient.GetPropertiesAsync();
}
finally
{
await containerClient.DeleteIfExistsAsync();
}
}
// Check hierarchical account.
{
DataLakeServiceClient serviceClient = new DataLakeServiceClient(
new Uri(TestConfigurations.DefaultTargetHierarchicalNamespaceTenant.BlobServiceEndpoint),
GetOAuthCredential(TestConfigurations.DefaultTargetHierarchicalNamespaceTenant));
await serviceClient.GetPropertiesAsync();
var fileSystemName = Guid.NewGuid().ToString();
var fileSystemClient = serviceClient.GetFileSystemClient(fileSystemName);
await fileSystemClient.CreateIfNotExistsAsync();
try
{
var directoryName = Guid.NewGuid().ToString();
var directoryClient = fileSystemClient.GetDirectoryClient(directoryName);
await directoryClient.CreateIfNotExistsAsync();
await directoryClient.GetPropertiesAsync();
var fileName = Guid.NewGuid().ToString();
var fileClient = directoryClient.GetFileClient(fileName);
await fileClient.CreateIfNotExistsAsync();
await fileClient.GetPropertiesAsync();
// call some APIs that talk to DFS endoint as well.
await fileClient.AppendAsync(new MemoryStream(new byte[] { 1 }), 0);
await fileClient.GetAccessControlAsync();
}
finally
{
await fileSystemClient.DeleteIfExistsAsync();
}
}
}
catch (RequestFailedException e) when(e.Status == 403 && e.ErrorCode == "AuthorizationPermissionMismatch")
{
TestContext.Error.WriteLine("Datalake Probing OAuth - not ready");
return(false);
}
TestContext.Error.WriteLine("Datalake Probing OAuth - ready");
return(true);
}