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

Refine DownloadBlobResult and DownloadBlobToResult (#1564)

Browse Source 
* blob result

* rename

* fix

* fix
This commit is contained in:
JinmingHu 2021-02-02 19:25:22 +08:00 committed by GitHub
parent 2cc9099e1a
commit fab5c1139b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 240 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -29,6 +29,7 @@
- Removed `TagValue` from `FilterBlobItem`, removed `Where` from `FindBlobsByTagsSinglePageResult`.
- Type for ETag was changed to `Azure::Core::ETag`.
- Removed `BlobPrefix` struct, use `std::string` instead.
- Refined `DownloadBlobResult` and `DownloadBlobToResult`.
## 12.0.0-beta.6 (2020-01-14)

32
sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_responses.hpp
View File

@ -21,39 +21,11 @@ namespace Azure { namespace Storage { namespace Blobs {
struct DownloadBlobToResult
{
Azure::Core::ETag ETag;
Azure::Core::DateTime LastModified;
Azure::Core::DateTime CreatedOn;
Azure::Core::Nullable<Azure::Core::DateTime> ExpiresOn;
Azure::Core::Nullable<Azure::Core::DateTime> LastAccessedOn;
Models::BlobType BlobType;
Azure::Core::Http::Range ContentRange;
int64_t BlobSize = 0;
BlobHttpHeaders HttpHeaders;
Storage::Metadata Metadata;
Azure::Core::Nullable<int64_t> SequenceNumber; // only for page blob
Azure::Core::Nullable<int64_t> CommittedBlockCount; // only for append blob
Azure::Core::Nullable<bool> IsSealed; // only for append blob
Models::BlobType BlobType;
Azure::Core::Nullable<ContentHash> TransactionalContentHash; // hash for the downloaded range
Azure::Core::Nullable<BlobLeaseDurationType> LeaseDuration;
Azure::Core::Nullable<BlobLeaseState> LeaseState;
Azure::Core::Nullable<BlobLeaseStatus> LeaseStatus;
bool IsServerEncrypted = false;
Azure::Core::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
Azure::Core::Nullable<std::string> EncryptionScope;
Azure::Core::Nullable<std::string>
ObjectReplicationDestinationPolicyId; // only valid for replication destination blob
std::vector<ObjectReplicationPolicy>
ObjectReplicationSourceProperties; // only valid for replication source blob
Azure::Core::Nullable<int32_t> TagCount;
Azure::Core::Nullable<std::string> CopyId;
Azure::Core::Nullable<std::string> CopySource;
Azure::Core::Nullable<Models::CopyStatus> CopyStatus;
Azure::Core::Nullable<std::string> CopyStatusDescription;
Azure::Core::Nullable<std::string> CopyProgress;
Azure::Core::Nullable<Azure::Core::DateTime> CopyCompletedOn;
Azure::Core::Nullable<std::string> VersionId;
Azure::Core::Nullable<bool> IsCurrentVersion;
DownloadBlobDetails Details;
};
using UploadBlockBlobFromResult = UploadBlockBlobResult;

248
sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/protocol/blob_rest_client.hpp
View File

@ -1038,24 +1038,18 @@ namespace Azure { namespace Storage { namespace Blobs {
ObjectReplicationSourceProperties; // only valid for replication source blob
}; // struct BlobItem
struct DownloadBlobResult
struct DownloadBlobDetails
{
std::string RequestId;
std::unique_ptr<Azure::Core::Http::BodyStream> BodyStream;
Azure::Core::ETag ETag;
Azure::Core::DateTime LastModified;
Azure::Core::DateTime CreatedOn;
Azure::Core::Nullable<Azure::Core::DateTime> ExpiresOn;
Azure::Core::Nullable<Azure::Core::DateTime> LastAccessedOn;
Azure::Core::Http::Range ContentRange;
int64_t BlobSize = 0;
BlobHttpHeaders HttpHeaders;
Storage::Metadata Metadata;
Azure::Core::Nullable<int64_t> SequenceNumber; // only for page blob
Azure::Core::Nullable<int64_t> CommittedBlockCount; // only for append blob
Azure::Core::Nullable<bool> IsSealed; // only for append blob
Models::BlobType BlobType;
Azure::Core::Nullable<ContentHash> TransactionalContentHash; // hash for the downloaded range
Azure::Core::Nullable<BlobLeaseDurationType> LeaseDuration;
Azure::Core::Nullable<BlobLeaseState> LeaseState;
Azure::Core::Nullable<BlobLeaseStatus> LeaseStatus;
@ -1075,7 +1069,7 @@ namespace Azure { namespace Storage { namespace Blobs {
Azure::Core::Nullable<Azure::Core::DateTime> CopyCompletedOn;
Azure::Core::Nullable<std::string> VersionId;
Azure::Core::Nullable<bool> IsCurrentVersion;
}; // struct DownloadBlobResult
}; // struct DownloadBlobDetails
struct GetBlobPropertiesResult
{
@ -1120,6 +1114,17 @@ namespace Azure { namespace Storage { namespace Blobs {
Azure::Core::Nullable<bool> IsCurrentVersion;
}; // struct GetBlobPropertiesResult
struct DownloadBlobResult
{
std::string RequestId;
std::unique_ptr<Azure::Core::Http::BodyStream> BodyStream;
Azure::Core::Http::Range ContentRange;
int64_t BlobSize = 0;
Models::BlobType BlobType;
Azure::Core::Nullable<ContentHash> TransactionalContentHash; // hash for the downloaded range
DownloadBlobDetails Details;
}; // struct DownloadBlobResult
struct ListBlobsByHierarchySinglePageResult
{
std::string RequestId;
@ -4924,10 +4929,6 @@ namespace Azure { namespace Storage { namespace Blobs {
}
response.BodyStream = httpResponse.GetBodyStream();
response.RequestId = httpResponse.GetHeaders().at("x-ms-request-id");
response.ETag = Azure::Core::ETag(httpResponse.GetHeaders().at("etag"));
response.LastModified = Azure::Core::DateTime::Parse(
httpResponse.GetHeaders().at("last-modified"),
Azure::Core::DateTime::DateFormat::Rfc1123);
{
const auto& headers = httpResponse.GetHeaders();
auto content_md5_iterator = headers.find("content-md5");
@ -4947,99 +4948,7 @@ namespace Azure { namespace Storage { namespace Blobs {
response.TransactionalContentHash = std::move(hash);
}
}
auto content_type__iterator = httpResponse.GetHeaders().find("content-type");
if (content_type__iterator != httpResponse.GetHeaders().end())
{
response.HttpHeaders.ContentType = content_type__iterator->second;
}
auto content_encoding__iterator = httpResponse.GetHeaders().find("content-encoding");
if (content_encoding__iterator != httpResponse.GetHeaders().end())
{
response.HttpHeaders.ContentEncoding = content_encoding__iterator->second;
}
auto content_language__iterator = httpResponse.GetHeaders().find("content-language");
if (content_language__iterator != httpResponse.GetHeaders().end())
{
response.HttpHeaders.ContentLanguage = content_language__iterator->second;
}
auto cache_control__iterator = httpResponse.GetHeaders().find("cache-control");
if (cache_control__iterator != httpResponse.GetHeaders().end())
{
response.HttpHeaders.CacheControl = cache_control__iterator->second;
}
auto content_md5__iterator = httpResponse.GetHeaders().find("content-md5");
if (content_md5__iterator != httpResponse.GetHeaders().end())
{
response.HttpHeaders.ContentHash.Value
= Azure::Core::Base64Decode(content_md5__iterator->second);
}
auto x_ms_blob_content_md5__iterator
= httpResponse.GetHeaders().find("x-ms-blob-content-md5");
if (x_ms_blob_content_md5__iterator != httpResponse.GetHeaders().end())
{
response.HttpHeaders.ContentHash.Value
= Azure::Core::Base64Decode(x_ms_blob_content_md5__iterator->second);
}
auto content_disposition__iterator
= httpResponse.GetHeaders().find("content-disposition");
if (content_disposition__iterator != httpResponse.GetHeaders().end())
{
response.HttpHeaders.ContentDisposition = content_disposition__iterator->second;
}
for (auto i = httpResponse.GetHeaders().lower_bound("x-ms-meta-");
i != httpResponse.GetHeaders().end() && i->first.substr(0, 10) == "x-ms-meta-";
++i)
{
response.Metadata.emplace(i->first.substr(10), i->second);
}
response.IsServerEncrypted
= httpResponse.GetHeaders().at("x-ms-server-encrypted") == "true";
auto x_ms_encryption_key_sha256__iterator
= httpResponse.GetHeaders().find("x-ms-encryption-key-sha256");
if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
{
response.EncryptionKeySha256
= Azure::Core::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
}
auto x_ms_encryption_scope__iterator
= httpResponse.GetHeaders().find("x-ms-encryption-scope");
if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
{
response.EncryptionScope = x_ms_encryption_scope__iterator->second;
}
auto x_ms_lease_status__iterator = httpResponse.GetHeaders().find("x-ms-lease-status");
if (x_ms_lease_status__iterator != httpResponse.GetHeaders().end())
{
response.LeaseStatus = BlobLeaseStatus(x_ms_lease_status__iterator->second);
}
auto x_ms_lease_state__iterator = httpResponse.GetHeaders().find("x-ms-lease-state");
if (x_ms_lease_state__iterator != httpResponse.GetHeaders().end())
{
response.LeaseState = BlobLeaseState(x_ms_lease_state__iterator->second);
}
auto x_ms_lease_duration__iterator
= httpResponse.GetHeaders().find("x-ms-lease-duration");
if (x_ms_lease_duration__iterator != httpResponse.GetHeaders().end())
{
response.LeaseDuration = BlobLeaseDurationType(x_ms_lease_duration__iterator->second);
}
response.CreatedOn = Azure::Core::DateTime::Parse(
httpResponse.GetHeaders().at("x-ms-creation-time"),
Azure::Core::DateTime::DateFormat::Rfc1123);
auto x_ms_expiry_time__iterator = httpResponse.GetHeaders().find("x-ms-expiry-time");
if (x_ms_expiry_time__iterator != httpResponse.GetHeaders().end())
{
response.ExpiresOn = Azure::Core::DateTime::Parse(
x_ms_expiry_time__iterator->second, Azure::Core::DateTime::DateFormat::Rfc1123);
}
auto x_ms_last_access_time__iterator
= httpResponse.GetHeaders().find("x-ms-last-access-time");
if (x_ms_last_access_time__iterator != httpResponse.GetHeaders().end())
{
response.LastAccessedOn = Azure::Core::DateTime::Parse(
x_ms_last_access_time__iterator->second,
Azure::Core::DateTime::DateFormat::Rfc1123);
}
response.BlobType = BlobType(httpResponse.GetHeaders().at("x-ms-blob-type"));
auto content_range_iterator = httpResponse.GetHeaders().find("content-range");
if (content_range_iterator != httpResponse.GetHeaders().end())
{
@ -5069,29 +4978,128 @@ namespace Azure { namespace Storage { namespace Blobs {
{
response.BlobSize = std::stoll(httpResponse.GetHeaders().at("content-length"));
}
response.Details.ETag = Azure::Core::ETag(httpResponse.GetHeaders().at("etag"));
response.Details.LastModified = Azure::Core::DateTime::Parse(
httpResponse.GetHeaders().at("last-modified"),
Azure::Core::DateTime::DateFormat::Rfc1123);
auto content_type__iterator = httpResponse.GetHeaders().find("content-type");
if (content_type__iterator != httpResponse.GetHeaders().end())
{
response.Details.HttpHeaders.ContentType = content_type__iterator->second;
}
auto content_encoding__iterator = httpResponse.GetHeaders().find("content-encoding");
if (content_encoding__iterator != httpResponse.GetHeaders().end())
{
response.Details.HttpHeaders.ContentEncoding = content_encoding__iterator->second;
}
auto content_language__iterator = httpResponse.GetHeaders().find("content-language");
if (content_language__iterator != httpResponse.GetHeaders().end())
{
response.Details.HttpHeaders.ContentLanguage = content_language__iterator->second;
}
auto cache_control__iterator = httpResponse.GetHeaders().find("cache-control");
if (cache_control__iterator != httpResponse.GetHeaders().end())
{
response.Details.HttpHeaders.CacheControl = cache_control__iterator->second;
}
auto content_md5__iterator = httpResponse.GetHeaders().find("content-md5");
if (content_md5__iterator != httpResponse.GetHeaders().end())
{
response.Details.HttpHeaders.ContentHash.Value
= Azure::Core::Base64Decode(content_md5__iterator->second);
}
auto x_ms_blob_content_md5__iterator
= httpResponse.GetHeaders().find("x-ms-blob-content-md5");
if (x_ms_blob_content_md5__iterator != httpResponse.GetHeaders().end())
{
response.Details.HttpHeaders.ContentHash.Value
= Azure::Core::Base64Decode(x_ms_blob_content_md5__iterator->second);
}
auto content_disposition__iterator
= httpResponse.GetHeaders().find("content-disposition");
if (content_disposition__iterator != httpResponse.GetHeaders().end())
{
response.Details.HttpHeaders.ContentDisposition = content_disposition__iterator->second;
}
for (auto i = httpResponse.GetHeaders().lower_bound("x-ms-meta-");
i != httpResponse.GetHeaders().end() && i->first.substr(0, 10) == "x-ms-meta-";
++i)
{
response.Details.Metadata.emplace(i->first.substr(10), i->second);
}
response.Details.IsServerEncrypted
= httpResponse.GetHeaders().at("x-ms-server-encrypted") == "true";
auto x_ms_encryption_key_sha256__iterator
= httpResponse.GetHeaders().find("x-ms-encryption-key-sha256");
if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
{
response.Details.EncryptionKeySha256
= Azure::Core::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
}
auto x_ms_encryption_scope__iterator
= httpResponse.GetHeaders().find("x-ms-encryption-scope");
if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
{
response.Details.EncryptionScope = x_ms_encryption_scope__iterator->second;
}
auto x_ms_lease_status__iterator = httpResponse.GetHeaders().find("x-ms-lease-status");
if (x_ms_lease_status__iterator != httpResponse.GetHeaders().end())
{
response.Details.LeaseStatus = BlobLeaseStatus(x_ms_lease_status__iterator->second);
}
auto x_ms_lease_state__iterator = httpResponse.GetHeaders().find("x-ms-lease-state");
if (x_ms_lease_state__iterator != httpResponse.GetHeaders().end())
{
response.Details.LeaseState = BlobLeaseState(x_ms_lease_state__iterator->second);
}
auto x_ms_lease_duration__iterator
= httpResponse.GetHeaders().find("x-ms-lease-duration");
if (x_ms_lease_duration__iterator != httpResponse.GetHeaders().end())
{
response.Details.LeaseDuration
= BlobLeaseDurationType(x_ms_lease_duration__iterator->second);
}
response.Details.CreatedOn = Azure::Core::DateTime::Parse(
httpResponse.GetHeaders().at("x-ms-creation-time"),
Azure::Core::DateTime::DateFormat::Rfc1123);
auto x_ms_expiry_time__iterator = httpResponse.GetHeaders().find("x-ms-expiry-time");
if (x_ms_expiry_time__iterator != httpResponse.GetHeaders().end())
{
response.Details.ExpiresOn = Azure::Core::DateTime::Parse(
x_ms_expiry_time__iterator->second, Azure::Core::DateTime::DateFormat::Rfc1123);
}
auto x_ms_last_access_time__iterator
= httpResponse.GetHeaders().find("x-ms-last-access-time");
if (x_ms_last_access_time__iterator != httpResponse.GetHeaders().end())
{
response.Details.LastAccessedOn = Azure::Core::DateTime::Parse(
x_ms_last_access_time__iterator->second,
Azure::Core::DateTime::DateFormat::Rfc1123);
}
auto x_ms_blob_sequence_number__iterator
= httpResponse.GetHeaders().find("x-ms-blob-sequence-number");
if (x_ms_blob_sequence_number__iterator != httpResponse.GetHeaders().end())
{
response.SequenceNumber = std::stoll(x_ms_blob_sequence_number__iterator->second);
response.Details.SequenceNumber
= std::stoll(x_ms_blob_sequence_number__iterator->second);
}
auto x_ms_blob_committed_block_count__iterator
= httpResponse.GetHeaders().find("x-ms-blob-committed-block-count");
if (x_ms_blob_committed_block_count__iterator != httpResponse.GetHeaders().end())
{
response.CommittedBlockCount
response.Details.CommittedBlockCount
= std::stoll(x_ms_blob_committed_block_count__iterator->second);
}
auto x_ms_blob_sealed__iterator = httpResponse.GetHeaders().find("x-ms-blob-sealed");
if (x_ms_blob_sealed__iterator != httpResponse.GetHeaders().end())
{
response.IsSealed = x_ms_blob_sealed__iterator->second == "true";
response.Details.IsSealed = x_ms_blob_sealed__iterator->second == "true";
}
response.BlobType = BlobType(httpResponse.GetHeaders().at("x-ms-blob-type"));
auto x_ms_or_policy_id__iterator = httpResponse.GetHeaders().find("x-ms-or-policy-id");
if (x_ms_or_policy_id__iterator != httpResponse.GetHeaders().end())
{
response.ObjectReplicationDestinationPolicyId = x_ms_or_policy_id__iterator->second;
response.Details.ObjectReplicationDestinationPolicyId
= x_ms_or_policy_id__iterator->second;
}
{
std::map<std::string, std::vector<ObjectReplicationRule>> orPropertiesMap;
@ -5119,58 +5127,58 @@ namespace Azure { namespace Storage { namespace Blobs {
ObjectReplicationPolicy policy;
policy.PolicyId = property.first;
policy.Rules = std::move(property.second);
response.ObjectReplicationSourceProperties.emplace_back(std::move(policy));
response.Details.ObjectReplicationSourceProperties.emplace_back(std::move(policy));
}
}
auto x_ms_tag_count__iterator = httpResponse.GetHeaders().find("x-ms-tag-count");
if (x_ms_tag_count__iterator != httpResponse.GetHeaders().end())
{
response.TagCount = std::stoi(x_ms_tag_count__iterator->second);
response.Details.TagCount = std::stoi(x_ms_tag_count__iterator->second);
}
auto x_ms_copy_id__iterator = httpResponse.GetHeaders().find("x-ms-copy-id");
if (x_ms_copy_id__iterator != httpResponse.GetHeaders().end())
{
response.CopyId = x_ms_copy_id__iterator->second;
response.Details.CopyId = x_ms_copy_id__iterator->second;
}
auto x_ms_copy_source__iterator = httpResponse.GetHeaders().find("x-ms-copy-source");
if (x_ms_copy_source__iterator != httpResponse.GetHeaders().end())
{
response.CopySource = x_ms_copy_source__iterator->second;
response.Details.CopySource = x_ms_copy_source__iterator->second;
}
auto x_ms_copy_status__iterator = httpResponse.GetHeaders().find("x-ms-copy-status");
if (x_ms_copy_status__iterator != httpResponse.GetHeaders().end())
{
response.CopyStatus = CopyStatus(x_ms_copy_status__iterator->second);
response.Details.CopyStatus = CopyStatus(x_ms_copy_status__iterator->second);
}
auto x_ms_copy_status_description__iterator
= httpResponse.GetHeaders().find("x-ms-copy-status-description");
if (x_ms_copy_status_description__iterator != httpResponse.GetHeaders().end())
{
response.CopyStatusDescription = x_ms_copy_status_description__iterator->second;
response.Details.CopyStatusDescription = x_ms_copy_status_description__iterator->second;
}
auto x_ms_copy_progress__iterator = httpResponse.GetHeaders().find("x-ms-copy-progress");
if (x_ms_copy_progress__iterator != httpResponse.GetHeaders().end())
{
response.CopyProgress = x_ms_copy_progress__iterator->second;
response.Details.CopyProgress = x_ms_copy_progress__iterator->second;
}
auto x_ms_copy_completion_time__iterator
= httpResponse.GetHeaders().find("x-ms-copy-completion-time");
if (x_ms_copy_completion_time__iterator != httpResponse.GetHeaders().end())
{
response.CopyCompletedOn = Azure::Core::DateTime::Parse(
response.Details.CopyCompletedOn = Azure::Core::DateTime::Parse(
x_ms_copy_completion_time__iterator->second,
Azure::Core::DateTime::DateFormat::Rfc1123);
}
auto x_ms_version_id__iterator = httpResponse.GetHeaders().find("x-ms-version-id");
if (x_ms_version_id__iterator != httpResponse.GetHeaders().end())
{
response.VersionId = x_ms_version_id__iterator->second;
response.Details.VersionId = x_ms_version_id__iterator->second;
}
auto x_ms_is_current_version__iterator
= httpResponse.GetHeaders().find("x-ms-is-current-version");
if (x_ms_is_current_version__iterator != httpResponse.GetHeaders().end())
{
response.IsCurrentVersion = x_ms_is_current_version__iterator->second == "true";
response.Details.IsCurrentVersion = x_ms_is_current_version__iterator->second == "true";
}
return Azure::Core::Response<DownloadBlobResult>(
std::move(response), std::move(pHttpResponse));

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

@ -180,7 +180,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
// In case network failure during reading the body
Azure::Core::ETag eTag = downloadResponse->ETag;
const Azure::Core::ETag eTag = downloadResponse->Details.ETag;
auto retryFunction
= [this, options, eTag](
@ -210,13 +210,14 @@ namespace Azure { namespace Storage { namespace Blobs {
std::move(downloadResponse->BodyStream), reliableStreamOptions, retryFunction);
}
if (downloadResponse->BlobType == Models::BlobType::AppendBlob
&& !downloadResponse->IsSealed.HasValue())
&& !downloadResponse->Details.IsSealed.HasValue())
{
downloadResponse->IsSealed = false;
downloadResponse->Details.IsSealed = false;
}
if (downloadResponse->VersionId.HasValue() && !downloadResponse->IsCurrentVersion.HasValue())
if (downloadResponse->Details.VersionId.HasValue()
&& !downloadResponse->Details.IsCurrentVersion.HasValue())
{
downloadResponse->IsCurrentVersion = false;
downloadResponse->Details.IsCurrentVersion = false;
}
return downloadResponse;
}
@ -245,6 +246,7 @@ namespace Azure { namespace Storage { namespace Blobs {
}
auto firstChunk = Download(firstChunkOptions);
const Azure::Core::ETag eTag = firstChunk->Details.ETag;
const int64_t blobSize = firstChunk->BlobSize;
int64_t blobRangeSize;
@ -278,40 +280,11 @@ namespace Azure { namespace Storage { namespace Blobs {
auto returnTypeConverter = [](Azure::Core::Response<Models::DownloadBlobResult>& response) {
Models::DownloadBlobToResult ret;
// Do not move ETag, we're gonna use it later
ret.ETag = response->ETag;
ret.LastModified = std::move(response->LastModified);
ret.CreatedOn = std::move(response->CreatedOn);
ret.ExpiresOn = std::move(response->ExpiresOn);
ret.LastAccessedOn = std::move(response->LastAccessedOn);
ret.HttpHeaders = std::move(response->HttpHeaders);
ret.Metadata = std::move(response->Metadata);
ret.SequenceNumber = std::move(response->SequenceNumber);
ret.CommittedBlockCount = std::move(response->CommittedBlockCount);
ret.IsSealed = std::move(response->IsSealed);
ret.BlobType = std::move(response->BlobType);
ret.TransactionalContentHash = std::move(response->TransactionalContentHash);
ret.LeaseDuration = std::move(response->LeaseDuration);
ret.LeaseState = std::move(response->LeaseState);
ret.LeaseStatus = std::move(response->LeaseStatus);
ret.IsServerEncrypted = response->IsServerEncrypted;
ret.EncryptionKeySha256 = std::move(response->EncryptionKeySha256);
ret.EncryptionScope = std::move(response->EncryptionScope);
ret.ObjectReplicationDestinationPolicyId
= std::move(response->ObjectReplicationDestinationPolicyId);
ret.ObjectReplicationSourceProperties
= std::move(response->ObjectReplicationSourceProperties);
ret.TagCount = std::move(response->TagCount);
ret.CopyId = std::move(response->CopyId);
ret.CopySource = std::move(response->CopySource);
ret.CopyStatus = std::move(response->CopyStatus);
ret.CopyStatusDescription = std::move(response->CopyStatusDescription);
ret.CopyProgress = std::move(response->CopyProgress);
ret.CopyCompletedOn = std::move(response->CopyCompletedOn);
ret.VersionId = std::move(response->VersionId);
ret.IsCurrentVersion = std::move(response->IsCurrentVersion);
ret.BlobSize = response->BlobSize;
ret.ContentRange = std::move(response->ContentRange);
ret.BlobSize = response->BlobSize;
ret.TransactionalContentHash = std::move(response->TransactionalContentHash);
ret.Details = std::move(response->Details);
return Azure::Core::Response<Models::DownloadBlobToResult>(
std::move(ret), response.ExtractRawResponse());
};
@ -327,7 +300,7 @@ namespace Azure { namespace Storage { namespace Blobs {
chunkOptions.Range.GetValue().Length = length;
if (!chunkOptions.AccessConditions.IfMatch.HasValue())
{
chunkOptions.AccessConditions.IfMatch = firstChunk->ETag;
chunkOptions.AccessConditions.IfMatch = eTag;
}
auto chunk = Download(chunkOptions);
int64_t bytesRead = Azure::Core::Http::BodyStream::ReadToCount(
@ -343,6 +316,7 @@ namespace Azure { namespace Storage { namespace Blobs {
if (chunkId == numChunks - 1)
{
ret = returnTypeConverter(chunk);
ret->TransactionalContentHash.Reset();
}
};
@ -385,6 +359,7 @@ namespace Azure { namespace Storage { namespace Blobs {
Storage::Details::FileWriter fileWriter(fileName);
auto firstChunk = Download(firstChunkOptions);
const Azure::Core::ETag eTag = firstChunk->Details.ETag;
const int64_t blobSize = firstChunk->BlobSize;
int64_t blobRangeSize;
@ -430,40 +405,11 @@ namespace Azure { namespace Storage { namespace Blobs {
auto returnTypeConverter = [](Azure::Core::Response<Models::DownloadBlobResult>& response) {
Models::DownloadBlobToResult ret;
// Do not move ETag, we're gonna use it later
ret.ETag = response->ETag;
ret.LastModified = std::move(response->LastModified);
ret.CreatedOn = std::move(response->CreatedOn);
ret.ExpiresOn = std::move(response->ExpiresOn);
ret.LastAccessedOn = std::move(response->LastAccessedOn);
ret.HttpHeaders = std::move(response->HttpHeaders);
ret.Metadata = std::move(response->Metadata);
ret.SequenceNumber = std::move(response->SequenceNumber);
ret.CommittedBlockCount = std::move(response->CommittedBlockCount);
ret.IsSealed = std::move(response->IsSealed);
ret.BlobType = std::move(response->BlobType);
ret.TransactionalContentHash = std::move(response->TransactionalContentHash);
ret.LeaseDuration = std::move(response->LeaseDuration);
ret.LeaseState = std::move(response->LeaseState);
ret.LeaseStatus = std::move(response->LeaseStatus);
ret.IsServerEncrypted = response->IsServerEncrypted;
ret.EncryptionKeySha256 = std::move(response->EncryptionKeySha256);
ret.EncryptionScope = std::move(response->EncryptionScope);
ret.ObjectReplicationDestinationPolicyId
= std::move(response->ObjectReplicationDestinationPolicyId);
ret.ObjectReplicationSourceProperties
= std::move(response->ObjectReplicationSourceProperties);
ret.TagCount = std::move(response->TagCount);
ret.CopyId = std::move(response->CopyId);
ret.CopySource = std::move(response->CopySource);
ret.CopyStatus = std::move(response->CopyStatus);
ret.CopyStatusDescription = std::move(response->CopyStatusDescription);
ret.CopyProgress = std::move(response->CopyProgress);
ret.CopyCompletedOn = std::move(response->CopyCompletedOn);
ret.VersionId = std::move(response->VersionId);
ret.IsCurrentVersion = std::move(response->IsCurrentVersion);
ret.BlobSize = response->BlobSize;
ret.ContentRange = std::move(response->ContentRange);
ret.BlobSize = response->BlobSize;
ret.TransactionalContentHash = std::move(response->TransactionalContentHash);
ret.Details = std::move(response->Details);
return Azure::Core::Response<Models::DownloadBlobToResult>(
std::move(ret), response.ExtractRawResponse());
};
@ -479,7 +425,7 @@ namespace Azure { namespace Storage { namespace Blobs {
chunkOptions.Range.GetValue().Length = length;
if (!chunkOptions.AccessConditions.IfMatch.HasValue())
{
chunkOptions.AccessConditions.IfMatch = firstChunk->ETag;
chunkOptions.AccessConditions.IfMatch = eTag;
}
auto chunk = Download(chunkOptions);
bodyStreamToFile(
@ -492,6 +438,7 @@ namespace Azure { namespace Storage { namespace Blobs {
if (chunkId == numChunks - 1)
{
ret = returnTypeConverter(chunk);
ret->TransactionalContentHash.Reset();
}
};

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

@ -274,8 +274,8 @@ namespace Azure { namespace Storage { namespace Test {
blobClient.AppendBlock(&blockContent);
auto downloadResult = blobClient.Download();
EXPECT_TRUE(downloadResult->IsSealed.HasValue());
EXPECT_FALSE(downloadResult->IsSealed.GetValue());
EXPECT_TRUE(downloadResult->Details.IsSealed.HasValue());
EXPECT_FALSE(downloadResult->Details.IsSealed.GetValue());
auto getPropertiesResult = blobClient.GetProperties();
EXPECT_TRUE(getPropertiesResult->IsSealed.HasValue());
@ -309,8 +309,8 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_TRUE(sealResult->IsSealed);
downloadResult = blobClient.Download();
EXPECT_TRUE(downloadResult->IsSealed.HasValue());
EXPECT_TRUE(downloadResult->IsSealed.GetValue());
EXPECT_TRUE(downloadResult->Details.IsSealed.HasValue());
EXPECT_TRUE(downloadResult->Details.IsSealed.GetValue());
getPropertiesResult = blobClient.GetProperties();
EXPECT_TRUE(getPropertiesResult->IsSealed.HasValue());

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

@ -734,7 +734,7 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_FALSE(properties.TagCount.HasValue());
auto downloadRet = blobClient.Download();
EXPECT_FALSE(downloadRet->TagCount.HasValue());
EXPECT_FALSE(downloadRet->Details.TagCount.HasValue());
std::map<std::string, std::string> tags;
std::string c1 = "k" + RandomString();
@ -758,8 +758,8 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_EQ(properties.TagCount.GetValue(), static_cast<int64_t>(tags.size()));
downloadRet = blobClient.Download();
EXPECT_TRUE(downloadRet->TagCount.HasValue());
EXPECT_EQ(downloadRet->TagCount.GetValue(), static_cast<int64_t>(tags.size()));
EXPECT_TRUE(downloadRet->Details.TagCount.HasValue());
EXPECT_EQ(downloadRet->Details.TagCount.GetValue(), static_cast<int64_t>(tags.size()));
auto blobServiceClient = Azure::Storage::Blobs::BlobServiceClient::CreateFromConnectionString(
StandardStorageConnectionString());

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

@ -88,11 +88,11 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
EXPECT_TRUE(res->ETag.HasValue());
EXPECT_TRUE(IsValidTime(res->LastModified));
EXPECT_TRUE(IsValidTime(res->CreatedOn));
EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
EXPECT_EQ(res->Metadata, m_blobUploadOptions.Metadata);
EXPECT_TRUE(res->Details.ETag.HasValue());
EXPECT_TRUE(IsValidTime(res->Details.LastModified));
EXPECT_TRUE(IsValidTime(res->Details.CreatedOn));
EXPECT_EQ(res->Details.HttpHeaders, m_blobUploadOptions.HttpHeaders);
EXPECT_EQ(res->Details.Metadata, m_blobUploadOptions.Metadata);
EXPECT_EQ(res->BlobType, Azure::Storage::Blobs::Models::BlobType::BlockBlob);
Azure::Storage::Blobs::DownloadBlobOptions options;
options.Range = {1_MB, 2_MB};
@ -137,8 +137,8 @@ namespace Azure { namespace Storage { namespace Test {
{
{
auto res = m_blockBlobClient->Download();
ASSERT_TRUE(res->LastAccessedOn.HasValue());
EXPECT_TRUE(IsValidTime(res->LastAccessedOn.GetValue()));
ASSERT_TRUE(res->Details.LastAccessedOn.HasValue());
EXPECT_TRUE(IsValidTime(res->Details.LastAccessedOn.GetValue()));
}
{
auto res = m_blockBlobClient->GetProperties();
@ -184,10 +184,10 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
EXPECT_TRUE(res->ETag.HasValue());
EXPECT_TRUE(IsValidTime(res->LastModified));
EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
EXPECT_EQ(res->Metadata, m_blobUploadOptions.Metadata);
EXPECT_TRUE(res->Details.ETag.HasValue());
EXPECT_TRUE(IsValidTime(res->Details.LastModified));
EXPECT_EQ(res->Details.HttpHeaders, m_blobUploadOptions.HttpHeaders);
EXPECT_EQ(res->Details.Metadata, m_blobUploadOptions.Metadata);
EXPECT_EQ(res->BlobType, Azure::Storage::Blobs::Models::BlobType::BlockBlob);
Azure::Storage::Blobs::DownloadBlobOptions options;
@ -230,16 +230,18 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_FALSE(properties.IncrementalCopyDestinationSnapshot.HasValue());
auto downloadResult = blobClient.Download();
EXPECT_EQ(downloadResult->CopyId.GetValue(), res->CopyId);
EXPECT_FALSE(downloadResult->CopySource.GetValue().empty());
EXPECT_EQ(downloadResult->Details.CopyId.GetValue(), res->CopyId);
EXPECT_FALSE(downloadResult->Details.CopySource.GetValue().empty());
EXPECT_TRUE(
downloadResult->CopyStatus.GetValue() == Azure::Storage::Blobs::Models::CopyStatus::Pending
|| downloadResult->CopyStatus.GetValue()
downloadResult->Details.CopyStatus.GetValue()
== Azure::Storage::Blobs::Models::CopyStatus::Pending
|| downloadResult->Details.CopyStatus.GetValue()
== Azure::Storage::Blobs::Models::CopyStatus::Success);
EXPECT_FALSE(downloadResult->CopyProgress.GetValue().empty());
if (downloadResult->CopyStatus.GetValue() == Azure::Storage::Blobs::Models::CopyStatus::Success)
EXPECT_FALSE(downloadResult->Details.CopyProgress.GetValue().empty());
if (downloadResult->Details.CopyStatus.GetValue()
== Azure::Storage::Blobs::Models::CopyStatus::Success)
{
EXPECT_TRUE(IsValidTime(downloadResult->CopyCompletedOn.GetValue()));
EXPECT_TRUE(IsValidTime(downloadResult->Details.CopyCompletedOn.GetValue()));
}
}
@ -302,9 +304,9 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_TRUE(properties.IsCurrentVersion.GetValue());
auto downloadResponse = blobClient.Download();
ASSERT_TRUE(downloadResponse->VersionId.HasValue());
ASSERT_TRUE(downloadResponse->IsCurrentVersion.HasValue());
EXPECT_TRUE(downloadResponse->IsCurrentVersion.GetValue());
ASSERT_TRUE(downloadResponse->Details.VersionId.HasValue());
ASSERT_TRUE(downloadResponse->Details.IsCurrentVersion.HasValue());
EXPECT_TRUE(downloadResponse->Details.IsCurrentVersion.GetValue());
std::string version1 = properties.VersionId.GetValue();
@ -324,10 +326,10 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_FALSE(properties.IsCurrentVersion.GetValue());
EXPECT_EQ(version1, properties.VersionId.GetValue());
downloadResponse = versionClient.Download();
ASSERT_TRUE(downloadResponse->VersionId.HasValue());
ASSERT_TRUE(downloadResponse->IsCurrentVersion.HasValue());
EXPECT_FALSE(downloadResponse->IsCurrentVersion.GetValue());
EXPECT_EQ(version1, downloadResponse->VersionId.GetValue());
ASSERT_TRUE(downloadResponse->Details.VersionId.HasValue());
ASSERT_TRUE(downloadResponse->Details.IsCurrentVersion.HasValue());
EXPECT_FALSE(downloadResponse->Details.IsCurrentVersion.GetValue());
EXPECT_EQ(version1, downloadResponse->Details.VersionId.GetValue());
Azure::Storage::Blobs::ListBlobsSinglePageOptions options;
options.Prefix = blobName;
@ -723,18 +725,18 @@ namespace Azure { namespace Storage { namespace Test {
auto res = blockBlobClient.DownloadTo(emptyContent.data(), 0);
EXPECT_EQ(res->BlobSize, 0);
EXPECT_EQ(res->ContentRange.Length.GetValue(), 0);
EXPECT_TRUE(res->ETag.HasValue());
EXPECT_TRUE(IsValidTime(res->LastModified));
EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
EXPECT_EQ(res->Metadata, m_blobUploadOptions.Metadata);
EXPECT_TRUE(res->Details.ETag.HasValue());
EXPECT_TRUE(IsValidTime(res->Details.LastModified));
EXPECT_EQ(res->Details.HttpHeaders, m_blobUploadOptions.HttpHeaders);
EXPECT_EQ(res->Details.Metadata, m_blobUploadOptions.Metadata);
EXPECT_EQ(res->BlobType, Azure::Storage::Blobs::Models::BlobType::BlockBlob);
res = blockBlobClient.DownloadTo(tempFilename);
EXPECT_EQ(res->BlobSize, 0);
EXPECT_EQ(res->ContentRange.Length.GetValue(), 0);
EXPECT_TRUE(res->ETag.HasValue());
EXPECT_TRUE(IsValidTime(res->LastModified));
EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
EXPECT_EQ(res->Metadata, m_blobUploadOptions.Metadata);
EXPECT_TRUE(res->Details.ETag.HasValue());
EXPECT_TRUE(IsValidTime(res->Details.LastModified));
EXPECT_EQ(res->Details.HttpHeaders, m_blobUploadOptions.HttpHeaders);
EXPECT_EQ(res->Details.Metadata, m_blobUploadOptions.Metadata);
EXPECT_EQ(res->BlobType, Azure::Storage::Blobs::Models::BlobType::BlockBlob);
EXPECT_TRUE(ReadFile(tempFilename).empty());
DeleteFile(tempFilename);
@ -742,18 +744,18 @@ namespace Azure { namespace Storage { namespace Test {
res = blockBlobClient.DownloadTo(emptyContent.data(), static_cast<std::size_t>(8_MB));
EXPECT_EQ(res->BlobSize, 0);
EXPECT_EQ(res->ContentRange.Length.GetValue(), 0);
EXPECT_TRUE(res->ETag.HasValue());
EXPECT_TRUE(IsValidTime(res->LastModified));
EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
EXPECT_EQ(res->Metadata, m_blobUploadOptions.Metadata);
EXPECT_TRUE(res->Details.ETag.HasValue());
EXPECT_TRUE(IsValidTime(res->Details.LastModified));
EXPECT_EQ(res->Details.HttpHeaders, m_blobUploadOptions.HttpHeaders);
EXPECT_EQ(res->Details.Metadata, m_blobUploadOptions.Metadata);
EXPECT_EQ(res->BlobType, Azure::Storage::Blobs::Models::BlobType::BlockBlob);
res = blockBlobClient.DownloadTo(tempFilename);
EXPECT_EQ(res->BlobSize, 0);
EXPECT_EQ(res->ContentRange.Length.GetValue(), 0);
EXPECT_TRUE(res->ETag.HasValue());
EXPECT_TRUE(IsValidTime(res->LastModified));
EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
EXPECT_EQ(res->Metadata, m_blobUploadOptions.Metadata);
EXPECT_TRUE(res->Details.ETag.HasValue());
EXPECT_TRUE(IsValidTime(res->Details.LastModified));
EXPECT_EQ(res->Details.HttpHeaders, m_blobUploadOptions.HttpHeaders);
EXPECT_EQ(res->Details.Metadata, m_blobUploadOptions.Metadata);
EXPECT_EQ(res->BlobType, Azure::Storage::Blobs::Models::BlobType::BlockBlob);
EXPECT_TRUE(ReadFile(tempFilename).empty());
DeleteFile(tempFilename);
@ -769,18 +771,18 @@ namespace Azure { namespace Storage { namespace Test {
emptyContent.data(), static_cast<std::size_t>(8_MB), options);
EXPECT_EQ(res->BlobSize, 0);
EXPECT_EQ(res->ContentRange.Length.GetValue(), 0);
EXPECT_TRUE(res->ETag.HasValue());
EXPECT_TRUE(IsValidTime(res->LastModified));
EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
EXPECT_EQ(res->Metadata, m_blobUploadOptions.Metadata);
EXPECT_TRUE(res->Details.ETag.HasValue());
EXPECT_TRUE(IsValidTime(res->Details.LastModified));
EXPECT_EQ(res->Details.HttpHeaders, m_blobUploadOptions.HttpHeaders);
EXPECT_EQ(res->Details.Metadata, m_blobUploadOptions.Metadata);
EXPECT_EQ(res->BlobType, Azure::Storage::Blobs::Models::BlobType::BlockBlob);
res = blockBlobClient.DownloadTo(tempFilename, options);
EXPECT_EQ(res->BlobSize, 0);
EXPECT_EQ(res->ContentRange.Length.GetValue(), 0);
EXPECT_TRUE(res->ETag.HasValue());
EXPECT_TRUE(IsValidTime(res->LastModified));
EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
EXPECT_EQ(res->Metadata, m_blobUploadOptions.Metadata);
EXPECT_TRUE(res->Details.ETag.HasValue());
EXPECT_TRUE(IsValidTime(res->Details.LastModified));
EXPECT_EQ(res->Details.HttpHeaders, m_blobUploadOptions.HttpHeaders);
EXPECT_EQ(res->Details.Metadata, m_blobUploadOptions.Metadata);
EXPECT_EQ(res->BlobType, Azure::Storage::Blobs::Models::BlobType::BlockBlob);
EXPECT_TRUE(ReadFile(tempFilename).empty());
DeleteFile(tempFilename);

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

@ -294,34 +294,34 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
auto result = m_blobClient.Download(blobOptions);
Models::DownloadDataLakeFileResult ret;
ret.Body = std::move(result->BodyStream);
ret.HttpHeaders = FromBlobHttpHeaders(std::move(result->HttpHeaders));
ret.HttpHeaders = FromBlobHttpHeaders(std::move(result->Details.HttpHeaders));
ret.ContentRange = std::move(result->ContentRange);
ret.FileSize = result->BlobSize;
ret.TransactionalContentHash = std::move(result->TransactionalContentHash);
ret.ETag = std::move(result->ETag);
ret.LastModified = std::move(result->LastModified);
if (result->LeaseDuration.HasValue())
ret.ETag = std::move(result->Details.ETag);
ret.LastModified = std::move(result->Details.LastModified);
if (result->Details.LeaseDuration.HasValue())
{
ret.LeaseDuration = Models::LeaseDurationType(result->LeaseDuration.GetValue().Get());
ret.LeaseDuration = Models::LeaseDurationType(result->Details.LeaseDuration.GetValue().Get());
}
ret.LeaseState = result->LeaseState.HasValue()
? FromBlobLeaseState(result->LeaseState.GetValue())
ret.LeaseState = result->Details.LeaseState.HasValue()
? FromBlobLeaseState(result->Details.LeaseState.GetValue())
: ret.LeaseState;
ret.LeaseStatus = result->LeaseStatus.HasValue()
? FromBlobLeaseStatus(result->LeaseStatus.GetValue())
ret.LeaseStatus = result->Details.LeaseStatus.HasValue()
? FromBlobLeaseStatus(result->Details.LeaseStatus.GetValue())
: ret.LeaseStatus;
ret.Metadata = std::move(result->Metadata);
ret.CreatedOn = std::move(result->CreatedOn);
ret.ExpiresOn = std::move(result->ExpiresOn);
ret.LastAccessedOn = std::move(result->LastAccessedOn);
ret.CopyId = std::move(result->CopyId);
ret.CopySource = std::move(result->CopySource);
ret.CopyStatus = std::move(result->CopyStatus);
ret.CopyStatusDescription = std::move(result->CopyStatusDescription);
ret.CopyProgress = std::move(result->CopyProgress);
ret.CopyCompletedOn = std::move(result->CopyCompletedOn);
ret.VersionId = std::move(result->VersionId);
ret.IsCurrentVersion = std::move(result->IsCurrentVersion);
ret.Metadata = std::move(result->Details.Metadata);
ret.CreatedOn = std::move(result->Details.CreatedOn);
ret.ExpiresOn = std::move(result->Details.ExpiresOn);
ret.LastAccessedOn = std::move(result->Details.LastAccessedOn);
ret.CopyId = std::move(result->Details.CopyId);
ret.CopySource = std::move(result->Details.CopySource);
ret.CopyStatus = std::move(result->Details.CopyStatus);
ret.CopyStatusDescription = std::move(result->Details.CopyStatusDescription);
ret.CopyProgress = std::move(result->Details.CopyProgress);
ret.CopyCompletedOn = std::move(result->Details.CopyCompletedOn);
ret.VersionId = std::move(result->Details.VersionId);
ret.IsCurrentVersion = std::move(result->Details.IsCurrentVersion);
ret.RequestId = std::move(result->RequestId);
return Azure::Core::Response<Models::DownloadDataLakeFileResult>(
std::move(ret), result.ExtractRawResponse());
@ -365,13 +365,13 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
auto result = m_blockBlobClient.DownloadTo(buffer, bufferSize, options);
Models::DownloadDataLakeFileToResult ret;
ret.ETag = std::move(result->ETag);
ret.LastModified = std::move(result->LastModified);
ret.ETag = std::move(result->Details.ETag);
ret.LastModified = std::move(result->Details.LastModified);
ret.ContentLength = result->ContentRange.Length.GetValue();
ret.HttpHeaders = FromBlobHttpHeaders(std::move(result->HttpHeaders));
ret.Metadata = std::move(result->Metadata);
ret.ServerEncrypted = result->IsServerEncrypted;
ret.EncryptionKeySha256 = std::move(result->EncryptionKeySha256);
ret.HttpHeaders = FromBlobHttpHeaders(std::move(result->Details.HttpHeaders));
ret.Metadata = std::move(result->Details.Metadata);
ret.ServerEncrypted = result->Details.IsServerEncrypted;
ret.EncryptionKeySha256 = std::move(result->Details.EncryptionKeySha256);
return Azure::Core::Response<Models::DownloadDataLakeFileToResult>(
std::move(ret), result.ExtractRawResponse());
}
@ -382,13 +382,13 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
auto result = m_blockBlobClient.DownloadTo(fileName, options);
Models::DownloadDataLakeFileToResult ret;
ret.ETag = std::move(result->ETag);
ret.LastModified = std::move(result->LastModified);
ret.ETag = std::move(result->Details.ETag);
ret.LastModified = std::move(result->Details.LastModified);
ret.ContentLength = result->ContentRange.Length.GetValue();
ret.HttpHeaders = FromBlobHttpHeaders(std::move(result->HttpHeaders));
ret.Metadata = std::move(result->Metadata);
ret.ServerEncrypted = result->IsServerEncrypted;
ret.EncryptionKeySha256 = std::move(result->EncryptionKeySha256);
ret.HttpHeaders = FromBlobHttpHeaders(std::move(result->Details.HttpHeaders));
ret.Metadata = std::move(result->Details.Metadata);
ret.ServerEncrypted = result->Details.IsServerEncrypted;
ret.EncryptionKeySha256 = std::move(result->Details.EncryptionKeySha256);
return Azure::Core::Response<Models::DownloadDataLakeFileToResult>(
std::move(ret), result.ExtractRawResponse());
}