Example #1
0
func TestLink(t *testing.T) {
	ino := maggiefs.NewInode(0, maggiefs.FTYPE_REG, 0755, uint32(os.Getuid()), uint32(os.Getgid()))
	id, err := testCluster.Names.AddInode(ino)
	if err != nil {
		panic(err)
	}
	ino.Inodeid = id

	ino2 := maggiefs.NewInode(0, maggiefs.FTYPE_REG, 0755, uint32(os.Getuid()), uint32(os.Getgid()))
	id, err = testCluster.Names.AddInode(ino)
	if err != nil {
		panic(err)
	}
	ino2.Inodeid = id

	// test normal link
	fmt.Println("linking")
	err = testCluster.Names.Link(ino.Inodeid, ino2.Inodeid, "name", true)
	if err != nil {
		panic(err)
	}
	ino, err = testCluster.Names.GetInode(ino.Inodeid)
	if err != nil {
		panic(err)
	}
	if ino.Children["name"].Inodeid != ino2.Inodeid {
		t.Fatalf("Didn't link properly!")
	}
	// test an unforced attempt to overwrite

	// test overwriting forced

}
Example #2
0
func TestWriteRead2(t *testing.T) {
	fmt.Println("testWriteRead2")
	fmt.Println("Adding node to cluster")
	ino := maggiefs.NewInode(0, maggiefs.FTYPE_REG, 0755, uint32(os.Getuid()), uint32(os.Getgid()))
	id, err := testCluster.Names.AddInode(ino)
	if err != nil {
		t.Fatal(err)
	}
	ino.Inodeid = id
	writer, err := client.NewInodeWriter(ino.Inodeid, testCluster.Leases, testCluster.Names, testCluster.Datas)
	if err != nil {
		t.Fatal(err)
	}
	// we wnat to write a bunch of bytes the way the fs does it, in chunks of 65536

	bytes := make([]byte, 65536)
	n, err := rand.Read(bytes)
	if n < len(bytes) {
		t.Fatal(fmt.Errorf("Only returned %d bytes in call to rand.Read", n))
	}
	if err != nil {
		t.Fatal(err)
	}
	for i := 0; i < 5000; i++ {
		n, err := writer.WriteAt(bytes, uint64(65536*i), uint32(len(bytes)))
		if err != nil {
			t.Fatal(err)
		}
		if n < uint32(len(bytes)) {
			t.Fatal(fmt.Sprintf("Only wrote %d bytes out of %d", n, len(bytes)))
		}
	}

	// then do that many reads across the file to confirm it's ok
	readBytes := make([]byte, 65536)
	reader, err := client.NewReader(ino.Inodeid, testCluster.Names, testCluster.Datas)
	if err != nil {
		t.Fatal(fmt.Sprintf("Error opening reader %s", err.Error()))
	}
	for i := 0; i < 5000; i++ {
		n, err := reader.ReadAt(readBytes, uint64(65536*i), 0, uint32(len(readBytes)))
		if err != nil {
			t.Fatal(err)
		}
		if n < uint32(len(readBytes)) {
			t.Fatal(fmt.Sprintf("Only read %d bytes out of %d", n, len(readBytes)))
		}
		for idx := 0; idx < 65536; idx++ {
			if readBytes[idx] != bytes[idx] {
				fmt.Printf("Bytes at beginning:  %x : %x\n", readBytes[:5], bytes[:5])
				//fmt.Printf("Bytes near offest:  %x : %x\n",readBytes[idx-5:idx+5],bytes[idx-5:idx+5])
				t.Fatal(fmt.Sprintf("Bytes not equal at offset %d, iteration %d : %x != %x", idx, i, readBytes[idx], bytes[idx]))
			}
		}
	}
	fmt.Println("Done TestReadWrite")
}
Example #3
0
func TestUnlink(t *testing.T) {
	ino := maggiefs.NewInode(0, maggiefs.FTYPE_REG, 0755, uint32(os.Getuid()), uint32(os.Getgid()))
	id, err := testCluster.Names.AddInode(ino)
	if err != nil {
		panic(err)
	}
	ino.Inodeid = id

	ino2 := maggiefs.NewInode(0, maggiefs.FTYPE_REG, 0755, uint32(os.Getuid()), uint32(os.Getgid()))
	id, err = testCluster.Names.AddInode(ino)
	if err != nil {
		panic(err)
	}
	ino2.Inodeid = id

	// test normal link
	fmt.Println("linking")
	err = testCluster.Names.Link(ino.Inodeid, ino2.Inodeid, "name", true)
	if err != nil {
		panic(err)
	}
	ino, err = testCluster.Names.GetInode(ino.Inodeid)
	if err != nil {
		panic(err)
	}
	if ino.Children["name"].Inodeid != ino2.Inodeid {
		t.Fatalf("Didn't link properly!")
	}

	err = testCluster.Names.Unlink(ino.Inodeid, "name")
	if err != nil {
		panic(err)
	}
	ino, err = testCluster.Names.GetInode(ino.Inodeid)
	if err != nil {
		panic(err)
	}
	_, ok := ino.Children["name"]
	if ok {
		t.Fatalf("Didn't unlink properly!")
	}
}
Example #4
0
// formats a new filesystem in the given data dir
func Format(dataDir string, rootUid, rootGid uint32) error {
	// wipe out previous
	err := os.RemoveAll(dataDir)
	if err != nil {
		return err
	}
	// create
	err = os.Mkdir(dataDir, 0755)
	if err != nil {
		return fmt.Errorf("issue creating namenode home dir: %s\n", err.Error())
	}
	err = os.Mkdir(dataDir+"/"+dir_inodb, 0755)
	if err != nil {
		return fmt.Errorf("issue creating inodb parent dir: %s\n", err.Error())
	}
	err = os.Mkdir(dataDir+"/"+dir_counters, 0755)
	if err != nil {
		return fmt.Errorf("issue creating counters parent dir: %s\n", err.Error())
	}

	opts := levigo.NewOptions()
	defer opts.Close()
	opts.SetCreateIfMissing(true)

	// create inodb
	db, err := levigo.Open(dataDir+"/"+dir_inodb, opts)
	if err != nil {
		return err
	}
	// add root node
	ino := maggiefs.NewInode(1, maggiefs.FTYPE_DIR, 0755, rootUid, rootGid)
	binSize := ino.BinSize()
	inoBytes := make([]byte, binSize)
	ino.ToBytes(inoBytes)
	rootNodeId := make([]byte, 8)
	binary.LittleEndian.PutUint64(rootNodeId, 1)
	db.Put(WriteOpts, rootNodeId, inoBytes)
	db.Close()
	db, err = levigo.Open(dataDir+"/"+dir_counters, opts)
	if err != nil {
		return err
	}
	// put 1 for inode counter so other nodes are higher
	key := []byte(COUNTER_INODE)
	val := make([]byte, 8)
	binary.LittleEndian.PutUint64(val, 1)
	err = db.Put(WriteOpts, key, val)
	if err != nil {
		return err
	}
	db.Close()

	return nil
}
Example #5
0
func TestAddInode(t *testing.T) {
	ino := maggiefs.NewInode(0, maggiefs.FTYPE_REG, 0755, uint32(os.Getuid()), uint32(os.Getgid()))
	id, err := testCluster.Names.AddInode(ino)
	if err != nil {
		panic(err)
	}
	ino.Inodeid = id

	ino2, err := testCluster.Names.GetInode(id)
	if !ino.Equals(ino2) {
		t.Fatal(fmt.Errorf("Error, inodes not equal : %+v : %+v\n", *ino, *ino2))
	}
}
Example #6
0
func TestAddBlock(t *testing.T) {
	fmt.Println("Adding node to cluster")
	ino := maggiefs.NewInode(0, maggiefs.FTYPE_REG, 0755, uint32(os.Getuid()), uint32(os.Getgid()))
	id, err := testCluster.Names.AddInode(ino)
	if err != nil {
		t.Fatal(err)
	}
	ino.Inodeid = id
	newBlock, err := testCluster.Names.AddBlock(ino.Inodeid, 1024)
	if err != nil {
		t.Fatal(err)
	}
	fmt.Printf("got block back %+v\n", newBlock)
	ino, err = testCluster.Names.GetInode(ino.Inodeid)

	if newBlock.Id != ino.Blocks[0].Id || ino.Blocks[0].EndPos != 1023 {
		// 1023 end pos for 1024 length because we're 0 indexed
		t.Fatal(fmt.Errorf("Wrong end length for block %+v", ino.Blocks[0]))
	}
	// check that block made it to each datanode
	fstat, err := testCluster.Names.StatFs()
	fmt.Printf("got fstat %+v\n", fstat)
	for _, dnInfo := range fstat.DnStat {
		for _, volStat := range dnInfo.Volumes {
			volId := volStat.VolId
			for _, blockVolId := range newBlock.Volumes {
				if blockVolId == volId {
					fmt.Printf("looking for vol %d on dn %d\n", volId, dnInfo.DnId)
					// dnIDs start at 1 so decrement
					blocks, err := testCluster.DataNodes[dnInfo.DnId-1].BlockReport(volId)
					if err != nil {
						t.Fatal(err.Error())
					}
					fmt.Printf("Blocks for vol %d : %+v\n", volId, blocks)

					var found = false
					for _, blk := range blocks {
						if blk.Id == newBlock.Id {
							found = true
						}
					}
					if !found {
						t.Fatalf("Didn't find block %d on volume %d!  Blocks on volume: \n %+v \n", newBlock.Id, volId, blocks)
					}
				}
			}

		}
	}
}
Example #7
0
func TestShortRead(t *testing.T) {
	fmt.Println("Adding node to cluster")
	ino := maggiefs.NewInode(0, maggiefs.FTYPE_REG, 0755, uint32(os.Getuid()), uint32(os.Getgid()))
	id, err := testCluster.Names.AddInode(ino)
	if err != nil {
		t.Fatal(err)
	}
	ino.Inodeid = id

	writer, err := client.NewInodeWriter(ino.Inodeid, testCluster.Leases, testCluster.Names, testCluster.Datas)
	if err != nil {
		t.Fatal(err)
	}
	// 5 bytes
	bytes := make([]byte, 5)
	_, err = rand.Read(bytes)
	if err != nil {
		t.Fatal(err)
	}
	fmt.Println("Writing some bytes")
	n, err := writer.WriteAt(bytes, 0, uint32(len(bytes)))
	if err != nil {
		t.Fatal(err)
	}
	if n < uint32(len(bytes)) {
		t.Fatal(fmt.Sprintf("Only wrote %d bytes out of %d", n, len(bytes)))
	}

	readBytes := make([]byte, 4096)
	r, err := client.NewReader(ino.Inodeid, testCluster.Names, testCluster.Datas)
	if err != nil {
		t.Fatal(fmt.Sprintf("Error opening reader %s", err.Error()))
	}
	n, err = r.ReadAt(readBytes, 0, 0, 5)
	fmt.Printf("Read %d bytes\n", n)
	if err != nil {
		t.Fatal(err)
	}

	for idx := 0; idx < 5; idx++ {
		if readBytes[idx] != bytes[idx] {
			t.Fatal(fmt.Sprintf("Bytes not equal at offset %d : %x != %x", idx, readBytes[idx], bytes[idx]))
		}
	}
	fmt.Println("Done TestShortRead")
}
Example #8
0
func TestWriteRead(t *testing.T) {
	fmt.Println("testWriteRead")
	fmt.Println("Adding node to cluster")
	ino := maggiefs.NewInode(0, maggiefs.FTYPE_REG, 0755, uint32(os.Getuid()), uint32(os.Getgid()))
	id, err := testCluster.Names.AddInode(ino)
	if err != nil {
		t.Fatal(err)
	}
	ino.Inodeid = id

	writer, err := client.NewInodeWriter(ino.Inodeid, testCluster.Leases, testCluster.Names, testCluster.Datas)
	if err != nil {
		t.Fatal(err)
	}
	// 200 MB to make us 2 blocks
	bytes := make([]byte, 1024*1024*200)
	_, err = rand.Read(bytes)
	if err != nil {
		t.Fatal(err)
	}
	fmt.Printf("first 5 before write %x\n", bytes[:5])
	fmt.Println("Writing some bytes")
	n, err := writer.WriteAt(bytes, 0, uint32(len(bytes)))
	if err != nil {
		t.Fatal(err)
	}
	if n < uint32(len(bytes)) {
		t.Fatal(fmt.Sprintf("Only wrote %d bytes out of %d", n, len(bytes)))
	}

	readBytes := make([]byte, 1024*1024*200)
	r, err := client.NewReader(ino.Inodeid, testCluster.Names, testCluster.Datas)
	if err != nil {
		t.Fatal(fmt.Sprintf("Error opening reader %s", err.Error()))
	}
	_, err = r.ReadAt(readBytes, 0, 0, 1024*1024*200)
	if err != nil {
		t.Fatal(err)
	}
	for idx, b := range readBytes {
		if b != bytes[idx] {
			t.Fatal(fmt.Sprintf("Bytes not equal at offset %d : %x != %x", idx, b, bytes[idx]))
		}
	}
}
Example #9
0
func TestGetInodeJson(t *testing.T) {
	ino := maggiefs.NewInode(0, maggiefs.FTYPE_REG, 0755, uint32(os.Getuid()), uint32(os.Getgid()))
	id, err := testCluster.Names.AddInode(ino)
	if err != nil {
		panic(err)
	}
	ino.Inodeid = id

	ino2, err := testCluster.Names.GetInode(id)
	if !ino.Equals(ino2) {
		t.Fatal(fmt.Errorf("Error, inodes not equal : %+v : %+v\n", *ino, *ino2))
	}
	inoJsonAddr := fmt.Sprintf("http://%s/inode?inodeid=%d", testCluster.NameServer.HttpAddr(), ino.Inodeid)
	fmt.Printf("Getting ino json from %s\n", inoJsonAddr)
	inoJson, err := http.Get(inoJsonAddr)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Got json %s\n", inoJson)

}