wip: local: implement the stat function

Signed-off-by: Anagh Kumar Baranwal <6824881+darthShadow@users.noreply.github.com>

Author: darthShadow

backend/local/local.go

@@ -1126,8 +1126,122 @@ func (f *Fs) Command(ctx context.Context, name string, arg []string, opt map[str
 // Stat returns the DirEntry for the given name
 //
 // It should return fs.ErrorNotImplemented if it can't return a DirEntry
-func (f *Fs) Stat(ctx context.Context, dir string, leaf string) (fs.DirEntry, error) {
-	return nil, fs.ErrorNotImplemented
+func (f *Fs) Stat(ctx context.Context, dir string, leaf string) (entry fs.DirEntry, err error) {
+	filter, useFilter := filter.GetConfig(ctx), filter.GetUseFilter(ctx)
+
+	fsDirPath := f.localPath(dir)
+	_, err = os.Stat(fsDirPath)
+	if err != nil {
+		return nil, fs.ErrorDirNotFound
+	}
+
+	fd, err := os.Open(fsDirPath)
+	if err != nil {
+		isPerm := os.IsPermission(err)
+		err = fmt.Errorf("failed to open directory %q: %w", dir, err)
+		fs.Errorf(dir, "%v", err)
+		if isPerm {
+			_ = accounting.Stats(ctx).Error(fserrors.NoRetryError(err))
+			err = nil // ignore error but fail sync
+		}
+		return nil, err
+	}
+	defer func() {
+		cerr := fd.Close()
+		if cerr != nil && err == nil {
+			err = fmt.Errorf("failed to close directory %q: %w", dir, cerr)
+		}
+	}()
+
+	names, err := fd.Readdirnames(-1)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read directory entry: %w", err)
+	}
+
+	foundLeaf := false
+	// Find the leaf in the directory
+	for _, name := range names {
+		if name == leaf {
+			foundLeaf = true
+			break
+		}
+	}
+	if !foundLeaf {
+		return nil, fs.ErrorObjectNotFound
+	}
+
+	leafPath := join.FilePathJoin(fsDirPath, leaf)
+	// Just a stat won't work without checking the entries from readdir first because of differences in unicode handling
+	fi, fierr := os.Lstat(leafPath)
+	if fierr != nil {
+		// Don't report errors on any file names that are excluded
+		if useFilter {
+			newRemote := f.cleanRemote(dir, leaf)
+			if !filter.IncludeRemote(newRemote) {
+				return nil, fs.ErrorObjectNotFound
+			}
+		}
+
+		_ = accounting.Stats(ctx).Error(fserrors.NoRetryError(fierr)) // fail the sync
+
+		return nil, fmt.Errorf("%q: failed to get info about directory entry %q: %w", dir, leafPath, fierr)
+	}
+
+	name := fi.Name()
+	mode := fi.Mode()
+	newRemote := f.cleanRemote(dir, name)
+
+	// Follow symlinks if required
+	if f.opt.FollowSymlinks && (mode&os.ModeSymlink) != 0 {
+		localPath := join.FilePathJoin(fsDirPath, name)
+		fi, fierr = os.Stat(localPath)
+		// Quietly skip errors on excluded files and directories
+		if fierr != nil && useFilter && !filter.IncludeRemote(newRemote) {
+			return nil, fs.ErrorObjectNotFound
+		}
+
+		if fierr != nil {
+			// Check for bad symlinks and circular symlinks
+			if os.IsNotExist(fierr) || isCircularSymlinkError(fierr) {
+				_ = accounting.Stats(ctx).Error(fserrors.NoRetryError(fierr)) // fail the sync
+			}
+			return nil, fmt.Errorf("%q: following symlink for %q: %w", dir, leafPath, fierr)
+		}
+
+		mode = fi.Mode()
+	}
+
+	if fi.IsDir() {
+		// Ignore directories which are symlinks.  These are junction points under windows which
+		// are kind of a souped up symlink. Unix doesn't have directories which are symlinks.
+		if (mode&os.ModeSymlink) == 0 && f.dev == readDevice(fi, f.opt.OneFileSystem) {
+			d := f.newDirectory(newRemote, fi)
+			return d, nil
+		}
+
+	} else {
+		// Check whether this link should be translated
+		if f.opt.TranslateSymlinks && fi.Mode()&os.ModeSymlink != 0 {
+			newRemote += fs.LinkSuffix
+		}
+
+		// Don't include non directory if not included
+		// we leave directory filtering to the layer above
+		if useFilter && !filter.IncludeRemote(newRemote) {
+			return nil, fs.ErrorObjectNotFound
+		}
+
+		fso, err := f.newObjectWithInfo(newRemote, fi)
+		if err != nil {
+			return nil, err
+		}
+
+		if fso.Storable() {
+			return fso, nil
+		}
+	}
+
+	return nil, fs.ErrorObjectNotFound
 }
 
 // ------------------------------------------------------------

backend/union/union.go

@@ -796,6 +796,41 @@ func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (
 	return callback(entries)
 }
 
+// Stat returns the DirEntry for the given name
+//
+// It should return fs.ErrorNotImplemented if it can't return a DirEntry
+func (f *Fs) Stat(ctx context.Context, dir string, leaf string) (fs.DirEntry, error) {
+	//entriesList := make([][]upstream.Entry, len(f.upstreams))
+	//errs := Errors(make([]error, len(f.upstreams)))
+	//multithread(len(f.upstreams), func(i int) {
+	//	u := f.upstreams[i]
+	//	entries, err := u.List(ctx, dir)
+	//	if err != nil {
+	//		errs[i] = fmt.Errorf("%s: %w", u.Name(), err)
+	//		return
+	//	}
+	//	uEntries := make([]upstream.Entry, len(entries))
+	//	for j, e := range entries {
+	//		uEntries[j], _ = u.WrapEntry(e)
+	//	}
+	//	entriesList[i] = uEntries
+	//})
+	//if len(errs) == len(errs.FilterNil()) {
+	//	errs = errs.Map(func(e error) error {
+	//		if errors.Is(e, fs.ErrorDirNotFound) {
+	//			return nil
+	//		}
+	//		return e
+	//	})
+	//	if len(errs) == 0 {
+	//		return nil, fs.ErrorDirNotFound
+	//	}
+	//	return nil, errs.Err()
+	//}
+	//return f.mergeDirEntries(entriesList)
+	return nil, fs.ErrorNotImplemented
+}
+
 // NewObject creates a new remote union file object
 func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) {
 	objs := make([]*upstream.Object, len(f.upstreams))
@@ -911,13 +946,6 @@ func (f *Fs) CleanUp(ctx context.Context) error {
 	return errs.Err()
 }
 
-// Stat returns the DirEntry for the given name
-//
-// It should return fs.ErrorNotImplemented if it can't return a DirEntry
-func (f *Fs) Stat(ctx context.Context, dir string, leaf string) (fs.DirEntry, error) {
-	return nil, fs.ErrorNotImplemented
-}
-
 // NewFs constructs an Fs from the path.
 //
 // The returned Fs is the actual Fs, referenced by remote in the config