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

Fixed datalake/file service protocol layer remaining issues. (#523)

Browse Source 
* Fixed datalake build warnings on linux

* Pass context by reference instead.

* Added metadata key case check

* Fixed acronym casing.

* Fixes more acronym casing.
This commit is contained in:
Kan Tang 2020-08-26 07:42:46 +08:00 committed by GitHub
parent 760c645af0
commit 9c9e631c0d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 194 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
sdk/storage/inc/common/reliable_stream.hpp
View File

@ -10,7 +10,7 @@
namespace Azure { namespace Storage {
// options used by the fm callback that will get a bodyStream starting from last offset
struct HTTPGetterInfo
struct HttpGetterInfo
{
int64_t Offset = 0;
};
@ -18,7 +18,7 @@ namespace Azure { namespace Storage {
// Defines a fn signature to be use to get a bodyStream from an specific offset.
typedef std::function<std::unique_ptr<Azure::Core::Http::BodyStream>(
Azure::Core::Context const&,
HTTPGetterInfo const&)>
HttpGetterInfo const&)>
HTTPGetter;
// Options used by reliable stream
@ -49,7 +49,7 @@ namespace Azure { namespace Storage {
// callback to get a bodyStream in case Read operation fails
HTTPGetter m_httpGetter;
// Options to use when getting a new bodyStream like current offset
HTTPGetterInfo m_retryInfo;
HttpGetterInfo m_retryInfo;
public:
explicit ReliableStream(

82
sdk/storage/inc/datalake/protocol/datalake_rest_client.hpp
View File

@ -176,9 +176,9 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
struct SetAccessControlRecursiveResponse
{
int32_t DirectoriesSuccessful;
int32_t FilesSuccessful;
int32_t FailureCount;
int32_t DirectoriesSuccessful = int32_t();
int32_t FilesSuccessful = int32_t();
int32_t FailureCount = int32_t();
std::vector<AclFailedEntry> FailedEntries;
static SetAccessControlRecursiveResponse CreateFromJson(const nlohmann::json& node)
@ -198,10 +198,10 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
struct Path
{
std::string Name;
Azure::Core::Nullable<bool> IsDirectory;
bool IsDirectory = bool();
std::string LastModified;
std::string ETag;
Azure::Core::Nullable<int64_t> ContentLength;
int64_t ContentLength = int64_t();
std::string Owner;
std::string Group;
std::string Permissions;
@ -721,8 +721,8 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
std::string ResourceType;
Azure::Core::Nullable<std::string> Properties;
Azure::Core::Nullable<std::string> LeaseDuration;
LeaseStateType LeaseState;
LeaseStatusType LeaseStatus;
LeaseStateType LeaseState = LeaseStateType::Unknown;
LeaseStatusType LeaseStatus = LeaseStatusType::Unknown;
Azure::Core::Nullable<std::string> ContentMD5;
};
@ -740,7 +740,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
Azure::Core::Nullable<std::string> Owner;
Azure::Core::Nullable<std::string> Group;
Azure::Core::Nullable<std::string> Permissions;
Azure::Core::Nullable<std::string> ACL;
Azure::Core::Nullable<std::string> Acl;
Azure::Core::Nullable<std::string> LeaseDuration;
Azure::Core::Nullable<LeaseStateType> LeaseState;
Azure::Core::Nullable<LeaseStatusType> LeaseStatus;
@ -825,7 +825,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
static Azure::Core::Response<ServiceListFileSystemsResult> ListFileSystems(
std::string url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const Azure::Core::Context& context,
const ListFileSystemsOptions& listFileSystemsOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
@ -863,7 +863,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
private:
static Azure::Core::Response<ServiceListFileSystemsResult> ListFileSystemsParseResult(
Azure::Core::Context context,
const Azure::Core::Context& context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -921,7 +921,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
static Azure::Core::Response<FileSystemCreateResult> Create(
std::string url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const Azure::Core::Context& context,
const CreateOptions& createOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
@ -979,7 +979,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
static Azure::Core::Response<FileSystemSetPropertiesResult> SetProperties(
std::string url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const Azure::Core::Context& context,
const SetPropertiesOptions& setPropertiesOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Patch, url);
@ -1033,7 +1033,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
static Azure::Core::Response<FileSystemGetPropertiesResult> GetProperties(
std::string url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const Azure::Core::Context& context,
const GetPropertiesOptions& getPropertiesOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Head, url);
@ -1077,7 +1077,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
static Azure::Core::Response<FileSystemDeleteResult> Delete(
std::string url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const Azure::Core::Context& context,
const DeleteOptions& deleteOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Delete, url);
@ -1147,7 +1147,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
static Azure::Core::Response<FileSystemListPathsResult> ListPaths(
std::string url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const Azure::Core::Context& context,
const ListPathsOptions& listPathsOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
@ -1192,7 +1192,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
private:
static Azure::Core::Response<FileSystemCreateResult> CreateParseResult(
Azure::Core::Context context,
const Azure::Core::Context& context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -1214,7 +1214,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
static Azure::Core::Response<FileSystemSetPropertiesResult> SetPropertiesParseResult(
Azure::Core::Context context,
const Azure::Core::Context& context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -1235,7 +1235,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
static Azure::Core::Response<FileSystemGetPropertiesResult> GetPropertiesParseResult(
Azure::Core::Context context,
const Azure::Core::Context& context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -1258,7 +1258,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
static Azure::Core::Response<FileSystemDeleteResult> DeleteParseResult(
Azure::Core::Context context,
const Azure::Core::Context& context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -1277,7 +1277,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
static Azure::Core::Response<FileSystemListPathsResult> ListPathsParseResult(
Azure::Core::Context context,
const Azure::Core::Context& context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -1412,7 +1412,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
static Azure::Core::Response<PathCreateResult> Create(
std::string url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const Azure::Core::Context& context,
const CreateOptions& createOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
@ -1669,7 +1669,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
std::string url,
Azure::Core::Http::BodyStream& bodyStream,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const Azure::Core::Context& context,
const UpdateOptions& updateOptions)
{
Azure::Core::Http::Request request(
@ -1853,7 +1853,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
static Azure::Core::Response<PathLeaseResult> Lease(
std::string url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const Azure::Core::Context& context,
const LeaseOptions& leaseOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Post, url);
@ -1957,7 +1957,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
static Azure::Core::Response<PathReadResult> Read(
std::string url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const Azure::Core::Context& context,
const ReadOptions& readOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url, true);
@ -2052,7 +2052,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
static Azure::Core::Response<PathGetPropertiesResult> GetProperties(
std::string url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const Azure::Core::Context& context,
const GetPropertiesOptions& getPropertiesOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Head, url);
@ -2146,7 +2146,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
static Azure::Core::Response<PathDeleteResult> Delete(
std::string url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const Azure::Core::Context& context,
const DeleteOptions& deleteOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Delete, url);
@ -2243,7 +2243,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
static Azure::Core::Response<PathSetAccessControlResult> SetAccessControl(
std::string url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const Azure::Core::Context& context,
const SetAccessControlOptions& setAccessControlOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Patch, url);
@ -2344,7 +2344,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
static Azure::Core::Response<PathSetAccessControlRecursiveResult> SetAccessControlRecursive(
std::string url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const Azure::Core::Context& context,
const SetAccessControlRecursiveOptions& setAccessControlRecursiveOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Patch, url);
@ -2468,7 +2468,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
static Azure::Core::Response<PathFlushDataResult> FlushData(
std::string url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const Azure::Core::Context& context,
const FlushDataOptions& flushDataOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Patch, url);
@ -2600,7 +2600,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
std::string url,
Azure::Core::Http::BodyStream& bodyStream,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const Azure::Core::Context& context,
const AppendDataOptions& appendDataOptions)
{
Azure::Core::Http::Request request(
@ -2645,7 +2645,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
private:
static Azure::Core::Response<PathCreateResult> CreateParseResult(
Azure::Core::Context context,
const Azure::Core::Context& context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -2683,7 +2683,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
static Azure::Core::Response<PathUpdateResult> UpdateParseResult(
Azure::Core::Context context,
const Azure::Core::Context& context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -2769,7 +2769,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
static Azure::Core::Response<PathLeaseResult> LeaseParseResult(
Azure::Core::Context context,
const Azure::Core::Context& context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -2816,7 +2816,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
static Azure::Core::Response<PathReadResult> ReadParseResult(
Azure::Core::Context context,
const Azure::Core::Context& context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -2961,7 +2961,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
static Azure::Core::Response<PathGetPropertiesResult> GetPropertiesParseResult(
Azure::Core::Context context,
const Azure::Core::Context& context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -3036,7 +3036,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
if (response.GetHeaders().find(Details::c_HeaderXMsAcl) != response.GetHeaders().end())
{
result.ACL = response.GetHeaders().at(Details::c_HeaderXMsAcl);
result.Acl = response.GetHeaders().at(Details::c_HeaderXMsAcl);
}
if (response.GetHeaders().find(Details::c_HeaderXMsLeaseDuration)
!= response.GetHeaders().end())
@ -3066,7 +3066,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
static Azure::Core::Response<PathDeleteResult> DeleteParseResult(
Azure::Core::Context context,
const Azure::Core::Context& context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -3089,7 +3089,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
static Azure::Core::Response<PathSetAccessControlResult> SetAccessControlParseResult(
Azure::Core::Context context,
const Azure::Core::Context& context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -3111,7 +3111,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
static Azure::Core::Response<PathSetAccessControlRecursiveResult>
SetAccessControlRecursiveParseResult(
Azure::Core::Context context,
const Azure::Core::Context& context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -3141,7 +3141,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
static Azure::Core::Response<PathFlushDataResult> FlushDataParseResult(
Azure::Core::Context context,
const Azure::Core::Context& context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -3168,7 +3168,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
static Azure::Core::Response<PathAppendDataResult> AppendDataParseResult(
Azure::Core::Context context,
const Azure::Core::Context& context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;

198
sdk/storage/inc/shares/protocol/share_rest_client.hpp
View File

@ -989,7 +989,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
{
};
struct FileSetHTTPHeadersResult
struct FileSetHttpHeadersResult
{
std::string ETag;
std::string LastModified;
@ -1044,7 +1044,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
bool IsServerEncrypted = bool();
};
struct FileUploadRangeFromURLResult
struct FileUploadRangeFromUrlResult
{
std::string ETag;
std::string LastModified;
@ -2107,10 +2107,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
request.AddQueryParameter(
Details::c_QueryTimeout, std::to_string(createOptions.Timeout.GetValue()));
}
std::set<std::string> metadataKeys;
for (const auto& pair : createOptions.Metadata)
{
std::string key = pair.first;
std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
return static_cast<char>(std::tolower(c));
});
if (metadataKeys.insert(key).second == false)
{
throw std::runtime_error("duplicate keys in metadata");
}
request.AddHeader(Details::c_HeaderMetadata + ("-" + pair.first), pair.second);
}
metadataKeys.clear();
if (createOptions.ShareQuota.HasValue())
{
request.AddHeader(
@ -2229,10 +2239,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
request.AddQueryParameter(
Details::c_QueryTimeout, std::to_string(createSnapshotOptions.Timeout.GetValue()));
}
std::set<std::string> metadataKeys;
for (const auto& pair : createSnapshotOptions.Metadata)
{
std::string key = pair.first;
std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
return static_cast<char>(std::tolower(c));
});
if (metadataKeys.insert(key).second == false)
{
throw std::runtime_error("duplicate keys in metadata");
}
request.AddHeader(Details::c_HeaderMetadata + ("-" + pair.first), pair.second);
}
metadataKeys.clear();
request.AddHeader(Details::c_HeaderVersion, createSnapshotOptions.ApiVersionParameter);
return CreateSnapshotParseResult(context, pipeline.Send(context, request));
}
@ -2375,10 +2395,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
request.AddQueryParameter(
Details::c_QueryTimeout, std::to_string(setMetadataOptions.Timeout.GetValue()));
}
std::set<std::string> metadataKeys;
for (const auto& pair : setMetadataOptions.Metadata)
{
std::string key = pair.first;
std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
return static_cast<char>(std::tolower(c));
});
if (metadataKeys.insert(key).second == false)
{
throw std::runtime_error("duplicate keys in metadata");
}
request.AddHeader(Details::c_HeaderMetadata + ("-" + pair.first), pair.second);
}
metadataKeys.clear();
request.AddHeader(Details::c_HeaderVersion, setMetadataOptions.ApiVersionParameter);
return SetMetadataParseResult(context, pipeline.Send(context, request));
}
@ -3195,10 +3225,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
request.AddQueryParameter(
Details::c_QueryTimeout, std::to_string(createOptions.Timeout.GetValue()));
}
std::set<std::string> metadataKeys;
for (const auto& pair : createOptions.Metadata)
{
std::string key = pair.first;
std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
return static_cast<char>(std::tolower(c));
});
if (metadataKeys.insert(key).second == false)
{
throw std::runtime_error("duplicate keys in metadata");
}
request.AddHeader(Details::c_HeaderMetadata + ("-" + pair.first), pair.second);
}
metadataKeys.clear();
request.AddHeader(Details::c_HeaderVersion, createOptions.ApiVersionParameter);
if (createOptions.FilePermission.HasValue())
{
@ -3370,10 +3410,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
request.AddQueryParameter(
Details::c_QueryTimeout, std::to_string(setMetadataOptions.Timeout.GetValue()));
}
std::set<std::string> metadataKeys;
for (const auto& pair : setMetadataOptions.Metadata)
{
std::string key = pair.first;
std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
return static_cast<char>(std::tolower(c));
});
if (metadataKeys.insert(key).second == false)
{
throw std::runtime_error("duplicate keys in metadata");
}
request.AddHeader(Details::c_HeaderMetadata + ("-" + pair.first), pair.second);
}
metadataKeys.clear();
request.AddHeader(Details::c_HeaderVersion, setMetadataOptions.ApiVersionParameter);
return SetMetadataParseResult(context, pipeline.Send(context, request));
}
@ -4454,10 +4504,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
Details::c_HeaderFileContentDisposition,
createOptions.FileContentDisposition.GetValue());
}
std::set<std::string> metadataKeys;
for (const auto& pair : createOptions.Metadata)
{
std::string key = pair.first;
std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
return static_cast<char>(std::tolower(c));
});
if (metadataKeys.insert(key).second == false)
{
throw std::runtime_error("duplicate keys in metadata");
}
request.AddHeader(Details::c_HeaderMetadata + ("-" + pair.first), pair.second);
}
metadataKeys.clear();
if (createOptions.FilePermission.HasValue())
{
request.AddHeader(
@ -4605,7 +4665,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
return DeleteParseResult(context, pipeline.Send(context, request));
}
struct SetHTTPHeadersOptions
struct SetHttpHeadersOptions
{
Azure::Core::Nullable<int32_t>
Timeout; // The timeout parameter is expressed in seconds. For more information, see <a
@ -4653,82 +4713,82 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
// active and matches this ID.
};
static Azure::Core::Response<FileSetHTTPHeadersResult> SetHTTPHeaders(
static Azure::Core::Response<FileSetHttpHeadersResult> SetHttpHeaders(
std::string url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const SetHTTPHeadersOptions& setHTTPHeadersOptions)
const SetHttpHeadersOptions& setHttpHeadersOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader(Details::c_HeaderContentLength, "0");
request.AddQueryParameter(Details::c_QueryComp, "properties");
if (setHTTPHeadersOptions.Timeout.HasValue())
if (setHttpHeadersOptions.Timeout.HasValue())
{
request.AddQueryParameter(
Details::c_QueryTimeout, std::to_string(setHTTPHeadersOptions.Timeout.GetValue()));
Details::c_QueryTimeout, std::to_string(setHttpHeadersOptions.Timeout.GetValue()));
}
request.AddHeader(Details::c_HeaderVersion, setHTTPHeadersOptions.ApiVersionParameter);
if (setHTTPHeadersOptions.XMsContentLength.HasValue())
request.AddHeader(Details::c_HeaderVersion, setHttpHeadersOptions.ApiVersionParameter);
if (setHttpHeadersOptions.XMsContentLength.HasValue())
{
request.AddHeader(
Details::c_HeaderFileContentLength,
std::to_string(setHTTPHeadersOptions.XMsContentLength.GetValue()));
std::to_string(setHttpHeadersOptions.XMsContentLength.GetValue()));
}
if (setHTTPHeadersOptions.FileContentType.HasValue())
if (setHttpHeadersOptions.FileContentType.HasValue())
{
request.AddHeader(
Details::c_HeaderFileContentType, setHTTPHeadersOptions.FileContentType.GetValue());
Details::c_HeaderFileContentType, setHttpHeadersOptions.FileContentType.GetValue());
}
if (setHTTPHeadersOptions.FileContentEncoding.HasValue())
if (setHttpHeadersOptions.FileContentEncoding.HasValue())
{
request.AddHeader(
Details::c_HeaderFileContentEncoding,
setHTTPHeadersOptions.FileContentEncoding.GetValue());
setHttpHeadersOptions.FileContentEncoding.GetValue());
}
if (setHTTPHeadersOptions.FileContentLanguage.HasValue())
if (setHttpHeadersOptions.FileContentLanguage.HasValue())
{
request.AddHeader(
Details::c_HeaderFileContentLanguage,
setHTTPHeadersOptions.FileContentLanguage.GetValue());
setHttpHeadersOptions.FileContentLanguage.GetValue());
}
if (setHTTPHeadersOptions.FileCacheControl.HasValue())
if (setHttpHeadersOptions.FileCacheControl.HasValue())
{
request.AddHeader(
Details::c_HeaderFileCacheControl, setHTTPHeadersOptions.FileCacheControl.GetValue());
Details::c_HeaderFileCacheControl, setHttpHeadersOptions.FileCacheControl.GetValue());
}
if (setHTTPHeadersOptions.FileContentMD5.HasValue())
if (setHttpHeadersOptions.FileContentMD5.HasValue())
{
request.AddHeader(
Details::c_HeaderFileContentMD5, setHTTPHeadersOptions.FileContentMD5.GetValue());
Details::c_HeaderFileContentMD5, setHttpHeadersOptions.FileContentMD5.GetValue());
}
if (setHTTPHeadersOptions.FileContentDisposition.HasValue())
if (setHttpHeadersOptions.FileContentDisposition.HasValue())
{
request.AddHeader(
Details::c_HeaderFileContentDisposition,
setHTTPHeadersOptions.FileContentDisposition.GetValue());
setHttpHeadersOptions.FileContentDisposition.GetValue());
}
if (setHTTPHeadersOptions.FilePermission.HasValue())
if (setHttpHeadersOptions.FilePermission.HasValue())
{
request.AddHeader(
Details::c_HeaderFilePermission, setHTTPHeadersOptions.FilePermission.GetValue());
Details::c_HeaderFilePermission, setHttpHeadersOptions.FilePermission.GetValue());
}
if (setHTTPHeadersOptions.FilePermissionKey.HasValue())
if (setHttpHeadersOptions.FilePermissionKey.HasValue())
{
request.AddHeader(
Details::c_HeaderFilePermissionKey,
setHTTPHeadersOptions.FilePermissionKey.GetValue());
setHttpHeadersOptions.FilePermissionKey.GetValue());
}
request.AddHeader(Details::c_HeaderFileAttributes, setHTTPHeadersOptions.FileAttributes);
request.AddHeader(Details::c_HeaderFileAttributes, setHttpHeadersOptions.FileAttributes);
request.AddHeader(
Details::c_HeaderFileCreationTime, setHTTPHeadersOptions.FileCreationTime);
Details::c_HeaderFileCreationTime, setHttpHeadersOptions.FileCreationTime);
request.AddHeader(
Details::c_HeaderFileLastWriteTime, setHTTPHeadersOptions.FileLastWriteTime);
if (setHTTPHeadersOptions.LeaseIdOptional.HasValue())
Details::c_HeaderFileLastWriteTime, setHttpHeadersOptions.FileLastWriteTime);
if (setHttpHeadersOptions.LeaseIdOptional.HasValue())
{
request.AddHeader(
Details::c_HeaderLeaseId, setHTTPHeadersOptions.LeaseIdOptional.GetValue());
Details::c_HeaderLeaseId, setHttpHeadersOptions.LeaseIdOptional.GetValue());
}
return SetHTTPHeadersParseResult(context, pipeline.Send(context, request));
return SetHttpHeadersParseResult(context, pipeline.Send(context, request));
}
struct SetMetadataOptions
@ -4761,10 +4821,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
request.AddQueryParameter(
Details::c_QueryTimeout, std::to_string(setMetadataOptions.Timeout.GetValue()));
}
std::set<std::string> metadataKeys;
for (const auto& pair : setMetadataOptions.Metadata)
{
std::string key = pair.first;
std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
return static_cast<char>(std::tolower(c));
});
if (metadataKeys.insert(key).second == false)
{
throw std::runtime_error("duplicate keys in metadata");
}
request.AddHeader(Details::c_HeaderMetadata + ("-" + pair.first), pair.second);
}
metadataKeys.clear();
request.AddHeader(Details::c_HeaderVersion, setMetadataOptions.ApiVersionParameter);
if (setMetadataOptions.LeaseIdOptional.HasValue())
{
@ -5045,7 +5115,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
return UploadRangeParseResult(context, pipeline.Send(context, request));
}
struct UploadRangeFromURLOptions
struct UploadRangeFromUrlOptions
{
Azure::Core::Nullable<int32_t>
Timeout; // The timeout parameter is expressed in seconds. For more information, see <a
@ -5087,59 +5157,59 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
// active and matches this ID.
};
static Azure::Core::Response<FileUploadRangeFromURLResult> UploadRangeFromURL(
static Azure::Core::Response<FileUploadRangeFromUrlResult> UploadRangeFromUrl(
std::string url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const UploadRangeFromURLOptions& uploadRangeFromURLOptions)
const UploadRangeFromUrlOptions& uploadRangeFromUrlOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader(Details::c_HeaderContentLength, "0");
request.AddQueryParameter(Details::c_QueryComp, "range");
if (uploadRangeFromURLOptions.Timeout.HasValue())
if (uploadRangeFromUrlOptions.Timeout.HasValue())
{
request.AddQueryParameter(
Details::c_QueryTimeout,
std::to_string(uploadRangeFromURLOptions.Timeout.GetValue()));
std::to_string(uploadRangeFromUrlOptions.Timeout.GetValue()));
}
request.AddHeader(Details::c_HeaderRange, uploadRangeFromURLOptions.TargetRange);
request.AddHeader(Details::c_HeaderCopySource, uploadRangeFromURLOptions.CopySource);
if (uploadRangeFromURLOptions.SourceRange.HasValue())
request.AddHeader(Details::c_HeaderRange, uploadRangeFromUrlOptions.TargetRange);
request.AddHeader(Details::c_HeaderCopySource, uploadRangeFromUrlOptions.CopySource);
if (uploadRangeFromUrlOptions.SourceRange.HasValue())
{
request.AddHeader(
Details::c_HeaderSourceRange, uploadRangeFromURLOptions.SourceRange.GetValue());
Details::c_HeaderSourceRange, uploadRangeFromUrlOptions.SourceRange.GetValue());
}
request.AddHeader(
Details::c_HeaderFileRangeWriteFromUrl,
FileRangeWriteFromUrlTypeToString(uploadRangeFromURLOptions.XMsWrite));
FileRangeWriteFromUrlTypeToString(uploadRangeFromUrlOptions.XMsWrite));
request.AddHeader(
Details::c_HeaderContentLength,
std::to_string(uploadRangeFromURLOptions.ContentLength));
if (uploadRangeFromURLOptions.SourceContentCrc64.HasValue())
std::to_string(uploadRangeFromUrlOptions.ContentLength));
if (uploadRangeFromUrlOptions.SourceContentCrc64.HasValue())
{
request.AddHeader(
Details::c_HeaderSourceContentCrc64,
uploadRangeFromURLOptions.SourceContentCrc64.GetValue());
uploadRangeFromUrlOptions.SourceContentCrc64.GetValue());
}
if (uploadRangeFromURLOptions.SourceIfMatchCrc64.HasValue())
if (uploadRangeFromUrlOptions.SourceIfMatchCrc64.HasValue())
{
request.AddHeader(
Details::c_HeaderSourceIfMatchCrc64,
uploadRangeFromURLOptions.SourceIfMatchCrc64.GetValue());
uploadRangeFromUrlOptions.SourceIfMatchCrc64.GetValue());
}
if (uploadRangeFromURLOptions.SourceIfNoneMatchCrc64.HasValue())
if (uploadRangeFromUrlOptions.SourceIfNoneMatchCrc64.HasValue())
{
request.AddHeader(
Details::c_HeaderSourceIfNoneMatchCrc64,
uploadRangeFromURLOptions.SourceIfNoneMatchCrc64.GetValue());
uploadRangeFromUrlOptions.SourceIfNoneMatchCrc64.GetValue());
}
request.AddHeader(Details::c_HeaderVersion, uploadRangeFromURLOptions.ApiVersionParameter);
if (uploadRangeFromURLOptions.LeaseIdOptional.HasValue())
request.AddHeader(Details::c_HeaderVersion, uploadRangeFromUrlOptions.ApiVersionParameter);
if (uploadRangeFromUrlOptions.LeaseIdOptional.HasValue())
{
request.AddHeader(
Details::c_HeaderLeaseId, uploadRangeFromURLOptions.LeaseIdOptional.GetValue());
Details::c_HeaderLeaseId, uploadRangeFromUrlOptions.LeaseIdOptional.GetValue());
}
return UploadRangeFromURLParseResult(context, pipeline.Send(context, request));
return UploadRangeFromUrlParseResult(context, pipeline.Send(context, request));
}
struct GetRangeListOptions
@ -5269,10 +5339,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
Details::c_QueryTimeout, std::to_string(startCopyOptions.Timeout.GetValue()));
}
request.AddHeader(Details::c_HeaderVersion, startCopyOptions.ApiVersionParameter);
std::set<std::string> metadataKeys;
for (const auto& pair : startCopyOptions.Metadata)
{
std::string key = pair.first;
std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
return static_cast<char>(std::tolower(c));
});
if (metadataKeys.insert(key).second == false)
{
throw std::runtime_error("duplicate keys in metadata");
}
request.AddHeader(Details::c_HeaderMetadata + ("-" + pair.first), pair.second);
}
metadataKeys.clear();
request.AddHeader(Details::c_HeaderCopySource, startCopyOptions.CopySource);
if (startCopyOptions.FilePermission.HasValue())
{
@ -5910,7 +5990,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
}
}
static Azure::Core::Response<FileSetHTTPHeadersResult> SetHTTPHeadersParseResult(
static Azure::Core::Response<FileSetHttpHeadersResult> SetHttpHeadersParseResult(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
@ -5918,7 +5998,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
{
// Success
FileSetHTTPHeadersResult result;
FileSetHttpHeadersResult result;
result.ETag = response.GetHeaders().at(Details::c_HeaderETag);
result.LastModified = response.GetHeaders().at(Details::c_HeaderLastModified);
result.IsServerEncrypted
@ -5930,7 +6010,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
result.FileChangeTime = response.GetHeaders().at(Details::c_HeaderFileChangeTime);
result.FileId = response.GetHeaders().at(Details::c_HeaderFileId);
result.FileParentId = response.GetHeaders().at(Details::c_HeaderFileParentId);
return Azure::Core::Response<FileSetHTTPHeadersResult>(
return Azure::Core::Response<FileSetHttpHeadersResult>(
std::move(result), std::move(responsePtr));
}
else
@ -6080,7 +6160,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
}
}
static Azure::Core::Response<FileUploadRangeFromURLResult> UploadRangeFromURLParseResult(
static Azure::Core::Response<FileUploadRangeFromUrlResult> UploadRangeFromUrlParseResult(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
@ -6088,13 +6168,13 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Created)
{
// Success (Created).
FileUploadRangeFromURLResult result;
FileUploadRangeFromUrlResult result;
result.ETag = response.GetHeaders().at(Details::c_HeaderETag);
result.LastModified = response.GetHeaders().at(Details::c_HeaderLastModified);
result.XMsContentCrc64 = response.GetHeaders().at(Details::c_HeaderXMsContentCrc64);
result.IsServerEncrypted
= response.GetHeaders().at(Details::c_HeaderRequestIsServerEncrypted) == "true";
return Azure::Core::Response<FileUploadRangeFromURLResult>(
return Azure::Core::Response<FileUploadRangeFromUrlResult>(
std::move(result), std::move(responsePtr));
}
else

6
sdk/storage/inc/shares/share_responses.hpp
View File

@ -89,12 +89,12 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
using StartCopyFileResult = FileStartCopyResult;
using AbortCopyFileResult = FileAbortCopyResult;
using GetFilePropertiesResult = FileGetPropertiesResult;
using SetFilePropertiesResult = FileSetHTTPHeadersResult;
using ResizeFileResult = FileSetHTTPHeadersResult;
using SetFilePropertiesResult = FileSetHttpHeadersResult;
using ResizeFileResult = FileSetHttpHeadersResult;
using SetFileMetadataResult = FileSetMetadataResult;
using UploadFileRangeResult = FileUploadRangeResult;
using ClearFileRangeResult = FileUploadRangeResult;
using UploadFileRangeFromUrlResult = FileUploadRangeFromURLResult;
using UploadFileRangeFromUrlResult = FileUploadRangeFromUrlResult;
using GetFileRangeListResult = FileGetRangeListResult;
using ListFileHandlesSegmentedResult = ListDirectoryHandlesSegmentedResult;
using ForceCloseFileHandlesResult = FileForceCloseHandlesResult;

2
sdk/storage/src/blobs/blob_client.cpp
View File

@ -191,7 +191,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto retryFunction
= [this, options, eTag](
const Azure::Core::Context& context,
const HTTPGetterInfo& retryInfo) -> std::unique_ptr<Azure::Core::Http::BodyStream> {
const HttpGetterInfo& retryInfo) -> std::unique_ptr<Azure::Core::Http::BodyStream> {
unused(context);
DownloadBlobOptions newOptions = options;

4
sdk/storage/src/datalake/datalake_path_client.cpp
View File

@ -320,9 +320,9 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
auto result = DataLakeRestClient::Path::GetProperties(
m_dfsUri.ToString(), *m_pipeline, options.Context, protocolLayerOptions);
Azure::Core::Nullable<std::vector<Acl>> acl;
if (result->ACL.HasValue())
if (result->Acl.HasValue())
{
acl = Acl::DeserializeAcls(result->ACL.GetValue());
acl = Acl::DeserializeAcls(result->Acl.GetValue());
}
auto ret = GetPathAccessControlResult{};
ret.ETag = std::move(result->ETag);

10
sdk/storage/src/shares/share_file_client.cpp
View File

@ -238,7 +238,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
auto retryFunction
= [this, options, eTag](
const Azure::Core::Context& context,
const HTTPGetterInfo& retryInfo) -> std::unique_ptr<Azure::Core::Http::BodyStream> {
const HttpGetterInfo& retryInfo) -> std::unique_ptr<Azure::Core::Http::BodyStream> {
unused(context);
DownloadFileOptions newOptions = options;
@ -322,7 +322,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
FileShareSmbProperties smbProperties,
const SetFilePropertiesOptions& options) const
{
auto protocolLayerOptions = ShareRestClient::File::SetHTTPHeadersOptions();
auto protocolLayerOptions = ShareRestClient::File::SetHttpHeadersOptions();
protocolLayerOptions.FileAttributes = FileAttributesToString(smbProperties.Attributes);
if (smbProperties.FileCreationTime.HasValue())
{
@ -376,7 +376,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
protocolLayerOptions.FileContentDisposition = httpHeaders.ContentDisposition;
}
return ShareRestClient::File::SetHTTPHeaders(
return ShareRestClient::File::SetHttpHeaders(
m_shareFileUri.ToString(), *m_pipeline, options.Context, protocolLayerOptions);
}
@ -413,7 +413,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
int64_t length,
const UploadFileRangeFromUrlOptions& options) const
{
auto protocolLayerOptions = ShareRestClient::File::UploadRangeFromURLOptions();
auto protocolLayerOptions = ShareRestClient::File::UploadRangeFromUrlOptions();
protocolLayerOptions.XMsWrite = FileRangeWriteFromUrlType::Update;
protocolLayerOptions.CopySource = std::move(sourceUrl);
protocolLayerOptions.ContentLength = length;
@ -437,7 +437,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
protocolLayerOptions.SourceIfMatchCrc64 = options.SourceIfMatchCrc64;
protocolLayerOptions.SourceIfNoneMatchCrc64 = options.SourceIfNoneMatchCrc64;
protocolLayerOptions.LeaseIdOptional = options.AccessConditions.LeaseId;
return ShareRestClient::File::UploadRangeFromURL(
return ShareRestClient::File::UploadRangeFromUrl(
m_shareFileUri.ToString(), *m_pipeline, options.Context, protocolLayerOptions);
}