github/azure-sdk-for-cpp
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Refactor pipeline building logic, add support for customized application id and API version (#1703)

Browse Source 
* refactor pipeline build code

* Changelog

* fix build error

* fix bug

* fix ut

* changelog
This commit is contained in:
JinmingHu 2021-02-20 09:13:20 +08:00 committed by GitHub
parent b8af41f79a
commit 249327a3fa
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
26 changed files with 470 additions and 847 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
sdk/storage/azure-storage-blobs/CHANGELOG.md
View File

@ -2,6 +2,9 @@
## 12.0.0-beta.9 (Unreleased)
### New Features
- Added support for customized application ID.
## 12.0.0-beta.8 (2021-02-12)

10
sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_options.hpp
View File

@ -155,6 +155,16 @@ namespace Azure { namespace Storage { namespace Blobs {
* @brief Customized HTTP client. We're going to use the default one if this is empty.
*/
Azure::Core::Http::TransportPolicyOptions TransportPolicyOptions;
/**
* @brief The last part of the user agent for telemetry.
*/
std::string ApplicationId;
/**
* API version used by this client.
*/
std::string ApiVersion = Details::ApiVersion;
};
/**

98
sdk/storage/azure-storage-blobs/src/blob_client.cpp
View File

@ -10,7 +10,6 @@
#include <azure/storage/common/reliable_stream.hpp>
#include <azure/storage/common/shared_key_policy.hpp>
#include <azure/storage/common/storage_common.hpp>
#include <azure/storage/common/storage_per_retry_policy.hpp>
#include "azure/storage/blobs/append_blob_client.hpp"
#include "azure/storage/blobs/block_blob_client.hpp"
@ -46,25 +45,16 @@ namespace Azure { namespace Storage { namespace Blobs {
const BlobClientOptions& options)
: BlobClient(blobUrl, options)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(
std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
options));
}
BlobClient::BlobClient(
@ -73,57 +63,35 @@ namespace Azure { namespace Storage { namespace Blobs {
const BlobClientOptions& options)
: BlobClient(blobUrl, options)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(
std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
{
Azure::Core::Http::TokenRequestOptions const tokenOptions
= {{Storage::Details::StorageScope}};
policies.emplace_back(std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
credential, tokenOptions));
}
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
Azure::Core::Http::TokenRequestOptions tokenOptions;
tokenOptions.Scopes.emplace_back(Storage::Details::StorageScope);
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
credential, tokenOptions),
options));
}
BlobClient::BlobClient(const std::string& blobUrl, const BlobClientOptions& options)
: m_blobUrl(blobUrl), m_customerProvidedKey(options.CustomerProvidedKey),
m_encryptionScope(options.EncryptionScope)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(
std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
nullptr,
options));
}
BlockBlobClient BlobClient::AsBlockBlobClient() const { return BlockBlobClient(*this); }

98
sdk/storage/azure-storage-blobs/src/blob_container_client.cpp
View File

@ -7,7 +7,6 @@
#include <azure/storage/common/constants.hpp>
#include <azure/storage/common/shared_key_policy.hpp>
#include <azure/storage/common/storage_common.hpp>
#include <azure/storage/common/storage_per_retry_policy.hpp>
#include "azure/storage/blobs/append_blob_client.hpp"
#include "azure/storage/blobs/block_blob_client.hpp"
@ -42,25 +41,16 @@ namespace Azure { namespace Storage { namespace Blobs {
const BlobClientOptions& options)
: BlobContainerClient(blobContainerUrl, options)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(
std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
options));
}
BlobContainerClient::BlobContainerClient(
@ -69,33 +59,19 @@ namespace Azure { namespace Storage { namespace Blobs {
const BlobClientOptions& options)
: BlobContainerClient(blobContainerUrl, options)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(
std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
{
Azure::Core::Http::TokenRequestOptions const tokenOptions
= {{Storage::Details::StorageScope}};
policies.emplace_back(std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
credential, tokenOptions));
}
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
Azure::Core::Http::TokenRequestOptions tokenOptions;
tokenOptions.Scopes.emplace_back(Storage::Details::StorageScope);
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
credential, tokenOptions),
options));
}
BlobContainerClient::BlobContainerClient(
@ -104,24 +80,16 @@ namespace Azure { namespace Storage { namespace Blobs {
: m_blobContainerUrl(blobContainerUrl), m_customerProvidedKey(options.CustomerProvidedKey),
m_encryptionScope(options.EncryptionScope)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(
std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
nullptr,
options));
}
BlobClient BlobContainerClient::GetBlobClient(const std::string& blobName) const

98
sdk/storage/azure-storage-blobs/src/blob_service_client.cpp
View File

@ -7,7 +7,6 @@
#include <azure/storage/common/constants.hpp>
#include <azure/storage/common/shared_key_policy.hpp>
#include <azure/storage/common/storage_common.hpp>
#include <azure/storage/common/storage_per_retry_policy.hpp>
#include "azure/storage/blobs/version.hpp"
@ -37,25 +36,16 @@ namespace Azure { namespace Storage { namespace Blobs {
const BlobClientOptions& options)
: m_serviceUrl(serviceUrl)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(
std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
options));
}
BlobServiceClient::BlobServiceClient(
@ -64,33 +54,19 @@ namespace Azure { namespace Storage { namespace Blobs {
const BlobClientOptions& options)
: m_serviceUrl(serviceUrl)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(
std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
{
Azure::Core::Http::TokenRequestOptions const tokenOptions
= {{Storage::Details::StorageScope}};
policies.emplace_back(std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
credential, tokenOptions));
}
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
Azure::Core::Http::TokenRequestOptions tokenOptions;
tokenOptions.Scopes.emplace_back(Storage::Details::StorageScope);
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
credential, tokenOptions),
options));
}
BlobServiceClient::BlobServiceClient(
@ -98,24 +74,16 @@ namespace Azure { namespace Storage { namespace Blobs {
const BlobClientOptions& options)
: m_serviceUrl(serviceUrl)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(
std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
nullptr,
options));
}
BlobContainerClient BlobServiceClient::GetBlobContainerClient(

60
sdk/storage/azure-storage-common/inc/azure/storage/common/storage_common.hpp
View File

@ -6,11 +6,17 @@
#include <algorithm>
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include <azure/core/http/policy.hpp>
#include <azure/core/internal/strings.hpp>
#include "azure/storage/common/constants.hpp"
#include "azure/storage/common/storage_per_retry_policy.hpp"
#include "azure/storage/common/storage_retry_policy.hpp"
namespace Azure { namespace Storage {
/**
@ -62,4 +68,58 @@ namespace Azure { namespace Storage {
} // namespace Details
using Metadata = std::map<std::string, std::string, Details::CaseInsensitiveComparator>;
namespace Details {
/*
* Policies order:
* Shared built-in per-operation policies
* Service-specific built-in per-operation policies
* Customer-defined per-operation policies
* Retry policy
* Shared built-in per-retry policies
* Service-specific built-in per-retry policies
* Customer-defined per-retry policies
* Authentication policy
* Transport policy
*/
template <class T>
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> ConstructPolicies(
std::unique_ptr<Azure::Core::Http::HttpPolicy> serviceBuiltinPerOperationPolicy,
std::unique_ptr<Azure::Core::Http::HttpPolicy> authenticationPolicy,
T&& clientOptions)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
{
Azure::Core::Http::Internal::ValuePolicyOptions options;
options.HeaderValues[Details::HttpHeaderXMsVersion] = clientOptions.ApiVersion;
policies.emplace_back(std::make_unique<Azure::Core::Http::Internal::ValuePolicy>(options));
}
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
if (serviceBuiltinPerOperationPolicy)
{
policies.emplace_back(std::move(serviceBuiltinPerOperationPolicy));
}
for (const auto& p : clientOptions.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(
std::forward<T>(clientOptions).RetryOptions));
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
for (const auto& p : clientOptions.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
if (authenticationPolicy)
{
policies.emplace_back(std::move(authenticationPolicy));
}
policies.emplace_back(std::make_unique<Azure::Core::Http::TransportPolicy>(
std::forward<T>(clientOptions).TransportPolicyOptions));
return policies;
}
} // namespace Details
}} // namespace Azure::Storage

7
sdk/storage/azure-storage-files-datalake/CHANGELOG.md
View File

@ -2,6 +2,13 @@
## 12.0.0-beta.9 (Unreleased)
### New Features
- Added support for customized application ID.
### Breaking Changes
- DataLake client constructors won't automatically convert blob url to dfs url anymore.
## 12.0.0-beta.8 (2021-02-12)

8
sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_file_client.hpp
View File

@ -73,7 +73,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
*
* @return The file's primary url endpoint.
*/
std::string GetUrl() const { return m_blockBlobClient.GetUrl(); }
std::string GetUrl() const { return m_blobClient.GetUrl(); }
/**
* @brief Uploads data to be appended to a file. Data can only be appended to a file.
@ -267,15 +267,11 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const Azure::Core::Context& context = Azure::Core::Context()) const;
private:
Blobs::BlockBlobClient m_blockBlobClient;
explicit DataLakeFileClient(
Azure::Core::Http::Url fileUrl,
Blobs::BlobClient blobClient,
Blobs::BlockBlobClient blockBlobClient,
std::shared_ptr<Azure::Core::Internal::Http::HttpPipeline> pipeline)
: DataLakePathClient(std::move(fileUrl), std::move(blobClient), pipeline),
m_blockBlobClient(std::move(blockBlobClient))
: DataLakePathClient(std::move(fileUrl), std::move(blobClient), pipeline)
{
}

10
sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_options.hpp
View File

@ -47,6 +47,16 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
* @brief Customized HTTP client. We're going to use the default one if this is empty.
*/
Azure::Core::Http::TransportPolicyOptions TransportPolicyOptions;
/**
* @brief The last part of the user agent for telemetry.
*/
std::string ApplicationId;
/**
* API version used by this client.
*/
std::string ApiVersion = Details::DefaultServiceApiVersion;
};
/**

5
sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_utilities.hpp
View File

@ -5,8 +5,11 @@
#include <string>
#include <azure/storage/blobs/blob_options.hpp>
#include <azure/storage/common/storage_common.hpp>
#include "azure/storage/files/datalake/datalake_options.hpp"
namespace Azure { namespace Storage { namespace Files { namespace DataLake { namespace Details {
std::string GetBlobUrlFromUrl(const std::string& url);
@ -21,4 +24,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { nam
bool MetadataIncidatesIsDirectory(const Storage::Metadata& metadata);
Blobs::BlobClientOptions GetBlobClientOptions(const DataLakeClientOptions& options);
}}}}} // namespace Azure::Storage::Files::DataLake::Details

85
sdk/storage/azure-storage-files-datalake/src/datalake_directory_client.cpp
View File

@ -8,8 +8,6 @@
#include <azure/storage/common/crypt.hpp>
#include <azure/storage/common/shared_key_policy.hpp>
#include <azure/storage/common/storage_common.hpp>
#include <azure/storage/common/storage_per_retry_policy.hpp>
#include <azure/storage/common/storage_retry_policy.hpp>
#include "azure/storage/files/datalake/datalake_file_client.hpp"
#include "azure/storage/files/datalake/datalake_utilities.hpp"
@ -45,28 +43,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const DataLakeClientOptions& options)
: DataLakePathClient(directoryUrl, credential, options)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
dfsRetryOptions.SecondaryHostForRetryReads
= Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
}
DataLakeDirectoryClient::DataLakeDirectoryClient(
@ -75,35 +51,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const DataLakeClientOptions& options)
: DataLakePathClient(directoryUrl, credential, options)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
dfsRetryOptions.SecondaryHostForRetryReads
= Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
{
Azure::Core::Http::TokenRequestOptions const tokenOptions
= {{Storage::Details::StorageScope}};
policies.emplace_back(std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
credential, tokenOptions));
}
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
}
DataLakeDirectoryClient::DataLakeDirectoryClient(
@ -111,26 +58,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const DataLakeClientOptions& options)
: DataLakePathClient(directoryUrl, options)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
dfsRetryOptions.SecondaryHostForRetryReads
= Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
}
DataLakeFileClient DataLakeDirectoryClient::GetFileClient(const std::string& fileName) const
@ -139,9 +66,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
builder.AppendPath(Storage::Details::UrlEncodePath(fileName));
auto blobClient = m_blobClient;
blobClient.m_blobUrl.AppendPath(Storage::Details::UrlEncodePath(fileName));
auto blockBlobClient = blobClient.AsBlockBlobClient();
return DataLakeFileClient(
std::move(builder), std::move(blobClient), std::move(blockBlobClient), m_pipeline);
return DataLakeFileClient(std::move(builder), std::move(blobClient), m_pipeline);
}
DataLakeDirectoryClient DataLakeDirectoryClient::GetSubdirectoryClient(
@ -192,12 +117,8 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
// Initialize the file client.
auto blobClient = m_blobClient;
blobClient.m_blobUrl.SetPath(destinationDfsUrl.GetPath());
auto blockBlobClient = blobClient.AsBlockBlobClient();
auto renamedFileClient = DataLakeFileClient(
std::move(destinationDfsUrl),
std::move(blobClient),
std::move(blockBlobClient),
m_pipeline);
auto renamedFileClient
= DataLakeFileClient(std::move(destinationDfsUrl), std::move(blobClient), m_pipeline);
return Azure::Core::Response<DataLakeFileClient>(
std::move(renamedFileClient), result.ExtractRawResponse());
}

91
sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp
View File

@ -8,8 +8,6 @@
#include <azure/storage/common/crypt.hpp>
#include <azure/storage/common/shared_key_policy.hpp>
#include <azure/storage/common/storage_common.hpp>
#include <azure/storage/common/storage_per_retry_policy.hpp>
#include <azure/storage/common/storage_retry_policy.hpp>
#include "azure/storage/files/datalake/datalake_constants.hpp"
#include "azure/storage/files/datalake/datalake_utilities.hpp"
@ -106,98 +104,23 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const std::string& fileUrl,
std::shared_ptr<StorageSharedKeyCredential> credential,
const DataLakeClientOptions& options)
: DataLakePathClient(fileUrl, credential, options),
m_blockBlobClient(m_blobClient.AsBlockBlobClient())
: DataLakePathClient(fileUrl, credential, options)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
dfsRetryOptions.SecondaryHostForRetryReads
= Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
}
DataLakeFileClient::DataLakeFileClient(
const std::string& fileUrl,
std::shared_ptr<Core::TokenCredential> credential,
const DataLakeClientOptions& options)
: DataLakePathClient(fileUrl, credential, options),
m_blockBlobClient(m_blobClient.AsBlockBlobClient())
: DataLakePathClient(fileUrl, credential, options)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
dfsRetryOptions.SecondaryHostForRetryReads
= Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
{
Azure::Core::Http::TokenRequestOptions const tokenOptions
= {{Storage::Details::StorageScope}};
policies.emplace_back(std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
credential, tokenOptions));
}
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
}
DataLakeFileClient::DataLakeFileClient(
const std::string& fileUrl,
const DataLakeClientOptions& options)
: DataLakePathClient(fileUrl, options), m_blockBlobClient(m_blobClient.AsBlockBlobClient())
: DataLakePathClient(fileUrl, options)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
dfsRetryOptions.SecondaryHostForRetryReads
= Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
}
Azure::Core::Response<Models::AppendDataLakeFileResult> DataLakeFileClient::Append(
@ -348,7 +271,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
blobOptions.TransferOptions.Concurrency = options.TransferOptions.Concurrency;
blobOptions.HttpHeaders = FromPathHttpHeaders(options.HttpHeaders);
blobOptions.Metadata = options.Metadata;
return m_blockBlobClient.UploadFrom(fileName, blobOptions, context);
return m_blobClient.AsBlockBlobClient().UploadFrom(fileName, blobOptions, context);
}
Azure::Core::Response<Models::UploadDataLakeFileFromResult> DataLakeFileClient::UploadFrom(
@ -364,7 +287,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
blobOptions.TransferOptions.Concurrency = options.TransferOptions.Concurrency;
blobOptions.HttpHeaders = FromPathHttpHeaders(options.HttpHeaders);
blobOptions.Metadata = options.Metadata;
return m_blockBlobClient.UploadFrom(buffer, bufferSize, blobOptions, context);
return m_blobClient.AsBlockBlobClient().UploadFrom(buffer, bufferSize, blobOptions, context);
}
Azure::Core::Response<Models::DownloadDataLakeFileToResult> DataLakeFileClient::DownloadTo(
@ -373,7 +296,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const DownloadDataLakeFileToOptions& options,
const Azure::Core::Context& context) const
{
auto result = m_blockBlobClient.DownloadTo(buffer, bufferSize, options, context);
auto result = m_blobClient.AsBlockBlobClient().DownloadTo(buffer, bufferSize, options, context);
Models::DownloadDataLakeFileToResult ret;
ret.ContentRange = std::move(result->ContentRange);
ret.FileSize = result->BlobSize;
@ -415,7 +338,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const DownloadDataLakeFileToOptions& options,
const Azure::Core::Context& context) const
{
auto result = m_blockBlobClient.DownloadTo(fileName, options, context);
auto result = m_blobClient.AsBlockBlobClient().DownloadTo(fileName, options, context);
Models::DownloadDataLakeFileToResult ret;
ret.ContentRange = std::move(result->ContentRange);
ret.FileSize = result->BlobSize;

157
sdk/storage/azure-storage-files-datalake/src/datalake_file_system_client.cpp
View File

@ -9,8 +9,6 @@
#include <azure/storage/common/crypt.hpp>
#include <azure/storage/common/shared_key_policy.hpp>
#include <azure/storage/common/storage_common.hpp>
#include <azure/storage/common/storage_per_retry_policy.hpp>
#include <azure/storage/common/storage_retry_policy.hpp>
#include "azure/storage/files/datalake/datalake_constants.hpp"
#include "azure/storage/files/datalake/datalake_directory_client.hpp"
@ -20,24 +18,6 @@
#include "azure/storage/files/datalake/version.hpp"
namespace Azure { namespace Storage { namespace Files { namespace DataLake {
namespace {
Blobs::BlobClientOptions GetBlobContainerClientOptions(const DataLakeClientOptions& options)
{
Blobs::BlobClientOptions blobOptions;
for (const auto& p : options.PerOperationPolicies)
{
blobOptions.PerOperationPolicies.emplace_back(p->Clone());
}
for (const auto& p : options.PerRetryPolicies)
{
blobOptions.PerRetryPolicies.emplace_back(p->Clone());
}
blobOptions.RetryOptions = options.RetryOptions;
blobOptions.RetryOptions.SecondaryHostForRetryReads
= Details::GetBlobUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
return blobOptions;
}
} // namespace
DataLakeFileSystemClient DataLakeFileSystemClient::CreateFromConnectionString(
const std::string& connectionString,
@ -63,119 +43,72 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const std::string& fileSystemUrl,
std::shared_ptr<StorageSharedKeyCredential> credential,
const DataLakeClientOptions& options)
: m_fileSystemUrl(Details::GetDfsUrlFromUrl(fileSystemUrl)),
m_blobContainerClient(
Details::GetBlobUrlFromUrl(fileSystemUrl),
credential,
GetBlobContainerClientOptions(options))
: m_fileSystemUrl(fileSystemUrl), m_blobContainerClient(
Details::GetBlobUrlFromUrl(fileSystemUrl),
credential,
Details::GetBlobClientOptions(options))
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
dfsRetryOptions.SecondaryHostForRetryReads
= Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
options));
}
DataLakeFileSystemClient::DataLakeFileSystemClient(
const std::string& fileSystemUrl,
std::shared_ptr<Core::TokenCredential> credential,
const DataLakeClientOptions& options)
: m_fileSystemUrl(Details::GetDfsUrlFromUrl(fileSystemUrl)),
m_blobContainerClient(
Details::GetBlobUrlFromUrl(fileSystemUrl),
credential,
GetBlobContainerClientOptions(options))
: m_fileSystemUrl(fileSystemUrl), m_blobContainerClient(
Details::GetBlobUrlFromUrl(fileSystemUrl),
credential,
Details::GetBlobClientOptions(options))
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
dfsRetryOptions.SecondaryHostForRetryReads
= Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
{
Azure::Core::Http::TokenRequestOptions const tokenOptions
= {{Storage::Details::StorageScope}};
policies.emplace_back(std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
credential, tokenOptions));
}
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
Azure::Core::Http::TokenRequestOptions tokenOptions;
tokenOptions.Scopes.emplace_back(Storage::Details::StorageScope);
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
credential, tokenOptions),
options));
}
DataLakeFileSystemClient::DataLakeFileSystemClient(
const std::string& fileSystemUrl,
const DataLakeClientOptions& options)
: m_fileSystemUrl(Details::GetDfsUrlFromUrl(fileSystemUrl)),
m_blobContainerClient(
Details::GetBlobUrlFromUrl(fileSystemUrl),
GetBlobContainerClientOptions(options))
: m_fileSystemUrl(fileSystemUrl), m_blobContainerClient(
Details::GetBlobUrlFromUrl(fileSystemUrl),
Details::GetBlobClientOptions(options))
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
dfsRetryOptions.SecondaryHostForRetryReads
= Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
nullptr,
options));
}
DataLakeFileClient DataLakeFileSystemClient::GetFileClient(const std::string& fileName) const
{
auto builder = m_fileSystemUrl;
builder.AppendPath(Storage::Details::UrlEncodePath(fileName));
auto blobClient = m_blobContainerClient.GetBlobClient(fileName);
auto blockBlobClient = blobClient.AsBlockBlobClient();
return DataLakeFileClient(
std::move(builder), std::move(blobClient), std::move(blockBlobClient), m_pipeline);
return DataLakeFileClient(std::move(builder), std::move(blobClient), m_pipeline);
}
DataLakeDirectoryClient DataLakeFileSystemClient::GetDirectoryClient(

143
sdk/storage/azure-storage-files-datalake/src/datalake_path_client.cpp
View File

@ -8,32 +8,14 @@
#include <azure/storage/common/crypt.hpp>
#include <azure/storage/common/shared_key_policy.hpp>
#include <azure/storage/common/storage_common.hpp>
#include <azure/storage/common/storage_per_retry_policy.hpp>
#include <azure/storage/common/storage_retry_policy.hpp>
#include "azure/storage/files/datalake/datalake_constants.hpp"
#include "azure/storage/files/datalake/datalake_utilities.hpp"
#include "azure/storage/files/datalake/version.hpp"
namespace Azure { namespace Storage { namespace Files { namespace DataLake {
namespace {
Blobs::BlobClientOptions GetBlobClientOptions(const DataLakeClientOptions& options)
{
Blobs::BlobClientOptions blobOptions;
for (const auto& p : options.PerOperationPolicies)
{
blobOptions.PerOperationPolicies.emplace_back(p->Clone());
}
for (const auto& p : options.PerRetryPolicies)
{
blobOptions.PerRetryPolicies.emplace_back(p->Clone());
}
blobOptions.RetryOptions = options.RetryOptions;
blobOptions.RetryOptions.SecondaryHostForRetryReads
= Details::GetBlobUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
return blobOptions;
}
namespace {
Models::LeaseStateType FromBlobLeaseState(Blobs::Models::BlobLeaseState state)
{
if (state == Blobs::Models::BlobLeaseState::Available)
@ -99,100 +81,63 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const std::string& pathUrl,
std::shared_ptr<StorageSharedKeyCredential> credential,
const DataLakeClientOptions& options)
: m_pathUrl(Details::GetDfsUrlFromUrl(pathUrl)),
m_blobClient(Details::GetBlobUrlFromUrl(pathUrl), credential, GetBlobClientOptions(options))
: m_pathUrl(pathUrl), m_blobClient(
Details::GetBlobUrlFromUrl(pathUrl),
credential,
Details::GetBlobClientOptions(options))
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
dfsRetryOptions.SecondaryHostForRetryReads
= Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
options));
}
DataLakePathClient::DataLakePathClient(
const std::string& pathUrl,
std::shared_ptr<Core::TokenCredential> credential,
const DataLakeClientOptions& options)
: m_pathUrl(Details::GetDfsUrlFromUrl(pathUrl)),
m_blobClient(Details::GetBlobUrlFromUrl(pathUrl), credential, GetBlobClientOptions(options))
: m_pathUrl(pathUrl), m_blobClient(
Details::GetBlobUrlFromUrl(pathUrl),
credential,
Details::GetBlobClientOptions(options))
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
dfsRetryOptions.SecondaryHostForRetryReads
= Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
{
Azure::Core::Http::TokenRequestOptions const tokenOptions
= {{Storage::Details::StorageScope}};
policies.emplace_back(std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
credential, tokenOptions));
}
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
Azure::Core::Http::TokenRequestOptions tokenOptions;
tokenOptions.Scopes.emplace_back(Storage::Details::StorageScope);
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
credential, tokenOptions),
options));
}
DataLakePathClient::DataLakePathClient(
const std::string& pathUrl,
const DataLakeClientOptions& options)
: m_pathUrl(Details::GetDfsUrlFromUrl(pathUrl)),
m_blobClient(Details::GetBlobUrlFromUrl(pathUrl), GetBlobClientOptions(options))
: m_pathUrl(pathUrl),
m_blobClient(Details::GetBlobUrlFromUrl(pathUrl), Details::GetBlobClientOptions(options))
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
dfsRetryOptions.SecondaryHostForRetryReads
= Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
Azure::Core::Http::TransportPolicyOptions transportPolicyOptions;
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
nullptr,
options));
}
Azure::Core::Response<Models::SetDataLakePathAccessControlListResult>

148
sdk/storage/azure-storage-files-datalake/src/datalake_service_client.cpp
View File

@ -9,32 +9,14 @@
#include <azure/storage/common/shared_key_policy.hpp>
#include <azure/storage/common/storage_common.hpp>
#include <azure/storage/common/storage_credential.hpp>
#include <azure/storage/common/storage_per_retry_policy.hpp>
#include <azure/storage/common/storage_retry_policy.hpp>
#include "azure/storage/files/datalake/datalake_file_system_client.hpp"
#include "azure/storage/files/datalake/datalake_utilities.hpp"
#include "azure/storage/files/datalake/version.hpp"
namespace Azure { namespace Storage { namespace Files { namespace DataLake {
namespace {
Blobs::BlobClientOptions GetBlobServiceClientOptions(const DataLakeClientOptions& options)
{
Blobs::BlobClientOptions blobOptions;
for (const auto& p : options.PerOperationPolicies)
{
blobOptions.PerOperationPolicies.emplace_back(p->Clone());
}
for (const auto& p : options.PerRetryPolicies)
{
blobOptions.PerRetryPolicies.emplace_back(p->Clone());
}
blobOptions.RetryOptions = options.RetryOptions;
blobOptions.RetryOptions.SecondaryHostForRetryReads
= Details::GetBlobUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
return blobOptions;
}
namespace {
std::vector<Models::FileSystemItem> FileSystemsFromContainerItems(
std::vector<Blobs::Models::BlobContainerItem> items)
{
@ -100,104 +82,64 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const std::string& serviceUrl,
std::shared_ptr<StorageSharedKeyCredential> credential,
const DataLakeClientOptions& options)
: m_serviceUrl(Details::GetDfsUrlFromUrl(serviceUrl)),
m_blobServiceClient(
Details::GetBlobUrlFromUrl(serviceUrl),
credential,
GetBlobServiceClientOptions(options))
: m_serviceUrl(serviceUrl), m_blobServiceClient(
Details::GetBlobUrlFromUrl(serviceUrl),
credential,
Details::GetBlobClientOptions(options))
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
dfsRetryOptions.SecondaryHostForRetryReads
= Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
options));
}
DataLakeServiceClient::DataLakeServiceClient(
const std::string& serviceUrl,
std::shared_ptr<Core::TokenCredential> credential,
const DataLakeClientOptions& options)
: m_serviceUrl(Details::GetDfsUrlFromUrl(serviceUrl)),
m_blobServiceClient(
Details::GetBlobUrlFromUrl(serviceUrl),
credential,
GetBlobServiceClientOptions(options))
: m_serviceUrl(serviceUrl), m_blobServiceClient(
Details::GetBlobUrlFromUrl(serviceUrl),
credential,
Details::GetBlobClientOptions(options))
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
dfsRetryOptions.SecondaryHostForRetryReads
= Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
{
Azure::Core::Http::TokenRequestOptions const tokenOptions
= {{Storage::Details::StorageScope}};
policies.emplace_back(std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
credential, tokenOptions));
}
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
Azure::Core::Http::TokenRequestOptions tokenOptions;
tokenOptions.Scopes.emplace_back(Storage::Details::StorageScope);
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
std::make_unique<Azure::Core::Http::BearerTokenAuthenticationPolicy>(
credential, tokenOptions),
options));
}
DataLakeServiceClient::DataLakeServiceClient(
const std::string& serviceUrl,
const DataLakeClientOptions& options)
: m_serviceUrl(Details::GetDfsUrlFromUrl(serviceUrl)),
m_blobServiceClient(
Details::GetBlobUrlFromUrl(serviceUrl),
GetBlobServiceClientOptions(options))
: m_serviceUrl(serviceUrl), m_blobServiceClient(
Details::GetBlobUrlFromUrl(serviceUrl),
Details::GetBlobClientOptions(options))
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::DatalakeServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
StorageRetryWithSecondaryOptions dfsRetryOptions = options.RetryOptions;
dfsRetryOptions.SecondaryHostForRetryReads
= Details::GetDfsUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
policies.emplace_back(std::make_unique<Storage::Details::StorageRetryPolicy>(dfsRetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
nullptr,
options));
}
DataLakeFileSystemClient DataLakeServiceClient::GetFileSystemClient(

21
sdk/storage/azure-storage-files-datalake/src/datalake_utilities.cpp
View File

@ -72,4 +72,25 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { nam
auto ite = metadata.find(DataLakeIsDirectoryKey);
return ite != metadata.end() && ite->second == "true";
}
Blobs::BlobClientOptions GetBlobClientOptions(const DataLakeClientOptions& options)
{
Blobs::BlobClientOptions blobOptions;
for (const auto& p : options.PerOperationPolicies)
{
blobOptions.PerOperationPolicies.emplace_back(p->Clone());
}
for (const auto& p : options.PerRetryPolicies)
{
blobOptions.PerRetryPolicies.emplace_back(p->Clone());
}
blobOptions.RetryOptions = options.RetryOptions;
blobOptions.RetryOptions.SecondaryHostForRetryReads
= Details::GetBlobUrlFromUrl(options.RetryOptions.SecondaryHostForRetryReads);
blobOptions.TransportPolicyOptions = options.TransportPolicyOptions;
blobOptions.ApplicationId = options.ApplicationId;
blobOptions.ApiVersion = options.ApiVersion;
return blobOptions;
}
}}}}} // namespace Azure::Storage::Files::DataLake::Details

8
sdk/storage/azure-storage-files-datalake/test/datalake_directory_client_test.cpp
View File

@ -8,6 +8,7 @@
#include <azure/identity/client_secret_credential.hpp>
#include <azure/storage/common/shared_key_policy.hpp>
#include <azure/storage/files/datalake/datalake_utilities.hpp>
namespace Azure { namespace Storage { namespace Test {
@ -614,9 +615,10 @@ namespace Azure { namespace Storage { namespace Test {
AadTenantId(), AadClientId(), AadClientSecret());
auto clientSecretClient = Azure::Storage::Files::DataLake::DataLakeDirectoryClient(
Azure::Storage::Files::DataLake::DataLakeDirectoryClient::CreateFromConnectionString(
AdlsGen2ConnectionString(), m_fileSystemName, RandomString(10))
.GetUrl(),
Azure::Storage::Files::DataLake::Details::GetDfsUrlFromUrl(
Azure::Storage::Files::DataLake::DataLakeDirectoryClient::CreateFromConnectionString(
AdlsGen2ConnectionString(), m_fileSystemName, RandomString(10))
.GetUrl()),
credential);
EXPECT_NO_THROW(clientSecretClient.Create());

8
sdk/storage/azure-storage-files-datalake/test/datalake_file_client_test.cpp
View File

@ -13,6 +13,7 @@
#include <azure/storage/blobs.hpp>
#include <azure/storage/common/file_io.hpp>
#include <azure/storage/common/shared_key_policy.hpp>
#include <azure/storage/files/datalake/datalake_utilities.hpp>
namespace Azure { namespace Storage { namespace Files { namespace DataLake { namespace Models {
@ -563,9 +564,10 @@ namespace Azure { namespace Storage { namespace Test {
AadTenantId(), AadClientId(), AadClientSecret());
auto clientSecretClient = Azure::Storage::Files::DataLake::DataLakeFileClient(
Azure::Storage::Files::DataLake::DataLakeFileClient::CreateFromConnectionString(
AdlsGen2ConnectionString(), m_fileSystemName, RandomString(10))
.GetUrl(),
Azure::Storage::Files::DataLake::Details::GetDfsUrlFromUrl(
Azure::Storage::Files::DataLake::DataLakeFileClient::CreateFromConnectionString(
AdlsGen2ConnectionString(), m_fileSystemName, RandomString(10))
.GetUrl()),
credential);
EXPECT_NO_THROW(clientSecretClient.Create());

8
sdk/storage/azure-storage-files-datalake/test/datalake_path_client_test.cpp
View File

@ -7,6 +7,7 @@
#include <thread>
#include <azure/identity/client_secret_credential.hpp>
#include <azure/storage/files/datalake/datalake_utilities.hpp>
namespace Azure { namespace Storage { namespace Test {
@ -364,9 +365,10 @@ namespace Azure { namespace Storage { namespace Test {
AadTenantId(), AadClientId(), AadClientSecret());
auto clientSecretClient = Azure::Storage::Files::DataLake::DataLakePathClient(
Azure::Storage::Files::DataLake::DataLakePathClient::CreateFromConnectionString(
AdlsGen2ConnectionString(), m_fileSystemName, LowercaseRandomString(10))
.GetUrl(),
Files::DataLake::Details::GetDfsUrlFromUrl(
Azure::Storage::Files::DataLake::DataLakePathClient::CreateFromConnectionString(
AdlsGen2ConnectionString(), m_fileSystemName, LowercaseRandomString(10))
.GetUrl()),
credential);
EXPECT_NO_THROW(clientSecretClient.Create(Files::DataLake::Models::PathResourceType::File));

2
sdk/storage/azure-storage-files-datalake/test/datalake_sas_test.cpp
View File

@ -56,7 +56,7 @@ namespace Azure { namespace Storage { namespace Test {
auto filesystemUrl = Files::DataLake::Details::GetDfsUrlFromUrl(filesystemClient0.GetUrl());
auto directory1Url = Files::DataLake::Details::GetDfsUrlFromUrl(directory1Client0.GetUrl());
auto directory2Url = Files::DataLake::Details::GetDfsUrlFromUrl(directory2Client0.GetUrl());
auto fileUrl = fileClient0.GetUrl();
auto fileUrl = Files::DataLake::Details::GetDfsUrlFromUrl(fileClient0.GetUrl());
auto serviceClient1 = Files::DataLake::DataLakeServiceClient(
serviceUrl,

3
sdk/storage/azure-storage-files-shares/CHANGELOG.md
View File

@ -2,6 +2,9 @@
## 12.0.0-beta.9 (Unreleased)
### New Features
- Added support for customized application ID.
## 12.0.0-beta.8 (2021-02-12)

10
sdk/storage/azure-storage-files-shares/inc/azure/storage/files/shares/share_options.hpp
View File

@ -43,6 +43,16 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
* @brief Customized HTTP client. We're going to use the default one if this is empty.
*/
Azure::Core::Http::TransportPolicyOptions TransportPolicyOptions;
/**
* @brief The last part of the user agent for telemetry.
*/
std::string ApplicationId;
/**
* API version used by this client.
*/
std::string ApiVersion = Details::DefaultServiceApiVersion;
};
struct ListSharesSinglePageOptions

60
sdk/storage/azure-storage-files-shares/src/share_client.cpp
View File

@ -9,8 +9,6 @@
#include <azure/storage/common/crypt.hpp>
#include <azure/storage/common/shared_key_policy.hpp>
#include <azure/storage/common/storage_common.hpp>
#include <azure/storage/common/storage_per_retry_policy.hpp>
#include <azure/storage/common/storage_retry_policy.hpp>
#include "azure/storage/files/shares/share_directory_client.hpp"
#include "azure/storage/files/shares/share_file_client.hpp"
@ -43,49 +41,31 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
const ShareClientOptions& options)
: m_shareUrl(shareUrl)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::FileServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(
std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
options));
}
ShareClient::ShareClient(const std::string& shareUrl, const ShareClientOptions& options)
: m_shareUrl(shareUrl)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::FileServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(
std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
nullptr,
options));
}
ShareDirectoryClient ShareClient::GetRootDirectoryClient() const

59
sdk/storage/azure-storage-files-shares/src/share_directory_client.cpp
View File

@ -9,8 +9,6 @@
#include <azure/storage/common/crypt.hpp>
#include <azure/storage/common/shared_key_policy.hpp>
#include <azure/storage/common/storage_common.hpp>
#include <azure/storage/common/storage_per_retry_policy.hpp>
#include <azure/storage/common/storage_retry_policy.hpp>
#include "azure/storage/files/shares/share_file_client.hpp"
#include "azure/storage/files/shares/version.hpp"
@ -45,25 +43,16 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
const ShareClientOptions& options)
: m_shareDirectoryUrl(shareDirectoryUrl)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::FileServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(
std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
options));
}
ShareDirectoryClient::ShareDirectoryClient(
@ -71,24 +60,16 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
const ShareClientOptions& options)
: m_shareDirectoryUrl(shareDirectoryUrl)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::FileServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(
std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
nullptr,
options));
}
ShareDirectoryClient ShareDirectoryClient::GetSubdirectoryClient(

59
sdk/storage/azure-storage-files-shares/src/share_file_client.cpp
View File

@ -12,8 +12,6 @@
#include <azure/storage/common/reliable_stream.hpp>
#include <azure/storage/common/shared_key_policy.hpp>
#include <azure/storage/common/storage_common.hpp>
#include <azure/storage/common/storage_per_retry_policy.hpp>
#include <azure/storage/common/storage_retry_policy.hpp>
#include "azure/storage/files/shares/share_constants.hpp"
#include "azure/storage/files/shares/version.hpp"
@ -48,26 +46,16 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
const ShareClientOptions& options)
: m_shareFileUrl(shareFileUrl)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::FileServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(
std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
options));
}
ShareFileClient::ShareFileClient(
@ -75,23 +63,16 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
const ShareClientOptions& options)
: m_shareFileUrl(shareFileUrl)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::FileServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
nullptr,
options));
}
ShareFileClient ShareFileClient::WithShareSnapshot(const std::string& shareSnapshot) const

58
sdk/storage/azure-storage-files-shares/src/share_service_client.cpp
View File

@ -9,8 +9,6 @@
#include <azure/storage/common/shared_key_policy.hpp>
#include <azure/storage/common/storage_common.hpp>
#include <azure/storage/common/storage_credential.hpp>
#include <azure/storage/common/storage_per_retry_policy.hpp>
#include <azure/storage/common/storage_retry_policy.hpp>
#include "azure/storage/files/shares/share_client.hpp"
#include "azure/storage/files/shares/version.hpp"
@ -40,25 +38,16 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
const ShareClientOptions& options)
: m_serviceUrl(serviceUrl)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::FileServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(
std::make_unique<Storage::Details::StorageRetryPolicy>(options.RetryOptions));
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Storage::Details::SharedKeyPolicy>(credential));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
std::make_unique<Storage::Details::SharedKeyPolicy>(credential),
options));
}
ShareServiceClient::ShareServiceClient(
@ -66,23 +55,16 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
const ShareClientOptions& options)
: m_serviceUrl(serviceUrl)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::FileServicePackageName, Details::Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
for (const auto& p : options.PerRetryPolicies)
{
policies.emplace_back(p->Clone());
}
policies.emplace_back(std::make_unique<Storage::Details::StoragePerRetryPolicy>());
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(policies);
Azure::Core::Http::TelemetryPolicyOptions telemetryPolicyOptions;
telemetryPolicyOptions.ApplicationId = options.ApplicationId;
m_pipeline = std::make_shared<Azure::Core::Internal::Http::HttpPipeline>(
Storage::Details::ConstructPolicies(
std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::BlobServicePackageName,
Details::Version::VersionString(),
telemetryPolicyOptions),
nullptr,
options));
}
ShareClient ShareServiceClient::GetShareClient(const std::string& shareName) const