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

Refined list related APIs and make LeaseDuration an enum. (#1445)

Browse Source 
* Refined list related APIs

* Update CHANGELOG.md
This commit is contained in:
Kan Tang 2021-01-24 18:14:33 -08:00 committed by GitHub
parent 23df72519b
commit f27c5770d1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 104 additions and 353 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -10,6 +10,8 @@
- Moved all protocol layer generated result types to `Details` namespace.
- Renamed `FileSystem` type returned from `ListDataLakeFileSystems` to be `FileSystemItem`. Member object name `FileSystems` is renamed to `Items`.
- Renamed `Path` type returned from `ListDataLakePaths` to be `PathItem`. Member object name `Paths` is renamed to `Items`.
- Added `Metadata`, `AccessType`, `HasImmutabilityPolicy`, `HasLegalHold`, `LeaseDuration`, `LeaseState` and `LeaseStatus` to `FileSystemItem`.
- Added new type `LeaseDurationType` to indicate if a lease duration is fixed or infinite.
### Breaking Changes
@ -22,6 +24,8 @@
- Renamed `GetUri` to `GetUrl`.
- Added `DataLakeLeaseClient`, all lease related APIs are moved to `DataLakeLeaseClient`.
- Changed lease duration to be `std::chrono::seconds`.
- Removed unused type `AccountResourceType` and `PathLeaseAction`.
- Changed all previous `LeaseDuration` members to a new type named `LeaseDurationType`.
## 12.0.0-beta.6 (2020-01-14)

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

@ -96,6 +96,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
* include up to 5,000 items.
*/
Azure::Core::Nullable<int32_t> PageSizeHint;
/**
* @brief Specifies that the filesystem's metadata be returned.
*/
Models::ListDataLakeFileSystemsIncludeItem Include
= Models::ListDataLakeFileSystemsIncludeItem::None;
};
/**

30
sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_responses.hpp
View File

@ -17,12 +17,36 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { nam
using GetUserDelegationKeyResult = Blobs::Models::GetUserDelegationKeyResult;
using UserDelegationKey = Blobs::Models::UserDelegationKey;
using ListFileSystemsSinglePageResult = Details::ServiceListFileSystemsResult;
struct FileSystemItem
{
std::string Name;
std::string ETag;
Azure::Core::DateTime LastModified;
Storage::Metadata Metadata;
PublicAccessType AccessType = PublicAccessType::None;
bool HasImmutabilityPolicy = false;
bool HasLegalHold = false;
Azure::Core::Nullable<LeaseDurationType> LeaseDuration;
LeaseStateType LeaseState = LeaseStateType::Available;
LeaseStatusType LeaseStatus = LeaseStatusType::Unlocked;
}; // struct BlobContainerItem
struct ListFileSystemsSinglePageResult
{
std::string RequestId;
std::string ServiceEndpoint;
std::string Prefix;
Azure::Core::Nullable<std::string> PreviousContinuationToken;
Azure::Core::Nullable<std::string> ContinuationToken;
std::vector<FileSystemItem> Items;
}; // struct ListFileSystemsSinglePageResult
// FileSystemClient models:
using ListPathsSinglePageResult = Details::FileSystemListPathsResult;
using DataLakeSignedIdentifier = Blobs::Models::BlobSignedIdentifier;
using ListDataLakeFileSystemsIncludeItem = Blobs::Models::ListBlobContainersIncludeItem;
struct GetDataLakeFileSystemAccessPolicyResult
{
@ -112,7 +136,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { nam
Core::DateTime CreatedOn;
int64_t FileSize;
Storage::Metadata Metadata;
Azure::Core::Nullable<std::string> LeaseDuration;
Azure::Core::Nullable<LeaseDurationType> LeaseDuration;
Azure::Core::Nullable<LeaseStateType> LeaseState;
Azure::Core::Nullable<LeaseStatusType> LeaseStatus;
PathHttpHeaders HttpHeaders;
@ -178,7 +202,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { nam
Azure::Core::Nullable<Storage::ContentHash> TransactionalContentHash;
std::string ETag;
Core::DateTime LastModified;
Azure::Core::Nullable<std::string> LeaseDuration;
Azure::Core::Nullable<LeaseDurationType> LeaseDuration;
LeaseStateType LeaseState;
LeaseStatusType LeaseStatus;
Storage::Metadata Metadata;

356
sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/protocol/datalake_rest_client.hpp
View File

@ -118,13 +118,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
std::string Permissions;
};
struct FileSystemItem
{
std::string Name;
Core::DateTime LastModified;
std::string ETag;
};
class PublicAccessType {
public:
PublicAccessType() = default;
@ -141,21 +134,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
std::string m_value;
}; // extensible enum PublicAccessType
// The value must be "account" for all account operations.
class AccountResourceType {
public:
AccountResourceType() = default;
explicit AccountResourceType(std::string value) : m_value(std::move(value)) {}
bool operator==(const AccountResourceType& other) const { return m_value == other.m_value; }
bool operator!=(const AccountResourceType& other) const { return !(*this == other); }
const std::string& Get() const { return m_value; }
AZ_STORAGE_FILES_DATALAKE_DLLEXPORT const static AccountResourceType Account;
private:
std::string m_value;
}; // extensible enum AccountResourceType
// Required only for Create File and Create Directory. The value must be "file" or "directory".
class PathResourceType {
public:
@ -190,33 +168,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
std::string m_value;
}; // extensible enum PathRenameMode
// There are five lease actions: "acquire", "break", "change", "renew", and "release". Use
// "acquire" and specify the "x-ms-proposed-lease-id" and "x-ms-lease-duration" to acquire a new
// lease. Use "break" to break an existing lease. When a lease is broken, the lease break period
// is allowed to elapse, during which time no lease operation except break and release can be
// performed on the file. When a lease is successfully broken, the response indicates the
// interval in seconds until a new lease can be acquired. Use "change" and specify the current
// lease ID in "x-ms-lease-id" and the new lease ID in "x-ms-proposed-lease-id" to change the
// lease ID of an active lease. Use "renew" and specify the "x-ms-lease-id" to renew an existing
// lease. Use "release" and specify the "x-ms-lease-id" to release a lease.
class PathLeaseAction {
public:
PathLeaseAction() = default;
explicit PathLeaseAction(std::string value) : m_value(std::move(value)) {}
bool operator==(const PathLeaseAction& other) const { return m_value == other.m_value; }
bool operator!=(const PathLeaseAction& other) const { return !(*this == other); }
const std::string& Get() const { return m_value; }
AZ_STORAGE_FILES_DATALAKE_DLLEXPORT const static PathLeaseAction Acquire;
AZ_STORAGE_FILES_DATALAKE_DLLEXPORT const static PathLeaseAction Break;
AZ_STORAGE_FILES_DATALAKE_DLLEXPORT const static PathLeaseAction Change;
AZ_STORAGE_FILES_DATALAKE_DLLEXPORT const static PathLeaseAction Renew;
AZ_STORAGE_FILES_DATALAKE_DLLEXPORT const static PathLeaseAction Release;
private:
std::string m_value;
}; // extensible enum PathLeaseAction
// Optional. If the value is "getStatus" only the system defined properties for the path are
// returned. If the value is "getAccessControl" the access control list is returned in the
// response headers (Hierarchical Namespace must be enabled for the account), otherwise the
@ -239,6 +190,22 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
std::string m_value;
}; // extensible enum PathGetPropertiesAction
// When a resource is leased, specifies whether the lease is of infinite or fixed duration.
class LeaseDurationType {
public:
LeaseDurationType() = default;
explicit LeaseDurationType(std::string value) : m_value(std::move(value)) {}
bool operator==(const LeaseDurationType& other) const { return m_value == other.m_value; }
bool operator!=(const LeaseDurationType& other) const { return !(*this == other); }
const std::string& Get() const { return m_value; }
AZ_STORAGE_FILES_DATALAKE_DLLEXPORT const static LeaseDurationType Infinite;
AZ_STORAGE_FILES_DATALAKE_DLLEXPORT const static LeaseDurationType Fixed;
private:
std::string m_value;
}; // extensible enum LeaseDurationType
// Lease state of the resource.
class LeaseStateType {
public:
@ -292,7 +259,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
constexpr static const char* QueryPosition = "position";
constexpr static const char* QueryRetainUncommittedData = "retainuncommitteddata";
constexpr static const char* QueryClose = "close";
constexpr static const char* QueryResource = "resource";
constexpr static const char* QueryPathResourceType = "resource";
constexpr static const char* QueryPathRenameMode = "mode";
constexpr static const char* QueryPathGetPropertiesAction = "action";
@ -331,18 +297,15 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
constexpr static const char* HeaderExpiryOptions = "x-ms-expiry-option";
constexpr static const char* HeaderExpiresOn = "x-ms-expiry-time";
constexpr static const char* HeaderDate = "date";
constexpr static const char* HeaderClientRequestId = "x-ms-client-request-id";
constexpr static const char* HeaderContinuationToken = "x-ms-continuation";
constexpr static const char* HeaderErrorCode = "x-ms-error-code";
constexpr static const char* HeaderETag = "etag";
constexpr static const char* HeaderLastModified = "last-modified";
constexpr static const char* HeaderClientRequestId = "x-ms-client-request-id";
constexpr static const char* HeaderNamespaceEnabled = "x-ms-namespace-enabled";
constexpr static const char* HeaderPathLeaseAction = "x-ms-lease-action";
constexpr static const char* HeaderXMsLeaseDuration = "x-ms-lease-duration";
constexpr static const char* HeaderXMsLeaseBreakPeriod = "x-ms-lease-break-period";
constexpr static const char* HeaderLeaseTime = "x-ms-lease-time";
constexpr static const char* HeaderErrorCode = "x-ms-error-code";
constexpr static const char* HeaderContinuationToken = "x-ms-continuation";
constexpr static const char* HeaderAcceptRanges = "accept-ranges";
constexpr static const char* HeaderResourceType = "x-ms-resource-type";
constexpr static const char* HeaderLeaseDuration = "x-ms-lease-duration";
constexpr static const char* HeaderLeaseState = "x-ms-lease-state";
constexpr static const char* HeaderLeaseStatus = "x-ms-lease-status";
constexpr static const char* HeaderRequestIsServerEncrypted = "x-ms-request-server-encrypted";
@ -360,17 +323,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
std::vector<PathItem> Items;
};
struct FileSystemList
{
std::vector<FileSystemItem> Items;
};
struct ServiceListFileSystemsResult
{
std::vector<FileSystemItem> Items;
Azure::Core::Nullable<std::string> ContinuationToken;
};
struct FileSystemCreateResult
{
std::string ETag;
@ -410,14 +362,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
Azure::Core::Nullable<int64_t> ContentLength;
};
struct PathLeaseResult
{
std::string ETag;
Core::DateTime LastModified;
std::string LeaseId;
int32_t LeaseTime = int32_t();
};
struct PathGetPropertiesResult
{
Azure::Core::Nullable<std::string> AcceptRanges;
@ -430,7 +374,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
Azure::Core::Nullable<std::string> Group;
Azure::Core::Nullable<std::string> Permissions;
Azure::Core::Nullable<std::string> Acl;
Azure::Core::Nullable<std::string> LeaseDuration;
Azure::Core::Nullable<LeaseDurationType> LeaseDuration;
Azure::Core::Nullable<LeaseStateType> LeaseState;
Azure::Core::Nullable<LeaseStatusType> LeaseStatus;
};
@ -476,122 +420,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
class DataLakeRestClient {
public:
class Service {
public:
struct ListFileSystemsOptions
{
Azure::Core::Nullable<std::string> Prefix;
Azure::Core::Nullable<std::string> ContinuationToken;
Azure::Core::Nullable<int32_t> MaxResults;
Azure::Core::Nullable<std::string> ClientRequestId;
Azure::Core::Nullable<int32_t> Timeout;
std::string ApiVersionParameter = Details::DefaultServiceApiVersion;
};
static Azure::Core::Response<ServiceListFileSystemsResult> ListFileSystems(
const Azure::Core::Http::Url& url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const ListFileSystemsOptions& listFileSystemsOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
request.GetUrl().AppendQueryParameter(Details::QueryResource, "account");
if (listFileSystemsOptions.Prefix.HasValue())
{
request.GetUrl().AppendQueryParameter(
Details::QueryPrefix,
Storage::Details::UrlEncodeQueryParameter(
listFileSystemsOptions.Prefix.GetValue()));
}
if (listFileSystemsOptions.ContinuationToken.HasValue())
{
request.GetUrl().AppendQueryParameter(
Details::QueryContinuationToken,
Storage::Details::UrlEncodeQueryParameter(
listFileSystemsOptions.ContinuationToken.GetValue()));
}
if (listFileSystemsOptions.MaxResults.HasValue())
{
request.GetUrl().AppendQueryParameter(
Details::QueryPageSizeHint,
Storage::Details::UrlEncodeQueryParameter(
std::to_string(listFileSystemsOptions.MaxResults.GetValue())));
}
if (listFileSystemsOptions.ClientRequestId.HasValue())
{
request.AddHeader(
Details::HeaderRequestId, listFileSystemsOptions.ClientRequestId.GetValue());
}
if (listFileSystemsOptions.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
Details::QueryTimeout,
Storage::Details::UrlEncodeQueryParameter(
std::to_string(listFileSystemsOptions.Timeout.GetValue())));
}
request.AddHeader(Details::HeaderVersion, listFileSystemsOptions.ApiVersionParameter);
return ListFileSystemsParseResult(context, pipeline.Send(context, request));
}
private:
static Azure::Core::Response<ServiceListFileSystemsResult> ListFileSystemsParseResult(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
{
// OK
const auto& bodyBuffer = response.GetBody();
ServiceListFileSystemsResult result = bodyBuffer.empty()
? ServiceListFileSystemsResult()
: ServiceListFileSystemsResultFromFileSystemList(
FileSystemListFromJson(Azure::Core::Internal::Json::json::parse(bodyBuffer)));
if (response.GetHeaders().find(Details::HeaderContinuationToken)
!= response.GetHeaders().end())
{
result.ContinuationToken = response.GetHeaders().at(Details::HeaderContinuationToken);
}
return Azure::Core::Response<ServiceListFileSystemsResult>(
std::move(result), std::move(responsePtr));
}
else
{
unused(context);
throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
}
}
static FileSystemItem FileSystemItemFromJson(const Azure::Core::Internal::Json::json& node)
{
FileSystemItem result;
result.Name = node["name"].get<std::string>();
result.LastModified = Core::DateTime::Parse(
node["lastModified"].get<std::string>(), Core::DateTime::DateFormat::Rfc1123);
result.ETag = node["etag"].get<std::string>();
return result;
}
static FileSystemList FileSystemListFromJson(const Azure::Core::Internal::Json::json& node)
{
FileSystemList result;
for (const auto& element : node["filesystems"])
{
result.Items.emplace_back(FileSystemItemFromJson(element));
}
return result;
}
static ServiceListFileSystemsResult ServiceListFileSystemsResultFromFileSystemList(
FileSystemList object)
{
ServiceListFileSystemsResult result;
result.Items = std::move(object.Items);
return result;
}
};
class FileSystem {
public:
struct CreateOptions
@ -1168,89 +996,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
return CreateParseResult(context, pipeline.Send(context, request));
}
struct LeaseOptions
{
Azure::Core::Nullable<std::string> ClientRequestId;
Azure::Core::Nullable<int32_t> Timeout;
std::string ApiVersionParameter = Details::DefaultServiceApiVersion;
PathLeaseAction XMsLeaseAction;
Azure::Core::Nullable<int32_t> XMsLeaseDuration;
Azure::Core::Nullable<int32_t> XMsLeaseBreakPeriod;
Azure::Core::Nullable<std::string> LeaseIdOptional;
Azure::Core::Nullable<std::string> ProposedLeaseIdOptional;
Azure::Core::Nullable<std::string> IfMatch;
Azure::Core::Nullable<std::string> IfNoneMatch;
Azure::Core::Nullable<Core::DateTime> IfModifiedSince;
Azure::Core::Nullable<Core::DateTime> IfUnmodifiedSince;
};
static Azure::Core::Response<PathLeaseResult> Lease(
const Azure::Core::Http::Url& url,
Azure::Core::Http::HttpPipeline& pipeline,
Azure::Core::Context context,
const LeaseOptions& leaseOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Post, url);
request.AddHeader(Details::HeaderContentLength, "0");
if (leaseOptions.ClientRequestId.HasValue())
{
request.AddHeader(Details::HeaderRequestId, leaseOptions.ClientRequestId.GetValue());
}
if (leaseOptions.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
Details::QueryTimeout,
Storage::Details::UrlEncodeQueryParameter(
std::to_string(leaseOptions.Timeout.GetValue())));
}
request.AddHeader(Details::HeaderVersion, leaseOptions.ApiVersionParameter);
request.AddHeader(Details::HeaderPathLeaseAction, (leaseOptions.XMsLeaseAction.Get()));
if (leaseOptions.XMsLeaseDuration.HasValue())
{
request.AddHeader(
Details::HeaderXMsLeaseDuration,
std::to_string(leaseOptions.XMsLeaseDuration.GetValue()));
}
if (leaseOptions.XMsLeaseBreakPeriod.HasValue())
{
request.AddHeader(
Details::HeaderXMsLeaseBreakPeriod,
std::to_string(leaseOptions.XMsLeaseBreakPeriod.GetValue()));
}
if (leaseOptions.LeaseIdOptional.HasValue())
{
request.AddHeader(Details::HeaderLeaseId, leaseOptions.LeaseIdOptional.GetValue());
}
if (leaseOptions.ProposedLeaseIdOptional.HasValue())
{
request.AddHeader(
Details::HeaderProposedLeaseId, leaseOptions.ProposedLeaseIdOptional.GetValue());
}
if (leaseOptions.IfMatch.HasValue())
{
request.AddHeader(Details::HeaderIfMatch, leaseOptions.IfMatch.GetValue());
}
if (leaseOptions.IfNoneMatch.HasValue())
{
request.AddHeader(Details::HeaderIfNoneMatch, leaseOptions.IfNoneMatch.GetValue());
}
if (leaseOptions.IfModifiedSince.HasValue())
{
request.AddHeader(
Details::HeaderIfModifiedSince,
leaseOptions.IfModifiedSince.GetValue().GetString(
Core::DateTime::DateFormat::Rfc1123));
}
if (leaseOptions.IfUnmodifiedSince.HasValue())
{
request.AddHeader(
Details::HeaderIfUnmodifiedSince,
leaseOptions.IfUnmodifiedSince.GetValue().GetString(
Core::DateTime::DateFormat::Rfc1123));
}
return LeaseParseResult(context, pipeline.Send(context, request));
}
struct GetPropertiesOptions
{
Azure::Core::Nullable<std::string> ClientRequestId;
@ -1837,60 +1582,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
}
static Azure::Core::Response<PathLeaseResult> LeaseParseResult(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
{
// The "renew", "change" or "release" action was successful.
PathLeaseResult result;
result.ETag = response.GetHeaders().at(Details::HeaderETag);
result.LastModified = Core::DateTime::Parse(
response.GetHeaders().at(Details::HeaderLastModified),
Core::DateTime::DateFormat::Rfc1123);
if (response.GetHeaders().find(Details::HeaderLeaseId) != response.GetHeaders().end())
{
result.LeaseId = response.GetHeaders().at(Details::HeaderLeaseId);
}
return Azure::Core::Response<PathLeaseResult>(
std::move(result), std::move(responsePtr));
}
else if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Created)
{
// A new lease has been created. The "acquire" action was successful.
PathLeaseResult result;
result.ETag = response.GetHeaders().at(Details::HeaderETag);
result.LastModified = Core::DateTime::Parse(
response.GetHeaders().at(Details::HeaderLastModified),
Core::DateTime::DateFormat::Rfc1123);
if (response.GetHeaders().find(Details::HeaderLeaseId) != response.GetHeaders().end())
{
result.LeaseId = response.GetHeaders().at(Details::HeaderLeaseId);
}
return Azure::Core::Response<PathLeaseResult>(
std::move(result), std::move(responsePtr));
}
else if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Accepted)
{
// The "break" lease action was successful.
PathLeaseResult result;
result.ETag = response.GetHeaders().at(Details::HeaderETag);
result.LastModified = Core::DateTime::Parse(
response.GetHeaders().at(Details::HeaderLastModified),
Core::DateTime::DateFormat::Rfc1123);
result.LeaseTime = std::stoi(response.GetHeaders().at(Details::HeaderLeaseTime));
return Azure::Core::Response<PathLeaseResult>(
std::move(result), std::move(responsePtr));
}
else
{
unused(context);
throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
}
}
static Azure::Core::Response<PathGetPropertiesResult> GetPropertiesParseResult(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
@ -1963,10 +1654,11 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
result.Acl = response.GetHeaders().at(Details::HeaderAcl);
}
if (response.GetHeaders().find(Details::HeaderXMsLeaseDuration)
if (response.GetHeaders().find(Details::HeaderLeaseDuration)
!= response.GetHeaders().end())
{
result.LeaseDuration = response.GetHeaders().at(Details::HeaderXMsLeaseDuration);
result.LeaseDuration
= LeaseDurationType(response.GetHeaders().at(Details::HeaderLeaseDuration));
}
if (response.GetHeaders().find(Details::HeaderLeaseState)
!= response.GetHeaders().end())

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

@ -331,10 +331,9 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
ret.TransactionalContentHash = std::move(result->TransactionalContentHash);
ret.ETag = std::move(result->ETag);
ret.LastModified = std::move(result->LastModified);
// FIXME
if (result->LeaseDuration.HasValue())
{
ret.LeaseDuration = result->LeaseDuration.GetValue().Get();
ret.LeaseDuration = Models::LeaseDurationType(result->LeaseDuration.GetValue().Get());
}
ret.LeaseState = result->LeaseState.HasValue()
? FromBlobLeaseState(result->LeaseState.GetValue())

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

@ -359,10 +359,9 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
ret.LastModified = std::move(result->LastModified);
ret.CreatedOn = std::move(result->CreatedOn);
ret.Metadata = std::move(result->Metadata);
// FIXME
if (result->LeaseDuration.HasValue())
{
ret.LeaseDuration = result->LeaseDuration.GetValue().Get();
ret.LeaseDuration = Models::LeaseDurationType(result->LeaseDuration.GetValue().Get());
}
ret.LeaseState = result->LeaseState.HasValue()
? FromBlobLeaseState(result->LeaseState.GetValue())

11
sdk/storage/azure-storage-files-datalake/src/datalake_rest_client.cpp
View File

@ -20,23 +20,18 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { nam
const PublicAccessType PublicAccessType::Path("Path");
const PublicAccessType PublicAccessType::None("None");
const AccountResourceType AccountResourceType::Account("account");
const PathResourceType PathResourceType::Directory("directory");
const PathResourceType PathResourceType::File("file");
const PathRenameMode PathRenameMode::Legacy("legacy");
const PathRenameMode PathRenameMode::Posix("posix");
const PathLeaseAction PathLeaseAction::Acquire("acquire");
const PathLeaseAction PathLeaseAction::Break("break");
const PathLeaseAction PathLeaseAction::Change("change");
const PathLeaseAction PathLeaseAction::Renew("renew");
const PathLeaseAction PathLeaseAction::Release("release");
const PathGetPropertiesAction PathGetPropertiesAction::GetAccessControl("getAccessControl");
const PathGetPropertiesAction PathGetPropertiesAction::GetStatus("getStatus");
const LeaseDurationType LeaseDurationType::Infinite("infinite");
const LeaseDurationType LeaseDurationType::Fixed("fixed");
const LeaseStateType LeaseStateType::Available("available");
const LeaseStateType LeaseStateType::Leased("leased");
const LeaseStateType LeaseStateType::Expired("expired");

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

@ -36,15 +36,42 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
std::vector<Models::FileSystemItem> FileSystemsFromContainerItems(
const std::vector<Blobs::Models::BlobContainerItem>& items)
std::vector<Blobs::Models::BlobContainerItem> items)
{
std::vector<Models::FileSystemItem> fileSystems;
for (const auto& item : items)
for (auto& item : items)
{
Models::FileSystemItem fileSystem;
fileSystem.ETag = item.ETag;
fileSystem.Name = item.Name;
fileSystem.LastModified = item.LastModified;
fileSystem.Name = std::move(item.Name);
fileSystem.ETag = std::move(item.ETag);
fileSystem.LastModified = std::move(item.LastModified);
fileSystem.Metadata = std::move(item.Metadata);
if (item.AccessType == Blobs::Models::PublicAccessType::BlobContainer)
{
fileSystem.AccessType = Models::PublicAccessType::FileSystem;
}
else if (item.AccessType == Blobs::Models::PublicAccessType::Blob)
{
fileSystem.AccessType = Models::PublicAccessType::Path;
}
else if (item.AccessType == Blobs::Models::PublicAccessType::Private)
{
fileSystem.AccessType = Models::PublicAccessType::None;
}
else
{
fileSystem.AccessType = Models::PublicAccessType(item.AccessType.Get());
}
fileSystem.HasImmutabilityPolicy = item.HasImmutabilityPolicy;
fileSystem.HasLegalHold = item.HasLegalHold;
if (item.LeaseDuration.HasValue())
{
fileSystem.LeaseDuration
= Models::LeaseDurationType((item.LeaseDuration.GetValue().Get()));
}
fileSystem.LeaseState = Models::LeaseStateType(item.LeaseState.Get());
fileSystem.LeaseStatus = Models::LeaseStatusType(item.LeaseStatus.Get());
fileSystems.emplace_back(std::move(fileSystem));
}
return fileSystems;
@ -177,6 +204,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const ListFileSystemsSinglePageOptions& options) const
{
Blobs::ListBlobContainersSinglePageOptions blobOptions;
blobOptions.Include = options.Include;
blobOptions.Context = options.Context;
blobOptions.Prefix = options.Prefix;
blobOptions.ContinuationToken = options.ContinuationToken;
@ -184,7 +212,11 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
auto result = m_blobServiceClient.ListBlobContainersSinglePage(blobOptions);
auto response = Models::ListFileSystemsSinglePageResult();
response.ContinuationToken = std::move(result->ContinuationToken);
response.Items = FileSystemsFromContainerItems(result->Items);
response.PreviousContinuationToken = std::move(result->PreviousContinuationToken);
response.RequestId = std::move(result->RequestId);
response.ServiceEndpoint = std::move(result->ServiceEndpoint);
response.Prefix = std::move(result->Prefix);
response.Items = FileSystemsFromContainerItems(std::move(result->Items));
return Azure::Core::Response<Models::ListFileSystemsSinglePageResult>(
std::move(response), result.ExtractRawResponse());
}