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

rename uri->url (#997)

Browse Source
This commit is contained in:
JinmingHu 2020-11-20 10:55:10 +08:00 committed by GitHub
parent 980f858676
commit 9fae36a4f7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
42 changed files with 249 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/append_blob_client.hpp
View File

@ -43,7 +43,7 @@ namespace Azure { namespace Storage { namespace Blobs {
/**
* @brief Initialize a new instance of AppendBlobClient.
*
* @param blobUri A uri
* @param blobUrl A url
* referencing the blob that includes the name of the account, the name of the container, and
* the name of the blob.
* @param credential The shared key credential used to sign
@ -52,14 +52,14 @@ namespace Azure { namespace Storage { namespace Blobs {
* policies for authentication, retries, etc., that are applied to every request.
*/
explicit AppendBlobClient(
const std::string& blobUri,
const std::string& blobUrl,
std::shared_ptr<SharedKeyCredential> credential,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initialize a new instance of AppendBlobClient.
*
* @param blobUri A uri
* @param blobUrl A url
* referencing the blob that includes the name of the account, the name of the container, and
* the name of the blob.
* @param credential The client secret credential used to sign requests.
@ -67,14 +67,14 @@ namespace Azure { namespace Storage { namespace Blobs {
* authentication, retries, etc., that are applied to every request.
*/
explicit AppendBlobClient(
const std::string& blobUri,
const std::string& blobUrl,
std::shared_ptr<Identity::ClientSecretCredential> credential,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initialize a new instance of AppendBlobClient.
*
* @param blobUri A uri
* @param blobUrl A url
* referencing the blob that includes the name of the account, the name of the container, and
* the name of the blob, and possibly also a SAS token.
* @param options Optional client
@ -82,11 +82,11 @@ namespace Azure { namespace Storage { namespace Blobs {
* are applied to every request.
*/
explicit AppendBlobClient(
const std::string& blobUri,
const std::string& blobUrl,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initializes a new instance of the AppendBlobClient class with an identical uri
* @brief Initializes a new instance of the AppendBlobClient class with an identical url
* source but the specified snapshot timestamp.
*
* @param snapshot The snapshot

12
sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_batch_client.hpp
View File

@ -101,39 +101,39 @@ namespace Azure { namespace Storage { namespace Blobs {
/**
* @brief Initialize a new instance of BlobBatchClient.
*
* @param serviceUri A uri referencing the blob that includes the name of the account.
* @param serviceUrl A url referencing the blob that includes the name of the account.
* @param credential The shared key credential used to sign requests.
* @param options Optional client options that define the transport pipeline policies for
* authentication, retries, etc., that are applied to every request and subrequest.
*/
explicit BlobBatchClient(
const std::string& serviceUri,
const std::string& serviceUrl,
std::shared_ptr<SharedKeyCredential> credential,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initialize a new instance of BlobBatchClient.
*
* @param serviceUri A uri referencing the blob that includes the name of the account.
* @param serviceUrl A url referencing the blob that includes the name of the account.
* @param credential The token credential used to sign requests.
* @param options Optional client options that define the transport pipeline policies for
* authentication, retries, etc., that are applied to every request and subrequest.
*/
explicit BlobBatchClient(
const std::string& serviceUri,
const std::string& serviceUrl,
std::shared_ptr<Core::TokenCredential> credential,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initialize a new instance of BlobBatchClient.
*
* @param serviceUri A uri referencing the blob that includes the name of the account, and
* @param serviceUrl A url referencing the blob that includes the name of the account, and
* possibly also a SAS token.
* @param options Optional client options that define the transport pipeline policies for
* authentication, retries, etc., that are applied to every request and subrequest.
*/
explicit BlobBatchClient(
const std::string& serviceUri,
const std::string& serviceUrl,
const BlobClientOptions& options = BlobClientOptions());
/**

30
sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_client.hpp
View File

@ -49,46 +49,46 @@ namespace Azure { namespace Storage { namespace Blobs {
/**
* @brief Initialize a new instance of BlobClient.
*
* @param blobUri A uri referencing the blob that includes the name of the account, the name of
* @param blobUrl A url referencing the blob that includes the name of the account, the name of
* the container, and the name of the blob.
* @param credential The shared key credential used to sign requests.
* @param options Optional client options that define the transport pipeline
* policies for authentication, retries, etc., that are applied to every request.
*/
explicit BlobClient(
const std::string& blobUri,
const std::string& blobUrl,
std::shared_ptr<SharedKeyCredential> credential,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initialize a new instance of BlobClient.
*
* @param blobUri A uri referencing the blob that includes the name of the account, the name of
* @param blobUrl A url referencing the blob that includes the name of the account, the name of
* the container, and the name of the blob.
* @param credential The client secret credential used to sign requests.
* @param options Optional client options that define the transport pipeline policies for
* authentication, retries, etc., that are applied to every request.
*/
explicit BlobClient(
const std::string& blobUri,
const std::string& blobUrl,
std::shared_ptr<Identity::ClientSecretCredential> credential,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initialize a new instance of BlobClient.
*
* @param blobUri A uri referencing the blob that includes the name of the account, the name of
* @param blobUrl A url referencing the blob that includes the name of the account, the name of
* the container, and the name of the blob, and possibly also a SAS token.
* @param options Optional client
* options that define the transport pipeline policies for authentication, retries, etc., that
* are applied to every request.
*/
explicit BlobClient(
const std::string& blobUri,
const std::string& blobUrl,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Creates a new BlockBlobClient object with the same uri as this BlobClient. The
* @brief Creates a new BlockBlobClient object with the same url as this BlobClient. The
* new BlockBlobClient uses the same request policy pipeline as this BlobClient.
*
*
@ -97,7 +97,7 @@ namespace Azure { namespace Storage { namespace Blobs {
BlockBlobClient AsBlockBlobClient() const;
/**
* @brief Creates a new AppendBlobClient object with the same uri as this BlobClient.
* @brief Creates a new AppendBlobClient object with the same url as this BlobClient.
* The new AppendBlobClient uses the same request policy pipeline as this BlobClient.
*
* @return A new AppendBlobClient instance.
@ -105,7 +105,7 @@ namespace Azure { namespace Storage { namespace Blobs {
AppendBlobClient AsAppendBlobClient() const;
/**
* @brief Creates a new PageBlobClient object with the same uri as this BlobClient.
* @brief Creates a new PageBlobClient object with the same url as this BlobClient.
* The new PageBlobClient uses the same request policy pipeline as this BlobClient.
*
* @return A new PageBlobClient instance.
@ -113,14 +113,14 @@ namespace Azure { namespace Storage { namespace Blobs {
PageBlobClient AsPageBlobClient() const;
/**
* @brief Gets the blob's primary uri endpoint.
* @brief Gets the blob's primary url endpoint.
*
* @return The blob's primary uri endpoint.
* @return The blob's primary url endpoint.
*/
std::string GetUri() const { return m_blobUrl.GetAbsoluteUrl(); }
std::string GetUrl() const { return m_blobUrl.GetAbsoluteUrl(); }
/**
* @brief Initializes a new instance of the BlobClient class with an identical uri
* @brief Initializes a new instance of the BlobClient class with an identical url
* source but the specified snapshot timestamp.
*
* @param snapshot The snapshot identifier.
@ -371,11 +371,11 @@ namespace Azure { namespace Storage { namespace Blobs {
private:
explicit BlobClient(
Azure::Core::Http::Url blobUri,
Azure::Core::Http::Url blobUrl,
std::shared_ptr<Azure::Core::Http::HttpPipeline> pipeline,
Azure::Core::Nullable<EncryptionKey> customerProvidedKey,
Azure::Core::Nullable<std::string> encryptionScope)
: m_blobUrl(std::move(blobUri)), m_pipeline(std::move(pipeline)),
: m_blobUrl(std::move(blobUrl)), m_pipeline(std::move(pipeline)),
m_customerProvidedKey(std::move(customerProvidedKey)),
m_encryptionScope(std::move(encryptionScope))
{

30
sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_container_client.hpp
View File

@ -39,7 +39,7 @@ namespace Azure { namespace Storage { namespace Blobs {
/**
* @brief Initialize a new instance of BlobContainerClient.
*
* @param containerUri A uri
* @param containerUrl A url
* referencing the blob container that includes the name of the account and the name of the
* container.
* @param credential The shared key credential used to sign
@ -48,14 +48,14 @@ namespace Azure { namespace Storage { namespace Blobs {
* policies for authentication, retries, etc., that are applied to every request.
*/
explicit BlobContainerClient(
const std::string& containerUri,
const std::string& containerUrl,
std::shared_ptr<SharedKeyCredential> credential,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initialize a new instance of BlobContainerClient.
*
* @param containerUri A uri
* @param containerUrl A url
* referencing the blob container that includes the name of the account and the name of the
* container.
* @param credential The client secret credential used to sign requests.
@ -63,14 +63,14 @@ namespace Azure { namespace Storage { namespace Blobs {
* authentication, retries, etc., that are applied to every request.
*/
explicit BlobContainerClient(
const std::string& containerUri,
const std::string& containerUrl,
std::shared_ptr<Identity::ClientSecretCredential> credential,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initialize a new instance of BlobContainerClient.
*
* @param containerUri A uri
* @param containerUrl A url
* referencing the blob that includes the name of the account and the name of the container, and
* possibly also a SAS token.
* @param options Optional client
@ -78,11 +78,11 @@ namespace Azure { namespace Storage { namespace Blobs {
* are applied to every request.
*/
explicit BlobContainerClient(
const std::string& containerUri,
const std::string& containerUrl,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Create a new BlobClient object by appending blobName to the end of uri. The
* @brief Create a new BlobClient object by appending blobName to the end of url. The
* new BlobClient uses the same request policy pipeline as this BlobContainerClient.
*
* @param blobName The name of the blob.
@ -91,7 +91,7 @@ namespace Azure { namespace Storage { namespace Blobs {
BlobClient GetBlobClient(const std::string& blobName) const;
/**
* @brief Create a new BlockBlobClient object by appending blobName to the end of uri.
* @brief Create a new BlockBlobClient object by appending blobName to the end of url.
* The new BlockBlobClient uses the same request policy pipeline as this BlobContainerClient.
*
* @param blobName The name of the blob.
@ -100,7 +100,7 @@ namespace Azure { namespace Storage { namespace Blobs {
BlockBlobClient GetBlockBlobClient(const std::string& blobName) const;
/**
* @brief Create a new AppendBlobClient object by appending blobName to the end of uri.
* @brief Create a new AppendBlobClient object by appending blobName to the end of url.
* The new AppendBlobClient uses the same request policy pipeline as this BlobContainerClient.
*
* @param blobName The name of the blob.
@ -109,7 +109,7 @@ namespace Azure { namespace Storage { namespace Blobs {
AppendBlobClient GetAppendBlobClient(const std::string& blobName) const;
/**
* @brief Create a new PageBlobClient object by appending blobName to the end of uri.
* @brief Create a new PageBlobClient object by appending blobName to the end of url.
* The new PageBlobClient uses the same request policy pipeline as this BlobContainerClient.
*
* @param blobName The name of the blob.
@ -118,12 +118,12 @@ namespace Azure { namespace Storage { namespace Blobs {
PageBlobClient GetPageBlobClient(const std::string& blobName) const;
/**
* @brief Gets the container's primary uri endpoint.
* @brief Gets the container's primary url endpoint.
*
* @return The
* container's primary uri endpoint.
* container's primary url endpoint.
*/
std::string GetUri() const { return m_containerUrl.GetAbsoluteUrl(); }
std::string GetUrl() const { return m_containerUrl.GetAbsoluteUrl(); }
/**
* @brief Creates a new container under the specified account. If the container with the
@ -312,11 +312,11 @@ namespace Azure { namespace Storage { namespace Blobs {
private:
explicit BlobContainerClient(
Azure::Core::Http::Url containerUri,
Azure::Core::Http::Url containerUrl,
std::shared_ptr<Azure::Core::Http::HttpPipeline> pipeline,
Azure::Core::Nullable<EncryptionKey> customerProvidedKey,
Azure::Core::Nullable<std::string> encryptionScope)
: m_containerUrl(std::move(containerUri)), m_pipeline(std::move(pipeline)),
: m_containerUrl(std::move(containerUrl)), m_pipeline(std::move(pipeline)),
m_customerProvidedKey(std::move(customerProvidedKey)),
m_encryptionScope(std::move(encryptionScope))
{

20
sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_service_client.hpp
View File

@ -36,43 +36,43 @@ namespace Azure { namespace Storage { namespace Blobs {
/**
* @brief Initialize a new instance of BlobServiceClient.
*
* @param serviceUri A uri referencing the blob that includes the name of the account.
* @param serviceUrl A url referencing the blob that includes the name of the account.
* @param credential The shared key credential used to sign requests.
* @param options Optional client options that define the transport pipeline policies for
* authentication, retries, etc., that are applied to every request.
*/
explicit BlobServiceClient(
const std::string& serviceUri,
const std::string& serviceUrl,
std::shared_ptr<SharedKeyCredential> credential,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initialize a new instance of BlobServiceClient.
*
* @param serviceUri A uri referencing the blob that includes the name of the account.
* @param serviceUrl A url referencing the blob that includes the name of the account.
* @param credential The client secret credential used to sign requests.
* @param options Optional client options that define the transport pipeline policies for
* authentication, retries, etc., that are applied to every request.
*/
explicit BlobServiceClient(
const std::string& serviceUri,
const std::string& serviceUrl,
std::shared_ptr<Identity::ClientSecretCredential> credential,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initialize a new instance of BlobServiceClient.
*
* @param serviceUri A uri referencing the blob that includes the name of the account, and
* @param serviceUrl A url referencing the blob that includes the name of the account, and
* possibly also a SAS token.
* @param options Optional client options that define the transport pipeline policies for
* authentication, retries, etc., that are applied to every request.
*/
explicit BlobServiceClient(
const std::string& serviceUri,
const std::string& serviceUrl,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Creates a new BlobContainerClient object with the same uri as this BlobServiceClient.
* @brief Creates a new BlobContainerClient object with the same url as this BlobServiceClient.
* The new BlobContainerClient uses the same request policy pipeline as this BlobServiceClient.
*
* @return A new BlobContainerClient instance.
@ -80,11 +80,11 @@ namespace Azure { namespace Storage { namespace Blobs {
BlobContainerClient GetBlobContainerClient(const std::string& containerName) const;
/**
* @brief Gets the blob service's primary uri endpoint.
* @brief Gets the blob service's primary url endpoint.
*
* @return the blob service's primary uri endpoint.
* @return the blob service's primary url endpoint.
*/
std::string GetUri() const { return m_serviceUrl.GetAbsoluteUrl(); }
std::string GetUrl() const { return m_serviceUrl.GetAbsoluteUrl(); }
/**
* @brief Returns a single segment of blob containers in the storage account, starting

14
sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/block_blob_client.hpp
View File

@ -53,7 +53,7 @@ namespace Azure { namespace Storage { namespace Blobs {
/**
* @brief Initialize a new instance of BlockBlobClient.
*
* @param blobUri A uri
* @param blobUrl A url
* referencing the blob that includes the name of the account, the name of the container, and
* the name of the blob.
* @param credential The shared key credential used to sign
@ -62,14 +62,14 @@ namespace Azure { namespace Storage { namespace Blobs {
* policies for authentication, retries, etc., that are applied to every request.
*/
explicit BlockBlobClient(
const std::string& blobUri,
const std::string& blobUrl,
std::shared_ptr<SharedKeyCredential> credential,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initialize a new instance of BlockBlobClient.
*
* @param blobUri A uri
* @param blobUrl A url
* referencing the blob that includes the name of the account, the name of the container, and
* the name of the blob.
* @param credential The client secret credential used to sign requests.
@ -77,14 +77,14 @@ namespace Azure { namespace Storage { namespace Blobs {
* authentication, retries, etc., that are applied to every request.
*/
explicit BlockBlobClient(
const std::string& blobUri,
const std::string& blobUrl,
std::shared_ptr<Identity::ClientSecretCredential> credential,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initialize a new instance of BlockBlobClient.
*
* @param blobUri A uri
* @param blobUrl A url
* referencing the blob that includes the name of the account, the name of the container, and
* the name of the blob, and possibly also a SAS token.
* @param options Optional client
@ -92,11 +92,11 @@ namespace Azure { namespace Storage { namespace Blobs {
* are applied to every request.
*/
explicit BlockBlobClient(
const std::string& blobUri,
const std::string& blobUrl,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initializes a new instance of the BlockBlobClient class with an identical uri
* @brief Initializes a new instance of the BlockBlobClient class with an identical url
* source but the specified snapshot timestamp.
*
* @param snapshot The snapshot

14
sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/page_blob_client.hpp
View File

@ -45,7 +45,7 @@ namespace Azure { namespace Storage { namespace Blobs {
/**
* @brief Initialize a new instance of PageBlobClient.
*
* @param blobUri A uri
* @param blobUrl A url
* referencing the blob that includes the name of the account, the name of the container, and
* the name of the blob.
* @param credential The shared key credential used to sign
@ -54,14 +54,14 @@ namespace Azure { namespace Storage { namespace Blobs {
* policies for authentication, retries, etc., that are applied to every request.
*/
explicit PageBlobClient(
const std::string& blobUri,
const std::string& blobUrl,
std::shared_ptr<SharedKeyCredential> credential,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initialize a new instance of PageBlobClient.
*
* @param blobUri A uri
* @param blobUrl A url
* referencing the blob that includes the name of the account, the name of the container, and
* the name of the blob.
* @param credential The client secret credential used to sign requests.
@ -69,14 +69,14 @@ namespace Azure { namespace Storage { namespace Blobs {
* authentication, retries, etc., that are applied to every request.
*/
explicit PageBlobClient(
const std::string& blobUri,
const std::string& blobUrl,
std::shared_ptr<Identity::ClientSecretCredential> credential,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initialize a new instance of PageBlobClient.
*
* @param blobUri A uri
* @param blobUrl A url
* referencing the blob that includes the name of the account, the name of the container, and
* the name of the blob, and possibly also a SAS token.
* @param options Optional client
@ -84,11 +84,11 @@ namespace Azure { namespace Storage { namespace Blobs {
* are applied to every request.
*/
explicit PageBlobClient(
const std::string& blobUri,
const std::string& blobUrl,
const BlobClientOptions& options = BlobClientOptions());
/**
* @brief Initializes a new instance of the PageBlobClient class with an identical uri
* @brief Initializes a new instance of the PageBlobClient class with an identical url
* source but the specified snapshot timestamp.
*
* @param snapshot The snapshot

12
sdk/storage/azure-storage-blobs/src/append_blob_client.cpp
View File

@ -20,23 +20,23 @@ namespace Azure { namespace Storage { namespace Blobs {
}
AppendBlobClient::AppendBlobClient(
const std::string& blobUri,
const std::string& blobUrl,
std::shared_ptr<SharedKeyCredential> credential,
const BlobClientOptions& options)
: BlobClient(blobUri, std::move(credential), options)
: BlobClient(blobUrl, std::move(credential), options)
{
}
AppendBlobClient::AppendBlobClient(
const std::string& blobUri,
const std::string& blobUrl,
std::shared_ptr<Identity::ClientSecretCredential> credential,
const BlobClientOptions& options)
: BlobClient(blobUri, std::move(credential), options)
: BlobClient(blobUrl, std::move(credential), options)
{
}
AppendBlobClient::AppendBlobClient(const std::string& blobUri, const BlobClientOptions& options)
: BlobClient(blobUri, options)
AppendBlobClient::AppendBlobClient(const std::string& blobUrl, const BlobClientOptions& options)
: BlobClient(blobUrl, options)
{
}

18
sdk/storage/azure-storage-blobs/src/blob_batch_client.cpp
View File

@ -70,24 +70,24 @@ namespace Azure { namespace Storage { namespace Blobs {
const BlobClientOptions& options)
{
auto parsedConnectionString = Storage::Details::ParseConnectionString(connectionString);
auto serviceUri = std::move(parsedConnectionString.BlobServiceUri);
auto serviceUrl = std::move(parsedConnectionString.BlobServiceUrl);
if (parsedConnectionString.KeyCredential)
{
return BlobBatchClient(
serviceUri.GetAbsoluteUrl(), parsedConnectionString.KeyCredential, options);
serviceUrl.GetAbsoluteUrl(), parsedConnectionString.KeyCredential, options);
}
else
{
return BlobBatchClient(serviceUri.GetAbsoluteUrl(), options);
return BlobBatchClient(serviceUrl.GetAbsoluteUrl(), options);
}
}
BlobBatchClient::BlobBatchClient(
const std::string& serviceUri,
const std::string& serviceUrl,
std::shared_ptr<SharedKeyCredential> credential,
const BlobClientOptions& options)
: m_serviceUrl(serviceUri)
: m_serviceUrl(serviceUrl)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
@ -125,10 +125,10 @@ namespace Azure { namespace Storage { namespace Blobs {
}
BlobBatchClient::BlobBatchClient(
const std::string& serviceUri,
const std::string& serviceUrl,
std::shared_ptr<Core::TokenCredential> credential,
const BlobClientOptions& options)
: m_serviceUrl(serviceUri)
: m_serviceUrl(serviceUrl)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
@ -167,8 +167,8 @@ namespace Azure { namespace Storage { namespace Blobs {
m_subRequestPipeline = std::make_shared<Azure::Core::Http::HttpPipeline>(policies);
}
BlobBatchClient::BlobBatchClient(const std::string& serviceUri, const BlobClientOptions& options)
: m_serviceUrl(serviceUri)
BlobBatchClient::BlobBatchClient(const std::string& serviceUrl, 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>(

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

@ -26,25 +26,25 @@ namespace Azure { namespace Storage { namespace Blobs {
const BlobClientOptions& options)
{
auto parsedConnectionString = Storage::Details::ParseConnectionString(connectionString);
auto blobUri = std::move(parsedConnectionString.BlobServiceUri);
blobUri.AppendPath(Storage::Details::UrlEncodePath(containerName));
blobUri.AppendPath(Storage::Details::UrlEncodePath(blobName));
auto blobUrl = std::move(parsedConnectionString.BlobServiceUrl);
blobUrl.AppendPath(Storage::Details::UrlEncodePath(containerName));
blobUrl.AppendPath(Storage::Details::UrlEncodePath(blobName));
if (parsedConnectionString.KeyCredential)
{
return BlobClient(blobUri.GetAbsoluteUrl(), parsedConnectionString.KeyCredential, options);
return BlobClient(blobUrl.GetAbsoluteUrl(), parsedConnectionString.KeyCredential, options);
}
else
{
return BlobClient(blobUri.GetAbsoluteUrl(), options);
return BlobClient(blobUrl.GetAbsoluteUrl(), options);
}
}
BlobClient::BlobClient(
const std::string& blobUri,
const std::string& blobUrl,
std::shared_ptr<SharedKeyCredential> credential,
const BlobClientOptions& options)
: BlobClient(blobUri, options)
: BlobClient(blobUrl, options)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
@ -67,10 +67,10 @@ namespace Azure { namespace Storage { namespace Blobs {
}
BlobClient::BlobClient(
const std::string& blobUri,
const std::string& blobUrl,
std::shared_ptr<Identity::ClientSecretCredential> credential,
const BlobClientOptions& options)
: BlobClient(blobUri, options)
: BlobClient(blobUrl, options)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
@ -93,8 +93,8 @@ namespace Azure { namespace Storage { namespace Blobs {
m_pipeline = std::make_shared<Azure::Core::Http::HttpPipeline>(policies);
}
BlobClient::BlobClient(const std::string& blobUri, const BlobClientOptions& options)
: m_blobUrl(blobUri), m_customerProvidedKey(options.CustomerProvidedKey),
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;

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

@ -22,25 +22,25 @@ namespace Azure { namespace Storage { namespace Blobs {
const BlobClientOptions& options)
{
auto parsedConnectionString = Storage::Details::ParseConnectionString(connectionString);
auto containerUri = std::move(parsedConnectionString.BlobServiceUri);
containerUri.AppendPath(Storage::Details::UrlEncodePath(containerName));
auto containerUrl = std::move(parsedConnectionString.BlobServiceUrl);
containerUrl.AppendPath(Storage::Details::UrlEncodePath(containerName));
if (parsedConnectionString.KeyCredential)
{
return BlobContainerClient(
containerUri.GetAbsoluteUrl(), parsedConnectionString.KeyCredential, options);
containerUrl.GetAbsoluteUrl(), parsedConnectionString.KeyCredential, options);
}
else
{
return BlobContainerClient(containerUri.GetAbsoluteUrl(), options);
return BlobContainerClient(containerUrl.GetAbsoluteUrl(), options);
}
}
BlobContainerClient::BlobContainerClient(
const std::string& containerUri,
const std::string& containerUrl,
std::shared_ptr<SharedKeyCredential> credential,
const BlobClientOptions& options)
: BlobContainerClient(containerUri, options)
: BlobContainerClient(containerUrl, options)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
@ -63,10 +63,10 @@ namespace Azure { namespace Storage { namespace Blobs {
}
BlobContainerClient::BlobContainerClient(
const std::string& containerUri,
const std::string& containerUrl,
std::shared_ptr<Identity::ClientSecretCredential> credential,
const BlobClientOptions& options)
: BlobContainerClient(containerUri, options)
: BlobContainerClient(containerUrl, options)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
@ -90,9 +90,9 @@ namespace Azure { namespace Storage { namespace Blobs {
}
BlobContainerClient::BlobContainerClient(
const std::string& containerUri,
const std::string& containerUrl,
const BlobClientOptions& options)
: m_containerUrl(containerUri), m_customerProvidedKey(options.CustomerProvidedKey),
: m_containerUrl(containerUrl), m_customerProvidedKey(options.CustomerProvidedKey),
m_encryptionScope(options.EncryptionScope)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
@ -116,9 +116,9 @@ namespace Azure { namespace Storage { namespace Blobs {
BlobClient BlobContainerClient::GetBlobClient(const std::string& blobName) const
{
auto blobUri = m_containerUrl;
blobUri.AppendPath(Storage::Details::UrlEncodePath(blobName));
return BlobClient(std::move(blobUri), m_pipeline, m_customerProvidedKey, m_encryptionScope);
auto blobUrl = m_containerUrl;
blobUrl.AppendPath(Storage::Details::UrlEncodePath(blobName));
return BlobClient(std::move(blobUrl), m_pipeline, m_customerProvidedKey, m_encryptionScope);
}
BlockBlobClient BlobContainerClient::GetBlockBlobClient(const std::string& blobName) const

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

@ -18,24 +18,24 @@ namespace Azure { namespace Storage { namespace Blobs {
const BlobClientOptions& options)
{
auto parsedConnectionString = Storage::Details::ParseConnectionString(connectionString);
auto serviceUri = std::move(parsedConnectionString.BlobServiceUri);
auto serviceUrl = std::move(parsedConnectionString.BlobServiceUrl);
if (parsedConnectionString.KeyCredential)
{
return BlobServiceClient(
serviceUri.GetAbsoluteUrl(), parsedConnectionString.KeyCredential, options);
serviceUrl.GetAbsoluteUrl(), parsedConnectionString.KeyCredential, options);
}
else
{
return BlobServiceClient(serviceUri.GetAbsoluteUrl(), options);
return BlobServiceClient(serviceUrl.GetAbsoluteUrl(), options);
}
}
BlobServiceClient::BlobServiceClient(
const std::string& serviceUri,
const std::string& serviceUrl,
std::shared_ptr<SharedKeyCredential> credential,
const BlobClientOptions& options)
: m_serviceUrl(serviceUri)
: m_serviceUrl(serviceUrl)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
@ -58,10 +58,10 @@ namespace Azure { namespace Storage { namespace Blobs {
}
BlobServiceClient::BlobServiceClient(
const std::string& serviceUri,
const std::string& serviceUrl,
std::shared_ptr<Identity::ClientSecretCredential> credential,
const BlobClientOptions& options)
: m_serviceUrl(serviceUri)
: m_serviceUrl(serviceUrl)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
@ -85,9 +85,9 @@ namespace Azure { namespace Storage { namespace Blobs {
}
BlobServiceClient::BlobServiceClient(
const std::string& serviceUri,
const std::string& serviceUrl,
const BlobClientOptions& options)
: m_serviceUrl(serviceUri)
: m_serviceUrl(serviceUrl)
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
@ -111,10 +111,10 @@ namespace Azure { namespace Storage { namespace Blobs {
BlobContainerClient BlobServiceClient::GetBlobContainerClient(
const std::string& containerName) const
{
auto containerUri = m_serviceUrl;
containerUri.AppendPath(Storage::Details::UrlEncodePath(containerName));
auto containerUrl = m_serviceUrl;
containerUrl.AppendPath(Storage::Details::UrlEncodePath(containerName));
return BlobContainerClient(
std::move(containerUri), m_pipeline, m_customerProvidedKey, m_encryptionScope);
std::move(containerUrl), m_pipeline, m_customerProvidedKey, m_encryptionScope);
}
Azure::Core::Response<Models::ListContainersSegmentResult>

12
sdk/storage/azure-storage-blobs/src/block_blob_client.cpp
View File

@ -23,23 +23,23 @@ namespace Azure { namespace Storage { namespace Blobs {
}
BlockBlobClient::BlockBlobClient(
const std::string& blobUri,
const std::string& blobUrl,
std::shared_ptr<SharedKeyCredential> credential,
const BlobClientOptions& options)
: BlobClient(blobUri, std::move(credential), options)
: BlobClient(blobUrl, std::move(credential), options)
{
}
BlockBlobClient::BlockBlobClient(
const std::string& blobUri,
const std::string& blobUrl,
std::shared_ptr<Identity::ClientSecretCredential> credential,
const BlobClientOptions& options)
: BlobClient(blobUri, std::move(credential), options)
: BlobClient(blobUrl, std::move(credential), options)
{
}
BlockBlobClient::BlockBlobClient(const std::string& blobUri, const BlobClientOptions& options)
: BlobClient(blobUri, options)
BlockBlobClient::BlockBlobClient(const std::string& blobUrl, const BlobClientOptions& options)
: BlobClient(blobUrl, options)
{
}

12
sdk/storage/azure-storage-blobs/src/page_blob_client.cpp
View File

@ -22,23 +22,23 @@ namespace Azure { namespace Storage { namespace Blobs {
}
PageBlobClient::PageBlobClient(
const std::string& blobUri,
const std::string& blobUrl,
std::shared_ptr<SharedKeyCredential> credential,
const BlobClientOptions& options)
: BlobClient(blobUri, std::move(credential), options)
: BlobClient(blobUrl, std::move(credential), options)
{
}
PageBlobClient::PageBlobClient(
const std::string& blobUri,
const std::string& blobUrl,
std::shared_ptr<Identity::ClientSecretCredential> credential,
const BlobClientOptions& options)
: BlobClient(blobUri, std::move(credential), options)
: BlobClient(blobUrl, std::move(credential), options)
{
}
PageBlobClient::PageBlobClient(const std::string& blobUri, const BlobClientOptions& options)
: BlobClient(blobUri, options)
PageBlobClient::PageBlobClient(const std::string& blobUrl, const BlobClientOptions& options)
: BlobClient(blobUrl, options)
{
}

26
sdk/storage/azure-storage-blobs/test/append_blob_client_test.cpp
View File

@ -81,7 +81,7 @@ namespace Azure { namespace Storage { namespace Test {
properties = *appendBlobClient.GetProperties();
int64_t originalLength = properties.ContentLength;
appendBlobClient.AppendBlockFromUri(m_appendBlobClient->GetUri() + GetSas());
appendBlobClient.AppendBlockFromUri(m_appendBlobClient->GetUrl() + GetSas());
properties = *appendBlobClient.GetProperties();
EXPECT_EQ(
properties.ContentLength, static_cast<int64_t>(originalLength + m_blobContent.size()));
@ -215,43 +215,43 @@ namespace Azure { namespace Storage { namespace Test {
/*
don't know why, the copy operation also succeeds even if the lease id doesn't match.
EXPECT_THROW(
destBlobClient.StartCopyFromUri(sourceBlobClient.GetUri(), options), StorageException);
destBlobClient.StartCopyFromUri(sourceBlobClient.GetUrl(), options), StorageException);
*/
options.SourceConditions.LeaseId = leaseId;
EXPECT_NO_THROW(destBlobClient.StartCopyFromUri(sourceBlobClient.GetUri(), options));
EXPECT_NO_THROW(destBlobClient.StartCopyFromUri(sourceBlobClient.GetUrl(), options));
}
sourceBlobClient.BreakLease();
{
Blobs::StartCopyBlobFromUriOptions options;
options.SourceConditions.IfMatch = eTag;
EXPECT_NO_THROW(destBlobClient.StartCopyFromUri(sourceBlobClient.GetUri(), options));
EXPECT_NO_THROW(destBlobClient.StartCopyFromUri(sourceBlobClient.GetUrl(), options));
options.SourceConditions.IfMatch = c_dummyETag;
EXPECT_THROW(
destBlobClient.StartCopyFromUri(sourceBlobClient.GetUri(), options), StorageException);
destBlobClient.StartCopyFromUri(sourceBlobClient.GetUrl(), options), StorageException);
}
{
Blobs::StartCopyBlobFromUriOptions options;
options.SourceConditions.IfNoneMatch = c_dummyETag;
EXPECT_NO_THROW(destBlobClient.StartCopyFromUri(sourceBlobClient.GetUri(), options));
EXPECT_NO_THROW(destBlobClient.StartCopyFromUri(sourceBlobClient.GetUrl(), options));
options.SourceConditions.IfNoneMatch = eTag;
EXPECT_THROW(
destBlobClient.StartCopyFromUri(sourceBlobClient.GetUri(), options), StorageException);
destBlobClient.StartCopyFromUri(sourceBlobClient.GetUrl(), options), StorageException);
}
{
Blobs::StartCopyBlobFromUriOptions options;
options.SourceConditions.IfModifiedSince = timeBeforeStr;
EXPECT_NO_THROW(destBlobClient.StartCopyFromUri(sourceBlobClient.GetUri(), options));
EXPECT_NO_THROW(destBlobClient.StartCopyFromUri(sourceBlobClient.GetUrl(), options));
options.SourceConditions.IfModifiedSince = timeAfterStr;
EXPECT_THROW(
destBlobClient.StartCopyFromUri(sourceBlobClient.GetUri(), options), StorageException);
destBlobClient.StartCopyFromUri(sourceBlobClient.GetUrl(), options), StorageException);
}
{
Blobs::StartCopyBlobFromUriOptions options;
options.SourceConditions.IfUnmodifiedSince = timeAfterStr;
EXPECT_NO_THROW(destBlobClient.StartCopyFromUri(sourceBlobClient.GetUri(), options));
EXPECT_NO_THROW(destBlobClient.StartCopyFromUri(sourceBlobClient.GetUrl(), options));
options.SourceConditions.IfUnmodifiedSince = timeBeforeStr;
EXPECT_THROW(
destBlobClient.StartCopyFromUri(sourceBlobClient.GetUri(), options), StorageException);
destBlobClient.StartCopyFromUri(sourceBlobClient.GetUrl(), options), StorageException);
}
}
@ -314,7 +314,7 @@ namespace Azure { namespace Storage { namespace Test {
Blobs::StartCopyBlobFromUriOptions copyOptions;
copyOptions.ShouldSealDestination = false;
auto copyResult = blobClient2.StartCopyFromUri(blobClient.GetUri() + GetSas(), copyOptions);
auto copyResult = blobClient2.StartCopyFromUri(blobClient.GetUrl() + GetSas(), copyOptions);
// TODO: poller wait here
getPropertiesResult = blobClient2.GetProperties();
if (getPropertiesResult->IsSealed.HasValue())
@ -323,7 +323,7 @@ namespace Azure { namespace Storage { namespace Test {
}
copyOptions.ShouldSealDestination = true;
copyResult = blobClient2.StartCopyFromUri(blobClient.GetUri() + GetSas(), copyOptions);
copyResult = blobClient2.StartCopyFromUri(blobClient.GetUrl() + GetSas(), copyOptions);
// TODO: poller wait here
getPropertiesResult = blobClient2.GetProperties();
EXPECT_TRUE(getPropertiesResult->IsSealed.HasValue());

4
sdk/storage/azure-storage-blobs/test/blob_batch_client_test.cpp
View File

@ -46,12 +46,12 @@ namespace Azure { namespace Storage { namespace Test {
auto batch = Azure::Storage::Blobs::BlobBatchClient::CreateBatch();
batch.DeleteBlob(containerName, blobName);
auto batchClient = Blobs::BlobBatchClient(serviceClient.GetUri());
auto batchClient = Blobs::BlobBatchClient(serviceClient.GetUrl());
EXPECT_THROW(batchClient.SubmitBatch(batch), StorageException);
batchClient = Blobs::BlobBatchClient(
serviceClient.GetUri() + accountSasBuilder.GenerateSasToken(*keyCredential));
serviceClient.GetUrl() + accountSasBuilder.GenerateSasToken(*keyCredential));
EXPECT_NO_THROW(batchClient.SubmitBatch(batch));

58
sdk/storage/azure-storage-blobs/test/blob_container_client_test.cpp
View File

@ -527,7 +527,7 @@ namespace Azure { namespace Storage { namespace Test {
std::string blockId2 = Base64Encode("2");
bodyStream.Rewind();
EXPECT_NO_THROW(blockBlob.StageBlock(blockId1, &bodyStream));
EXPECT_NO_THROW(blockBlob.StageBlockFromUri(blockId2, copySourceBlob.GetUri() + GetSas()));
EXPECT_NO_THROW(blockBlob.StageBlockFromUri(blockId2, copySourceBlob.GetUrl() + GetSas()));
EXPECT_NO_THROW(blockBlob.CommitBlockList(
{{Blobs::Models::BlockType::Uncommitted, blockId1},
{Blobs::Models::BlockType::Uncommitted, blockId2}}));
@ -555,7 +555,7 @@ namespace Azure { namespace Storage { namespace Test {
bodyStream.Rewind();
EXPECT_NO_THROW(appendBlob.AppendBlock(&bodyStream));
EXPECT_NO_THROW(appendBlob.AppendBlockFromUri(copySourceBlob.GetUri() + GetSas()));
EXPECT_NO_THROW(appendBlob.AppendBlockFromUri(copySourceBlob.GetUrl() + GetSas()));
EXPECT_NO_THROW(appendBlob.Download());
EXPECT_NO_THROW(appendBlob.GetProperties());
EXPECT_NO_THROW(appendBlob.SetMetadata({}));
@ -568,7 +568,7 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_THROW(appendBlobClientWithoutEncryptionKey.AppendBlock(&bodyStream), StorageException);
EXPECT_THROW(
appendBlobClientWithoutEncryptionKey.AppendBlockFromUri(
copySourceBlob.GetUri() + GetSas()),
copySourceBlob.GetUrl() + GetSas()),
StorageException);
EXPECT_THROW(appendBlobClientWithoutEncryptionKey.Download(), StorageException);
EXPECT_THROW(appendBlobClientWithoutEncryptionKey.GetProperties(), StorageException);
@ -596,7 +596,7 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_NO_THROW(pageBlob.UploadPages(0, &bodyStream));
EXPECT_NO_THROW(pageBlob.ClearPages(0, blobContent.size()));
EXPECT_NO_THROW(pageBlob.UploadPagesFromUri(
0, copySourceBlob.GetUri() + GetSas(), 0, blobContent.size()));
0, copySourceBlob.GetUrl() + GetSas(), 0, blobContent.size()));
auto pageBlobClientWithoutEncryptionKey
= Azure::Storage::Blobs::PageBlobClient::CreateFromConnectionString(
@ -899,32 +899,32 @@ namespace Azure { namespace Storage { namespace Test {
content.Rewind();
EXPECT_NO_THROW(appendBlobClient.AppendBlock(&content, options));
std::string uri = appendBlobClient.GetUri() + GetSas();
std::string url = appendBlobClient.GetUrl() + GetSas();
Blobs::AppendBlockFromUriOptions options2;
options2.AccessConditions.TagConditions = failWhereExpression;
EXPECT_THROW(appendBlobClient.AppendBlockFromUri(uri, options2), StorageException);
EXPECT_THROW(appendBlobClient.AppendBlockFromUri(url, options2), StorageException);
options2.AccessConditions.TagConditions = successWhereExpression;
EXPECT_NO_THROW(appendBlobClient.AppendBlockFromUri(uri, options2));
EXPECT_NO_THROW(appendBlobClient.AppendBlockFromUri(url, options2));
}
{
std::string uri = appendBlobClient.GetUri() + GetSas();
std::string url = appendBlobClient.GetUrl() + GetSas();
Blobs::StartCopyBlobFromUriOptions options;
auto blobClient2 = Azure::Storage::Blobs::AppendBlobClient::CreateFromConnectionString(
StandardStorageConnectionString(), m_containerName, RandomString());
options.SourceConditions.TagConditions = failWhereExpression;
EXPECT_THROW(blobClient2.StartCopyFromUri(uri, options), StorageException);
EXPECT_THROW(blobClient2.StartCopyFromUri(url, options), StorageException);
options.SourceConditions.TagConditions = successWhereExpression;
EXPECT_NO_THROW(blobClient2.StartCopyFromUri(uri, options));
EXPECT_NO_THROW(blobClient2.StartCopyFromUri(url, options));
options.SourceConditions.TagConditions.Reset();
blobClient2.SetTags(tags);
options.AccessConditions.TagConditions = failWhereExpression;
EXPECT_THROW(blobClient2.StartCopyFromUri(uri, options), StorageException);
EXPECT_THROW(blobClient2.StartCopyFromUri(url, options), StorageException);
options.AccessConditions.TagConditions = successWhereExpression;
EXPECT_NO_THROW(blobClient2.StartCopyFromUri(uri, options));
EXPECT_NO_THROW(blobClient2.StartCopyFromUri(url, options));
}
{
@ -977,13 +977,13 @@ namespace Azure { namespace Storage { namespace Test {
}
{
std::string uri = pageBlobClient.GetUri() + GetSas();
std::string url = pageBlobClient.GetUrl() + GetSas();
Blobs::UploadPageBlobPagesFromUriOptions options;
options.AccessConditions.TagConditions = failWhereExpression;
EXPECT_THROW(
pageBlobClient.UploadPagesFromUri(0, uri, 0, contentSize, options), StorageException);
pageBlobClient.UploadPagesFromUri(0, url, 0, contentSize, options), StorageException);
options.AccessConditions.TagConditions = successWhereExpression;
EXPECT_NO_THROW(pageBlobClient.UploadPagesFromUri(0, uri, 0, contentSize, options));
EXPECT_NO_THROW(pageBlobClient.UploadPagesFromUri(0, url, 0, contentSize, options));
}
{
@ -1061,28 +1061,28 @@ namespace Azure { namespace Storage { namespace Test {
std::string blobName = baseBlobName + RandomString();
auto blobClient = m_blobContainerClient->GetAppendBlobClient(blobName);
EXPECT_NO_THROW(blobClient.Create());
auto blobUrl = blobClient.GetUri();
auto blobUrl = blobClient.GetUrl();
EXPECT_EQ(
blobUrl,
m_blobContainerClient->GetUri() + "/" + Storage::Details::UrlEncodePath(blobName));
m_blobContainerClient->GetUrl() + "/" + Storage::Details::UrlEncodePath(blobName));
}
{
std::string blobName = baseBlobName + RandomString();
auto blobClient = m_blobContainerClient->GetPageBlobClient(blobName);
EXPECT_NO_THROW(blobClient.Create(1024));
auto blobUrl = blobClient.GetUri();
auto blobUrl = blobClient.GetUrl();
EXPECT_EQ(
blobUrl,
m_blobContainerClient->GetUri() + "/" + Storage::Details::UrlEncodePath(blobName));
m_blobContainerClient->GetUrl() + "/" + Storage::Details::UrlEncodePath(blobName));
}
{
std::string blobName = baseBlobName + RandomString();
auto blobClient = m_blobContainerClient->GetBlockBlobClient(blobName);
EXPECT_NO_THROW(blobClient.UploadFrom(nullptr, 0));
auto blobUrl = blobClient.GetUri();
auto blobUrl = blobClient.GetUrl();
EXPECT_EQ(
blobUrl,
m_blobContainerClient->GetUri() + "/" + Storage::Details::UrlEncodePath(blobName));
m_blobContainerClient->GetUrl() + "/" + Storage::Details::UrlEncodePath(blobName));
}
{
@ -1090,30 +1090,30 @@ namespace Azure { namespace Storage { namespace Test {
auto blobClient = Blobs::AppendBlobClient::CreateFromConnectionString(
StandardStorageConnectionString(), m_containerName, blobName);
EXPECT_NO_THROW(blobClient.Create());
auto blobUrl = blobClient.GetUri();
auto blobUrl = blobClient.GetUrl();
EXPECT_EQ(
blobUrl,
m_blobContainerClient->GetUri() + "/" + Storage::Details::UrlEncodePath(blobName));
m_blobContainerClient->GetUrl() + "/" + Storage::Details::UrlEncodePath(blobName));
}
{
std::string blobName = baseBlobName + RandomString();
auto blobClient = Blobs::PageBlobClient::CreateFromConnectionString(
StandardStorageConnectionString(), m_containerName, blobName);
EXPECT_NO_THROW(blobClient.Create(1024));
auto blobUrl = blobClient.GetUri();
auto blobUrl = blobClient.GetUrl();
EXPECT_EQ(
blobUrl,
m_blobContainerClient->GetUri() + "/" + Storage::Details::UrlEncodePath(blobName));
m_blobContainerClient->GetUrl() + "/" + Storage::Details::UrlEncodePath(blobName));
}
{
std::string blobName = baseBlobName + RandomString();
auto blobClient = Blobs::BlockBlobClient::CreateFromConnectionString(
StandardStorageConnectionString(), m_containerName, blobName);
EXPECT_NO_THROW(blobClient.UploadFrom(nullptr, 0));
auto blobUrl = blobClient.GetUri();
auto blobUrl = blobClient.GetUrl();
EXPECT_EQ(
blobUrl,
m_blobContainerClient->GetUri() + "/" + Storage::Details::UrlEncodePath(blobName));
m_blobContainerClient->GetUrl() + "/" + Storage::Details::UrlEncodePath(blobName));
}
}
@ -1122,9 +1122,9 @@ namespace Azure { namespace Storage { namespace Test {
std::string blobName = "?";
auto blobClient = m_blobContainerClient->GetAppendBlobClient(blobName);
EXPECT_NO_THROW(blobClient.Create());
auto blobUrl = blobClient.GetUri();
auto blobUrl = blobClient.GetUrl();
EXPECT_EQ(
blobUrl, m_blobContainerClient->GetUri() + "/" + Storage::Details::UrlEncodePath(blobName));
blobUrl, m_blobContainerClient->GetUrl() + "/" + Storage::Details::UrlEncodePath(blobName));
}
}}} // namespace Azure::Storage::Test

62
sdk/storage/azure-storage-blobs/test/blob_sas_test.cpp
View File

@ -39,12 +39,12 @@ namespace Azure { namespace Storage { namespace Test {
auto blobContainerClient0 = blobServiceClient0.GetBlobContainerClient(m_containerName);
auto blobClient0 = blobContainerClient0.GetAppendBlobClient(blobName);
auto serviceUri = blobServiceClient0.GetUri();
auto containerUri = blobContainerClient0.GetUri();
auto blobUri = blobClient0.GetUri();
auto serviceUrl = blobServiceClient0.GetUrl();
auto containerUrl = blobContainerClient0.GetUrl();
auto blobUrl = blobClient0.GetUrl();
auto blobServiceClient1 = Blobs::BlobServiceClient(
serviceUri,
serviceUrl,
std::make_shared<Azure::Identity::ClientSecretCredential>(
AadTenantId(), AadClientId(), AadClientSecret()));
auto userDelegationKey = *blobServiceClient1.GetUserDelegationKey(
@ -53,21 +53,21 @@ namespace Azure { namespace Storage { namespace Test {
auto verify_blob_read = [&](const std::string& sas) {
EXPECT_NO_THROW(blobClient0.Create());
auto blobClient = Blobs::AppendBlobClient(blobUri + sas);
auto blobClient = Blobs::AppendBlobClient(blobUrl + sas);
auto downloadedContent = blobClient.Download();
EXPECT_TRUE(ReadBodyStream(downloadedContent->BodyStream).empty());
blobClient0.Delete();
};
auto verify_blob_write = [&](const std::string& sas) {
auto blobClient = Blobs::AppendBlobClient(blobUri + sas);
auto blobClient = Blobs::AppendBlobClient(blobUrl + sas);
EXPECT_NO_THROW(blobClient.Create());
blobClient0.Delete();
};
auto verify_blob_delete = [&](const std::string& sas) {
blobClient0.Create();
auto blobClient = Blobs::AppendBlobClient(blobUri + sas);
auto blobClient = Blobs::AppendBlobClient(blobUrl + sas);
EXPECT_NO_THROW(blobClient.Delete());
};
@ -76,13 +76,13 @@ namespace Azure { namespace Storage { namespace Test {
std::string content = "Hello world";
auto blockContent = Azure::Core::Http::MemoryBodyStream(
reinterpret_cast<const uint8_t*>(content.data()), content.size());
auto blobClient = Blobs::AppendBlobClient(blobUri + sas);
auto blobClient = Blobs::AppendBlobClient(blobUrl + sas);
EXPECT_NO_THROW(blobClient.AppendBlock(&blockContent));
blobClient0.Delete();
};
auto verify_blob_list = [&](const std::string& sas) {
auto blobContainerClient = Blobs::BlobContainerClient(containerUri + sas);
auto blobContainerClient = Blobs::BlobContainerClient(containerUrl + sas);
EXPECT_NO_THROW(blobContainerClient.ListBlobsFlatSegment());
};
@ -94,7 +94,7 @@ namespace Azure { namespace Storage { namespace Test {
catch (StorageException&)
{
}
auto blobClient = Blobs::AppendBlobClient(blobUri + sas);
auto blobClient = Blobs::AppendBlobClient(blobUrl + sas);
blobClient.Create();
blobClient.CreateSnapshot();
Blobs::DeleteBlobOptions options;
@ -106,13 +106,13 @@ namespace Azure { namespace Storage { namespace Test {
// blobClient0.Create();
// std::map<std::string, std::string> tags = {{"tag_key1", "tag_value1"}};
// blobClient0.SetTags(tags);
// auto blobClient = Blobs::AppendBlobClient(blobUri + sas);
// auto blobClient = Blobs::AppendBlobClient(blobUrl + sas);
// EXPECT_NO_THROW(blobClient.GetTags());
// blobClient0.Delete();
//};
// auto verify_blob_filter = [&](const std::string& sas) {
// auto serviceClient = Blobs::BlobServiceClient(serviceUri + sas);
// auto serviceClient = Blobs::BlobServiceClient(serviceUrl + sas);
// EXPECT_NO_THROW(serviceClient.FindBlobsByTags("\"tag_key1\" = 'tag_value1'"));
//};
@ -262,7 +262,7 @@ namespace Azure { namespace Storage { namespace Test {
auto sasToken = builder2.GenerateSasToken(*keyCredential);
EXPECT_THROW(verify_blob_create(sasToken), StorageException);
auto serviceClient = Blobs::BlobServiceClient(serviceUri + sasToken);
auto serviceClient = Blobs::BlobServiceClient(serviceUrl + sasToken);
EXPECT_NO_THROW(serviceClient.ListBlobContainersSegment());
}
@ -404,7 +404,7 @@ namespace Azure { namespace Storage { namespace Test {
builder2.CacheControl = "no-cache";
builder2.ContentEncoding = "identify";
auto sasToken = builder2.GenerateSasToken(*keyCredential);
auto blobClient = Blobs::AppendBlobClient(blobUri + sasToken);
auto blobClient = Blobs::AppendBlobClient(blobUrl + sasToken);
blobClient0.Create();
auto p = blobClient.GetProperties();
EXPECT_EQ(p->HttpHeaders.ContentType, headers.ContentType);
@ -414,7 +414,7 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_EQ(p->HttpHeaders.ContentEncoding, headers.ContentEncoding);
auto sasToken2 = builder2.GenerateSasToken(userDelegationKey, accountName);
blobClient = Blobs::AppendBlobClient(blobUri + sasToken2);
blobClient = Blobs::AppendBlobClient(blobUrl + sasToken2);
p = blobClient.GetProperties();
EXPECT_EQ(p->HttpHeaders.ContentType, headers.ContentType);
EXPECT_EQ(p->HttpHeaders.ContentLanguage, headers.ContentLanguage);
@ -428,26 +428,26 @@ namespace Azure { namespace Storage { namespace Test {
Blobs::BlobSasBuilder BlobSnapshotSasBuilder = blobSasBuilder;
BlobSnapshotSasBuilder.Resource = Blobs::BlobSasResource::BlobSnapshot;
std::string blobSnapshotUri;
std::string blobSnapshotUrl;
auto create_snapshot = [&]() {
std::string snapshot = blobClient0.CreateSnapshot()->Snapshot;
BlobSnapshotSasBuilder.Snapshot = snapshot;
blobSnapshotUri = blobClient0.WithSnapshot(snapshot).GetUri();
blobSnapshotUrl = blobClient0.WithSnapshot(snapshot).GetUrl();
};
auto verify_blob_snapshot_read = [&](const std::string sas) {
Azure::Core::Http::Url blobSnapshotUriWithSas(blobSnapshotUri);
blobSnapshotUriWithSas.AppendQueryParameters(sas);
auto blobSnapshotClient = Blobs::AppendBlobClient(blobSnapshotUriWithSas.GetAbsoluteUrl());
Azure::Core::Http::Url blobSnapshotUrlWithSas(blobSnapshotUrl);
blobSnapshotUrlWithSas.AppendQueryParameters(sas);
auto blobSnapshotClient = Blobs::AppendBlobClient(blobSnapshotUrlWithSas.GetAbsoluteUrl());
auto downloadedContent = blobSnapshotClient.Download();
EXPECT_TRUE(ReadBodyStream(downloadedContent->BodyStream).empty());
};
auto verify_blob_snapshot_delete = [&](const std::string sas) {
Azure::Core::Http::Url blobSnapshotUriWithSas(blobSnapshotUri);
blobSnapshotUriWithSas.AppendQueryParameters(sas);
auto blobSnapshotClient = Blobs::AppendBlobClient(blobSnapshotUriWithSas.GetAbsoluteUrl());
Azure::Core::Http::Url blobSnapshotUrlWithSas(blobSnapshotUrl);
blobSnapshotUrlWithSas.AppendQueryParameters(sas);
auto blobSnapshotClient = Blobs::AppendBlobClient(blobSnapshotUrlWithSas.GetAbsoluteUrl());
EXPECT_NO_THROW(blobSnapshotClient.Delete());
};
@ -488,27 +488,27 @@ namespace Azure { namespace Storage { namespace Test {
Blobs::BlobSasBuilder BlobVersionSasBuilder = blobSasBuilder;
BlobVersionSasBuilder.Resource = Blobs::BlobSasResource::BlobVersion;
std::string blobVersionUri;
std::string blobVersionUrl;
auto create_version = [&]() {
std::string versionId = blobClient0.CreateSnapshot()->VersionId.GetValue();
BlobVersionSasBuilder.BlobVersionId = versionId;
blobVersionUri = blobClient0.WithVersionId(versionId).GetUri();
blobVersionUrl = blobClient0.WithVersionId(versionId).GetUrl();
blobClient0.SetMetadata({});
};
auto verify_blob_version_read = [&](const std::string sas) {
Azure::Core::Http::Url blobVersionUriWithSas(blobVersionUri);
blobVersionUriWithSas.AppendQueryParameters(sas);
auto blobVersionClient = Blobs::AppendBlobClient(blobVersionUriWithSas.GetAbsoluteUrl());
Azure::Core::Http::Url blobVersionUrlWithSas(blobVersionUrl);
blobVersionUrlWithSas.AppendQueryParameters(sas);
auto blobVersionClient = Blobs::AppendBlobClient(blobVersionUrlWithSas.GetAbsoluteUrl());
auto downloadedContent = blobVersionClient.Download();
EXPECT_TRUE(ReadBodyStream(downloadedContent->BodyStream).empty());
};
auto verify_blob_delete_version = [&](const std::string& sas) {
Azure::Core::Http::Url blobVersionUriWithSas(blobVersionUri);
blobVersionUriWithSas.AppendQueryParameters(sas);
auto blobVersionClient = Blobs::AppendBlobClient(blobVersionUriWithSas.GetAbsoluteUrl());
Azure::Core::Http::Url blobVersionUrlWithSas(blobVersionUrl);
blobVersionUrlWithSas.AppendQueryParameters(sas);
auto blobVersionClient = Blobs::AppendBlobClient(blobVersionUrlWithSas.GetAbsoluteUrl());
blobVersionClient.Delete();
};

2
sdk/storage/azure-storage-blobs/test/blob_service_client_test.cpp
View File

@ -328,7 +328,7 @@ namespace Azure { namespace Storage { namespace Test {
auto keyCredential
= Details::ParseConnectionString(StandardStorageConnectionString()).KeyCredential;
auto secondaryServiceClient
= Blobs::BlobServiceClient(InferSecondaryUri(m_blobServiceClient.GetUri()), keyCredential);
= Blobs::BlobServiceClient(InferSecondaryUrl(m_blobServiceClient.GetUrl()), keyCredential);
auto serviceStatistics = *secondaryServiceClient.GetStatistics();
EXPECT_NE(
serviceStatistics.GeoReplication.Status, Blobs::Models::BlobGeoReplicationStatus::Unknown);

4
sdk/storage/azure-storage-blobs/test/block_blob_client_test.cpp
View File

@ -167,7 +167,7 @@ namespace Azure { namespace Storage { namespace Test {
TEST_F(BlockBlobClientTest, CopyFromUri)
{
auto blobClient = m_blobContainerClient->GetBlobClient(RandomString());
auto res = blobClient.StartCopyFromUri(m_blockBlobClient->GetUri());
auto res = blobClient.StartCopyFromUri(m_blockBlobClient->GetUrl());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderDate).empty());
@ -294,7 +294,7 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_EQ(res->CommittedBlocks[0].Size, static_cast<int64_t>(block1Content.size()));
EXPECT_TRUE(res->UncommittedBlocks.empty());
blockBlobClient.StageBlockFromUri(blockId2, m_blockBlobClient->GetUri() + GetSas());
blockBlobClient.StageBlockFromUri(blockId2, m_blockBlobClient->GetUrl() + GetSas());
Blobs::GetBlockListOptions options2;
options2.ListType = Blobs::Models::BlockListTypeOption::All;
res = blockBlobClient.GetBlockList(options2);

4
sdk/storage/azure-storage-blobs/test/page_blob_client_test.cpp
View File

@ -137,7 +137,7 @@ namespace Azure { namespace Storage { namespace Test {
StandardStorageConnectionString(), m_containerName, RandomString());
pageBlobClient.Create(m_blobContent.size(), m_blobUploadOptions);
pageBlobClient.UploadPagesFromUri(
0, m_pageBlobClient->GetUri() + GetSas(), 0, m_blobContent.size());
0, m_pageBlobClient->GetUrl() + GetSas(), 0, m_blobContent.size());
}
TEST_F(PageBlobClientTest, StartCopyIncremental)
@ -145,7 +145,7 @@ namespace Azure { namespace Storage { namespace Test {
auto pageBlobClient = Azure::Storage::Blobs::PageBlobClient::CreateFromConnectionString(
StandardStorageConnectionString(), m_containerName, RandomString());
std::string snapshot = m_pageBlobClient->CreateSnapshot()->Snapshot;
Azure::Core::Http::Url sourceUri(m_pageBlobClient->WithSnapshot(snapshot).GetUri());
Azure::Core::Http::Url sourceUri(m_pageBlobClient->WithSnapshot(snapshot).GetUrl());
sourceUri.AppendQueryParameters(GetSas());
auto copyInfo = pageBlobClient.StartCopyIncremental(sourceUri.GetAbsoluteUrl());
EXPECT_FALSE(copyInfo->ETag.empty());

12
sdk/storage/azure-storage-blobs/test/storage_retry_policy_test.cpp
View File

@ -306,8 +306,8 @@ namespace Azure { namespace Storage { namespace Test {
std::string primaryUrl
= Azure::Storage::Blobs::BlobClient::CreateFromConnectionString(
StandardStorageConnectionString(), RandomString(), RandomString())
.GetUri();
std::string secondaryUrl = InferSecondaryUri(primaryUrl);
.GetUrl();
std::string secondaryUrl = InferSecondaryUrl(primaryUrl);
std::string secondaryHost = Core::Http::Url(secondaryUrl).GetHost();
clientOptions.RetryOptions.SecondaryHostForRetryReads = secondaryHost;
}
@ -355,8 +355,8 @@ namespace Azure { namespace Storage { namespace Test {
std::string primaryUrl
= Azure::Storage::Blobs::BlobClient::CreateFromConnectionString(
StandardStorageConnectionString(), RandomString(), RandomString())
.GetUri();
std::string secondaryUrl = InferSecondaryUri(primaryUrl);
.GetUrl();
std::string secondaryUrl = InferSecondaryUrl(primaryUrl);
std::string secondaryHost = Core::Http::Url(secondaryUrl).GetHost();
clientOptions.RetryOptions.SecondaryHostForRetryReads = secondaryHost;
}
@ -410,8 +410,8 @@ namespace Azure { namespace Storage { namespace Test {
std::string primaryUrl
= Azure::Storage::Blobs::BlobClient::CreateFromConnectionString(
StandardStorageConnectionString(), RandomString(), RandomString())
.GetUri();
std::string secondaryUrl = InferSecondaryUri(primaryUrl);
.GetUrl();
std::string secondaryUrl = InferSecondaryUrl(primaryUrl);
std::string secondaryHost = Core::Http::Url(secondaryUrl).GetHost();
clientOptions.RetryOptions.SecondaryHostForRetryReads = secondaryHost;
}

10
sdk/storage/azure-storage-common/inc/azure/storage/common/storage_credential.hpp
View File

@ -33,7 +33,7 @@ namespace Azure { namespace Storage {
public:
/**
* @brief Initializes a new instance of the SharedKeyCredential.
*
*
* @param accountName Name of the storage account.
* @param accountKey Access key of the storage
* account.
@ -80,10 +80,10 @@ namespace Azure { namespace Storage {
struct ConnectionStringParts
{
Azure::Core::Http::Url BlobServiceUri;
Azure::Core::Http::Url FileServiceUri;
Azure::Core::Http::Url QueueServiceUri;
Azure::Core::Http::Url DataLakeServiceUri;
Azure::Core::Http::Url BlobServiceUrl;
Azure::Core::Http::Url FileServiceUrl;
Azure::Core::Http::Url QueueServiceUrl;
Azure::Core::Http::Url DataLakeServiceUrl;
std::shared_ptr<SharedKeyCredential> KeyCredential;
};

16
sdk/storage/azure-storage-common/src/storage_credential.cpp
View File

@ -59,28 +59,28 @@ namespace Azure { namespace Storage { namespace Details {
{
endpoint = defaultEndpointsProtocol + "://" + accountName + ".blob." + EndpointSuffix;
}
connectionStringParts.BlobServiceUri = Azure::Core::Http::Url(std::move(endpoint));
connectionStringParts.BlobServiceUrl = Azure::Core::Http::Url(std::move(endpoint));
endpoint = getWithDefault(connectionStringMap, "DfsEndpoint");
if (endpoint.empty() && !accountName.empty())
{
endpoint = defaultEndpointsProtocol + "://" + accountName + ".dfs." + EndpointSuffix;
}
connectionStringParts.DataLakeServiceUri = Azure::Core::Http::Url(std::move(endpoint));
connectionStringParts.DataLakeServiceUrl = Azure::Core::Http::Url(std::move(endpoint));
endpoint = getWithDefault(connectionStringMap, "FileEndpoint");
if (endpoint.empty() && !accountName.empty())
{
endpoint = defaultEndpointsProtocol + "://" + accountName + ".file." + EndpointSuffix;
}
connectionStringParts.FileServiceUri = Azure::Core::Http::Url(std::move(endpoint));
connectionStringParts.FileServiceUrl = Azure::Core::Http::Url(std::move(endpoint));
endpoint = getWithDefault(connectionStringMap, "QueueEndpoint");
if (endpoint.empty() && !accountName.empty())
{
endpoint = defaultEndpointsProtocol + "://" + accountName + ".queue." + EndpointSuffix;
}
connectionStringParts.QueueServiceUri = Azure::Core::Http::Url(std::move(endpoint));
connectionStringParts.QueueServiceUrl = Azure::Core::Http::Url(std::move(endpoint));
std::string accountKey = getWithDefault(connectionStringMap, "AccountKey");
if (!accountKey.empty())
@ -96,10 +96,10 @@ namespace Azure { namespace Storage { namespace Details {
std::string sas = getWithDefault(connectionStringMap, "SharedAccessSignature");
if (!sas.empty())
{
connectionStringParts.BlobServiceUri.AppendQueryParameters(sas);
connectionStringParts.DataLakeServiceUri.AppendQueryParameters(sas);
connectionStringParts.FileServiceUri.AppendQueryParameters(sas);
connectionStringParts.QueueServiceUri.AppendQueryParameters(sas);
connectionStringParts.BlobServiceUrl.AppendQueryParameters(sas);
connectionStringParts.DataLakeServiceUrl.AppendQueryParameters(sas);
connectionStringParts.FileServiceUrl.AppendQueryParameters(sas);
connectionStringParts.QueueServiceUrl.AppendQueryParameters(sas);
}
return connectionStringParts;

2
sdk/storage/azure-storage-common/test/bearer_token_test.cpp
View File

@ -19,7 +19,7 @@ namespace Azure { namespace Storage { namespace Test {
auto containerClient = Azure::Storage::Blobs::BlobContainerClient(
Azure::Storage::Blobs::BlobContainerClient::CreateFromConnectionString(
StandardStorageConnectionString(), containerName)
.GetUri(),
.GetUrl(),
credential);
EXPECT_NO_THROW(containerClient.Create());

4
sdk/storage/azure-storage-common/test/storage_credential_test.cpp
View File

@ -11,14 +11,14 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_EQ(
Azure::Storage::Details::ParseConnectionString(
"DefaultEndpointsProtocol=https;AccountName=testaccount;AccountKey=testkey")
.BlobServiceUri.GetHost(),
.BlobServiceUrl.GetHost(),
"testaccount.blob.core.windows.net");
EXPECT_EQ(
Azure::Storage::Details::ParseConnectionString(
"DefaultEndpointsProtocol=https;AccountName=testaccount;AccountKey=testkey;"
"EndpointSuffix=core.windows.net")
.BlobServiceUri.GetHost(),
.BlobServiceUrl.GetHost(),
"testaccount.blob.core.windows.net");
}

4
sdk/storage/azure-storage-common/test/test_base.cpp
View File

@ -294,9 +294,9 @@ namespace Azure { namespace Storage { namespace Test {
return std::chrono::system_clock::from_time_t(tt);
}
std::string InferSecondaryUri(const std::string primaryUri)
std::string InferSecondaryUrl(const std::string primaryUrl)
{
Azure::Core::Http::Url secondaryUri(primaryUri);
Azure::Core::Http::Url secondaryUri(primaryUrl);
std::string primaryHost = secondaryUri.GetHost();
auto dotPos = primaryHost.find(".");
std::string accountName = primaryHost.substr(0, dotPos);

2
sdk/storage/azure-storage-common/test/test_base.hpp
View File

@ -79,6 +79,6 @@ namespace Azure { namespace Storage { namespace Test {
std::chrono::system_clock::time_point FromRfc1123(const std::string& timeStr);
std::string InferSecondaryUri(const std::string primaryUri);
std::string InferSecondaryUrl(const std::string primaryUri);
}}} // namespace Azure::Storage::Test

2
sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_directory_client.hpp
View File

@ -84,7 +84,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
*
* @return The directory's primary uri endpoint.
*/
std::string GetUri() const { return m_blobClient.GetUri(); }
std::string GetUri() const { return m_blobClient.GetUrl(); }
/**
* @brief Gets the directory's primary uri endpoint. This is the endpoint used for dfs

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

@ -71,7 +71,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
*
* @return The file's primary uri endpoint.
*/
std::string GetUri() const { return m_blockBlobClient.GetUri(); }
std::string GetUri() const { return m_blockBlobClient.GetUrl(); }
/**
* @brief Gets the file's primary uri endpoint. This is the endpoint used for dfs

2
sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_file_system_client.hpp
View File

@ -94,7 +94,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
*
* @return The filesystem's primary uri endpoint.
*/
std::string GetUri() const { return m_blobContainerClient.GetUri(); }
std::string GetUri() const { return m_blobContainerClient.GetUrl(); }
/**
* @brief Gets the filesystem's primary uri endpoint. This is the endpoint used for dfs

2
sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_path_client.hpp
View File

@ -71,7 +71,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
*
* @return The path's primary uri endpoint.
*/
std::string GetUri() const { return m_blobClient.GetUri(); }
std::string GetUri() const { return m_blobClient.GetUrl(); }
/**
* @brief Gets the path's primary uri endpoint. This is the endpoint used for dfs

2
sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_service_client.hpp
View File

@ -75,7 +75,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
*
* @return The datalake service's primary uri endpoint.
*/
std::string GetUri() const { return m_blobServiceClient.GetUri(); }
std::string GetUri() const { return m_blobServiceClient.GetUrl(); }
/**
* @brief Gets the datalake service's primary uri endpoint. This is the endpoint used for dfs

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

@ -27,7 +27,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const DataLakeClientOptions& options)
{
auto parsedConnectionString = Azure::Storage::Details::ParseConnectionString(connectionString);
auto directoryUri = std::move(parsedConnectionString.DataLakeServiceUri);
auto directoryUri = std::move(parsedConnectionString.DataLakeServiceUrl);
directoryUri.AppendPath(Storage::Details::UrlEncodePath(fileSystemName));
directoryUri.AppendPath(Storage::Details::UrlEncodePath(path));

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

@ -105,7 +105,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const DataLakeClientOptions& options)
{
auto parsedConnectionString = Azure::Storage::Details::ParseConnectionString(connectionString);
auto fileUri = std::move(parsedConnectionString.DataLakeServiceUri);
auto fileUri = std::move(parsedConnectionString.DataLakeServiceUrl);
fileUri.AppendPath(Storage::Details::UrlEncodePath(fileSystemName));
fileUri.AppendPath(Storage::Details::UrlEncodePath(filePath));

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

@ -44,7 +44,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const DataLakeClientOptions& options)
{
auto parsedConnectionString = Azure::Storage::Details::ParseConnectionString(connectionString);
auto fileSystemUri = std::move(parsedConnectionString.DataLakeServiceUri);
auto fileSystemUri = std::move(parsedConnectionString.DataLakeServiceUrl);
fileSystemUri.AppendPath(Storage::Details::UrlEncodePath(fileSystemName));
if (parsedConnectionString.KeyCredential)

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

@ -89,7 +89,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const DataLakeClientOptions& options)
{
auto parsedConnectionString = Azure::Storage::Details::ParseConnectionString(connectionString);
auto pathUri = std::move(parsedConnectionString.DataLakeServiceUri);
auto pathUri = std::move(parsedConnectionString.DataLakeServiceUrl);
pathUri.AppendPath(Storage::Details::UrlEncodePath(fileSystemName));
pathUri.AppendPath(Storage::Details::UrlEncodePath(path));

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

@ -56,7 +56,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const DataLakeClientOptions& options)
{
auto parsedConnectionString = Azure::Storage::Details::ParseConnectionString(connectionString);
auto serviceUri = std::move(parsedConnectionString.DataLakeServiceUri);
auto serviceUri = std::move(parsedConnectionString.DataLakeServiceUrl);
if (parsedConnectionString.KeyCredential)
{

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

@ -23,7 +23,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
const ShareClientOptions& options)
{
auto parsedConnectionString = Azure::Storage::Details::ParseConnectionString(connectionString);
auto shareUri = std::move(parsedConnectionString.FileServiceUri);
auto shareUri = std::move(parsedConnectionString.FileServiceUrl);
shareUri.AppendPath(Storage::Details::UrlEncodePath(shareName));
if (parsedConnectionString.KeyCredential)

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

@ -23,7 +23,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
const ShareClientOptions& options)
{
auto parsedConnectionString = Azure::Storage::Details::ParseConnectionString(connectionString);
auto directoryUri = std::move(parsedConnectionString.FileServiceUri);
auto directoryUri = std::move(parsedConnectionString.FileServiceUrl);
directoryUri.AppendPath(Storage::Details::UrlEncodePath(shareName));
directoryUri.AppendPath(Storage::Details::UrlEncodePath(directoryPath));

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

@ -26,7 +26,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
const ShareClientOptions& options)
{
auto parsedConnectionString = Azure::Storage::Details::ParseConnectionString(connectionString);
auto fileUri = std::move(parsedConnectionString.FileServiceUri);
auto fileUri = std::move(parsedConnectionString.FileServiceUrl);
fileUri.AppendPath(Storage::Details::UrlEncodePath(shareName));
fileUri.AppendPath(Storage::Details::UrlEncodePath(filePath));

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

@ -20,7 +20,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
const ShareClientOptions& options)
{
auto parsedConnectionString = Azure::Storage::Details::ParseConnectionString(connectionString);
auto serviceUri = std::move(parsedConnectionString.FileServiceUri);
auto serviceUri = std::move(parsedConnectionString.FileServiceUrl);
if (parsedConnectionString.KeyCredential)
{