mirror of
https://github.com/rclone/rclone.git
synced 2024-11-26 18:34:41 +01:00
110 lines
2.3 KiB
Go
110 lines
2.3 KiB
Go
package ftp
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path"
|
|
"strings"
|
|
)
|
|
|
|
//Walker traverses the directory tree of a remote FTP server
|
|
type Walker struct {
|
|
serverConn *ServerConn
|
|
root string
|
|
cur *item
|
|
stack []*item
|
|
descend bool
|
|
}
|
|
|
|
type item struct {
|
|
path string
|
|
entry *Entry
|
|
err error
|
|
}
|
|
|
|
// Next advances the Walker to the next file or directory,
|
|
// which will then be available through the Path, Stat, and Err methods.
|
|
// It returns false when the walk stops at the end of the tree.
|
|
func (w *Walker) Next() bool {
|
|
var isRoot bool
|
|
if w.cur == nil {
|
|
w.cur = &item{
|
|
path: strings.Trim(w.root, string(os.PathSeparator)),
|
|
}
|
|
|
|
isRoot = true
|
|
}
|
|
|
|
entries, err := w.serverConn.List(w.cur.path)
|
|
w.cur.err = err
|
|
if err == nil {
|
|
if len(entries) == 0 {
|
|
w.cur.err = fmt.Errorf("no such file or directory: %s", w.cur.path)
|
|
|
|
return false
|
|
}
|
|
|
|
if isRoot && len(entries) == 1 && entries[0].Type == EntryTypeFile {
|
|
w.cur.err = fmt.Errorf("root is not a directory: %s", w.cur.path)
|
|
|
|
return false
|
|
}
|
|
|
|
for i, entry := range entries {
|
|
if entry.Name == "." || (i == 0 && entry.Type == EntryTypeFile) {
|
|
entry.Name = path.Base(w.cur.path)
|
|
w.cur.entry = entry
|
|
continue
|
|
}
|
|
|
|
if entry.Name == ".." || !w.descend {
|
|
continue
|
|
}
|
|
|
|
item := &item{
|
|
path: path.Join(w.cur.path, entry.Name),
|
|
entry: entry,
|
|
}
|
|
|
|
w.stack = append(w.stack, item)
|
|
}
|
|
}
|
|
|
|
if len(w.stack) == 0 {
|
|
return false
|
|
}
|
|
|
|
i := len(w.stack) - 1
|
|
w.cur = w.stack[i]
|
|
w.stack = w.stack[:i]
|
|
w.descend = true
|
|
|
|
return true
|
|
}
|
|
|
|
//SkipDir tells the Next function to skip the currently processed directory
|
|
func (w *Walker) SkipDir() {
|
|
w.descend = false
|
|
}
|
|
|
|
//Err returns the error, if any, for the most recent attempt by Next to
|
|
//visit a file or a directory. If a directory has an error, the walker
|
|
//will not descend in that directory
|
|
func (w *Walker) Err() error {
|
|
return w.cur.err
|
|
}
|
|
|
|
// Stat returns info for the most recent file or directory
|
|
// visited by a call to Step.
|
|
func (w *Walker) Stat() *Entry {
|
|
return w.cur.entry
|
|
}
|
|
|
|
// Path returns the path to the most recent file or directory
|
|
// visited by a call to Next. It contains the argument to Walk
|
|
// as a prefix; that is, if Walk is called with "dir", which is
|
|
// a directory containing the file "a", Path will return "dir/a".
|
|
func (w *Walker) Path() string {
|
|
return w.cur.path
|
|
}
|