From ae6ada5cfb6701b7199ed006812d626c7a7fc0b9 Mon Sep 17 00:00:00 2001 From: Kan Tang Date: Wed, 26 Aug 2020 07:43:29 +0800 Subject: [PATCH] Added lease support for DataLake's Path (#521) --- sdk/storage/inc/datalake/datalake_options.hpp | 7 ++ .../inc/datalake/datalake_path_client.hpp | 74 +++++++++++++++++++ .../inc/datalake/datalake_responses.hpp | 5 ++ .../datalake/datalake_path_client_test.cpp | 55 ++++++++++++++ 4 files changed, 141 insertions(+) diff --git a/sdk/storage/inc/datalake/datalake_options.hpp b/sdk/storage/inc/datalake/datalake_options.hpp index f842e241b..5207642b1 100644 --- a/sdk/storage/inc/datalake/datalake_options.hpp +++ b/sdk/storage/inc/datalake/datalake_options.hpp @@ -719,4 +719,11 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { */ int Concurrency = 1; }; + + using AcquirePathLeaseOptions = Blobs::AcquireBlobLeaseOptions; + using BreakPathLeaseOptions = Blobs::BreakBlobLeaseOptions; + using RenewPathLeaseOptions = Blobs::RenewBlobLeaseOptions; + using ReleasePathLeaseOptions = Blobs::ReleaseBlobLeaseOptions; + using ChangePathLeaseOptions = Blobs::ChangeBlobLeaseOptions; + }}}} // namespace Azure::Storage::Files::DataLake diff --git a/sdk/storage/inc/datalake/datalake_path_client.hpp b/sdk/storage/inc/datalake/datalake_path_client.hpp index 6365c1b2f..7d48d6afd 100644 --- a/sdk/storage/inc/datalake/datalake_path_client.hpp +++ b/sdk/storage/inc/datalake/datalake_path_client.hpp @@ -170,6 +170,80 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { const std::map& metadata, const SetPathMetadataOptions& options = SetPathMetadataOptions()) const; + /** + * @brief Acquires a lease on the path. + * @param proposedLeaseId Proposed lease ID, in a GUID string format. + * @param duration Specifies the duration of the lease, in seconds, or + * Azure::Storage::c_InfiniteLeaseDuration for a lease that never expires. A non-infinite lease + * can be between 15 and 60 seconds. A lease duration cannot be changed using renew or change. + * @param options Optional parameters to execute this function. + * @return A AcquirePathLeaseResult describing the lease. + * @remark This request is sent to blob endpoint. + */ + Azure::Core::Response AcquireLease( + const std::string& proposedLeaseId, + int32_t duration, + const AcquirePathLeaseOptions& options = AcquirePathLeaseOptions()) const + { + return m_blobClient.AcquireLease(proposedLeaseId, duration, options); + } + + /** + * @brief Renews the path's previously-acquired lease. + * @param leaseId ID of the previously-acquired lease. + * @param options Optional parameters to execute this function. + * @return A RenewPathLeaseResult describing the lease. + * @remark This request is sent to blob endpoint. + */ + Azure::Core::Response RenewLease( + const std::string& leaseId, + const RenewPathLeaseOptions& options = RenewPathLeaseOptions()) const + { + return m_blobClient.RenewLease(leaseId, options); + } + + /** + * @brief Releases the path's previously-acquired lease. + * @param leaseId ID of the previously-acquired lease. + * @param options Optional parameters to execute this function. + * @return A ReleasePathLeaseResult describing the updated path. + * @remark This request is sent to blob endpoint. + */ + Azure::Core::Response ReleaseLease( + const std::string& leaseId, + const ReleasePathLeaseOptions& options = ReleasePathLeaseOptions()) const + { + return m_blobClient.ReleaseLease(leaseId, options); + } + + /** + * @brief Changes the lease of an active lease. + * @param leaseId ID of the previously-acquired lease. + * @param proposedLeaseId Proposed lease ID, in a GUID string format. + * @param options Optional parameters to execute this function. + * @return A ChangePathLeaseResult describing the lease. + * @remark This request is sent to blob endpoint. + */ + Azure::Core::Response ChangeLease( + const std::string& leaseId, + const std::string& proposedLeaseId, + const ChangePathLeaseOptions& options = ChangePathLeaseOptions()) const + { + return m_blobClient.ChangeLease(leaseId, proposedLeaseId, options); + } + + /** + * @brief Breaks the previously-acquired lease. + * @param options Optional parameters to execute this function. + * @return A BreakPathLeaseResult describing the broken lease. + * @remark This request is sent to blob endpoint. + */ + Azure::Core::Response BreakLease( + const BreakPathLeaseOptions& options = BreakPathLeaseOptions()) const + { + return m_blobClient.BreakLease(options); + } + protected: UriBuilder m_dfsUri; Blobs::BlobClient m_blobClient; diff --git a/sdk/storage/inc/datalake/datalake_responses.hpp b/sdk/storage/inc/datalake/datalake_responses.hpp index c9f05e157..a2e500fe7 100644 --- a/sdk/storage/inc/datalake/datalake_responses.hpp +++ b/sdk/storage/inc/datalake/datalake_responses.hpp @@ -31,6 +31,11 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { // PathClient models: using DeletePathResult = PathDeleteResult; + using AcquirePathLeaseResult = Blobs::AcquireBlobLeaseResult; + using RenewPathLeaseResult = Blobs::RenewBlobLeaseResult; + using ReleasePathLeaseResult = Blobs::ReleaseBlobLeaseResult; + using ChangePathLeaseResult = Blobs::ChangeBlobLeaseResult; + using BreakPathLeaseResult = Blobs::BreakBlobLeaseResult; struct Acl { diff --git a/sdk/storage/test/datalake/datalake_path_client_test.cpp b/sdk/storage/test/datalake/datalake_path_client_test.cpp index 921d51c4d..dc268d335 100644 --- a/sdk/storage/test/datalake/datalake_path_client_test.cpp +++ b/sdk/storage/test/datalake/datalake_path_client_test.cpp @@ -231,4 +231,59 @@ namespace Azure { namespace Storage { namespace Test { EXPECT_NO_THROW(m_pathClient->SetAccessControl(acls, options2)); } } + + TEST_F(DataLakePathClientTest, LeaseRelated) + { + std::string leaseId1 = CreateUniqueLeaseId(); + int32_t leaseDuration = 20; + auto aLease = *m_pathClient->AcquireLease(leaseId1, leaseDuration); + EXPECT_FALSE(aLease.ETag.empty()); + EXPECT_FALSE(aLease.LastModified.empty()); + EXPECT_EQ(aLease.LeaseId, leaseId1); + aLease = *m_pathClient->AcquireLease(leaseId1, leaseDuration); + EXPECT_FALSE(aLease.ETag.empty()); + EXPECT_FALSE(aLease.LastModified.empty()); + EXPECT_EQ(aLease.LeaseId, leaseId1); + + auto properties = *m_pathClient->GetProperties(); + EXPECT_EQ(properties.LeaseState.GetValue(), Files::DataLake::LeaseStateType::Leased); + EXPECT_EQ(properties.LeaseStatus.GetValue(), Files::DataLake::LeaseStatusType::Locked); + EXPECT_FALSE(properties.LeaseDuration.GetValue().empty()); + + auto rLease = *m_pathClient->RenewLease(leaseId1); + EXPECT_FALSE(rLease.ETag.empty()); + EXPECT_FALSE(rLease.LastModified.empty()); + EXPECT_EQ(rLease.LeaseId, leaseId1); + + std::string leaseId2 = CreateUniqueLeaseId(); + EXPECT_NE(leaseId1, leaseId2); + auto cLease = *m_pathClient->ChangeLease(leaseId1, leaseId2); + EXPECT_FALSE(cLease.ETag.empty()); + EXPECT_FALSE(cLease.LastModified.empty()); + EXPECT_EQ(cLease.LeaseId, leaseId2); + + auto pathInfo = *m_pathClient->ReleaseLease(leaseId2); + EXPECT_FALSE(pathInfo.ETag.empty()); + EXPECT_FALSE(pathInfo.LastModified.empty()); + + aLease = *m_pathClient->AcquireLease(CreateUniqueLeaseId(), c_InfiniteLeaseDuration); + properties = *m_pathClient->GetProperties(); + EXPECT_FALSE(properties.LeaseDuration.GetValue().empty()); + auto brokenLease = *m_pathClient->BreakLease(); + EXPECT_FALSE(brokenLease.ETag.empty()); + EXPECT_FALSE(brokenLease.LastModified.empty()); + EXPECT_EQ(brokenLease.LeaseTime, 0); + + aLease = *m_pathClient->AcquireLease(CreateUniqueLeaseId(), leaseDuration); + Files::DataLake::BreakPathLeaseOptions breakOptions; + breakOptions.breakPeriod = 30; + brokenLease = *m_pathClient->BreakLease(breakOptions); + EXPECT_FALSE(brokenLease.ETag.empty()); + EXPECT_FALSE(brokenLease.LastModified.empty()); + EXPECT_NE(brokenLease.LeaseTime, 0); + + Files::DataLake::BreakPathLeaseOptions options; + options.breakPeriod = 0; + m_pathClient->BreakLease(options); + } }}} // namespace Azure::Storage::Test