added a validation to check whether lock exists in case of network pa…

zk/lock.go

@@ -12,6 +12,7 @@ var (
 	ErrDeadlock = errors.New("zk: trying to acquire a lock twice")
 	// ErrNotLocked is returned by Unlock when trying to release a lock that has not first be acquired.
 	ErrNotLocked = errors.New("zk: not locked")
+
 )
 
 // Lock is a mutual exclusion lock.
@@ -23,6 +24,11 @@ type Lock struct {
 	seq      int
 }
 
+// Initializing a map using the built-in make() function
+// This map stores the lock_path of last successfully requested sequential ephemeral znode queued
+// In case of any conflict, the sequence number is used to check whether lock has been acquired
+var mapEphermeralSequenceLockPath = make(map[string]string)
+
 // NewLock creates a new lock instance using the provided connection, path, and acl.
 // The path must be a node that is only used by this lock. A lock instances starts
 // unlocked until Lock() is called.
@@ -47,13 +53,23 @@ func (l *Lock) Lock() error {
 		return ErrDeadlock
 	}
 
+	if seqZnodePath, ok := mapEphermeralSequenceLockPath[l.path]; ok && seqZnodePath != "" {
+		// Check whether lock has been acquired previously and it still exists
+		if(lockExists(l.c,l.path,seqZnodePath)) {
+			return nil
+		}
+	}
+
 	prefix := fmt.Sprintf("%s/lock-", l.path)
 
 	path := ""
 	var err error
-	for i := 0; i < 3; i++ {
+	tryLock: for i := 0; i < 3; i++ {
 		path, err = l.c.CreateProtectedEphemeralSequential(prefix, []byte{}, l.acl)
-		if err == ErrNoNode {
+		// Store the path of newly created sequential ephemeral znode against the parent znode path
+		mapEphermeralSequenceLockPath[l.path] = path
+		switch err {
+		case ErrNoNode:
 			// Create parent node.
 			parts := strings.Split(l.path, "/")
 			pth := ""
@@ -72,9 +88,9 @@ func (l *Lock) Lock() error {
 					return err
 				}
 			}
-		} else if err == nil {
-			break
-		} else {
+		case nil:
+			break tryLock
+		default:
 			return err
 		}
 	}
@@ -146,5 +162,46 @@ func (l *Lock) Unlock() error {
 	}
 	l.lockPath = ""
 	l.seq = 0
+	// Remove the entry of path of newly created sequential ephemeral znode
+	// this was stored against the parent znode path
+	delete(mapEphermeralSequenceLockPath,l.path)
 	return nil
 }
+
+//Check whether lock got created and response was lost because of network partition failure.
+//It queries zookeeper and scans existing sequential ephemeral znodes under the parent path
+//It finds out that previously requested sequence number corresponds to child having lowest sequence number
+func lockExists(c *Conn, rootPath string, znodePath string) bool {
+	seq, err := parseSeq(znodePath)
+	if err != nil {
+		return false
+	}
+
+	//Scan the existing znodes if there are any
+	children, _, err := c.Children(rootPath)
+	if err != nil {
+		return false
+	}
+
+	lowestSeq := seq
+	prevSeq := -1
+	for _, p := range children {
+		s, err := parseSeq(p)
+		if err != nil {
+			return false
+		}
+		if s < lowestSeq {
+			lowestSeq = s
+		}
+		if s < seq && s > prevSeq {
+			prevSeq = s
+		}
+	}
+
+	if seq == lowestSeq {
+		// Acquired the lock
+		return true
+	} else {
+		return false
+	}
+}