2017-01-17 02:05:00 +01:00
|
|
|
/*
|
2019-04-09 20:39:42 +02:00
|
|
|
* MinIO Cloud Storage, (C) 2016, 2017, 2018 MinIO, Inc.
|
2017-01-17 02:05:00 +01:00
|
|
|
*
|
|
|
|
* 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 cmd
|
|
|
|
|
|
|
|
import (
|
2018-04-06 00:04:40 +02:00
|
|
|
"context"
|
2017-01-17 02:05:00 +01:00
|
|
|
"io"
|
|
|
|
"os"
|
|
|
|
pathutil "path"
|
2017-04-14 21:06:24 +02:00
|
|
|
"runtime"
|
2017-11-25 20:58:29 +01:00
|
|
|
|
2018-04-06 00:04:40 +02:00
|
|
|
"github.com/minio/minio/cmd/logger"
|
2018-01-31 22:17:24 +01:00
|
|
|
"github.com/minio/minio/pkg/lock"
|
2017-01-17 02:05:00 +01:00
|
|
|
)
|
|
|
|
|
|
|
|
// Removes only the file at given path does not remove
|
|
|
|
// any parent directories, handles long paths for
|
|
|
|
// windows automatically.
|
2018-04-06 00:04:40 +02:00
|
|
|
func fsRemoveFile(ctx context.Context, filePath string) (err error) {
|
2017-01-17 02:05:00 +01:00
|
|
|
if filePath == "" {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, errInvalidArgument)
|
|
|
|
return errInvalidArgument
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if err = checkPathLength(filePath); err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
2017-08-13 04:25:43 +02:00
|
|
|
if err = os.Remove((filePath)); err != nil {
|
2018-05-03 04:59:38 +02:00
|
|
|
err = osErrToFSFileErr(err)
|
|
|
|
if err != errFileNotFound {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
}
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
2018-05-03 04:59:38 +02:00
|
|
|
return err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Removes all files and folders at a given path, handles
|
|
|
|
// long paths for windows automatically.
|
2018-04-06 00:04:40 +02:00
|
|
|
func fsRemoveAll(ctx context.Context, dirPath string) (err error) {
|
2017-01-17 02:05:00 +01:00
|
|
|
if dirPath == "" {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, errInvalidArgument)
|
|
|
|
return errInvalidArgument
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if err = checkPathLength(dirPath); err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
2018-08-06 06:15:28 +02:00
|
|
|
if err = removeAll(dirPath); err != nil {
|
2017-01-17 02:05:00 +01:00
|
|
|
if os.IsPermission(err) {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, errVolumeAccessDenied)
|
|
|
|
return errVolumeAccessDenied
|
2017-08-13 04:24:20 +02:00
|
|
|
} else if isSysErrNotEmpty(err) {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, errVolumeNotEmpty)
|
|
|
|
return errVolumeNotEmpty
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
2017-01-27 00:40:10 +01:00
|
|
|
return nil
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Removes a directory only if its empty, handles long
|
|
|
|
// paths for windows automatically.
|
2018-04-06 00:04:40 +02:00
|
|
|
func fsRemoveDir(ctx context.Context, dirPath string) (err error) {
|
2017-01-17 02:05:00 +01:00
|
|
|
if dirPath == "" {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, errInvalidArgument)
|
|
|
|
return errInvalidArgument
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if err = checkPathLength(dirPath); err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
2017-08-13 04:25:43 +02:00
|
|
|
if err = os.Remove((dirPath)); err != nil {
|
2017-01-17 02:05:00 +01:00
|
|
|
if os.IsNotExist(err) {
|
2018-04-06 00:04:40 +02:00
|
|
|
return errVolumeNotFound
|
2017-01-17 02:05:00 +01:00
|
|
|
} else if isSysErrNotEmpty(err) {
|
2018-04-06 00:04:40 +02:00
|
|
|
return errVolumeNotEmpty
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
2017-01-27 00:40:10 +01:00
|
|
|
return nil
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Creates a new directory, parent dir should exist
|
|
|
|
// otherwise returns an error. If directory already
|
|
|
|
// exists returns an error. Windows long paths
|
|
|
|
// are handled automatically.
|
2018-04-06 00:04:40 +02:00
|
|
|
func fsMkdir(ctx context.Context, dirPath string) (err error) {
|
2017-01-17 02:05:00 +01:00
|
|
|
if dirPath == "" {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, errInvalidArgument)
|
|
|
|
return errInvalidArgument
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if err = checkPathLength(dirPath); err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
2017-08-13 04:25:43 +02:00
|
|
|
if err = os.Mkdir((dirPath), 0777); err != nil {
|
2018-08-06 19:26:40 +02:00
|
|
|
switch {
|
|
|
|
case os.IsExist(err):
|
2018-04-06 00:04:40 +02:00
|
|
|
return errVolumeExists
|
2018-08-06 19:26:40 +02:00
|
|
|
case os.IsPermission(err):
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, errDiskAccessDenied)
|
|
|
|
return errDiskAccessDenied
|
2018-08-06 19:26:40 +02:00
|
|
|
case isSysErrNotDir(err):
|
2017-01-17 02:05:00 +01:00
|
|
|
// File path cannot be verified since
|
|
|
|
// one of the parents is a file.
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, errDiskAccessDenied)
|
|
|
|
return errDiskAccessDenied
|
2018-08-06 19:26:40 +02:00
|
|
|
case isSysErrPathNotFound(err):
|
2017-01-17 02:05:00 +01:00
|
|
|
// Add specific case for windows.
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, errDiskAccessDenied)
|
|
|
|
return errDiskAccessDenied
|
2018-08-06 19:26:40 +02:00
|
|
|
default:
|
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-10-17 02:20:54 +02:00
|
|
|
// fsStat is a low level call which validates input arguments
|
|
|
|
// and checks input length upto supported maximum. Does
|
|
|
|
// not perform any higher layer interpretation of files v/s
|
|
|
|
// directories. For higher level interpretation look at
|
|
|
|
// fsStatFileDir, fsStatFile, fsStatDir.
|
2018-04-06 00:04:40 +02:00
|
|
|
func fsStat(ctx context.Context, statLoc string) (os.FileInfo, error) {
|
2017-06-06 21:15:35 +02:00
|
|
|
if statLoc == "" {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, errInvalidArgument)
|
|
|
|
return nil, errInvalidArgument
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
2017-06-06 21:15:35 +02:00
|
|
|
if err := checkPathLength(statLoc); err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return nil, err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
2018-05-03 04:59:38 +02:00
|
|
|
fi, err := os.Stat(statLoc)
|
2017-06-06 21:15:35 +02:00
|
|
|
if err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
return nil, err
|
2017-06-06 21:15:35 +02:00
|
|
|
}
|
2017-06-13 02:40:28 +02:00
|
|
|
|
2017-06-06 21:15:35 +02:00
|
|
|
return fi, nil
|
|
|
|
}
|
2017-01-17 02:05:00 +01:00
|
|
|
|
2017-10-17 02:20:54 +02:00
|
|
|
// Lookup if volume exists, returns volume attributes upon success.
|
2018-04-06 00:04:40 +02:00
|
|
|
func fsStatVolume(ctx context.Context, volume string) (os.FileInfo, error) {
|
|
|
|
fi, err := fsStat(ctx, volume)
|
2017-01-17 02:05:00 +01:00
|
|
|
if err != nil {
|
2017-06-13 02:40:28 +02:00
|
|
|
if os.IsNotExist(err) {
|
2018-04-06 00:04:40 +02:00
|
|
|
return nil, errVolumeNotFound
|
2017-06-13 02:40:28 +02:00
|
|
|
} else if os.IsPermission(err) {
|
2018-04-06 00:04:40 +02:00
|
|
|
return nil, errVolumeAccessDenied
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
2018-04-06 00:04:40 +02:00
|
|
|
return nil, err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if !fi.IsDir() {
|
2018-04-06 00:04:40 +02:00
|
|
|
return nil, errVolumeAccessDenied
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return fi, nil
|
|
|
|
}
|
|
|
|
|
2017-10-17 02:20:54 +02:00
|
|
|
// Is a one place function which converts all os.PathError
|
|
|
|
// into a more FS object layer friendly form, converts
|
|
|
|
// known errors into their typed form for top level
|
|
|
|
// interpretation.
|
|
|
|
func osErrToFSFileErr(err error) error {
|
|
|
|
if err == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
if os.IsNotExist(err) {
|
2018-04-06 00:04:40 +02:00
|
|
|
return errFileNotFound
|
2017-10-17 02:20:54 +02:00
|
|
|
}
|
|
|
|
if os.IsPermission(err) {
|
2018-04-06 00:04:40 +02:00
|
|
|
return errFileAccessDenied
|
2017-10-17 02:20:54 +02:00
|
|
|
}
|
|
|
|
if isSysErrNotDir(err) {
|
2018-06-26 03:24:00 +02:00
|
|
|
return errFileNotFound
|
2017-10-17 02:20:54 +02:00
|
|
|
}
|
|
|
|
if isSysErrPathNotFound(err) {
|
2018-04-06 00:04:40 +02:00
|
|
|
return errFileNotFound
|
2017-10-17 02:20:54 +02:00
|
|
|
}
|
2019-05-02 16:09:57 +02:00
|
|
|
if isSysErrTooManyFiles(err) {
|
|
|
|
return errTooManyOpenFiles
|
|
|
|
}
|
2017-10-17 02:20:54 +02:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Lookup if directory exists, returns directory attributes upon success.
|
2018-04-06 00:04:40 +02:00
|
|
|
func fsStatDir(ctx context.Context, statDir string) (os.FileInfo, error) {
|
|
|
|
fi, err := fsStat(ctx, statDir)
|
2017-10-17 02:20:54 +02:00
|
|
|
if err != nil {
|
2018-05-03 04:59:38 +02:00
|
|
|
err = osErrToFSFileErr(err)
|
|
|
|
if err != errFileNotFound {
|
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
}
|
|
|
|
return nil, err
|
2017-10-17 02:20:54 +02:00
|
|
|
}
|
|
|
|
if !fi.IsDir() {
|
2018-06-26 03:24:00 +02:00
|
|
|
return nil, errFileNotFound
|
2017-10-17 02:20:54 +02:00
|
|
|
}
|
|
|
|
return fi, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Lookup if file exists, returns file attributes upon success.
|
2018-04-06 00:04:40 +02:00
|
|
|
func fsStatFile(ctx context.Context, statFile string) (os.FileInfo, error) {
|
|
|
|
fi, err := fsStat(ctx, statFile)
|
2017-01-17 02:05:00 +01:00
|
|
|
if err != nil {
|
2018-05-03 04:59:38 +02:00
|
|
|
err = osErrToFSFileErr(err)
|
|
|
|
if err != errFileNotFound {
|
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
}
|
|
|
|
return nil, err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
if fi.IsDir() {
|
2018-06-26 03:24:00 +02:00
|
|
|
return nil, errFileNotFound
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
return fi, nil
|
|
|
|
}
|
|
|
|
|
2018-05-09 04:09:15 +02:00
|
|
|
// Returns if the filePath is a regular file.
|
|
|
|
func fsIsFile(ctx context.Context, filePath string) bool {
|
|
|
|
fi, err := fsStat(ctx, filePath)
|
|
|
|
if err != nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
return fi.Mode().IsRegular()
|
|
|
|
}
|
|
|
|
|
2017-01-17 02:05:00 +01:00
|
|
|
// Opens the file at given path, optionally from an offset. Upon success returns
|
|
|
|
// a readable stream and the size of the readable stream.
|
2018-04-06 00:04:40 +02:00
|
|
|
func fsOpenFile(ctx context.Context, readPath string, offset int64) (io.ReadCloser, int64, error) {
|
2017-01-17 02:05:00 +01:00
|
|
|
if readPath == "" || offset < 0 {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, errInvalidArgument)
|
|
|
|
return nil, 0, errInvalidArgument
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
if err := checkPathLength(readPath); err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return nil, 0, err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
2018-05-03 04:59:38 +02:00
|
|
|
fr, err := os.Open(readPath)
|
2017-01-17 02:05:00 +01:00
|
|
|
if err != nil {
|
2017-10-17 02:20:54 +02:00
|
|
|
return nil, 0, osErrToFSFileErr(err)
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Stat to get the size of the file at path.
|
2019-07-23 07:36:15 +02:00
|
|
|
st, err := fr.Stat()
|
2017-01-17 02:05:00 +01:00
|
|
|
if err != nil {
|
2018-05-03 04:59:38 +02:00
|
|
|
err = osErrToFSFileErr(err)
|
|
|
|
if err != errFileNotFound {
|
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
}
|
2018-04-06 00:04:40 +02:00
|
|
|
return nil, 0, err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Verify if its not a regular file, since subsequent Seek is undefined.
|
|
|
|
if !st.Mode().IsRegular() {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, errIsNotRegular)
|
|
|
|
return nil, 0, errIsNotRegular
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Seek to the requested offset.
|
|
|
|
if offset > 0 {
|
2019-02-13 13:59:36 +01:00
|
|
|
_, err = fr.Seek(offset, io.SeekStart)
|
2017-01-17 02:05:00 +01:00
|
|
|
if err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return nil, 0, err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Success.
|
|
|
|
return fr, st.Size(), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Creates a file and copies data from incoming reader. Staging buffer is used by io.CopyBuffer.
|
2018-04-06 00:04:40 +02:00
|
|
|
func fsCreateFile(ctx context.Context, filePath string, reader io.Reader, buf []byte, fallocSize int64) (int64, error) {
|
2017-05-05 17:49:09 +02:00
|
|
|
if filePath == "" || reader == nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, errInvalidArgument)
|
|
|
|
return 0, errInvalidArgument
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
2017-03-07 21:25:40 +01:00
|
|
|
if err := checkPathLength(filePath); err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return 0, err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
2018-01-13 18:13:02 +01:00
|
|
|
if err := mkdirAll(pathutil.Dir(filePath), 0777); err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return 0, err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
2017-03-07 21:25:40 +01:00
|
|
|
if err := checkDiskFree(pathutil.Dir(filePath), fallocSize); err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return 0, err
|
2017-03-07 21:25:40 +01:00
|
|
|
}
|
|
|
|
|
2018-01-31 22:17:24 +01:00
|
|
|
writer, err := lock.Open(filePath, os.O_CREATE|os.O_WRONLY, 0666)
|
2017-01-17 02:05:00 +01:00
|
|
|
if err != nil {
|
2017-10-17 02:20:54 +02:00
|
|
|
return 0, osErrToFSFileErr(err)
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
defer writer.Close()
|
|
|
|
|
|
|
|
// Fallocate only if the size is final object is known.
|
|
|
|
if fallocSize > 0 {
|
|
|
|
if err = fsFAllocate(int(writer.Fd()), 0, fallocSize); err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return 0, err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-05 17:49:09 +02:00
|
|
|
var bytesWritten int64
|
|
|
|
if buf != nil {
|
|
|
|
bytesWritten, err = io.CopyBuffer(writer, reader, buf)
|
|
|
|
if err != nil {
|
2018-08-16 21:57:49 +02:00
|
|
|
if err != io.ErrUnexpectedEOF {
|
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
}
|
2018-04-06 00:04:40 +02:00
|
|
|
return 0, err
|
2017-05-05 17:49:09 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
bytesWritten, err = io.Copy(writer, reader)
|
|
|
|
if err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return 0, err
|
2017-05-05 17:49:09 +02:00
|
|
|
}
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
2018-01-31 22:17:24 +01:00
|
|
|
|
2017-01-17 02:05:00 +01:00
|
|
|
return bytesWritten, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// fsFAllocate is similar to Fallocate but provides a convenient
|
|
|
|
// wrapper to handle various operating system specific errors.
|
|
|
|
func fsFAllocate(fd int, offset int64, len int64) (err error) {
|
|
|
|
e := Fallocate(fd, offset, len)
|
|
|
|
// Ignore errors when Fallocate is not supported in the current system
|
|
|
|
if e != nil && !isSysErrNoSys(e) && !isSysErrOpNotSupported(e) {
|
|
|
|
switch {
|
|
|
|
case isSysErrNoSpace(e):
|
|
|
|
err = errDiskFull
|
|
|
|
case isSysErrIO(e):
|
|
|
|
err = e
|
|
|
|
default:
|
|
|
|
// For errors: EBADF, EINTR, EINVAL, ENODEV, EPERM, ESPIPE and ETXTBSY
|
|
|
|
// Appending was failed anyway, returns unexpected error
|
|
|
|
err = errUnexpected
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-07-23 07:36:15 +02:00
|
|
|
// Renames source path to destination path, fails if the destination path
|
|
|
|
// parents are not already created.
|
|
|
|
func fsSimpleRenameFile(ctx context.Context, sourcePath, destPath string) error {
|
|
|
|
if err := checkPathLength(sourcePath); err != nil {
|
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if err := checkPathLength(destPath); err != nil {
|
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := os.Rename(sourcePath, destPath); err != nil {
|
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return osErrToFSFileErr(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-17 02:05:00 +01:00
|
|
|
// Renames source path to destination path, creates all the
|
|
|
|
// missing parents if they don't exist.
|
2018-04-06 00:04:40 +02:00
|
|
|
func fsRenameFile(ctx context.Context, sourcePath, destPath string) error {
|
2017-05-05 17:49:09 +02:00
|
|
|
if err := checkPathLength(sourcePath); err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
2017-05-05 17:49:09 +02:00
|
|
|
}
|
|
|
|
if err := checkPathLength(destPath); err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
2017-05-05 17:49:09 +02:00
|
|
|
}
|
2018-01-13 18:13:02 +01:00
|
|
|
|
|
|
|
if err := renameAll(sourcePath, destPath); err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
2018-01-13 18:13:02 +01:00
|
|
|
|
2017-01-17 02:05:00 +01:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-08-04 05:04:28 +02:00
|
|
|
// fsDeleteFile is a wrapper for deleteFile(), after checking the path length.
|
2018-04-06 00:04:40 +02:00
|
|
|
func fsDeleteFile(ctx context.Context, basePath, deletePath string) error {
|
2017-01-17 02:05:00 +01:00
|
|
|
if err := checkPathLength(basePath); err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if err := checkPathLength(deletePath); err != nil {
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
|
|
|
|
2018-04-06 00:04:40 +02:00
|
|
|
if err := deleteFile(basePath, deletePath); err != nil {
|
2018-05-09 04:09:15 +02:00
|
|
|
if err != errFileNotFound {
|
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
}
|
2018-04-06 00:04:40 +02:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
2017-01-17 02:05:00 +01:00
|
|
|
}
|
2017-04-14 21:06:24 +02:00
|
|
|
|
|
|
|
// fsRemoveMeta safely removes a locked file and takes care of Windows special case
|
2018-04-06 00:04:40 +02:00
|
|
|
func fsRemoveMeta(ctx context.Context, basePath, deletePath, tmpDir string) error {
|
2017-04-14 21:06:24 +02:00
|
|
|
// Special case for windows please read through.
|
|
|
|
if runtime.GOOS == globalWindowsOSName {
|
|
|
|
// Ordinarily windows does not permit deletion or renaming of files still
|
|
|
|
// in use, but if all open handles to that file were opened with FILE_SHARE_DELETE
|
|
|
|
// then it can permit renames and deletions of open files.
|
|
|
|
//
|
|
|
|
// There are however some gotchas with this, and it is worth listing them here.
|
|
|
|
// Firstly, Windows never allows you to really delete an open file, rather it is
|
|
|
|
// flagged as delete pending and its entry in its directory remains visible
|
|
|
|
// (though no new file handles may be opened to it) and when the very last
|
|
|
|
// open handle to the file in the system is closed, only then is it truly
|
|
|
|
// deleted. Well, actually only sort of truly deleted, because Windows only
|
|
|
|
// appears to remove the file entry from the directory, but in fact that
|
|
|
|
// entry is merely hidden and actually still exists and attempting to create
|
|
|
|
// a file with the same name will return an access denied error. How long it
|
|
|
|
// silently exists for depends on a range of factors, but put it this way:
|
|
|
|
// if your code loops creating and deleting the same file name as you might
|
|
|
|
// when operating a lock file, you're going to see lots of random spurious
|
|
|
|
// access denied errors and truly dismal lock file performance compared to POSIX.
|
|
|
|
//
|
|
|
|
// We work-around these un-POSIX file semantics by taking a dual step to
|
|
|
|
// deleting files. Firstly, it renames the file to tmp location into multipartTmpBucket
|
|
|
|
// We always open files with FILE_SHARE_DELETE permission enabled, with that
|
|
|
|
// flag Windows permits renaming and deletion, and because the name was changed
|
|
|
|
// to a very random name somewhere not in its origin directory before deletion,
|
|
|
|
// you don't see those unexpected random errors when creating files with the
|
|
|
|
// same name as a recently deleted file as you do anywhere else on Windows.
|
|
|
|
// Because the file is probably not in its original containing directory any more,
|
|
|
|
// deletions of that directory will not fail with "directory not empty" as they
|
|
|
|
// otherwise normally would either.
|
|
|
|
|
|
|
|
tmpPath := pathJoin(tmpDir, mustGetUUID())
|
|
|
|
|
2018-04-06 00:04:40 +02:00
|
|
|
fsRenameFile(ctx, deletePath, tmpPath)
|
2017-04-14 21:06:24 +02:00
|
|
|
|
|
|
|
// Proceed to deleting the directory if empty
|
2018-04-06 00:04:40 +02:00
|
|
|
fsDeleteFile(ctx, basePath, pathutil.Dir(deletePath))
|
2017-04-14 21:06:24 +02:00
|
|
|
|
|
|
|
// Finally delete the renamed file.
|
2018-04-06 00:04:40 +02:00
|
|
|
return fsDeleteFile(ctx, tmpDir, tmpPath)
|
2017-04-14 21:06:24 +02:00
|
|
|
}
|
2018-04-06 00:04:40 +02:00
|
|
|
return fsDeleteFile(ctx, basePath, deletePath)
|
2017-04-14 21:06:24 +02:00
|
|
|
}
|