Implement restoring

4 files changed, 283 insertions, 39 deletions

diff --git a/backup/backup_test.go b/backup/backup_test.go
index 2fee26e..714d814 100644
--- a/backup/backup_test.go
+++ b/backup/backup_test.go
@@ -12,15 +12,9 @@ import (
 func wantObject(
 	t *testing.T,
 	s storage.Storage,
-	id_str string,
+	id objects.ObjectId,
 	want []byte,
 ) {
-	id, err := objects.ParseObjectId(id_str)
-	if err != nil {
-		t.Errorf("Could not parse id: %s", err)
-		return
-	}
-
 	have, err := s.Get(id)
 	if err != nil {
 		t.Errorf("Could not get %s: %s", id, err)
@@ -51,9 +45,9 @@ func TestWriteLargeFile(t *testing.T) {
 		"blob=sha3-256:7287cbb09bdd8a0d96a6f6297413cd9d09a2763814636245a5a44120e6351be3&size=16777216\n" +
 		"blob=sha3-256:ddf124464f7b80e95f4a9c704f79e7037ff5d731648ba6b40c769893b428128c&size=100\n")
 
-	wantObject(t, s, "sha3-256:ab7907ee6b45b343422a0354de500bcf99f5ff69fe8125be84e43d421803c34e", want_file)
-	wantObject(t, s, "sha3-256:7287cbb09bdd8a0d96a6f6297413cd9d09a2763814636245a5a44120e6351be3", want_large_blob)
-	wantObject(t, s, "sha3-256:ddf124464f7b80e95f4a9c704f79e7037ff5d731648ba6b40c769893b428128c", want_small_blob)
+	wantObject(t, s, objects.MustParseObjectId("sha3-256:ab7907ee6b45b343422a0354de500bcf99f5ff69fe8125be84e43d421803c34e"), want_file)
+	wantObject(t, s, objects.MustParseObjectId("sha3-256:7287cbb09bdd8a0d96a6f6297413cd9d09a2763814636245a5a44120e6351be3"), want_large_blob)
+	wantObject(t, s, objects.MustParseObjectId("sha3-256:ddf124464f7b80e95f4a9c704f79e7037ff5d731648ba6b40c769893b428128c"), want_small_blob)
 }
 
 func mkfile(t *testing.T, d fs.Dir, name string, exec bool, content []byte) {
@@ -101,33 +95,10 @@ func TestWriteDir(t *testing.T) {
 		t.Errorf("Unexpected dir id: %s", id)
 	}
 
-	//4a10682307d5b5dc072d1b862497296640176109347b149aad38cd640000491b
-	obj_emptyfile := []byte("file 0\n")
-
-	//ba632076629ff33238850c870fcb51e4b7b67b3d9dcb66314adbcf1770a5fea7
-	obj_fooblob := []byte("blob 3\nfoo")
-	//fa50ca1fc739852528ecc149b424a8ccbdf84b73c8718cde4525f2a410d79244
-	obj_foofile := []byte("file 86\nblob=sha3-256:ba632076629ff33238850c870fcb51e4b7b67b3d9dcb66314adbcf1770a5fea7&size=3\n")
-
-	//1dc6fae780ae4a1e823a5b8e26266356a2e1d22e5904b0652dcff6e3c0e72067
-	obj_emptytree := []byte("tree 0\n")
-
-	//f1716a1b0cad23b6faab9712243402b8f8e7919c377fc5d5d87bd465cef056d7
-	obj_subdir := []byte("tree 239\n" +
-		"acl=u::rw-,g::r--,o::r--&name=a&ref=sha3-256:4a10682307d5b5dc072d1b862497296640176109347b149aad38cd640000491b&type=file\n" +
-		"acl=u::rwx,g::r-x,o::r-x&name=b&ref=sha3-256:1dc6fae780ae4a1e823a5b8e26266356a2e1d22e5904b0652dcff6e3c0e72067&type=dir\n")
-
-	//09e881f57befa1eacec744e3857a36f0d9d5dd1fa72ba96564b467a3d7d0c0d5
-	obj_dir := []byte("tree 423\n" +
-		"acl=u::rw-,g::r--,o::r--&name=baz&target=foo&type=symlink\n" +
-		"acl=u::rw-,g::r--,o::r--&name=foo&ref=sha3-256:fa50ca1fc739852528ecc149b424a8ccbdf84b73c8718cde4525f2a410d79244&type=file\n" +
-		"acl=u::rwx,g::r-x,o::r-x&name=bar&ref=sha3-256:4a10682307d5b5dc072d1b862497296640176109347b149aad38cd640000491b&type=file\n" +
-		"acl=u::rwx,g::r-x,o::r-x&name=sub&ref=sha3-256:f1716a1b0cad23b6faab9712243402b8f8e7919c377fc5d5d87bd465cef056d7&type=dir\n")
-
-	wantObject(t, s, "sha3-256:4a10682307d5b5dc072d1b862497296640176109347b149aad38cd640000491b", obj_emptyfile)
-	wantObject(t, s, "sha3-256:ba632076629ff33238850c870fcb51e4b7b67b3d9dcb66314adbcf1770a5fea7", obj_fooblob)
-	wantObject(t, s, "sha3-256:fa50ca1fc739852528ecc149b424a8ccbdf84b73c8718cde4525f2a410d79244", obj_foofile)
-	wantObject(t, s, "sha3-256:1dc6fae780ae4a1e823a5b8e26266356a2e1d22e5904b0652dcff6e3c0e72067", obj_emptytree)
-	wantObject(t, s, "sha3-256:f1716a1b0cad23b6faab9712243402b8f8e7919c377fc5d5d87bd465cef056d7", obj_subdir) //!
-	wantObject(t, s, "sha3-256:09e881f57befa1eacec744e3857a36f0d9d5dd1fa72ba96564b467a3d7d0c0d5", obj_dir)    //!
+	wantObject(t, s, objid_emptyfile, obj_emptyfile)
+	wantObject(t, s, objid_fooblob, obj_fooblob)
+	wantObject(t, s, objid_foofile, obj_foofile)
+	wantObject(t, s, objid_emptytree, obj_emptytree)
+	wantObject(t, s, objid_subtree, obj_subtree)
+	wantObject(t, s, objid_testtree, obj_testtree)
 }
diff --git a/backup/common_test.go b/backup/common_test.go
new file mode 100644
index 0000000..f06d737
--- /dev/null
+++ b/backup/common_test.go
@@ -0,0 +1,30 @@
+package backup
+
+import (
+	"code.laria.me/petrific/objects"
+)
+
+var (
+	objid_emptyfile = objects.MustParseObjectId("sha3-256:4a10682307d5b5dc072d1b862497296640176109347b149aad38cd640000491b")
+	obj_emptyfile   = []byte("file 0\n")
+
+	objid_fooblob = objects.MustParseObjectId("sha3-256:ba632076629ff33238850c870fcb51e4b7b67b3d9dcb66314adbcf1770a5fea7")
+	obj_fooblob   = []byte("blob 3\nfoo")
+	objid_foofile = objects.MustParseObjectId("sha3-256:fa50ca1fc739852528ecc149b424a8ccbdf84b73c8718cde4525f2a410d79244")
+	obj_foofile   = []byte("file 86\nblob=sha3-256:ba632076629ff33238850c870fcb51e4b7b67b3d9dcb66314adbcf1770a5fea7&size=3\n")
+
+	objid_emptytree = objects.MustParseObjectId("sha3-256:1dc6fae780ae4a1e823a5b8e26266356a2e1d22e5904b0652dcff6e3c0e72067")
+	obj_emptytree   = []byte("tree 0\n")
+
+	objid_subtree = objects.MustParseObjectId("sha3-256:f1716a1b0cad23b6faab9712243402b8f8e7919c377fc5d5d87bd465cef056d7")
+	obj_subtree   = []byte("tree 239\n" +
+		"acl=u::rw-,g::r--,o::r--&name=a&ref=sha3-256:4a10682307d5b5dc072d1b862497296640176109347b149aad38cd640000491b&type=file\n" +
+		"acl=u::rwx,g::r-x,o::r-x&name=b&ref=sha3-256:1dc6fae780ae4a1e823a5b8e26266356a2e1d22e5904b0652dcff6e3c0e72067&type=dir\n")
+
+	objid_testtree = objects.MustParseObjectId("sha3-256:09e881f57befa1eacec744e3857a36f0d9d5dd1fa72ba96564b467a3d7d0c0d5")
+	obj_testtree   = []byte("tree 423\n" +
+		"acl=u::rw-,g::r--,o::r--&name=baz&target=foo&type=symlink\n" +
+		"acl=u::rw-,g::r--,o::r--&name=foo&ref=sha3-256:fa50ca1fc739852528ecc149b424a8ccbdf84b73c8718cde4525f2a410d79244&type=file\n" +
+		"acl=u::rwx,g::r-x,o::r-x&name=bar&ref=sha3-256:4a10682307d5b5dc072d1b862497296640176109347b149aad38cd640000491b&type=file\n" +
+		"acl=u::rwx,g::r-x,o::r-x&name=sub&ref=sha3-256:f1716a1b0cad23b6faab9712243402b8f8e7919c377fc5d5d87bd465cef056d7&type=dir\n")
+)
diff --git a/backup/restore.go b/backup/restore.go
new file mode 100644
index 0000000..6a03200
--- /dev/null
+++ b/backup/restore.go
@@ -0,0 +1,134 @@
+package backup
+
+import (
+	"code.laria.me/petrific/acl"
+	"code.laria.me/petrific/fs"
+	"code.laria.me/petrific/objects"
+	"code.laria.me/petrific/storage"
+	"fmt"
+	"io"
+	"os"
+)
+
+func RestoreFile(s storage.Storage, id objects.ObjectId, w io.Writer) error {
+	file, err := storage.GetObjectOfType(s, id, objects.OTFile)
+	if err != nil {
+		return err
+	}
+
+	for i, fragment := range *file.(*objects.File) {
+		blob_obj, err := storage.GetObjectOfType(s, fragment.Blob, objects.OTBlob)
+		if err != nil {
+			return err
+		}
+		blob := *blob_obj.(*objects.Blob)
+
+		if uint64(len(blob)) != fragment.Size {
+			return fmt.Errorf("RestoreFile: blob size of %s doesn't match size in fragment %d of file %s", fragment.Blob, i, id)
+		}
+
+		if _, err := w.Write(blob); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func execBitFromACL(a acl.ACL) bool {
+	return a.ToUnixPerms()&0100 != 0
+}
+
+func RestoreDir(s storage.Storage, id objects.ObjectId, root fs.Dir) error {
+	tree_obj, err := storage.GetObjectOfType(s, id, objects.OTTree)
+	tree := tree_obj.(objects.Tree)
+
+	seen := make(map[string]struct{})
+
+	for name, file_info := range tree {
+		switch file_info.Type() {
+		case objects.TETFile:
+			tmpname := fmt.Sprintf(".petrific-%d-%s", os.Getpid(), id)
+			new_file, err := root.CreateChildFile(tmpname, execBitFromACL(file_info.ACL()))
+			if err != nil {
+				return err
+			}
+			rwc, err := new_file.Open()
+			if err != nil {
+				return err
+			}
+
+			if err := RestoreFile(s, file_info.(objects.TreeEntryFile).Ref, rwc); err != nil {
+				rwc.Close()
+				return err
+			}
+			rwc.Close()
+
+			if err := root.RenameChild(tmpname, name); err != nil {
+				return err
+			}
+		case objects.TETDir:
+			var subdir fs.Dir
+
+			// Try to use existing directory
+			child, err := root.GetChild(name)
+			if err == nil {
+				if child.Type() == fs.FDir {
+					subdir = child.(fs.Dir)
+				} else {
+					if err := child.Delete(); err != nil {
+						return err
+					}
+				}
+			} else if err != os.ErrNotExist {
+				return err
+			}
+
+			// Create directory, if it doesn't exist
+			if subdir == nil {
+				subdir, err = root.CreateChildDir(name)
+				if err != nil {
+					return err
+				}
+			}
+
+			if err := RestoreDir(s, file_info.(objects.TreeEntryDir).Ref, subdir); err != nil {
+				return err
+			}
+		case objects.TETSymlink:
+			// Is there already a child of that name? If yes, delete it
+			child, err := root.GetChild(name)
+			if err == nil {
+				if err := child.Delete(); err != nil {
+					return err
+				}
+			} else if err != os.ErrNotExist {
+				return err
+			}
+
+			if _, err := root.CreateChildSymlink(name, file_info.(objects.TreeEntrySymlink).Target); err != nil {
+				return err
+			}
+		default:
+			return fmt.Errorf("child '%s' of %s has unknown tree entry type %s", name, id, file_info.Type())
+		}
+
+		seen[name] = struct{}{}
+	}
+
+	// We now restored all children, we now need to remove the children of root, that shouldn't be there accoring to the backup
+	children, err := root.Readdir()
+	if err != nil {
+		return err
+	}
+	for _, c := range children {
+		_, ok := seen[c.Name()]
+		if !ok {
+			if err := c.Delete(); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
diff --git a/backup/restore_test.go b/backup/restore_test.go
new file mode 100644
index 0000000..1a88e5f
--- /dev/null
+++ b/backup/restore_test.go
@@ -0,0 +1,109 @@
+package backup
+
+import (
+	"bytes"
+	"code.laria.me/petrific/fs"
+	"code.laria.me/petrific/objects"
+	"code.laria.me/petrific/storage"
+	"io"
+	"testing"
+)
+
+func withChildOfType(t *testing.T, root fs.Dir, name string, ft fs.FileType, do func(*testing.T, fs.File)) {
+	f, err := root.GetChild(name)
+	if err != nil {
+		t.Errorf("Could not GetChild(%s): %s", name, err)
+		return
+	}
+
+	if f.Type() != ft {
+		t.Errorf("Child '%s' has type %s, expected %s", name, f.Type(), ft)
+		return
+	}
+
+	do(t, f)
+}
+
+func wantFileWithContent(want []byte, exec bool) func(*testing.T, fs.File) {
+	return func(t *testing.T, f fs.File) {
+		rf := f.(fs.RegularFile)
+
+		if rf.Executable() != exec {
+			t.Errorf("Child '%s' has executable bit %b, expected %b", f.Name(), rf.Executable(), exec)
+		}
+
+		rwc, err := rf.Open()
+		if err != nil {
+			t.Errorf("could not open child '%s': %s", f.Name(), err)
+		}
+		defer rwc.Close()
+
+		buf := new(bytes.Buffer)
+		if _, err := io.Copy(buf, rwc); err != nil {
+			t.Errorf("Could not read content of child '%s': %s", err)
+			return
+		}
+
+		have := buf.Bytes()
+		if !bytes.Equal(have, want) {
+			t.Errorf("Unexpected content of child '%s': %s", f.Name(), have)
+		}
+	}
+}
+
+func wantDir(n int, fx func(*testing.T, fs.Dir)) func(*testing.T, fs.File) {
+	return func(t *testing.T, f fs.File) {
+		d := f.(fs.Dir)
+
+		children, err := d.Readdir()
+		if err != nil {
+			t.Errorf("Could not Readdir() '%s': %s", f.Name(), err)
+			return
+		}
+
+		if len(children) != n {
+			t.Errorf("Expected '%s' to have %d children, got %d", f.Name(), n, len(children))
+			return
+		}
+
+		fx(t, d)
+	}
+}
+
+func TestRestoreDir(t *testing.T) {
+	s := storage.NewMemoryStorage()
+
+	s.Set(objid_emptyfile, objects.OTFile, obj_emptyfile)
+	s.Set(objid_fooblob, objects.OTBlob, obj_fooblob)
+	s.Set(objid_foofile, objects.OTFile, obj_foofile)
+	s.Set(objid_emptytree, objects.OTTree, obj_emptytree)
+	s.Set(objid_subtree, objects.OTTree, obj_subtree)
+	s.Set(objid_testtree, objects.OTTree, obj_testtree)
+
+	root := fs.NewMemoryFSRoot("")
+
+	if err := RestoreDir(s, objid_testtree, root); err != nil {
+		t.Fatalf("Unexpected error from RestoreDir(): %s", err)
+	}
+
+	wantDir(4, func(t *testing.T, root fs.Dir) {
+		withChildOfType(t, root, "foo", fs.FFile, wantFileWithContent([]byte("foo"), false))
+		withChildOfType(t, root, "bar", fs.FFile, wantFileWithContent([]byte{}, true))
+		withChildOfType(t, root, "baz", fs.FSymlink, func(t *testing.T, f fs.File) {
+			target, err := f.(fs.Symlink).Readlink()
+			if err != nil {
+				t.Errorf("Could not Readlink() child 'baz': %s", err)
+				return
+			}
+
+			if target != "foo" {
+				t.Errorf("Unexpected target for baz: %s", target)
+			}
+		})
+
+		withChildOfType(t, root, "sub", fs.FDir, wantDir(2, func(t *testing.T, d fs.Dir) {
+			withChildOfType(t, d, "a", fs.FFile, wantFileWithContent([]byte{}, false))
+			withChildOfType(t, d, "b", fs.FDir, wantDir(0, func(t *testing.T, d fs.Dir) {}))
+		}))
+	})(t, root)
+}