Let lock function be pluggable.

Allows for more involved locking methods, lock cleanup policy,
and disabling locking altogether.

Author: bradfitz

kv.go

@@ -7,6 +7,7 @@ package kv
 import (
 	"encoding/binary"
 	"fmt"
+	"io"
 	"os"
 	"os/signal"
 	"sync"
@@ -52,7 +53,7 @@ type DB struct {
 	gracePeriod   time.Duration // WAL grace period
 	isMem         bool          // No signal capture
 	lastCommitErr error         // from failed EndUpdate
-	lock          *os.File      // The DB file lock
+	lock          io.Closer     // The DB file lock
 	root          *lldb.BTree   // The KV layer
 	wal           *os.File      // WAL if any
 }
@@ -78,9 +79,7 @@ func create(f *os.File, filer lldb.Filer, opts *Options, isMem bool) (db *DB, er
 	defer func() {
 		lock := opts.lock
 		if err != nil && lock != nil {
-			n := lock.Name()
 			lock.Close()
-			os.Remove(n)
 			db = nil
 		}
 	}()
@@ -178,9 +177,7 @@ func Open(name string, opts *Options) (db *DB, err error) {
 	defer func() {
 		lock := opts.lock
 		if err != nil && lock != nil {
-			n := lock.Name()
 			lock.Close()
-			os.Remove(n)
 			db = nil
 		}
 		if err != nil {
@@ -289,15 +286,10 @@ func (db *DB) Close() (err error) {
 	}
 
 	if lock := db.lock; lock != nil {
-		n := lock.Name()
 		e1 := lock.Close()
-		e2 := os.Remove(n)
 		if err == nil {
 			err = e1
 		}
-		if err == nil {
-			err = e2
-		}
 	}
 	return
 }

lock.go

@@ -0,0 +1,58 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package kv
+
+import (
+	"crypto/sha1"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"sync"
+)
+
+func lockName(dbname string) string {
+	base := filepath.Base(filepath.Clean(dbname)) + "lockfile"
+	h := sha1.New()
+	io.WriteString(h, base)
+	return filepath.Join(filepath.Dir(dbname), fmt.Sprintf(".%x", h.Sum(nil)))
+}
+
+func defaultLocker(dbname string) (io.Closer, error) {
+	lname := lockName(dbname)
+	abs, err := filepath.Abs(lname)
+	if err != nil {
+		return nil, err
+	}
+	f, err := os.OpenFile(abs, os.O_CREATE|os.O_EXCL|os.O_RDONLY, 0666)
+	if os.IsExist(err) {
+		return nil, fmt.Errorf("cannot access DB %q: lock file %q exists", dbname, abs)
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &lockCloser{f: f, abs: abs}, nil
+}
+
+type lockCloser struct {
+	f    *os.File
+	abs  string
+	once sync.Once
+	err  error
+}
+
+func (lc *lockCloser) Close() error {
+	lc.once.Do(lc.close)
+	return lc.err
+}
+
+func (lc *lockCloser) close() {
+	if err := lc.f.Close(); err != nil {
+		lc.err = err
+	}
+	if err := os.Remove(lc.abs); err != nil {
+		lc.err = err
+	}
+}

options.go

@@ -65,6 +65,11 @@ type Options struct {
 	//	+1 if x >  y
 	Compare func(x, y []byte) int
 
+	// Locker specifies a function to lock a named file.
+	// On success it returns an io.Closer to release the lock.
+	// If nil, a default implementation is used.
+	Locker func(name string) (io.Closer, error)
+
 	// See the ACID* constants documentation.
 	_ACID int
 
@@ -98,11 +103,18 @@ type Options struct {
 	// and they may not be always honored.
 	_GracePeriod time.Duration
 	wal          *os.File
-	lock         *os.File
+	lock         io.Closer
 
 	noClone bool // test hook
 }
 
+func (o *Options) locker(dbname string) (io.Closer, error) {
+	if o == nil || o.Locker == nil {
+		return defaultLocker(dbname)
+	}
+	return o.Locker(dbname)
+}
+
 func (o *Options) clone() *Options {
 	if o.noClone {
 		return o
@@ -112,13 +124,8 @@ func (o *Options) clone() *Options {
 }
 
 func (o *Options) check(dbname string, new, lock bool) (err error) {
-	var lname string
 	if lock {
-		lname = o.lockName(dbname)
-		if o.lock, err = os.OpenFile(lname, os.O_CREATE|os.O_EXCL|os.O_RDONLY, 0666); err != nil {
-			if os.IsExist(err) {
-				err = fmt.Errorf("cannot access DB %q: lock file %q exists", dbname, lname)
-			}
+		if o.lock, err = o.locker(dbname); err != nil {
 			return
 		}
 	}
@@ -130,9 +137,6 @@ func (o *Options) check(dbname string, new, lock bool) (err error) {
 	case _ACIDFull:
 		o._GracePeriod = time.Second
 		o._WAL = o.walName(dbname, o._WAL)
-		if lname == o._WAL {
-			panic("internal error")
-		}
 
 		switch new {
 		case true:
@@ -155,13 +159,6 @@ func (o *Options) check(dbname string, new, lock bool) (err error) {
 	return
 }
 
-func (o *Options) lockName(dbname string) (r string) {
-	base := filepath.Base(filepath.Clean(dbname)) + "lockfile"
-	h := sha1.New()
-	io.WriteString(h, base)
-	return filepath.Join(filepath.Dir(dbname), fmt.Sprintf(".%x", h.Sum(nil)))
-}
-
 func (o *Options) walName(dbname, wal string) (r string) {
 	if wal != "" {
 		return filepath.Clean(wal)