From ce50f2cfb753af54021eda0a24f6ed2be56258b7 Mon Sep 17 00:00:00 2001
From: Fazlul Shahriar <fshahriar@gmail.com>
Date: Sun, 26 Jul 2020 20:15:33 -0400
Subject: [PATCH] Add os.Rename wrapper for Plan 9

os.Rename documentation says: "OS-specific restrictions may apply when
oldpath and newpath are in different directories." On Unix, this means
we can't rename across devices. On Plan 9 however, the functionality is
even more limited: cross-directory renames are not allowed at all.

Add a wrapper around os.Rename for Plan 9, which will copy the file if
we're renaming across directory. All tests seems to pass.

(Aside: I also had to write this wrapper to get go-git working on Plan 9:
https://github.com/go-git/go-billy/blob/v5.0.0/osfs/os_plan9.go#L27
but I notice few issues with that one.)

Fixes #86
---
 convert.go      |  4 +--
 flatfs.go       |  4 +--
 rename.go       |  7 +++++
 rename_plan9.go | 77 +++++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 88 insertions(+), 4 deletions(-)
 create mode 100644 rename.go
 create mode 100644 rename_plan9.go

diff --git a/convert.go b/convert.go
index 2df5ccb..58a12fb 100644
--- a/convert.go
+++ b/convert.go
@@ -156,7 +156,7 @@ func Move(oldPath string, newPath string, out io.Writer) error {
 			// else we found something unexpected, so to be safe just move it
 			log.Warnw("found unexpected file in datastore directory, moving anyways", "file", fn)
 			newPath := filepath.Join(newDS.path, fn)
-			err := os.Rename(oldPath, newPath)
+			err := rename(oldPath, newPath)
 			if err != nil {
 				return err
 			}
@@ -177,7 +177,7 @@ func moveKey(oldDS *Datastore, newDS *Datastore, key datastore.Key) error {
 	if err != nil && !os.IsExist(err) {
 		return err
 	}
-	err = os.Rename(oldPath, newPath)
+	err = rename(oldPath, newPath)
 	if err != nil {
 		return err
 	}
diff --git a/flatfs.go b/flatfs.go
index 9d372cd..40be67d 100644
--- a/flatfs.go
+++ b/flatfs.go
@@ -369,7 +369,7 @@ func (fs *Datastore) renameAndUpdateDiskUsage(tmpPath, path string) error {
 	// it will either a) Re-add the size of an existing file, which
 	// was sustracted before b) Add 0 if there is no existing file.
 	for i := 0; i < RetryAttempts; i++ {
-		err = os.Rename(tmpPath, path)
+		err = rename(tmpPath, path)
 		// if there's no error, or the source file doesn't exist, abort.
 		if err == nil || os.IsNotExist(err) {
 			break
@@ -1060,7 +1060,7 @@ func (fs *Datastore) writeDiskUsageFile(du int64, doSync bool) {
 	}
 	closed = true
 
-	if err := os.Rename(tmp.Name(), filepath.Join(fs.path, DiskUsageFile)); err != nil {
+	if err := rename(tmp.Name(), filepath.Join(fs.path, DiskUsageFile)); err != nil {
 		log.Warnw("cound not write disk usage", "error", err)
 		return
 	}
diff --git a/rename.go b/rename.go
new file mode 100644
index 0000000..da458b1
--- /dev/null
+++ b/rename.go
@@ -0,0 +1,7 @@
+// +build !plan9
+
+package flatfs
+
+import "os"
+
+var rename = os.Rename
diff --git a/rename_plan9.go b/rename_plan9.go
new file mode 100644
index 0000000..c32a59a
--- /dev/null
+++ b/rename_plan9.go
@@ -0,0 +1,77 @@
+package flatfs
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+	"syscall"
+)
+
+// rename behaves like os.Rename but can rename files across directories.
+func rename(oldpath, newpath string) error {
+	err := os.Rename(oldpath, newpath)
+	if le, ok := err.(*os.LinkError); !ok || le.Err != os.ErrInvalid {
+		return err
+	}
+	if filepath.Dir(oldpath) == filepath.Dir(newpath) {
+		// We should not get here, but just in case
+		// os.ErrInvalid is used for something else in the future.
+		return err
+	}
+
+	src, err := os.Open(oldpath)
+	if err != nil {
+		return &os.LinkError{"rename", oldpath, newpath, err}
+	}
+	defer src.Close()
+
+	fi, err := src.Stat()
+	if err != nil {
+		return &os.LinkError{"rename", oldpath, newpath, err}
+	}
+	if fi.Mode().IsDir() {
+		return &os.LinkError{"rename", oldpath, newpath, syscall.EISDIR}
+	}
+
+	dst, err := os.OpenFile(newpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, fi.Mode())
+	if err != nil {
+		return &os.LinkError{"rename", oldpath, newpath, err}
+	}
+
+	if _, err := io.Copy(dst, src); err != nil {
+		dst.Close()
+		os.Remove(newpath)
+		return &os.LinkError{"rename", oldpath, newpath, err}
+	}
+	if err := dst.Close(); err != nil {
+		os.Remove(newpath)
+		return &os.LinkError{"rename", oldpath, newpath, err}
+	}
+
+	// Copy mtime and mode from original file.
+	// We need only one syscall if we avoid os.Chmod and os.Chtimes.
+	dir := fi.Sys().(*syscall.Dir)
+	var d syscall.Dir
+	d.Null()
+	d.Mtime = dir.Mtime
+	d.Mode = dir.Mode
+	_ = dirwstat(newpath, &d) // ignore error, as per mv(1)
+
+	if err := os.Remove(oldpath); err != nil {
+		return &os.LinkError{"rename", oldpath, newpath, err}
+	}
+	return nil
+}
+
+func dirwstat(name string, d *syscall.Dir) error {
+	var buf [syscall.STATFIXLEN]byte
+
+	n, err := d.Marshal(buf[:])
+	if err != nil {
+		return &os.PathError{"dirwstat", name, err}
+	}
+	if err = syscall.Wstat(name, buf[:n]); err != nil {
+		return &os.PathError{"dirwstat", name, err}
+	}
+	return nil
+}