diff --git a/sdk/storage/azure-storage-files-datalake/CHANGELOG.md b/sdk/storage/azure-storage-files-datalake/CHANGELOG.md index b91ddc816..e7d37bf00 100644 --- a/sdk/storage/azure-storage-files-datalake/CHANGELOG.md +++ b/sdk/storage/azure-storage-files-datalake/CHANGELOG.md @@ -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) diff --git a/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_options.hpp b/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_options.hpp index 15955ac09..0b76babb6 100644 --- a/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_options.hpp +++ b/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_options.hpp @@ -96,6 +96,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { * include up to 5,000 items. */ Azure::Core::Nullable PageSizeHint; + + /** + * @brief Specifies that the filesystem's metadata be returned. + */ + Models::ListDataLakeFileSystemsIncludeItem Include + = Models::ListDataLakeFileSystemsIncludeItem::None; }; /** diff --git a/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_responses.hpp b/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_responses.hpp index 45a096a6f..b3d4ad00c 100644 --- a/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_responses.hpp +++ b/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_responses.hpp @@ -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 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 PreviousContinuationToken; + Azure::Core::Nullable ContinuationToken; + std::vector 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 LeaseDuration; + Azure::Core::Nullable LeaseDuration; Azure::Core::Nullable LeaseState; Azure::Core::Nullable LeaseStatus; PathHttpHeaders HttpHeaders; @@ -178,7 +202,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { nam Azure::Core::Nullable TransactionalContentHash; std::string ETag; Core::DateTime LastModified; - Azure::Core::Nullable LeaseDuration; + Azure::Core::Nullable LeaseDuration; LeaseStateType LeaseState; LeaseStatusType LeaseStatus; Storage::Metadata Metadata; diff --git a/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/protocol/datalake_rest_client.hpp b/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/protocol/datalake_rest_client.hpp index ef11a642e..89aefe483 100644 --- a/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/protocol/datalake_rest_client.hpp +++ b/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/protocol/datalake_rest_client.hpp @@ -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 Items; }; - struct FileSystemList - { - std::vector Items; - }; - - struct ServiceListFileSystemsResult - { - std::vector Items; - Azure::Core::Nullable ContinuationToken; - }; - struct FileSystemCreateResult { std::string ETag; @@ -410,14 +362,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { Azure::Core::Nullable ContentLength; }; - struct PathLeaseResult - { - std::string ETag; - Core::DateTime LastModified; - std::string LeaseId; - int32_t LeaseTime = int32_t(); - }; - struct PathGetPropertiesResult { Azure::Core::Nullable AcceptRanges; @@ -430,7 +374,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { Azure::Core::Nullable Group; Azure::Core::Nullable Permissions; Azure::Core::Nullable Acl; - Azure::Core::Nullable LeaseDuration; + Azure::Core::Nullable LeaseDuration; Azure::Core::Nullable LeaseState; Azure::Core::Nullable LeaseStatus; }; @@ -476,122 +420,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { class DataLakeRestClient { public: - class Service { - public: - struct ListFileSystemsOptions - { - Azure::Core::Nullable Prefix; - Azure::Core::Nullable ContinuationToken; - Azure::Core::Nullable MaxResults; - Azure::Core::Nullable ClientRequestId; - Azure::Core::Nullable Timeout; - std::string ApiVersionParameter = Details::DefaultServiceApiVersion; - }; - - static Azure::Core::Response 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 ListFileSystemsParseResult( - Azure::Core::Context context, - std::unique_ptr 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( - 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(); - result.LastModified = Core::DateTime::Parse( - node["lastModified"].get(), Core::DateTime::DateFormat::Rfc1123); - result.ETag = node["etag"].get(); - 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 ClientRequestId; - Azure::Core::Nullable Timeout; - std::string ApiVersionParameter = Details::DefaultServiceApiVersion; - PathLeaseAction XMsLeaseAction; - Azure::Core::Nullable XMsLeaseDuration; - Azure::Core::Nullable XMsLeaseBreakPeriod; - Azure::Core::Nullable LeaseIdOptional; - Azure::Core::Nullable ProposedLeaseIdOptional; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - }; - - static Azure::Core::Response 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 ClientRequestId; @@ -1837,60 +1582,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { } } - static Azure::Core::Response LeaseParseResult( - Azure::Core::Context context, - std::unique_ptr 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( - 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( - 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( - std::move(result), std::move(responsePtr)); - } - else - { - unused(context); - throw Storage::StorageException::CreateFromResponse(std::move(responsePtr)); - } - } - static Azure::Core::Response GetPropertiesParseResult( Azure::Core::Context context, std::unique_ptr 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()) diff --git a/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp b/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp index 5e74bab06..65421a6b1 100644 --- a/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp +++ b/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp @@ -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()) diff --git a/sdk/storage/azure-storage-files-datalake/src/datalake_path_client.cpp b/sdk/storage/azure-storage-files-datalake/src/datalake_path_client.cpp index fbb329fe7..5bc1dd981 100644 --- a/sdk/storage/azure-storage-files-datalake/src/datalake_path_client.cpp +++ b/sdk/storage/azure-storage-files-datalake/src/datalake_path_client.cpp @@ -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()) diff --git a/sdk/storage/azure-storage-files-datalake/src/datalake_rest_client.cpp b/sdk/storage/azure-storage-files-datalake/src/datalake_rest_client.cpp index a501c6c48..e3db90f72 100644 --- a/sdk/storage/azure-storage-files-datalake/src/datalake_rest_client.cpp +++ b/sdk/storage/azure-storage-files-datalake/src/datalake_rest_client.cpp @@ -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"); diff --git a/sdk/storage/azure-storage-files-datalake/src/datalake_service_client.cpp b/sdk/storage/azure-storage-files-datalake/src/datalake_service_client.cpp index f51bac5ab..5065bb1c6 100644 --- a/sdk/storage/azure-storage-files-datalake/src/datalake_service_client.cpp +++ b/sdk/storage/azure-storage-files-datalake/src/datalake_service_client.cpp @@ -36,15 +36,42 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { } std::vector FileSystemsFromContainerItems( - const std::vector& items) + std::vector items) { std::vector 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( std::move(response), result.ExtractRawResponse()); }