Example #1
0
func TestFileWriteRead(t *testing.T) {
	snapshotio := inodedb.NewSimpleDBStateSnapshotIO()
	txio := inodedb.NewSimpleDBTransactionLogIO()
	idb, err := inodedb.NewEmptyDB(snapshotio, txio)
	if err != nil {
		t.Errorf("NewEmptyDB failed: %v", err)
		return
	}

	bs := tu.TestFileBlobStore()
	fs := otaru.NewFileSystem(idb, bs, tu.TestCipher())
	h, err := fs.OpenFileFullPath("/hello.txt", flags.O_CREATE|flags.O_RDWR, 0666)
	if err != nil {
		t.Errorf("OpenFileFullPath failed: %v", err)
		return
	}

	err = h.PWrite(tu.HelloWorld, 0)
	if err != nil {
		t.Errorf("PWrite failed: %v", err)
	}

	buf := make([]byte, 32)
	n, err := h.ReadAt(buf, 0)
	if err != nil {
		t.Errorf("PRead failed: %v", err)
	}
	buf = buf[:n]
	if n != len(tu.HelloWorld) {
		t.Errorf("n: %d", n)
	}
	if !bytes.Equal(tu.HelloWorld, buf) {
		t.Errorf("PRead content != PWrite content: %v", buf)
	}
}
Example #2
0
func TestCreateFile(t *testing.T) {
	db, err := i.NewEmptyDB(i.NewSimpleDBStateSnapshotIO(), i.NewSimpleDBTransactionLogIO())
	if err != nil {
		t.Errorf("Failed to NewEmptyDB: %v", err)
		return
	}

	nlock, err := db.LockNode(i.AllocateNewNodeID)
	if err != nil {
		t.Errorf("Failed to LockNode: %v", err)
		return
	}

	tx := i.DBTransaction{Ops: []i.DBOperation{
		&i.CreateNodeOp{NodeLock: nlock, OrigPath: "/hoge.txt", Type: i.FileNodeT},
		&i.HardLinkOp{NodeLock: i.NodeLock{1, i.NoTicket}, Name: "hoge.txt", TargetID: nlock.ID},
	}}
	if _, err := db.ApplyTransaction(tx); err != nil {
		t.Errorf("Failed to apply tx: %v", err)
	}

	if err := db.UnlockNode(nlock); err != nil {
		t.Errorf("Failed to UnlockNode: %v", err)
	}

	fbps, errs := db.Fsck()
	if len(fbps) != 0 {
		t.Errorf("Fsck returned used fbp on db: %v", fbps)
	}
	if len(errs) != 0 {
		t.Errorf("Fsck returned err on db: %v", errs)
	}
}
Example #3
0
func TestINodeDB_Rollback(t *testing.T) {
	sio := i.NewSimpleDBStateSnapshotIO()
	txio := i.NewSimpleDBTransactionLogIO()

	db, err := i.NewEmptyDB(sio, txio)
	if err != nil {
		t.Errorf("Failed to NewEmptyDB: %v", err)
		return
	}

	tx := i.DBTransaction{Ops: []i.DBOperation{
		&i.CreateNodeOp{NodeLock: i.NodeLock{2, 123456}, OrigPath: "/hoge.txt", Type: i.FileNodeT},
		&i.HardLinkOp{NodeLock: i.NodeLock{1, i.NoTicket}, Name: "hoge.txt", TargetID: 2},
	}}
	if _, err := db.ApplyTransaction(tx); err != nil {
		t.Errorf("ApplyTransaction failed: %v", err)
		return
	}

	txF := i.DBTransaction{Ops: []i.DBOperation{
		&i.AlwaysFailForTestingOp{},
	}}
	if _, err := db.ApplyTransaction(txF); err == nil {
		t.Errorf("ApplyTransaction succeeded unexpectedly!")
	}
}
Example #4
0
func TestFileWriteRead(t *testing.T) {
	snapshotio := inodedb.NewSimpleDBStateSnapshotIO()
	txio := inodedb.NewSimpleDBTransactionLogIO()
	idb, err := inodedb.NewEmptyDB(snapshotio, txio)
	if err != nil {
		t.Errorf("NewEmptyDB failed: %v", err)
		return
	}

	bs := TestFileBlobStore()
	fs := otaru.NewFileSystem(idb, bs, TestCipher())
	h, err := fs.OpenFileFullPath("/hello.txt", flags.O_CREATE|flags.O_RDWR, 0666)
	if err != nil {
		t.Errorf("OpenFileFullPath failed: %v", err)
		return
	}

	err = h.PWrite(0, []byte("hello world!\n"))
	if err != nil {
		t.Errorf("PWrite failed: %v", err)
	}

	buf := make([]byte, 13)
	err = h.PRead(0, buf)
	if err != nil {
		t.Errorf("PRead failed: %v", err)
	}
	if !bytes.Equal([]byte("hello world!\n"), buf) {
		t.Errorf("PRead content != PWrite content")
	}
}
Example #5
0
func fusetestFileSystem() *otaru.FileSystem {
	sio := inodedb.NewSimpleDBStateSnapshotIO()
	txio := inodedb.NewSimpleDBTransactionLogIO()

	idb, err := inodedb.NewEmptyDB(sio, txio)
	if err != nil {
		log.Fatalf("NewEmptyDB failed: %v", err)
	}

	bs := TestFileBlobStore()
	fs := otaru.NewFileSystem(idb, bs, TestCipher())

	return fs
}
Example #6
0
func TestNewEmptyDB_ShouldFailOnNonEmptyTxIO(t *testing.T) {
	sio := i.NewSimpleDBStateSnapshotIO()
	txio := i.NewSimpleDBTransactionLogIO()

	tx := i.DBTransaction{TxID: 123, Ops: []i.DBOperation{
		&i.CreateNodeOp{NodeLock: i.NodeLock{2, 123456}, OrigPath: "/hoge.txt", Type: i.FileNodeT},
		&i.HardLinkOp{NodeLock: i.NodeLock{1, i.NoTicket}, Name: "hoge.txt", TargetID: 2},
	}}
	if err := txio.AppendTransaction(tx); err != nil {
		t.Errorf("AppendTransaction failed: %v", err)
		return
	}

	_, err := i.NewEmptyDB(sio, txio)
	if err == nil {
		t.Errorf("NewEmptyDB should fail on non-empty txio")
		return
	}
}
Example #7
0
func TestNewEmptyDB_ShouldFailOnNonEmptySnapsshotIO(t *testing.T) {
	sio := i.NewSimpleDBStateSnapshotIO()
	{
		db, err := i.NewEmptyDB(sio, i.NewSimpleDBTransactionLogIO())
		if err != nil {
			t.Errorf("Failed to NewEmptyDB: %v", err)
			return
		}
		if err := db.Sync(); err != nil {
			t.Errorf("Failed to Sync DB: %v", err)
			return
		}
	}

	_, err := i.NewEmptyDB(sio, i.NewSimpleDBTransactionLogIO())
	if err == nil {
		t.Errorf("NewEmptyDB should fail on non-empty snapshot io")
		return
	}
}
Example #8
0
func TestInitialState(t *testing.T) {
	db, err := i.NewEmptyDB(i.NewSimpleDBStateSnapshotIO(), i.NewSimpleDBTransactionLogIO())
	if err != nil {
		t.Errorf("Failed to NewEmptyDB: %v", err)
		return
	}

	nv, _, err := db.QueryNode(1, false)
	if err != nil {
		t.Errorf("Failed to query root dir")
		return
	}
	if nv.GetType() != i.DirNodeT {
		t.Errorf("root dir not found!")
	}

	fbps, errs := db.Fsck()
	if len(fbps) != 0 {
		t.Errorf("Fsck returned used fbp on new empty db: %v", fbps)
	}
	if len(errs) != 0 {
		t.Errorf("Fsck returned err on new empty db: %v", errs)
	}
}