Completelly changed file container

Implemented Changes pool instead of refreshing all drive

internal/fs/gdrivefs/client.go

@@ -19,7 +19,7 @@ func getTokenFromWeb(config *oauth2.Config) *oauth2.Token {
 	fmt.Printf(
 		`Go to the following link in your browser: 
 ----------------------------------------------------------------------------------------------
-	%v
+%v
 ----------------------------------------------------------------------------------------------
 
 type the authorization code: `, authURL)

internal/fs/gdrivefs/file_container.go

@@ -1,9 +1,13 @@
 package gdrivefs
 
 import (
+	"fmt"
 	"os"
+	"strings"
 	"sync"
 
+	drive "google.golang.org/api/drive/v3"
+
 	"github.com/jacobsa/fuse/fuseops"
 )
 
@@ -25,7 +29,7 @@ func NewFileContainer(fs *GDriveFS) *FileContainer {
 		uid:         fs.config.UID,
 		gid:         fs.config.GID,
 	}
-	rootEntry := fc.FileEntry(fuseops.RootInodeID)
+	rootEntry := fc.FileEntry(nil, fuseops.RootInodeID)
 	rootEntry.Attr.Mode = os.FileMode(0755) | os.ModeDir
 	fc.tree = rootEntry
 
@@ -45,8 +49,27 @@ func (fc *FileContainer) FindByGID(gid string) *FileEntry {
 	return nil
 }
 
-//Return or create inode
-func (fc *FileContainer) FileEntry(inodeOps ...fuseops.InodeID) *FileEntry {
+func (fc *FileContainer) LookupByGID(parentGID string, name string) *FileEntry {
+	for _, entry := range fc.fileEntries {
+		if entry.HasParentGID(parentGID) && entry.Name == name {
+			return entry
+		}
+	}
+	return nil
+}
+
+func (fc *FileContainer) ListByParentGID(parentGID string) []*FileEntry {
+	ret := []*FileEntry{}
+	for _, entry := range fc.fileEntries {
+		if entry.HasParentGID(parentGID) {
+			ret = append(ret, entry)
+		}
+	}
+	return ret
+}
+
+//Return or create inode // Pass name maybe?
+func (fc *FileContainer) FileEntry(gfile *drive.File, inodeOps ...fuseops.InodeID) *FileEntry {
 
 	fc.inodeMU.Lock()
 	defer fc.inodeMU.Unlock()
@@ -67,20 +90,54 @@ func (fc *FileContainer) FileEntry(inodeOps ...fuseops.InodeID) *FileEntry {
 		}
 	}
 
+	name := ""
+	if gfile != nil {
+		name = gfile.Name
+		count := 1
+		nameParts := strings.Split(name, ".")
+		for {
+			// We find if we have a GFile in same parent with same name
+			var entry *FileEntry
+			for _, p := range gfile.Parents {
+				entry = fc.LookupByGID(p, name)
+				if entry != nil {
+					break
+				}
+			}
+			if entry == nil { // Not found return
+				break
+			}
+			count++
+			if len(nameParts) > 1 {
+				name = fmt.Sprintf("%s(%d).%s", nameParts[0], count, strings.Join(nameParts[1:], "."))
+			} else {
+				name = fmt.Sprintf("%s(%d)", nameParts[0], count)
+			}
+			log.Printf("Conflicting name generated new '%s' as '%s'", gfile.Name, name)
+		}
+	}
+
 	fe := &FileEntry{
+		GFile:     gfile,
 		Inode:     inode,
 		container: fc,
-		children:  []*FileEntry{},
+		Name:      name,
+		//children:  []*FileEntry{},
 		Attr: fuseops.InodeAttributes{
 			Uid: fc.uid,
 			Gid: fc.gid,
 		},
 	}
+	fe.SetGFile(gfile)
 	fc.fileEntries[inode] = fe
 
 	return fe
 }
 
+func (fc *FileContainer) AddEntry(entry *FileEntry) {
+	fc.fileEntries[entry.Inode] = entry
+}
+
 // RemoveEntry remove file entry
 func (fc *FileContainer) RemoveEntry(entry *FileEntry) {
 	var inode fuseops.InodeID
@@ -91,3 +148,15 @@ func (fc *FileContainer) RemoveEntry(entry *FileEntry) {
 	}
 	delete(fc.fileEntries, inode)
 }
+
+func (fc *FileContainer) AddGFile(gfile *drive.File) *FileEntry {
+	entry := fc.FindByGID(gfile.Id)
+	if entry != nil {
+		return entry
+	}
+	// Create new Entry
+	entry = fc.FileEntry(gfile)
+	entry.SetGFile(gfile)
+
+	return entry
+}

internal/fs/gdrivefs/file_entry.go

@@ -1,13 +1,10 @@
 package gdrivefs
 
 import (
-	"fmt"
 	"io"
 	"io/ioutil"
-	_ "log"
 	"net/http"
 	"os"
-	"strings"
 	"time"
 
 	"github.com/jacobsa/fuse/fuseops"
@@ -19,6 +16,7 @@ type FileEntry struct {
 	//parent *FileEntry
 	container *FileContainer
 	//fs    *GDriveFS
+	GID   string      // google driveID
 	GFile *drive.File // GDrive file
 	Name  string      // local name
 	// fuseops
@@ -28,17 +26,43 @@ type FileEntry struct {
 	// cache file
 	tempFile *os.File // Cached file
 	// childs
-	children []*FileEntry // children
+	//children []*FileEntry // children
 }
 
-func (fe *FileEntry) AddChild(child *FileEntry) {
+func (fe *FileEntry) HasParentGID(gid string) bool {
+
+	// Exceptional case
+	if fe.Inode == fuseops.RootInodeID {
+		return false
+	}
+	if gid == "" { // We are looking in root
+		if fe.GFile == nil {
+			return true
+		}
+		if len(fe.GFile.Parents) == 0 {
+			return true
+		}
+	}
+
+	if fe.GFile == nil { // Case gid is not empty and GFile is null
+		return false
+	}
+	for _, pgid := range fe.GFile.Parents {
+		if pgid == gid {
+			return true
+		}
+	}
+	return false
+}
+
+/*func (fe *FileEntry) AddChild(child *FileEntry) {
 	//child.parent = fe // is this needed at all?
 	// Solve name here?
 
 	fe.children = append(fe.children, child)
-}
+}*/
 
-func (fe *FileEntry) RemoveChild(child *FileEntry) {
+/*func (fe *FileEntry) RemoveChild(child *FileEntry) {
 	toremove := -1
 	for i, v := range fe.children {
 		if v == child {
@@ -50,7 +74,7 @@ func (fe *FileEntry) RemoveChild(child *FileEntry) {
 		return
 	}
 	fe.children = append(fe.children[:toremove], fe.children[toremove+1:]...)
-}
+}*/
 
 // useful for debug to count children
 /*func (fe *FileEntry) Count() int {
@@ -63,27 +87,31 @@ func (fe *FileEntry) RemoveChild(child *FileEntry) {
 }*/
 
 // SetGFile update attributes and set drive.File
-func (fe *FileEntry) SetGFile(f *drive.File) {
+func (fe *FileEntry) SetGFile(gfile *drive.File) {
+	if gfile == nil {
+		fe.GFile = nil
+	} else {
+		fe.GFile = gfile
+	}
+
 	// Create Attribute
 	attr := fuseops.InodeAttributes{}
 	attr.Nlink = 1
-	attr.Size = uint64(f.Size)
-	//attr.Size = uint64(f.QuotaBytesUsed)
-	// Temp
 	attr.Uid = fe.container.uid
 	attr.Gid = fe.container.gid
-	attr.Crtime, _ = time.Parse(time.RFC3339, f.CreatedTime)
-	attr.Ctime = attr.Crtime // Set CTime to created, although it is change inode metadata
-	attr.Mtime, _ = time.Parse(time.RFC3339, f.ModifiedTime)
-	attr.Atime = attr.Mtime // Set access time to modified, not sure if gdrive has access time
 
 	attr.Mode = os.FileMode(0644) // default
-
-	if f.MimeType == "application/vnd.google-apps.folder" {
-		attr.Mode = os.FileMode(0755) | os.ModeDir
+	if gfile != nil {
+		attr.Size = uint64(gfile.Size)
+		attr.Crtime, _ = time.Parse(time.RFC3339, gfile.CreatedTime)
+		attr.Ctime = attr.Crtime // Set CTime to created, although it is change inode metadata
+		attr.Mtime, _ = time.Parse(time.RFC3339, gfile.ModifiedTime)
+		attr.Atime = attr.Mtime // Set access time to modified, not sure if gdrive has access time
+		if gfile.MimeType == "application/vnd.google-apps.folder" {
+			attr.Mode = os.FileMode(0755) | os.ModeDir
+		}
+		fe.GID = gfile.Id
 	}
-
-	fe.GFile = f
 	fe.Attr = attr
 }
 
@@ -98,7 +126,7 @@ func (fe *FileEntry) Sync() (err error) {
 
 	ngFile := &drive.File{}
 	up := fe.container.fs.client.Files.Update(fe.GFile.Id, ngFile)
-	upFile, err := up.Media(fe.tempFile).Do()
+	upFile, err := up.Media(fe.tempFile).Fields(fileFields).Do()
 
 	fe.SetGFile(upFile) // update local GFile entry
 	return
@@ -155,122 +183,6 @@ func (fe *FileEntry) Cache() *os.File {
 
 }
 
-// Find the right parent?
-// WRONG
-func (fe *FileEntry) solveAppendGFile(f *drive.File, inode fuseops.InodeID) *FileEntry {
-
-	fil := fe.container.FindByGID(f.Id)
-	if fil != nil { // ignore existing ID
-		return fil
-	}
-
-	if len(f.Parents) == 0 {
-		return fe.AppendGFile(f, inode) // = append(fs.root.fileList, entry)
-	}
-	for _, parent := range f.Parents { // hierarchy add
-		parentEntry := fe.container.FindByGID(parent)
-		if parentEntry == nil {
-			log.Fatalln("Non existent parent", parent)
-		}
-		// Here
-		return parentEntry.AppendGFile(f, inode)
-	}
-	return nil
-}
-
-// Load append whatever?
-// append file to this tree
-func (fe *FileEntry) AppendGFile(f *drive.File, inode fuseops.InodeID) *FileEntry {
-
-	name := f.Name
-	count := 1
-	nameParts := strings.Split(f.Name, ".")
-	for {
-		en := fe.FindByName(name, false) // locally only
-		if en == nil {                   // ok we want no value
-			break
-		}
-		count++
-		if len(nameParts) > 1 {
-			name = fmt.Sprintf("%s(%d).%s", nameParts[0], count, strings.Join(nameParts[1:], "."))
-		} else {
-			name = fmt.Sprintf("%s(%d)", nameParts[0], count)
-		}
-	}
-
-	// Create an entry
-
-	//log.Println("Creating new file entry for name:", name, "for GFile:", f.Name)
-	// lock from find inode to fileList append
-	entry := fe.container.FileEntry(inode)
-	entry.Name = name
-	entry.SetGFile(f)
-
-	fe.AddChild(entry)
-
-	//fe.fileList = append(fe.fileList, entry)
-	//fe.fileMap[f.Name] = entry
-
-	return entry
-}
-
-//FindByInode find by Inode or return self
-func (fe *FileEntry) FindByInode(inode fuseops.InodeID, recurse bool) *FileEntry {
-	if inode == fe.Inode {
-		return fe // return self
-	}
-	// Recurse??
-	for _, e := range fe.children {
-		if e.Inode == inode {
-			return e
-		}
-		if recurse {
-			re := e.FindByInode(inode, recurse)
-			if re != nil {
-				return re
-			}
-		}
-	}
-	// For each child we findByInode
-	return nil
-}
-
-// FindByName return a child entry by name
-func (fe *FileEntry) FindByName(name string, recurse bool) *FileEntry {
-	// Recurse??
-	for _, e := range fe.children {
-		if e.Name == name {
-			return e
-		}
-		if recurse {
-			re := e.FindByName(name, recurse)
-			if re != nil {
-				return re
-			}
-		}
-	}
-	// For each child we findByInode
-	return nil
-}
-
 func (fe *FileEntry) IsDir() bool {
 	return fe.Attr.Mode&os.ModeDir == os.ModeDir
 }
-
-// FindByGID find by google drive ID
-/*func (fe *FileEntry) FindByGID(gdriveID string, recurse bool) *FileEntry {
-	// Recurse??
-	for _, e := range fe.children {
-		if e.GFile.Id == gdriveID {
-			return e
-		}
-		if recurse {
-			re := e.FindByGID(gdriveID, recurse)
-			if re != nil {
-				return re
-			}
-		}
-	}
-	// For each child we findByInode
-	return nil
-}*/

internal/fs/gdrivefs/gdrivefs.go

@@ -69,14 +69,63 @@ func New(core *core.Core) core.Driver {
 	//fs.root = rootEntry
 
 	// Temporary entry
-	entry := fs.root.tree.AppendGFile(&drive.File{Id: "0", Name: "Loading..."}, 999999)
+	entry := fs.root.FileEntry(&drive.File{Id: "0", Name: "Loading..."}, 9999)
 	entry.Attr.Mode = os.FileMode(0)
 
 	return fs
 }
 
 func (fs *GDriveFS) Start() {
-	fs.timedRefresh() // start synching
+	go func() {
+		fs.Refresh()
+
+		log.Println("Checking changes:")
+		startPageTokenRes, err := fs.client.Changes.GetStartPageToken().Do()
+		if err != nil {
+			log.Println("GDrive err", err)
+		}
+		savedStartPageToken := startPageTokenRes.StartPageToken
+		for {
+			pageToken := savedStartPageToken
+			for pageToken != "" {
+				changesRes, err := fs.client.Changes.List(pageToken).Fields(googleapi.Field("newStartPageToken,nextPageToken,changes(removed,fileId,file(" + fileFields + "))")).Do()
+				if err != nil {
+					log.Println("Err fetching changes", err)
+					break
+				}
+				log.Println("Changes:", len(changesRes.Changes))
+				for _, c := range changesRes.Changes {
+					if c.File != nil {
+						log.Printf("File %s changed", c.File.Name)
+						log.Println("Parents:", c.File.Parents)
+					}
+					entry := fs.root.FindByGID(c.FileId)
+					log.Println("Is entry nil?", entry)
+					if c.Removed {
+						if entry == nil {
+							continue
+						} else {
+							fs.root.RemoveEntry(entry)
+						}
+						continue
+					}
+
+					if entry != nil {
+						entry.SetGFile(c.File)
+					} else {
+						//Create new one
+						fs.root.FileEntry(c.File) // Creating new one
+					}
+				}
+				if changesRes.NewStartPageToken != "" {
+					savedStartPageToken = changesRes.NewStartPageToken
+				}
+				pageToken = changesRes.NextPageToken
+			}
+
+			time.Sleep(10 * time.Second)
+		}
+	}()
 }
 
 ////////////////////////////////////////////////////////
@@ -103,34 +152,22 @@ func (fs *GDriveFS) createHandle() *Handle {
 	return handle
 }
 
-func (fs *GDriveFS) timedRefresh() {
-
-	go func() {
-		for {
-			if time.Now().After(fs.nextRefresh) {
-				fs.Refresh()
-			}
-			time.Sleep(fs.config.RefreshTime) // 2 minutes
-		}
-	}()
-
-}
+const fileFields = googleapi.Field("id, name, size,mimeType, parents,createdTime,modifiedTime")
+const gdFields = googleapi.Field("files(" + fileFields + ")")
 
-// Refresh service files
+// FULL Refresh service files
 func (fs *GDriveFS) Refresh() {
 	fs.nextRefresh = time.Now().Add(1 * time.Minute)
 
 	fileList := []*drive.File{}
 	fileMap := map[string]*drive.File{} // Temporary map by google drive fileID
 
-	gdFields := googleapi.Field("nextPageToken, files(id,name,size,quotaBytesUsed, mimeType,parents,createdTime,modifiedTime)")
-	log.Println("Loading file entries from gdrive")
 	r, err := fs.client.Files.List().
 		OrderBy("createdTime").
 		PageSize(1000).
 		SupportsTeamDrives(true).
 		IncludeTeamDriveItems(true).
-		Fields(gdFields).
+		Fields(googleapi.Field("nextPageToken"), gdFields).
 		Do()
 	if err != nil {
 		// Sometimes gdrive returns error 500 randomly
@@ -145,7 +182,7 @@ func (fs *GDriveFS) Refresh() {
 		r, err = fs.client.Files.List().
 			OrderBy("createdTime").
 			PageToken(r.NextPageToken).
-			Fields(gdFields).
+			Fields(googleapi.Field("nextPageToken"), gdFields).
 			Do()
 		if err != nil {
 			log.Println("GDrive ERR:", err)
@@ -168,20 +205,14 @@ func (fs *GDriveFS) Refresh() {
 
 	// Create clean fileList
 	root := NewFileContainer(fs)
-
-	// Helper func to recurse
-	// Everything loaded we add to our entries
-	// Add file and its parents priorizing it parent
-
-	var appendFile func(df *drive.File)
-
-	appendFile = func(df *drive.File) {
-		for _, pID := range df.Parents {
+	var appendFile func(gfile *drive.File)
+	appendFile = func(gfile *drive.File) {
+		for _, pID := range gfile.Parents {
 			parentFile, ok := fileMap[pID]
 			if !ok {
 				parentFile, err = fs.client.Files.Get(pID).Do()
 				if err != nil {
-					panic(err)
+					log.Println("Error fetching single file:", err)
 				}
 				fileMap[parentFile.Id] = parentFile
 			}
@@ -189,20 +220,12 @@ func (fs *GDriveFS) Refresh() {
 		}
 
 		// Find existing entry
-		var inode fuseops.InodeID
-		entry := fs.root.FindByGID(df.Id)
+		entry := fs.root.FindByGID(gfile.Id)
 		// Store for later add
 		if entry == nil {
-			inode = fs.root.FileEntry().Inode // Register new inode on Same Root fs
-			//inode = root.FileEntry().Inode // This can be a problem if next time a existing inode comes? Allocate new file entry with new Inode
-		} else {
-			inode = entry.Inode // Reuse existing root fs inode
-		}
-
-		newEntry := root.tree.solveAppendGFile(df, inode) // Find right parent
-		if entry != nil && entry.GFile.Name == df.Name {  // Copy name from old entry
-			newEntry.Name = entry.Name
+			entry = fs.root.FileEntry(gfile) // Add New and retrieve
 		}
+		root.AddEntry(entry)
 		// add File
 	}
 
@@ -214,7 +237,7 @@ func (fs *GDriveFS) Refresh() {
 	fs.root = root
 	//fs.root.children = root.children
 
-	log.Println("File count:", len(fs.root.fileEntries))
+	log.Println("File count:", len(root.fileEntries))
 }
 
 ///////////////////////////////
@@ -245,8 +268,9 @@ func (fs *GDriveFS) ReadDir(ctx context.Context, op *fuseops.ReadDirOp) (err err
 
 	if op.Offset == 0 { // Rebuild/rewind dir list
 		fh.entries = []fuseutil.Dirent{}
+		children := fs.root.ListByParentGID(fh.entry.GID)
 
-		for i, v := range fh.entry.children {
+		for i, v := range children {
 			fusetype := fuseutil.DT_File
 			if v.IsDir() {
 				fusetype = fuseutil.DT_Directory
@@ -271,7 +295,6 @@ func (fs *GDriveFS) ReadDir(ctx context.Context, op *fuseops.ReadDirOp) (err err
 	}
 	for i := index; i < len(fh.entries); i++ {
 		n := fuseutil.WriteDirent(op.Dst[op.BytesRead:], fh.entries[i])
-		//log.Println("Written:", n)
 		if n == 0 {
 			break
 		}
@@ -293,7 +316,7 @@ func (fs *GDriveFS) SetInodeAttributes(ctx context.Context, op *fuseops.SetInode
 		}
 		// Delete and create another on truncate 0
 		err = fs.client.Files.Delete(f.GFile.Id).Do() // XXX: Careful on this
-		createdFile, err := fs.client.Files.Create(&drive.File{Parents: f.GFile.Parents, Name: f.GFile.Name}).Do()
+		createdFile, err := fs.client.Files.Create(&drive.File{Parents: f.GFile.Parents, Name: f.GFile.Name}).Fields(fileFields).Do()
 		if err != nil {
 			return fuse.EINVAL
 		}
@@ -330,16 +353,18 @@ func (fs *GDriveFS) LookUpInode(ctx context.Context, op *fuseops.LookUpInodeOp)
 		return fuse.ENOENT
 	}
 
-	now := time.Now()
-	// Transverse only local
-	f := parentFile.FindByName(op.Name, false)
-	if f == nil {
+	entry := fs.root.LookupByGID(parentFile.GID, op.Name)
+
+	if entry == nil {
 		return fuse.ENOENT
 	}
 
+	// Transverse only local
+
+	now := time.Now()
 	op.Entry = fuseops.ChildInodeEntry{
-		Attributes:           f.Attr,
-		Child:                f.Inode,
+		Attributes:           entry.Attr,
+		Child:                entry.Inode,
 		AttributesExpiration: now.Add(time.Second),
 		EntryExpiration:      now.Add(time.Second),
 	}
@@ -404,30 +429,23 @@ func (fs *GDriveFS) CreateFile(ctx context.Context, op *fuseops.CreateFileOp) (e
 		return syscall.EPERM
 	}
 
-	existsFile := parentFile.FindByName(op.Name, false)
+	existsFile := fs.root.LookupByGID(parentFile.GID, op.Name)
+	//existsFile := parentFile.FindByName(op.Name, false)
 	if existsFile != nil {
 		return fuse.EEXIST
 	}
 
-	newFile := &drive.File{
+	newGFile := &drive.File{
 		Parents: []string{parentFile.GFile.Id},
 		Name:    op.Name,
 	}
 
-	createdFile, err := fs.client.Files.Create(newFile).Do()
+	createdGFile, err := fs.client.Files.Create(newGFile).Fields(fileFields).Do()
 	if err != nil {
 		err = fuse.EINVAL
 		return
 	}
-
-	// Temp
-	entry := fs.root.FileEntry()
-
-	entry = parentFile.AppendGFile(createdFile, entry.Inode) // Add new created file
-	if entry == nil {
-		err = fuse.EINVAL
-		return
-	}
+	entry := fs.root.FileEntry(createdGFile) // New Entry added // Or Return same?
 
 	// Associate a temp file to a new handle
 	// Local copy
@@ -486,7 +504,6 @@ func (fs *GDriveFS) FlushFile(ctx context.Context, op *fuseops.FlushFileOp) (err
 			return fuse.EINVAL
 		}
 	}
-
 	return
 }
 
@@ -511,7 +528,8 @@ func (fs *GDriveFS) Unlink(ctx context.Context, op *fuseops.UnlinkOp) (err error
 		return syscall.EPERM
 	}
 
-	fileEntry := parentEntry.FindByName(op.Name, false)
+	fileEntry := fs.root.LookupByGID(parentEntry.GID, op.Name)
+	//fileEntry := parentEntry.FindByName(op.Name, false)
 	if fileEntry == nil {
 		return fuse.ENOATTR
 	}
@@ -521,7 +539,7 @@ func (fs *GDriveFS) Unlink(ctx context.Context, op *fuseops.UnlinkOp) (err error
 	}
 
 	fs.root.RemoveEntry(fileEntry)
-	parentEntry.RemoveChild(fileEntry)
+	//parentEntry.RemoveChild(fileEntry)
 
 	return
 }
@@ -538,19 +556,19 @@ func (fs *GDriveFS) MkDir(ctx context.Context, op *fuseops.MkDirOp) (err error)
 	}
 
 	// Should check existent first too
-	fi, err := fs.client.Files.Create(&drive.File{
+	createdGFile, err := fs.client.Files.Create(&drive.File{
 		Parents:  []string{parentFile.GFile.Id},
 		MimeType: "application/vnd.google-apps.folder",
 		Name:     op.Name,
-	}).Do()
+	}).Fields(fileFields).Do()
 	if err != nil {
 		return fuse.ENOATTR
 	}
-	entry := fs.root.FileEntry()
-	entry = parentFile.AppendGFile(fi, entry.Inode)
-	if entry == nil {
-		return fuse.EINVAL
-	}
+	entry := fs.root.FileEntry(createdGFile)
+	//entry = parentFile.AppendGFile(fi, entry.Inode)
+	//if entry == nil {
+	//		return fuse.EINVAL
+	//	}
 
 	op.Entry = fuseops.ChildInodeEntry{
 		Attributes:           entry.Attr,
@@ -573,14 +591,16 @@ func (fs *GDriveFS) RmDir(ctx context.Context, op *fuseops.RmDirOp) (err error)
 		return syscall.EPERM
 	}
 
-	theFile := parentFile.FindByName(op.Name, false)
+	theFile := fs.root.LookupByGID(parentFile.GID, op.Name)
+	//theFile := parentFile.FindByName(op.Name, false)
 
 	err = fs.client.Files.Delete(theFile.GFile.Id).Do()
 	if err != nil {
 		return fuse.ENOTEMPTY
 	}
+	fs.root.RemoveEntry(theFile)
 
-	parentFile.RemoveChild(theFile)
+	//parentFile.RemoveChild(theFile)
 
 	// Remove from entry somehow
 
@@ -602,12 +622,14 @@ func (fs *GDriveFS) Rename(ctx context.Context, op *fuseops.RenameOp) (err error
 		return syscall.EPERM
 	}
 
-	oldFile := oldParentFile.FindByName(op.OldName, false)
+	//oldFile := oldParentFile.FindByName(op.OldName, false)
+	oldEntry := fs.root.LookupByGID(oldParentFile.GID, op.OldName)
 
 	// Although GDrive allows duplicate names, there is some issue with inode caching
 	// So we prevent a rename to a file with same name
-	existsFile := newParentFile.FindByName(op.NewName, false)
-	if existsFile != nil {
+	//existsFile := newParentFile.FindByName(op.NewName, false)
+	existsEntry := fs.root.LookupByGID(newParentFile.GID, op.NewName)
+	if existsEntry != nil {
 		return fuse.EEXIST
 	}
 
@@ -615,15 +637,17 @@ func (fs *GDriveFS) Rename(ctx context.Context, op *fuseops.RenameOp) (err error
 		Name: op.NewName,
 	}
 
-	updateCall := fs.client.Files.Update(oldFile.GFile.Id, ngFile)
+	updateCall := fs.client.Files.Update(oldEntry.GID, ngFile).Fields(fileFields)
 	if oldParentFile != newParentFile {
-		updateCall.RemoveParents(oldParentFile.GFile.Id)
-		updateCall.AddParents(newParentFile.GFile.Id)
+		updateCall.RemoveParents(oldParentFile.GID)
+		updateCall.AddParents(newParentFile.GID)
 	}
 	updatedFile, err := updateCall.Do()
 
-	oldParentFile.RemoveChild(oldFile)
-	newParentFile.AppendGFile(updatedFile, oldFile.Inode)
+	oldEntry.SetGFile(updatedFile)
+
+	//oldParentFile.RemoveChild(oldFile)
+	//newParentFile.AppendGFile(updatedFile, oldFile.Inode)
 
 	return