Support MinIO to be deployed on more than 32 nodes (#8492)

This PR implements locking from a global entity into
a more localized set level entity, allowing for locks
to be held only on the resources which are writing
to a collection of disks rather than a global level.

In this process this PR also removes the top-level
limit of 32 nodes to an unlimited number of nodes. This
is a precursor change before bring in bucket expansion.

cmd/lock-rest-server-common.go

@@ -18,23 +18,19 @@ package cmd
 
 import (
 	"errors"
-	"time"
 )
 
 const (
 	lockRESTVersion       = "v2"
 	lockRESTVersionPrefix = SlashSeparator + "v2"
 	lockRESTPrefix        = minioReservedBucketPath + "/lock"
-	lockRESTPath          = lockRESTPrefix + lockRESTVersionPrefix
 )
 
 const (
-	lockRESTMethodLock        = "/lock"
-	lockRESTMethodRLock       = "/rlock"
-	lockRESTMethodUnlock      = "/unlock"
-	lockRESTMethodRUnlock     = "/runlock"
-	lockRESTMethodForceUnlock = "/forceunlock"
-	lockRESTMethodExpired     = "/expired"
+	lockRESTMethodLock    = "/lock"
+	lockRESTMethodRLock   = "/rlock"
+	lockRESTMethodUnlock  = "/unlock"
+	lockRESTMethodRUnlock = "/runlock"
 
 	// Unique ID of lock/unlock request.
 	lockRESTUID = "uid"
@@ -43,67 +39,6 @@ const (
 	lockRESTSource = "source"
 	// Resource contains a entity to be locked/unlocked.
 	lockRESTResource = "resource"
-	// ServerAddr contains the address of the server who requested lock/unlock of the above resource.
-	lockRESTServerAddr = "serverAddr"
-	// ServiceEndpoint contains the network path of above server to do lock/unlock.
-	lockRESTServerEndpoint = "serverEndpoint"
 )
 
-// nameLockRequesterInfoPair is a helper type for lock maintenance
-type nameLockRequesterInfoPair struct {
-	name string
-	lri  lockRequesterInfo
-}
-
 var errLockConflict = errors.New("lock conflict")
-var errLockNotExpired = errors.New("lock not expired")
-
-// Similar to removeEntry but only removes an entry only if the lock entry exists in map.
-func (l *localLocker) removeEntryIfExists(nlrip nameLockRequesterInfoPair) {
-	// Check if entry is still in map (could have been removed altogether by 'concurrent' (R)Unlock of last entry)
-	if lri, ok := l.lockMap[nlrip.name]; ok {
-		// Even if the entry exists, it may not be the same entry which was
-		// considered as expired, so we simply an attempt to remove it if its
-		// not possible there is nothing we need to do.
-		l.removeEntry(nlrip.name, nlrip.lri.UID, &lri)
-	}
-}
-
-// removeEntry based on the uid of the lock message, removes a single entry from the
-// lockRequesterInfo array or the whole array from the map (in case of a write lock
-// or last read lock)
-func (l *localLocker) removeEntry(name, uid string, lri *[]lockRequesterInfo) bool {
-	// Find correct entry to remove based on uid.
-	for index, entry := range *lri {
-		if entry.UID == uid {
-			if len(*lri) == 1 {
-				// Remove the write lock.
-				delete(l.lockMap, name)
-			} else {
-				// Remove the appropriate read lock.
-				*lri = append((*lri)[:index], (*lri)[index+1:]...)
-				l.lockMap[name] = *lri
-			}
-			return true
-		}
-	}
-
-	// None found return false, perhaps entry removed in previous run.
-	return false
-}
-
-// getLongLivedLocks returns locks that are older than a certain time and
-// have not been 'checked' for validity too soon enough
-func getLongLivedLocks(m map[string][]lockRequesterInfo, interval time.Duration) []nameLockRequesterInfoPair {
-	rslt := []nameLockRequesterInfoPair{}
-	for name, lriArray := range m {
-		for idx := range lriArray {
-			// Check whether enough time has gone by since last check
-			if time.Since(lriArray[idx].TimeLastCheck) >= interval {
-				rslt = append(rslt, nameLockRequesterInfoPair{name: name, lri: lriArray[idx]})
-				lriArray[idx].TimeLastCheck = UTCNow()
-			}
-		}
-	}
-	return rslt
-}