|
|
@@ -1,17 +1,654 @@
|
|
|
+// gdrivemount implements a google drive fuse driver
|
|
|
package gdrivefs
|
|
|
|
|
|
-import "dev.hexasoftware.com/hxs/cloudmount/cloudfs"
|
|
|
+import (
|
|
|
+ "io"
|
|
|
+ "os"
|
|
|
+ "syscall"
|
|
|
+ "time"
|
|
|
|
|
|
-// Driver for gdrive
|
|
|
-type GDriveDriver struct {
|
|
|
- core *core.Core
|
|
|
+ "dev.hexasoftware.com/hxs/cloudmount/cloudfs"
|
|
|
+ "dev.hexasoftware.com/hxs/prettylog"
|
|
|
+
|
|
|
+ "golang.org/x/net/context"
|
|
|
+
|
|
|
+ drive "google.golang.org/api/drive/v3"
|
|
|
+ "google.golang.org/api/googleapi"
|
|
|
+
|
|
|
+ "github.com/jacobsa/fuse"
|
|
|
+ "github.com/jacobsa/fuse/fuseops"
|
|
|
+ "github.com/jacobsa/fuse/fuseutil"
|
|
|
+)
|
|
|
+
|
|
|
+var (
|
|
|
+ log = prettylog.New("gdrivemount")
|
|
|
+)
|
|
|
+
|
|
|
+type fileHandle struct {
|
|
|
+ handleID fuseops.HandleID
|
|
|
+ entry *FileEntry
|
|
|
+ uploadOnDone bool
|
|
|
+ // Handling for dir
|
|
|
+ entries []fuseutil.Dirent
|
|
|
+}
|
|
|
+
|
|
|
+/*type DirEntry struct {
|
|
|
+ file *FileEntry
|
|
|
+}*/
|
|
|
+
|
|
|
+// FuseHndler handler
|
|
|
+type GDriveFS struct {
|
|
|
+ fuseutil.NotImplementedFileSystem // Defaults
|
|
|
+
|
|
|
+ core *cloudfs.Core // Core Config instead?
|
|
|
+ client *drive.Service
|
|
|
+ root *FileEntry // hiearchy reference
|
|
|
+ fileHandles map[fuseops.HandleID]*fileHandle
|
|
|
+
|
|
|
+ nextRefresh time.Time
|
|
|
+
|
|
|
+ //fileMap map[string]
|
|
|
+ // Map IDS with FileEntries
|
|
|
+}
|
|
|
+
|
|
|
+func New(core *cloudfs.Core) cloudfs.Driver {
|
|
|
+
|
|
|
+ fs := &GDriveFS{
|
|
|
+ core: core,
|
|
|
+ fileHandles: map[fuseops.HandleID]*fileHandle{},
|
|
|
+ }
|
|
|
+ fs.initClient() // Init Oauth2 client
|
|
|
+
|
|
|
+ rootEntry := fs.NewFileEntry()
|
|
|
+ rootEntry.Attr = fuseops.InodeAttributes{
|
|
|
+ Mode: os.FileMode(0755) | os.ModeDir,
|
|
|
+ Uid: core.Config.UID,
|
|
|
+ Gid: core.Config.GID,
|
|
|
+ }
|
|
|
+ rootEntry.Inode = fuseops.RootInodeID
|
|
|
+ rootEntry.isDir = true
|
|
|
+
|
|
|
+ fs.root = rootEntry
|
|
|
+
|
|
|
+ // Temporary entry
|
|
|
+ entry := fs.root.AppendGFile(&drive.File{Id: "0", Name: "Loading..."}, 999999)
|
|
|
+ entry.Attr.Mode = os.FileMode(0)
|
|
|
+
|
|
|
+ return fs
|
|
|
+}
|
|
|
+
|
|
|
+func (fs *GDriveFS) Start() {
|
|
|
+ fs.timedRefresh()
|
|
|
+}
|
|
|
+
|
|
|
+func (fs *GDriveFS) NewFileEntry() *FileEntry {
|
|
|
+ return &FileEntry{
|
|
|
+ fs: fs,
|
|
|
+ children: []*FileEntry{},
|
|
|
+ Attr: fuseops.InodeAttributes{},
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////
|
|
|
+// TOOLS & HELPERS
|
|
|
+////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+func (fs *GDriveFS) createHandle() *fileHandle {
|
|
|
+ // Lock here instead
|
|
|
+
|
|
|
+ var handle fuseops.HandleID
|
|
|
+
|
|
|
+ for handle = 1; handle < 99999; handle++ {
|
|
|
+ _, ok := fs.fileHandles[handle]
|
|
|
+ if !ok {
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fh := &fileHandle{handleID: handle}
|
|
|
+ fs.fileHandles[handle] = fh
|
|
|
+
|
|
|
+ return fh
|
|
|
+}
|
|
|
+
|
|
|
+// Cache somewhere?
|
|
|
+/*func (fs *GDriveFS) getUID() uint32 {
|
|
|
+ uid, _ := strconv.Atoi(fs.osuser.Uid)
|
|
|
+ return uint32(uid)
|
|
|
+}
|
|
|
+func (fs *GDriveFS) getGID() uint32 {
|
|
|
+ gid, _ := strconv.Atoi(fs.osuser.Gid)
|
|
|
+ return uint32(gid)
|
|
|
+}*/
|
|
|
+
|
|
|
+func (fs *GDriveFS) timedRefresh() {
|
|
|
+
|
|
|
+ go func() {
|
|
|
+ for {
|
|
|
+ if time.Now().After(fs.nextRefresh) {
|
|
|
+ fs.Refresh()
|
|
|
+ }
|
|
|
+ time.Sleep(2 * time.Minute) // 2 minutes
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// 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).
|
|
|
+ Do()
|
|
|
+ if err != nil {
|
|
|
+ log.Println("GDrive ERR:", err)
|
|
|
+ return
|
|
|
+ }
|
|
|
+ fileList = append(fileList, r.Files...)
|
|
|
+
|
|
|
+ // Rest of the pages
|
|
|
+ for r.NextPageToken != "" {
|
|
|
+ r, err = fs.client.Files.List().
|
|
|
+ OrderBy("createdTime").
|
|
|
+ PageToken(r.NextPageToken).
|
|
|
+ Fields(gdFields).
|
|
|
+ Do()
|
|
|
+ if err != nil {
|
|
|
+ log.Println("GDrive ERR:", err)
|
|
|
+ return
|
|
|
+ }
|
|
|
+ fileList = append(fileList, r.Files...)
|
|
|
+ }
|
|
|
+ log.Println("Total entries:", len(fileList))
|
|
|
+
|
|
|
+ // TimeSort
|
|
|
+ /*log.Println("Sort by time")
|
|
|
+ sort.Slice(fileList, func(i, j int) bool {
|
|
|
+ createdTimeI, _ := time.Parse(time.RFC3339, fileList[i].CreatedTime)
|
|
|
+ createdTimeJ, _ := time.Parse(time.RFC3339, fileList[i].CreatedTime)
|
|
|
+ if createdTimeI.Before(createdTimeJ) {
|
|
|
+ return true
|
|
|
+ }
|
|
|
+ return false
|
|
|
+ })*/
|
|
|
+
|
|
|
+ // Cache ID for faster retrieval, might not be necessary
|
|
|
+ for _, f := range fileList {
|
|
|
+ fileMap[f.Id] = f
|
|
|
+ }
|
|
|
+
|
|
|
+ if err != nil || r == nil {
|
|
|
+ log.Println("Unable to retrieve files", err)
|
|
|
+ return
|
|
|
+ }
|
|
|
+
|
|
|
+ // Create clean fileList
|
|
|
+ root := fs.NewFileEntry()
|
|
|
+
|
|
|
+ // 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 {
|
|
|
+ parentFile, ok := fileMap[pID]
|
|
|
+ if !ok {
|
|
|
+ parentFile, err = fs.client.Files.Get(pID).Do()
|
|
|
+ if err != nil {
|
|
|
+ panic(err)
|
|
|
+ }
|
|
|
+ fileMap[parentFile.Id] = parentFile
|
|
|
+ }
|
|
|
+ appendFile(parentFile) // Recurse
|
|
|
+ }
|
|
|
+ // Find existing entry
|
|
|
+ var inode fuseops.InodeID
|
|
|
+ entry := fs.root.FindByGID(df.Id, true)
|
|
|
+ if entry == nil {
|
|
|
+ inode = root.FindUnusedInode()
|
|
|
+ } else {
|
|
|
+ inode = entry.Inode
|
|
|
+ }
|
|
|
+
|
|
|
+ newEntry := root.solveAppendGFile(df, inode) // Find right parent
|
|
|
+ if entry != nil && entry.GFile.Name == df.Name { // Copy name from old entry
|
|
|
+ newEntry.Name = entry.Name
|
|
|
+ }
|
|
|
+
|
|
|
+ // add File
|
|
|
+ }
|
|
|
+
|
|
|
+ for _, f := range fileList { // Ordered
|
|
|
+ appendFile(f) // Check parent first
|
|
|
+ }
|
|
|
+
|
|
|
+ log.Println("Refresh done, update root")
|
|
|
+ fs.root.children = root.children
|
|
|
+
|
|
|
+ log.Println("File count:", fs.root.Count())
|
|
|
+}
|
|
|
+
|
|
|
+// OpenDir return nil error allows open dir
|
|
|
+func (fs *GDriveFS) OpenDir(ctx context.Context, op *fuseops.OpenDirOp) (err error) {
|
|
|
+
|
|
|
+ entry := fs.root.FindByInode(op.Inode, true)
|
|
|
+ if entry == nil {
|
|
|
+ return fuse.ENOENT
|
|
|
+ }
|
|
|
+
|
|
|
+ fh := fs.createHandle()
|
|
|
+ fh.entry = entry
|
|
|
+ op.Handle = fh.handleID
|
|
|
+
|
|
|
+ return // No error allow, dir open
|
|
|
}
|
|
|
|
|
|
-func (d *GDriveDriver) Init(core *core.Core) {
|
|
|
- d.core = core
|
|
|
+// ReadDir lists files into readdirop
|
|
|
+func (fs *GDriveFS) ReadDir(ctx context.Context, op *fuseops.ReadDirOp) (err error) {
|
|
|
+ fh, ok := fs.fileHandles[op.Handle]
|
|
|
+ if !ok {
|
|
|
+ log.Fatal("Handle does not exists")
|
|
|
+ }
|
|
|
+
|
|
|
+ if op.Offset == 0 { // Rebuild/rewind dir list
|
|
|
+ fh.entries = []fuseutil.Dirent{}
|
|
|
|
|
|
+ for i, v := range fh.entry.children {
|
|
|
+ fusetype := fuseutil.DT_File
|
|
|
+ if v.isDir {
|
|
|
+ fusetype = fuseutil.DT_Directory
|
|
|
+ }
|
|
|
+ dirEnt := fuseutil.Dirent{
|
|
|
+ Inode: v.Inode,
|
|
|
+ Name: v.Name,
|
|
|
+ Type: fusetype,
|
|
|
+ Offset: fuseops.DirOffset(i) + 1,
|
|
|
+ }
|
|
|
+ // written += fuseutil.WriteDirent(fh.buf[written:], dirEnt)
|
|
|
+ fh.entries = append(fh.entries, dirEnt)
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ index := int(op.Offset)
|
|
|
+ if index > len(fh.entries) {
|
|
|
+ return fuse.EINVAL
|
|
|
+ }
|
|
|
+ if index > 0 {
|
|
|
+ index++
|
|
|
+ }
|
|
|
+ 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
|
|
|
+ }
|
|
|
+ op.BytesRead += n
|
|
|
+ }
|
|
|
+ return
|
|
|
}
|
|
|
|
|
|
-func (d *GDriveDriver) Start() {
|
|
|
+// SetInodeAttributes Not sure what attributes gdrive support we just leave this blank for now
|
|
|
+func (fs *GDriveFS) SetInodeAttributes(ctx context.Context, op *fuseops.SetInodeAttributesOp) (err error) {
|
|
|
+
|
|
|
+ // Hack to truncate file?
|
|
|
+
|
|
|
+ if op.Size != nil {
|
|
|
+ f := fs.root.FindByInode(op.Inode, true)
|
|
|
+
|
|
|
+ if *op.Size != 0 { // We only allow truncate to 0
|
|
|
+ return fuse.ENOSYS
|
|
|
+ }
|
|
|
+ // 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()
|
|
|
+ if err != nil {
|
|
|
+ return fuse.EINVAL
|
|
|
+ }
|
|
|
+ f.SetGFile(createdFile) // Set new file
|
|
|
+ }
|
|
|
+
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+//GetInodeAttributes return attributes
|
|
|
+func (fs *GDriveFS) GetInodeAttributes(ctx context.Context, op *fuseops.GetInodeAttributesOp) (err error) {
|
|
|
+
|
|
|
+ f := fs.root.FindByInode(op.Inode, true)
|
|
|
+ if f == nil {
|
|
|
+ return fuse.ENOENT
|
|
|
+ }
|
|
|
+ op.Attributes = f.Attr
|
|
|
+ op.AttributesExpiration = time.Now().Add(time.Minute)
|
|
|
+
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// ReleaseDirHandle deletes file handle entry
|
|
|
+func (fs *GDriveFS) ReleaseDirHandle(ctx context.Context, op *fuseops.ReleaseDirHandleOp) (err error) {
|
|
|
+ delete(fs.fileHandles, op.Handle)
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// LookUpInode based on Parent and Name we return a self cached inode
|
|
|
+func (fs *GDriveFS) LookUpInode(ctx context.Context, op *fuseops.LookUpInodeOp) (err error) {
|
|
|
+
|
|
|
+ parentFile := fs.root.FindByInode(op.Parent, true) // true means transverse all
|
|
|
+ if parentFile == nil {
|
|
|
+ return fuse.ENOENT
|
|
|
+ }
|
|
|
+
|
|
|
+ now := time.Now()
|
|
|
+ // Transverse only local
|
|
|
+ f := parentFile.FindByName(op.Name, false)
|
|
|
+ if f == nil {
|
|
|
+ return fuse.ENOENT
|
|
|
+ }
|
|
|
+
|
|
|
+ op.Entry = fuseops.ChildInodeEntry{
|
|
|
+ Attributes: f.Attr,
|
|
|
+ Child: f.Inode,
|
|
|
+ AttributesExpiration: now.Add(time.Second),
|
|
|
+ EntryExpiration: now.Add(time.Second),
|
|
|
+ }
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// StatFS basically allows StatFS to run
|
|
|
+/*func (fs *GDriveFS) StatFS(ctx context.Context, op *fuseops.StatFSOp) (err error) {
|
|
|
+ return
|
|
|
+}*/
|
|
|
+
|
|
|
+// ForgetInode allows to forgetInode
|
|
|
+func (fs *GDriveFS) ForgetInode(ctx context.Context, op *fuseops.ForgetInodeOp) (err error) {
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// GetXAttr special attributes
|
|
|
+func (fs *GDriveFS) GetXAttr(ctx context.Context, op *fuseops.GetXattrOp) (err error) {
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+//////////////////////////////////////////////////////////////////////////
|
|
|
+// File OPS
|
|
|
+//////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+// OpenFile creates a temporary handle to be handled on read or write
|
|
|
+func (fs *GDriveFS) OpenFile(ctx context.Context, op *fuseops.OpenFileOp) (err error) {
|
|
|
+ f := fs.root.FindByInode(op.Inode, true) // might not exists
|
|
|
+
|
|
|
+ // Generate new handle
|
|
|
+ fh := fs.createHandle()
|
|
|
+ fh.entry = f
|
|
|
+
|
|
|
+ op.Handle = fh.handleID
|
|
|
+ op.UseDirectIO = true
|
|
|
+
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// ReadFile if the first time we download the google drive file into a local temporary file
|
|
|
+func (fs *GDriveFS) ReadFile(ctx context.Context, op *fuseops.ReadFileOp) (err error) {
|
|
|
+ lf := fs.fileHandles[op.Handle]
|
|
|
+
|
|
|
+ localFile := lf.entry.Cache()
|
|
|
+ op.BytesRead, err = localFile.ReadAt(op.Dst, op.Offset)
|
|
|
+ if err == io.EOF { // fuse does not expect a EOF
|
|
|
+ err = nil
|
|
|
+ }
|
|
|
+
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// CreateFile creates empty file in google Drive and returns its ID and attributes, only allows file creation on 'My Drive'
|
|
|
+func (fs *GDriveFS) CreateFile(ctx context.Context, op *fuseops.CreateFileOp) (err error) {
|
|
|
+
|
|
|
+ parentFile := fs.root.FindByInode(op.Parent, true)
|
|
|
+ if parentFile == nil {
|
|
|
+ return fuse.ENOENT
|
|
|
+ }
|
|
|
+ // Only write on child folders
|
|
|
+ if parentFile.Inode == fuseops.RootInodeID {
|
|
|
+ return syscall.EPERM
|
|
|
+ }
|
|
|
+
|
|
|
+ existsFile := parentFile.FindByName(op.Name, false)
|
|
|
+ if existsFile != nil {
|
|
|
+ return fuse.EEXIST
|
|
|
+ }
|
|
|
+
|
|
|
+ // Generate ID
|
|
|
+ //genId, err := fs.client.Files.GenerateIds().Count(1).Do()
|
|
|
+ //id := genId.Ids[0]
|
|
|
+ parents := []string{parentFile.GFile.Id}
|
|
|
+ newFile := &drive.File{
|
|
|
+ Parents: parents,
|
|
|
+ Name: op.Name,
|
|
|
+ }
|
|
|
+ createdFile, err := fs.client.Files.Create(newFile).Do()
|
|
|
+ if err != nil {
|
|
|
+ err = fuse.EINVAL
|
|
|
+ return
|
|
|
+ }
|
|
|
+
|
|
|
+ entry := parentFile.AppendGFile(createdFile, fs.root.FindUnusedInode()) // Add new created file
|
|
|
+ if entry == nil {
|
|
|
+ err = fuse.EINVAL
|
|
|
+ return
|
|
|
+ }
|
|
|
+
|
|
|
+ localFile := entry.Cache()
|
|
|
+ if localFile == nil {
|
|
|
+ return fuse.EINVAL
|
|
|
+ }
|
|
|
+ // Associate a temp file to a new handle
|
|
|
+ // Local copy
|
|
|
+ // Lock
|
|
|
+ fh := fs.createHandle()
|
|
|
+ fh.entry = entry
|
|
|
+ fh.uploadOnDone = true
|
|
|
+ //
|
|
|
+ op.Handle = fh.handleID
|
|
|
+ op.Entry = fuseops.ChildInodeEntry{
|
|
|
+ Attributes: entry.Attr,
|
|
|
+ Child: entry.Inode,
|
|
|
+ AttributesExpiration: time.Now().Add(time.Minute),
|
|
|
+ EntryExpiration: time.Now().Add(time.Minute),
|
|
|
+ }
|
|
|
+ op.Mode = entry.Attr.Mode
|
|
|
+
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// WriteFile as ReadFile it creates a temporary file on first read
|
|
|
+// Maybe the ReadFile should be called here aswell to cache current contents since we are using writeAt
|
|
|
+func (fs *GDriveFS) WriteFile(ctx context.Context, op *fuseops.WriteFileOp) (err error) {
|
|
|
+ lf, ok := fs.fileHandles[op.Handle]
|
|
|
+ if !ok {
|
|
|
+ return fuse.EIO
|
|
|
+ }
|
|
|
+
|
|
|
+ localFile := lf.entry.Cache()
|
|
|
+ if localFile == nil {
|
|
|
+ return fuse.EINVAL
|
|
|
+ }
|
|
|
+
|
|
|
+ _, err = localFile.WriteAt(op.Data, op.Offset)
|
|
|
+ if err != nil {
|
|
|
+ err = fuse.EIO
|
|
|
+ return
|
|
|
+ }
|
|
|
+ lf.uploadOnDone = true
|
|
|
+
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// FlushFile just returns no error, maybe upload should be handled here
|
|
|
+func (fs *GDriveFS) FlushFile(ctx context.Context, op *fuseops.FlushFileOp) (err error) {
|
|
|
+ lf, ok := fs.fileHandles[op.Handle]
|
|
|
+ if !ok {
|
|
|
+ return fuse.EIO
|
|
|
+ }
|
|
|
+ if lf.entry.tempFile == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ if lf.uploadOnDone { // or if content changed basically
|
|
|
+ err = lf.entry.Sync()
|
|
|
+ if err != nil {
|
|
|
+ return fuse.EINVAL
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// ReleaseFileHandle closes and deletes any temporary files, upload in case if changed locally
|
|
|
+func (fs *GDriveFS) ReleaseFileHandle(ctx context.Context, op *fuseops.ReleaseFileHandleOp) (err error) {
|
|
|
+ lf := fs.fileHandles[op.Handle]
|
|
|
+
|
|
|
+ /*if lf.uploadOnDone {
|
|
|
+ err = lf.entry.Sync()
|
|
|
+ if err != nil {
|
|
|
+ return fuse.EINVAL
|
|
|
+ }
|
|
|
+ }*/
|
|
|
+ lf.entry.ClearCache()
|
|
|
+ delete(fs.fileHandles, op.Handle)
|
|
|
+
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// Unlink remove file and remove from local cache entry
|
|
|
+func (fs *GDriveFS) Unlink(ctx context.Context, op *fuseops.UnlinkOp) (err error) {
|
|
|
+ parentEntry := fs.root.FindByInode(op.Parent, true)
|
|
|
+ if parentEntry == nil {
|
|
|
+ return fuse.ENOENT
|
|
|
+ }
|
|
|
+ if parentEntry.Inode == fuseops.RootInodeID {
|
|
|
+ return syscall.EPERM
|
|
|
+ }
|
|
|
+
|
|
|
+ fileEntry := parentEntry.FindByName(op.Name, false)
|
|
|
+ if fileEntry == nil {
|
|
|
+ return fuse.ENOATTR
|
|
|
+ }
|
|
|
+ err = fs.client.Files.Delete(fileEntry.GFile.Id).Do()
|
|
|
+ if err != nil {
|
|
|
+ return fuse.EIO
|
|
|
+ }
|
|
|
+
|
|
|
+ parentEntry.RemoveChild(fileEntry)
|
|
|
+
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// MkDir creates a directory on a parent dir
|
|
|
+func (fs *GDriveFS) MkDir(ctx context.Context, op *fuseops.MkDirOp) (err error) {
|
|
|
+
|
|
|
+ parentFile := fs.root.FindByInode(op.Parent, true)
|
|
|
+ if parentFile == nil {
|
|
|
+ return fuse.ENOENT
|
|
|
+ }
|
|
|
+ if parentFile.Inode == fuseops.RootInodeID {
|
|
|
+ return syscall.EPERM
|
|
|
+ }
|
|
|
+
|
|
|
+ // Should check existent first too
|
|
|
+ fi, err := fs.client.Files.Create(&drive.File{
|
|
|
+ Parents: []string{parentFile.GFile.Id},
|
|
|
+ MimeType: "application/vnd.google-apps.folder",
|
|
|
+ Name: op.Name,
|
|
|
+ }).Do()
|
|
|
+ if err != nil {
|
|
|
+ return fuse.ENOATTR
|
|
|
+ }
|
|
|
+ entry := parentFile.AppendGFile(fi, fs.root.FindUnusedInode())
|
|
|
+ if entry == nil {
|
|
|
+ return fuse.EINVAL
|
|
|
+ }
|
|
|
+
|
|
|
+ op.Entry = fuseops.ChildInodeEntry{
|
|
|
+ Attributes: entry.Attr,
|
|
|
+ Child: entry.Inode,
|
|
|
+ AttributesExpiration: time.Now().Add(time.Minute),
|
|
|
+ EntryExpiration: time.Now().Add(time.Microsecond),
|
|
|
+ }
|
|
|
+
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// RmDir fuse implementation
|
|
|
+func (fs *GDriveFS) RmDir(ctx context.Context, op *fuseops.RmDirOp) (err error) {
|
|
|
+
|
|
|
+ parentFile := fs.root.FindByInode(op.Parent, true)
|
|
|
+ if parentFile == nil {
|
|
|
+ return fuse.ENOENT
|
|
|
+ }
|
|
|
+ if parentFile.Inode == fuseops.RootInodeID {
|
|
|
+ return syscall.EPERM
|
|
|
+ }
|
|
|
+
|
|
|
+ theFile := parentFile.FindByName(op.Name, false)
|
|
|
+
|
|
|
+ err = fs.client.Files.Delete(theFile.GFile.Id).Do()
|
|
|
+ if err != nil {
|
|
|
+ return fuse.ENOTEMPTY
|
|
|
+ }
|
|
|
+
|
|
|
+ parentFile.RemoveChild(theFile)
|
|
|
+
|
|
|
+ // Remove from entry somehow
|
|
|
+
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// Rename fuse implementation
|
|
|
+func (fs *GDriveFS) Rename(ctx context.Context, op *fuseops.RenameOp) (err error) {
|
|
|
+ oldParentFile := fs.root.FindByInode(op.OldParent, true)
|
|
|
+ if oldParentFile == nil {
|
|
|
+ return fuse.ENOENT
|
|
|
+ }
|
|
|
+ newParentFile := fs.root.FindByInode(op.NewParent, true)
|
|
|
+ if newParentFile == nil {
|
|
|
+ return fuse.ENOENT
|
|
|
+ }
|
|
|
+
|
|
|
+ if oldParentFile.Inode == fuseops.RootInodeID || newParentFile.Inode == fuseops.RootInodeID {
|
|
|
+ return syscall.EPERM
|
|
|
+ }
|
|
|
+
|
|
|
+ oldFile := oldParentFile.FindByName(op.OldName, false)
|
|
|
+
|
|
|
+ // 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 {
|
|
|
+ return fuse.EEXIST
|
|
|
+ }
|
|
|
+
|
|
|
+ ngFile := &drive.File{
|
|
|
+ Name: op.NewName,
|
|
|
+ }
|
|
|
+
|
|
|
+ updateCall := fs.client.Files.Update(oldFile.GFile.Id, ngFile)
|
|
|
+ if oldParentFile != newParentFile {
|
|
|
+ updateCall.RemoveParents(oldParentFile.GFile.Id)
|
|
|
+ updateCall.AddParents(newParentFile.GFile.Id)
|
|
|
+ }
|
|
|
+ updatedFile, err := updateCall.Do()
|
|
|
+
|
|
|
+ oldParentFile.RemoveChild(oldFile)
|
|
|
+ newParentFile.AppendGFile(updatedFile, oldFile.Inode)
|
|
|
+
|
|
|
+ return
|
|
|
|
|
|
}
|
