You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
99 lines
2.1 KiB
99 lines
2.1 KiB
// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
|
|
// All rights reserved.
|
|
//
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
// +build darwin dragonfly freebsd linux netbsd openbsd
|
|
|
|
package storage
|
|
|
|
import (
|
|
"os"
|
|
"syscall"
|
|
)
|
|
|
|
type unixFileLock struct {
|
|
f *os.File
|
|
}
|
|
|
|
func (fl *unixFileLock) release() error {
|
|
if err := setFileLock(fl.f, false, false); err != nil {
|
|
return err
|
|
}
|
|
return fl.f.Close()
|
|
}
|
|
|
|
func newFileLock(path string, readOnly bool) (fl fileLock, err error) {
|
|
var flag int
|
|
if readOnly {
|
|
flag = os.O_RDONLY
|
|
} else {
|
|
flag = os.O_RDWR
|
|
}
|
|
f, err := os.OpenFile(path, flag, 0)
|
|
if os.IsNotExist(err) {
|
|
f, err = os.OpenFile(path, flag|os.O_CREATE, 0644)
|
|
}
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = setFileLock(f, readOnly, true)
|
|
if err != nil {
|
|
f.Close()
|
|
return
|
|
}
|
|
fl = &unixFileLock{f: f}
|
|
return
|
|
}
|
|
|
|
func setFileLock(f *os.File, readOnly, lock bool) error {
|
|
how := syscall.LOCK_UN
|
|
if lock {
|
|
if readOnly {
|
|
how = syscall.LOCK_SH
|
|
} else {
|
|
how = syscall.LOCK_EX
|
|
}
|
|
}
|
|
return syscall.Flock(int(f.Fd()), how|syscall.LOCK_NB)
|
|
}
|
|
|
|
func rename(oldpath, newpath string) error {
|
|
return os.Rename(oldpath, newpath)
|
|
}
|
|
|
|
func isErrInvalid(err error) bool {
|
|
if err == os.ErrInvalid {
|
|
return true
|
|
}
|
|
// Go < 1.8
|
|
if syserr, ok := err.(*os.SyscallError); ok && syserr.Err == syscall.EINVAL {
|
|
return true
|
|
}
|
|
// Go >= 1.8 returns *os.PathError instead
|
|
if patherr, ok := err.(*os.PathError); ok && patherr.Err == syscall.EINVAL {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func syncDir(name string) error {
|
|
// As per fsync manpage, Linux seems to expect fsync on directory, however
|
|
// some system don't support this, so we will ignore syscall.EINVAL.
|
|
//
|
|
// From fsync(2):
|
|
// Calling fsync() does not necessarily ensure that the entry in the
|
|
// directory containing the file has also reached disk. For that an
|
|
// explicit fsync() on a file descriptor for the directory is also needed.
|
|
f, err := os.Open(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer f.Close()
|
|
if err := f.Sync(); err != nil && !isErrInvalid(err) {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|