/dir_plan9.go
Go | 150 lines | 81 code | 17 blank | 52 comment | 24 complexity | d7d1be9f414a59f2f39841cdad1c4817 MD5 | raw file
- /*
- * Copyright 2020 Dgraph Labs, Inc. and Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
- package badger
- import (
- "fmt"
- "os"
- "path/filepath"
- "strings"
- "github.com/dgraph-io/badger/v3/y"
- )
- // directoryLockGuard holds a lock on a directory and a pid file inside. The pid file isn't part
- // of the locking mechanism, it's just advisory.
- type directoryLockGuard struct {
- // File handle on the directory, which we've locked.
- f *os.File
- // The absolute path to our pid file.
- path string
- }
- // acquireDirectoryLock gets a lock on the directory.
- // It will also write our pid to dirPath/pidFileName for convenience.
- // readOnly is not supported on Plan 9.
- func acquireDirectoryLock(dirPath string, pidFileName string, readOnly bool) (
- *directoryLockGuard, error) {
- if readOnly {
- return nil, ErrPlan9NotSupported
- }
- // Convert to absolute path so that Release still works even if we do an unbalanced
- // chdir in the meantime.
- absPidFilePath, err := filepath.Abs(filepath.Join(dirPath, pidFileName))
- if err != nil {
- return nil, y.Wrap(err, "cannot get absolute path for pid lock file")
- }
- // If the file was unpacked or created by some other program, it might not
- // have the ModeExclusive bit set. Set it before we call OpenFile, so that we
- // can be confident that a successful OpenFile implies exclusive use.
- //
- // OpenFile fails if the file ModeExclusive bit set *and* the file is already open.
- // So, if the file is closed when the DB crashed, we're fine. When the process
- // that was managing the DB crashes, the OS will close the file for us.
- //
- // This bit of code is copied from Go's lockedfile internal package:
- // https://github.com/golang/go/blob/go1.15rc1/src/cmd/go/internal/lockedfile/lockedfile_plan9.go#L58
- if fi, err := os.Stat(absPidFilePath); err == nil {
- if fi.Mode()&os.ModeExclusive == 0 {
- if err := os.Chmod(absPidFilePath, fi.Mode()|os.ModeExclusive); err != nil {
- return nil, y.Wrapf(err, "could not set exclusive mode bit")
- }
- }
- } else if !os.IsNotExist(err) {
- return nil, err
- }
- f, err := os.OpenFile(absPidFilePath, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0666|os.ModeExclusive)
- if err != nil {
- if isLocked(err) {
- return nil, y.Wrapf(err,
- "Cannot open pid lock file %q. Another process is using this Badger database",
- absPidFilePath)
- }
- return nil, y.Wrapf(err, "Cannot open pid lock file %q", absPidFilePath)
- }
- if _, err = fmt.Fprintf(f, "%d\n", os.Getpid()); err != nil {
- f.Close()
- return nil, y.Wrapf(err, "could not write pid")
- }
- return &directoryLockGuard{f, absPidFilePath}, nil
- }
- // Release deletes the pid file and releases our lock on the directory.
- func (guard *directoryLockGuard) release() error {
- // It's important that we remove the pid file first.
- err := os.Remove(guard.path)
- if closeErr := guard.f.Close(); err == nil {
- err = closeErr
- }
- guard.path = ""
- guard.f = nil
- return err
- }
- // openDir opens a directory for syncing.
- func openDir(path string) (*os.File, error) { return os.Open(path) }
- // When you create or delete a file, you have to ensure the directory entry for the file is synced
- // in order to guarantee the file is visible (if the system crashes). (See the man page for fsync,
- // or see https://github.com/coreos/etcd/issues/6368 for an example.)
- func syncDir(dir string) error {
- f, err := openDir(dir)
- if err != nil {
- return y.Wrapf(err, "While opening directory: %s.", dir)
- }
- err = f.Sync()
- closeErr := f.Close()
- if err != nil {
- return y.Wrapf(err, "While syncing directory: %s.", dir)
- }
- return y.Wrapf(closeErr, "While closing directory: %s.", dir)
- }
- // Opening an exclusive-use file returns an error.
- // The expected error strings are:
- //
- // - "open/create -- file is locked" (cwfs, kfs)
- // - "exclusive lock" (fossil)
- // - "exclusive use file already open" (ramfs)
- //
- // See https://github.com/golang/go/blob/go1.15rc1/src/cmd/go/internal/lockedfile/lockedfile_plan9.go#L16
- var lockedErrStrings = [...]string{
- "file is locked",
- "exclusive lock",
- "exclusive use file already open",
- }
- // Even though plan9 doesn't support the Lock/RLock/Unlock functions to
- // manipulate already-open files, IsLocked is still meaningful: os.OpenFile
- // itself may return errors that indicate that a file with the ModeExclusive bit
- // set is already open.
- func isLocked(err error) bool {
- s := err.Error()
- for _, frag := range lockedErrStrings {
- if strings.Contains(s, frag) {
- return true
- }
- }
- return false
- }