Reject Range Lock/Unlock Requests with Conflicting Range, User, or Lock Type (#12047)

* fix range lock

* make bulkload workload correct

* fix bugs and improve test coverage

* nits

* address comments

* nits

* address comments

Author: kakaiu

Diff for: documentation/sphinx/source/rangelock.rst

@@ -39,16 +39,19 @@ Ideally, we would use the write lock to achieve this; however, we are currently
 
 How to use?
 -----------
-Currently, FDB only provides ManagementAPI to lock a range. 
-Before a user can lock a range, the user must register its identity to the database.
-A range can only be locked by a registered owner.
-The user can use the following API to register an identity and lock a range.
+Currently, FDB provides the ManagementAPI for range locking, intended as an interface for FDB feature development.
+Before locking a range, a user must first register their identity with the database.
+Only registered users are permitted to acquire range locks.
+The following API can be used to register an identity and lock a range.
 
 Put an exclusive read lock on a range. The range must be within the user key space, aka ``"" ~ \xff``.
+The locking request is rejected with a range_lock_reject error if the range contains any existing lock with a different range, user, or lock type.
+Currently, only the ExclusiveReadLock type is supported, but the design allows for future extension.
 
 ``ACTOR Future<Void> takeExclusiveReadLockOnRange(Database cx, KeyRange range, RangeLockOwnerName ownerUniqueID);``
 
 Release an exclusive read lock on a range. The range must be within the user key space, aka ``"" ~ \xff``.
+The release request is rejected with a range_lock_reject error if the range contains any existing lock with a different range, user, or lock type.
 
 ``ACTOR Future<Void> releaseExclusiveReadLockOnRange(Database cx, KeyRange range, RangeLockOwnerName ownerUniqueID);``
 
@@ -58,7 +61,7 @@ If the execution is failed, no range is locked/unlocked.
 
 Get exclusive read locks on the input range
 
-``ACTOR Future<std::vector<KeyRange>> getExclusiveReadLockOnRange(Database cx, KeyRange range);``
+``ACTOR Future<std::vector<std::pair<KeyRange, RangeLockState>>> findExclusiveReadLockOnRange(Database cx, KeyRange range);``
 
 Register a range lock owner to database metadata.
 

Diff for: fdbcli/BulkLoadCommand.actor.cpp

@@ -291,6 +291,50 @@ ACTOR Future<UID> bulkLoadCommandActor(Database cx, std::vector<StringRef> token
 		printLongDesc(tokens[0]);
 		return UID();
 
+	} else if (tokencmp(tokens[1], "printlock")) {
+		// For debugging purposes and invisible to users.
+		if (tokens.size() != 2) {
+			fmt::println("{}", BULK_LOAD_STATUS_USAGE);
+			return UID();
+		}
+		std::vector<std::pair<KeyRange, RangeLockState>> lockedRanges =
+		    wait(findExclusiveReadLockOnRange(cx, normalKeys));
+		fmt::println("Total {} locked ranges", lockedRanges.size());
+		if (lockedRanges.size() > 10) {
+			fmt::println("First 10 locks are:");
+		}
+		int count = 1;
+		for (const auto& lock : lockedRanges) {
+			if (count > 10) {
+				break;
+			}
+			fmt::println("Lock {} on {} for {}", count, lock.first.toString(), lock.second.toString());
+			count++;
+		}
+		return UID();
+
+	} else if (tokencmp(tokens[1], "printlockowner")) {
+		// For debugging purposes and invisible to users.
+		if (tokens.size() != 2) {
+			fmt::println("{}", BULK_LOAD_STATUS_USAGE);
+			return UID();
+		}
+		std::vector<RangeLockOwner> owners = wait(getAllRangeLockOwners(cx));
+		for (const auto owner : owners) {
+			fmt::println("{}", owner.toString());
+		}
+		return UID();
+
+	} else if (tokencmp(tokens[1], "clearlock")) {
+		// For debugging purposes and invisible to users.
+		if (tokens.size() != 3) {
+			fmt::println("{}", BULK_LOAD_STATUS_USAGE);
+			return UID();
+		}
+		std::string ownerUniqueID = tokens[2].toString();
+		wait(releaseExclusiveReadLockByUser(cx, ownerUniqueID));
+		return UID();
+
 	} else {
 		printUsage(tokens[0]);
 		printLongDesc(tokens[0]);