diff options
Diffstat (limited to 'backup')
| -rw-r--r-- | backup/backup_test.go | 49 | ||||
| -rw-r--r-- | backup/common_test.go | 30 | ||||
| -rw-r--r-- | backup/restore.go | 134 | ||||
| -rw-r--r-- | backup/restore_test.go | 109 |
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) +} |