func (d *Dir) Lookup(ctx context.Context, name string) (fs.Node, error) {
	d.fs.Lock()
	defer d.fs.Unlock()
	d.Attrs.Atime = time.Now()
	if ent, ok := d.Children[name]; ok {
		logger.Debug("lookup %s in %s", name, d.Path())
		if ent.IsDir() {
			return ent.(*Dir), nil
		}
		return ent.(*File), nil
	}
	logger.Debug("(error) couldn't lookup %s in %s", name, d.Path())
	return nil, fuse.ENOENT
}
Lookup looks up a specific entry in the receiver,
which must be a directory.  Lookup should return a Node
corresponding to the entry.  If the name does not exist in
the directory, Lookup should return ENOENT.

Lookup need not to handle the names "." and "..".

https://godoc.org/bazil.org/fuse/fs#NodeStringLookuper
NOTE: implemented NodeStringLookuper rather than NodeRequestLookuper
https://godoc.org/bazil.org/fuse/fs#NodeRequestLookuper
package memfs
import (
	"os"
	"time"
	"bazil.org/fuse"
	"bazil.org/fuse/fs"
	"golang.org/x/net/context"
)
type Dir struct {
	Node
	Children map[string]Entity  
}
func (d *Dir) Init(name string, mode os.FileMode, parent *Dir, memfs *FileSystem) {
	mode = os.ModeDir | mode
	d.Node.Init(name, mode, parent, memfs)
	d.Children = make(map[string]Entity)
}
func (d *Dir) GetNode() *Node {
	return &d.Node
}
func (d *Dir) Create(ctx context.Context, req *fuse.CreateRequest, resp *fuse.CreateResponse) (fs.Node, fs.Handle, error) {
	if d.IsArchive() || d.fs.readonly {
		return nil, nil, fuse.EPERM
	}
	d.fs.Lock()
	defer d.fs.Unlock()
	d.Attrs.Atime = time.Now()
	f := new(File)
	f.Init(req.Name, req.Mode, d, d.fs)
	f.Attrs.Uid = req.Header.Uid
	f.Attrs.Gid = req.Header.Gid
	d.Children[f.Name] = f
	d.Attrs.Mtime = time.Now()
	d.fs.nfiles++
	logger.Info("create %q in %q, mode %v", f.Name, d.Path(), req.Mode)
	return f, f, nil
}
func (d *Dir) Mkdir(ctx context.Context, req *fuse.MkdirRequest) (fs.Node, error) {
	if d.IsArchive() || d.fs.readonly {
		return nil, fuse.EPERM
	}
	d.fs.Lock()
	defer d.fs.Unlock()
	d.Attrs.Atime = time.Now()
	c := new(Dir)
	c.Init(req.Name, req.Mode, d, d.fs)
	c.Attrs.Uid = req.Header.Uid
	c.Attrs.Gid = req.Header.Gid
	d.Children[c.Name] = c
	d.Attrs.Mtime = time.Now()
	d.fs.ndirs++
	logger.Info("mkdir %q in %q, mode %v", c.Name, d.Path(), req.Mode)
	return c, nil
}
func (d *Dir) Remove(ctx context.Context, req *fuse.RemoveRequest) error {
	if d.IsArchive() || d.fs.readonly {
		return fuse.EPERM
	}
	d.fs.Lock()
	defer d.fs.Unlock()
	d.Attrs.Atime = time.Now()
	var ent Entity
	var ok bool
	if ent, ok = d.Children[req.Name]; !ok {
		logger.Debug("(error) could not find node to remove named %q in %q", req.Name, d.Path())
		return fuse.EEXIST
	}
	if ent.IsDir() && len(ent.(*Dir).Children) > 0 {
		logger.Debug("(error) will not remove non-empty directory %q in %q", req.Name, d.Path())
		return fuse.EIO
	}
	delete(d.Children, req.Name)
	d.Attrs.Mtime = time.Now()
	if ent.IsDir() {
		d.fs.ndirs--
	} else {
		d.fs.nfiles--
	}
	logger.Info("removed %q from %q", req.Name, d.Path())
	return nil
}
func (d *Dir) Rename(ctx context.Context, req *fuse.RenameRequest, newDir fs.Node) error {
	if d.IsArchive() || d.fs.readonly {
		return fuse.EPERM
	}
	d.fs.Lock()
	defer d.fs.Unlock()
	d.Attrs.Atime = time.Now()
	var dst *Dir
	var ok bool
	var ent Entity
	var node *Node
	if dst, ok = newDir.(*Dir); !ok {
		logger.Debug("(error) could not convert %q to a directory", newDir)
		return fuse.EEXIST
	}
	dst.Attrs.Atime = time.Now()
	if ent, ok = d.Children[req.OldName]; !ok {
		logger.Debug("(error) could not find %q in %q to move", req.OldName, d.Path())
		return fuse.EEXIST
	}
	node = ent.GetNode()
	node.Name = req.NewName
	node.Attrs.Mtime = time.Now()
	dst.Children[req.NewName] = ent  
	dst.Attrs.Mtime = time.Now()
	delete(dst.Children, req.OldName)  
	d.Attrs.Mtime = time.Now()
	logger.Info("moved %q from %q to %q", req.OldName, d.Path(), ent.Path())
	return nil
}