Merge pull request gluster#26 from jfontan/implement-readdir

Implement File.Readdir and File.Readdirnames

Author: kshlm

gfapi/fd.go

@@ -8,6 +8,7 @@ package gfapi
 // #include <sys/stat.h>
 import "C"
 import (
+	"os"
 	"syscall"
 	"unsafe"
 )
@@ -190,3 +191,71 @@ func (fd *Fd) Fremovexattr(attr string) error {
 	}
 	return err
 }
+
+func direntName(dirent *syscall.Dirent) string {
+	name := make([]byte, 0, len(dirent.Name))
+	for i, c := range dirent.Name {
+		if c == 0 || i > 255 {
+			break
+		}
+
+		name = append(name, byte(c))
+	}
+
+	return string(name)
+}
+
+// Readdir returns the information of files in a directory.
+//
+// n is the maximum number of items to return. If there are more items than
+// the maximum they can be obtained in successive calls. If maximum is 0
+// then all the items will be returned.
+func (fd *Fd) Readdir(n int) ([]os.FileInfo, error) {
+	var (
+		stat  syscall.Stat_t
+		files []os.FileInfo
+		statP = (*C.struct_stat)(unsafe.Pointer(&stat))
+	)
+
+	for i := 0; n == 0 || i < n; i++ {
+		d, err := C.glfs_readdirplus(fd.fd, statP)
+		if err != nil {
+			return nil, err
+		}
+
+		dirent := (*syscall.Dirent)(unsafe.Pointer(d))
+		if dirent == nil {
+			break
+		}
+
+		name := direntName(dirent)
+		file := fileInfoFromStat(&stat, name)
+		files = append(files, file)
+	}
+
+	return files, nil
+}
+
+// Readdirnames returns the names of files in a directory.
+//
+// n is the maximum number of items to return and works the same way as Readdir.
+func (fd *Fd) Readdirnames(n int) ([]string, error) {
+	var names []string
+
+	for i := 0; n == 0 || i < n; i++ {
+		d, err := C.glfs_readdir(fd.fd)
+		if err != nil {
+			return nil, err
+		}
+
+		dirent := (*syscall.Dirent)(unsafe.Pointer(d))
+		if dirent == nil {
+			break
+		}
+
+		name := direntName(dirent)
+		names = append(names, name)
+	}
+
+	return names, nil
+}

gfapi/file.go

@@ -87,14 +87,20 @@ func (f *File) ReadAt(b []byte, off int64) (int, error) {
 	return f.Fd.Pread(b, off)
 }
 
-// Readdir has not been implemented yet
+// Readdir returns the information of files in a directory.
+//
+// n is the maximum number of items to return. If there are more items than
+// the maximum they can be obtained in successive calls. If maximum is 0
+// then all the items will be returned.
 func (f *File) Readdir(n int) ([]os.FileInfo, error) {
-	return nil, errors.New("Readdir has not been implemented yet")
+	return f.Fd.Readdir(n)
 }
 
-// Readdirnames has not been implemented yet
+// Readdirnames returns the names of files in a directory.
+//
+// n is the maximum number of items to return and works the same way as Readdir.
 func (f *File) Readdirnames(n int) ([]string, error) {
-	return nil, errors.New("Readdirnames has not been implemented yet")
+	return f.Fd.Readdirnames(n)
 }
 
 // Seek sets the offset for the next read or write on the file based on whence,

gfapi/gfapi_test.go

@@ -3,7 +3,9 @@ package gfapi
 import (
 	"os"
 	"path/filepath"
+	"reflect"
 	"runtime"
+	"sort"
 	"testing"
 )
 
@@ -24,7 +26,7 @@ func TestInit(t *testing.T) {
 		t.Fatalf("Failed to allocate variable")
 	}
 
-	err := vol.Init("localhost", "test")
+	err := vol.Init("test", "localhost")
 	if err != nil {
 		t.Fatalf("Failed to initialize volume. error: %v", err)
 	}
@@ -248,9 +250,173 @@ func TestStatvfs(t *testing.T) {
 	}
 }
 
+func TestReaddir(t *testing.T) {
+	tmpDir, clean := setupReaddir(t)
+	defer clean()
+
+	d, err := vol.Open(tmpDir)
+	check(t, err == nil, "Open %q: %s", tmpDir, err)
+
+	info, err := d.Readdir(0)
+	check(t, err == nil, "Readdir %q: %s", tmpDir, err)
+
+	err = d.Close()
+	check(t, err == nil, "Close %q: %s", tmpDir, err)
+
+	check(t, len(info) == 4,
+		"incorrect number of files %v != %v", len(info), 4)
+
+	files := map[string]os.FileInfo{
+		"dir":  nil,
+		"file": nil,
+	}
+
+	for _, d := range info {
+		if d == nil {
+			continue
+		}
+		if _, ok := files[d.Name()]; ok {
+			files[d.Name()] = d
+		}
+	}
+
+	check(t, files["file"] != nil, "no info for file")
+	check(t, files["file"].IsDir() == false, "file should not be a dir")
+	check(t, files["file"].Size() == int64(len(data)),
+		"incorrect file size %v != %v", files["file"].Size(), len(data))
+
+	check(t, files["dir"] != nil, "no info for dir")
+	check(t, files["dir"].IsDir() == true, "dir should be a directory")
+	check(t, files["dir"].Mode()&os.ModePerm == dirPerm,
+		"incorrect dir mode %#o != %#o", files["dir"].Mode(), dirPerm)
+
+	// test readdir with limit
+
+	d, err = vol.Open(tmpDir)
+	check(t, err == nil, "Open %q: %s", tmpDir, err)
+
+	info, err = d.Readdir(2)
+	check(t, err == nil, "Readdir %q: %s", tmpDir, err)
+	check(t, len(info) == 2, "should only read 2 files")
+
+	info, err = d.Readdir(2)
+	check(t, err == nil, "Readdir %q: %s", tmpDir, err)
+	check(t, len(info) == 2, "should only read 2 files")
+
+	info, err = d.Readdir(2)
+	check(t, err == nil, "Readdir %q: %s", tmpDir, err)
+	check(t, len(info) == 0, "should not read more files")
+
+	err = d.Close()
+	check(t, err == nil, "Close %q: %s", tmpDir, err)
+}
+
+func TestReaddirnames(t *testing.T) {
+	tmpDir, clean := setupReaddir(t)
+	defer clean()
+
+	d, err := vol.Open(tmpDir)
+	check(t, err == nil, "Open %q: %s", tmpDir, err)
+
+	names, err := d.Readdirnames(0)
+	check(t, err == nil, "Readdirnames %q: %s", tmpDir, err)
+
+	err = d.Close()
+	check(t, err == nil, "Close %q: %s", tmpDir, err)
+
+	check(t, len(names) == 4,
+		"incorrect number of files %v != %v", len(names), 4)
+
+	expected := []string{
+		".",
+		"..",
+		"dir",
+		"file",
+	}
+
+	sort.Strings(names)
+	check(t, reflect.DeepEqual(names, expected),
+		"file names doesn't match %v != %v", names, expected)
+
+	// test readdirnames with limit
+
+	d, err = vol.Open(tmpDir)
+	check(t, err == nil, "Open %q: %s", tmpDir, err)
+
+	var all []string
+
+	names, err = d.Readdirnames(2)
+	check(t, err == nil, "Readdirnames %q: %s", tmpDir, err)
+	check(t, len(names) == 2, "should only read 2 files")
+	all = append(all, names...)
+
+	names, err = d.Readdirnames(2)
+	check(t, err == nil, "Readdirnames %q: %s", tmpDir, err)
+	check(t, len(names) == 2, "should only read 2 files")
+	all = append(all, names...)
+
+	names, err = d.Readdirnames(2)
+	check(t, err == nil, "Readdirnames %q: %s", tmpDir, err)
+	check(t, len(names) == 0, "should not read more files")
+
+	err = d.Close()
+	check(t, err == nil, "Close %q: %s", tmpDir, err)
+
+	check(t, len(all) == 4,
+		"incorrect number of files %v != %v", len(all), 4)
+
+	sort.Strings(all)
+	check(t, reflect.DeepEqual(all, expected),
+		"file names doesn't match %v != %v", all, expected)
+}
+
 func TestUnmount(t *testing.T) {
 	err := vol.Unmount()
 	if err != nil {
 		t.Logf("Failed to unmount volume. Ret = %v", err)
 	}
 }
+
+var (
+	dirPerm = os.FileMode(0700)
+	data    = []byte("data")
+)
+
+func setupReaddir(t *testing.T) (string, func()) {
+	tmpDir := "/test-gluster-readdir"
+	err := vol.MkdirAll(tmpDir, 0777)
+	check(t, err == nil, "MkdirAll %q: %s", tmpDir, err)
+
+	dir := filepath.Join(tmpDir, "dir")
+	file := filepath.Join(tmpDir, "file")
+
+	err = vol.MkdirAll(dir, dirPerm)
+	check(t, err == nil, "MkdirAll %q: %s", dir, err)
+
+	f, err := vol.Create(file)
+	check(t, err == nil, "Create %q: %s", file, err)
+
+	n, err := f.Write(data)
+	check(t, err == nil, "Write %q: %s", file, err)
+	check(t, n == len(data), "write length incorrect, %v != %v", n, len(data))
+
+	_, err = f.Readdir(0)
+	check(t, err != nil, "Readdir should fail with files, %v", file)
+
+	err = f.Close()
+	check(t, err == nil, "Close %q: %s", file, err)
+
+	return tmpDir, func() {
+		vol.Unlink(file)
+		vol.Unlink(dir)
+		vol.Unlink(tmpDir)
+	}
+}
+
+func check(t *testing.T, c bool, message string, args ...interface{}) {
+	t.Helper()
+
+	if !c {
+		t.Fatalf(message, args...)
+	}
+}