2017-05-03 12:51:03 +00:00
|
|
|
// Package ftp interfaces with FTP servers
|
2016-12-27 20:52:30 +00:00
|
|
|
package ftp
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"io"
|
|
|
|
"path/filepath"
|
|
|
|
"regexp"
|
|
|
|
"strconv"
|
|
|
|
"strings"
|
2017-05-03 12:18:17 +00:00
|
|
|
"sync"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/jlaffaye/ftp"
|
|
|
|
"github.com/ncw/rclone/fs"
|
2017-05-03 12:51:03 +00:00
|
|
|
"github.com/pkg/errors"
|
2016-12-27 20:52:30 +00:00
|
|
|
)
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// This mutex is only used by ftpConnection. We create a new ftp
|
|
|
|
// connection for each transfer, but we need to serialize it otherwise
|
|
|
|
// Dial() and Login() might be mixed...
|
|
|
|
var globalMux = sync.Mutex{}
|
|
|
|
|
2016-12-27 20:52:30 +00:00
|
|
|
// Register with Fs
|
|
|
|
func init() {
|
|
|
|
fs.Register(&fs.RegInfo{
|
2017-05-03 12:18:17 +00:00
|
|
|
Name: "Ftp",
|
2016-12-27 20:52:30 +00:00
|
|
|
Description: "FTP interface",
|
2017-05-03 12:18:17 +00:00
|
|
|
NewFs: NewFs,
|
2016-12-27 20:52:30 +00:00
|
|
|
Options: []fs.Option{
|
|
|
|
{
|
|
|
|
Name: "username",
|
|
|
|
Help: "Username",
|
|
|
|
}, {
|
|
|
|
Name: "password",
|
|
|
|
Help: "Password",
|
|
|
|
}, {
|
|
|
|
Name: "url",
|
|
|
|
Help: "FTP url",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// Fs represents a remote FTP server
|
2016-12-27 20:52:30 +00:00
|
|
|
type Fs struct {
|
2017-05-03 12:18:17 +00:00
|
|
|
name string // name of this remote
|
|
|
|
root string // the path we are working on if any
|
|
|
|
features *fs.Features // optional features
|
|
|
|
c *ftp.ServerConn // the connection to the FTP server
|
2017-05-03 12:51:03 +00:00
|
|
|
url URL
|
2017-05-03 12:18:17 +00:00
|
|
|
mu sync.Mutex
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// Object describes an FTP file
|
2016-12-27 20:52:30 +00:00
|
|
|
type Object struct {
|
2017-05-03 12:18:17 +00:00
|
|
|
fs *Fs
|
|
|
|
remote string
|
|
|
|
info *FileInfo
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// FileInfo is the metadata known about an FTP file
|
2016-12-27 20:52:30 +00:00
|
|
|
type FileInfo struct {
|
|
|
|
Name string
|
|
|
|
Size uint64
|
|
|
|
ModTime time.Time
|
|
|
|
IsDir bool
|
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// URL represents an FTP URL
|
|
|
|
type URL struct {
|
|
|
|
Scheme string
|
|
|
|
Host string
|
|
|
|
Port int
|
|
|
|
Path string
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// ToDial converts the URL to Dial format
|
|
|
|
func (u *URL) ToDial() string {
|
2016-12-27 20:52:30 +00:00
|
|
|
return fmt.Sprintf("%s:%d", u.Host, u.Port)
|
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
func (u *URL) String() string {
|
2016-12-27 20:52:30 +00:00
|
|
|
return fmt.Sprintf("ftp://%s:%d/%s", u.Host, u.Port, u.Path)
|
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// ------------------------------------------------------------
|
2016-12-27 20:52:30 +00:00
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// Name of this fs
|
2016-12-27 20:52:30 +00:00
|
|
|
func (f *Fs) Name() string {
|
2017-05-03 12:18:17 +00:00
|
|
|
return f.name
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Root of the remote (as passed into NewFs)
|
|
|
|
func (f *Fs) Root() string {
|
|
|
|
return f.root
|
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// String returns a description of the FS
|
2016-12-27 20:52:30 +00:00
|
|
|
func (f *Fs) String() string {
|
|
|
|
return fmt.Sprintf("FTP Connection to %s", f.url.String())
|
|
|
|
}
|
|
|
|
|
2017-05-03 12:18:17 +00:00
|
|
|
// Features returns the optional features of this Fs
|
|
|
|
func (f *Fs) Features() *fs.Features {
|
|
|
|
return f.features
|
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// Parse a URL
|
|
|
|
func parseURL(url string) URL {
|
|
|
|
// This is *similar* to the RFC 3986 regexp but it matches the
|
|
|
|
// port independently from the host
|
|
|
|
r, _ := regexp.Compile("^(([^:/?#]+):)?(//([^/?#:]*))?(:([0-9]+))?([^?#]*)(\\?([^#]*))?(#(.*))?")
|
2016-12-27 20:52:30 +00:00
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
data := r.FindAllStringSubmatch(url, -1)
|
2016-12-27 20:52:30 +00:00
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
if data[0][5] == "" {
|
|
|
|
data[0][5] = "21"
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
2017-05-03 12:51:03 +00:00
|
|
|
port, _ := strconv.Atoi(data[0][5])
|
|
|
|
return URL{data[0][2], data[0][4], port, data[0][7]}
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// Open a new connection to the FTP server.
|
|
|
|
func ftpConnection(name, root string) (*ftp.ServerConn, URL, error) {
|
|
|
|
url := fs.ConfigFileGet(name, "url")
|
|
|
|
user := fs.ConfigFileGet(name, "username")
|
|
|
|
pass := fs.ConfigFileGet(name, "password")
|
|
|
|
u := parseURL(url)
|
|
|
|
u.Path = filepath.Join(u.Path, root)
|
|
|
|
fs.Debugf(nil, "New ftp Connection with name %s and url %s (path %s)", name, u.String(), u.Path)
|
|
|
|
globalMux.Lock()
|
|
|
|
defer globalMux.Unlock()
|
|
|
|
c, err := ftp.DialTimeout(u.ToDial(), 30*time.Second)
|
|
|
|
if err != nil {
|
|
|
|
fs.Errorf(nil, "Error while Dialing %s: %s", u.ToDial(), err)
|
|
|
|
return nil, u, err
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
2017-05-03 12:51:03 +00:00
|
|
|
err = c.Login(user, pass)
|
|
|
|
if err != nil {
|
|
|
|
fs.Errorf(nil, "Error while Logging in into %s: %s", u.ToDial(), err)
|
|
|
|
return nil, u, err
|
|
|
|
}
|
|
|
|
return c, u, nil
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// NewFs contstructs an Fs from the path, container:path
|
|
|
|
func NewFs(name, root string) (fs.Fs, error) {
|
|
|
|
fs.Debugf(nil, "ENTER function 'NewFs' with name %s and root %s", name, root)
|
|
|
|
defer fs.Debugf(nil, "EXIT function 'NewFs'")
|
|
|
|
c, u, err := ftpConnection(name, root)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
2017-05-03 12:51:03 +00:00
|
|
|
f := &Fs{
|
|
|
|
name: name,
|
|
|
|
root: u.Path,
|
|
|
|
c: c,
|
|
|
|
url: u,
|
|
|
|
mu: sync.Mutex{},
|
|
|
|
}
|
|
|
|
f.features = (&fs.Features{}).Fill(f)
|
|
|
|
return f, err
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// NewObject finds the Object at remote. If it can't be found
|
|
|
|
// it returns the error fs.ErrorObjectNotFound.
|
2016-12-27 20:52:30 +00:00
|
|
|
func (f *Fs) NewObject(remote string) (fs.Object, error) {
|
2017-05-03 12:18:17 +00:00
|
|
|
fs.Debugf(f, "ENTER function 'NewObject' called with remote %s", remote)
|
|
|
|
defer fs.Debugf(f, "EXIT function 'NewObject'")
|
2016-12-27 20:52:30 +00:00
|
|
|
dir := filepath.Dir(remote)
|
|
|
|
base := filepath.Base(remote)
|
|
|
|
|
|
|
|
f.mu.Lock()
|
|
|
|
files, _ := f.c.List(dir)
|
|
|
|
f.mu.Unlock()
|
2017-05-03 12:18:17 +00:00
|
|
|
for i := range files {
|
2016-12-27 20:52:30 +00:00
|
|
|
if files[i].Name == base {
|
|
|
|
o := &Object{
|
|
|
|
fs: f,
|
|
|
|
remote: remote,
|
|
|
|
}
|
|
|
|
info := &FileInfo{
|
2017-05-03 12:18:17 +00:00
|
|
|
Name: remote,
|
|
|
|
Size: files[i].Size,
|
2016-12-27 20:52:30 +00:00
|
|
|
ModTime: files[i].Time,
|
|
|
|
}
|
|
|
|
o.info = info
|
2017-05-03 12:18:17 +00:00
|
|
|
|
2016-12-27 20:52:30 +00:00
|
|
|
return o, nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil, fs.ErrorObjectNotFound
|
|
|
|
}
|
|
|
|
|
2017-05-03 12:18:17 +00:00
|
|
|
func (f *Fs) list(out fs.ListOpts, dir string, curlevel int) {
|
|
|
|
fs.Debugf(f, "ENTER function 'list'")
|
|
|
|
defer fs.Debugf(f, "EXIT function 'list'")
|
2016-12-27 20:52:30 +00:00
|
|
|
f.mu.Lock()
|
|
|
|
files, _ := f.c.List(filepath.Join(f.root, dir))
|
|
|
|
f.mu.Unlock()
|
2017-05-03 12:18:17 +00:00
|
|
|
for i := range files {
|
2016-12-27 20:52:30 +00:00
|
|
|
object := files[i]
|
|
|
|
newremote := filepath.Join(dir, object.Name)
|
|
|
|
switch object.Type {
|
|
|
|
case ftp.EntryTypeFolder:
|
2017-05-03 12:18:17 +00:00
|
|
|
if out.IncludeDirectory(newremote) {
|
2016-12-27 20:52:30 +00:00
|
|
|
d := &fs.Dir{
|
|
|
|
Name: newremote,
|
|
|
|
When: object.Time,
|
|
|
|
Bytes: 0,
|
|
|
|
Count: -1,
|
|
|
|
}
|
2017-05-03 12:18:17 +00:00
|
|
|
if curlevel < out.Level() {
|
|
|
|
f.list(out, filepath.Join(dir, object.Name), curlevel+1)
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
|
|
|
if out.AddDir(d) {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
o := &Object{
|
|
|
|
fs: f,
|
|
|
|
remote: newremote,
|
|
|
|
}
|
|
|
|
info := &FileInfo{
|
2017-05-03 12:18:17 +00:00
|
|
|
Name: newremote,
|
|
|
|
Size: object.Size,
|
2016-12-27 20:52:30 +00:00
|
|
|
ModTime: object.Time,
|
|
|
|
}
|
|
|
|
o.info = info
|
|
|
|
if out.Add(o) {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// List the objects and directories of the Fs starting from dir
|
|
|
|
//
|
|
|
|
// dir should be "" to start from the root, and should not
|
|
|
|
// have trailing slashes.
|
|
|
|
//
|
|
|
|
// This should return ErrDirNotFound (using out.SetError())
|
|
|
|
// if the directory isn't found.
|
|
|
|
//
|
|
|
|
// Fses must support recursion levels of fs.MaxLevel and 1.
|
|
|
|
// They may return ErrorLevelNotSupported otherwise.
|
2016-12-27 20:52:30 +00:00
|
|
|
func (f *Fs) List(out fs.ListOpts, dir string) {
|
2017-05-03 12:18:17 +00:00
|
|
|
fs.Debugf(f, "ENTER function 'List' on directory '%s/%s'", f.root, dir)
|
|
|
|
defer fs.Debugf(f, "EXIT function 'List' for directory '%s/%s'", f.root, dir)
|
2016-12-27 20:52:30 +00:00
|
|
|
f.list(out, dir, 1)
|
|
|
|
out.Finished()
|
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// Hashes are not supported
|
|
|
|
func (f *Fs) Hashes() fs.HashSet {
|
|
|
|
return 0
|
|
|
|
}
|
2016-12-27 20:52:30 +00:00
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// Precision shows Modified Time not supported
|
|
|
|
func (f *Fs) Precision() time.Duration {
|
|
|
|
return fs.ModTimeNotSupported
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// Put in to the remote path with the modTime given of the given size
|
|
|
|
//
|
|
|
|
// May create the object even if it returns an error - if so
|
|
|
|
// will return the object and the error, otherwise will return
|
|
|
|
// nil and the error
|
|
|
|
func (f *Fs) Put(in io.Reader, src fs.ObjectInfo) (fs.Object, error) {
|
|
|
|
fs.Debugf(f, "Trying to put file %s", src.Remote())
|
|
|
|
o := &Object{
|
|
|
|
fs: f,
|
|
|
|
remote: src.Remote(),
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
2017-05-03 12:51:03 +00:00
|
|
|
err := o.Update(in, src)
|
|
|
|
return o, err
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// getInfo reads the FileInfo for a path
|
|
|
|
func (f *Fs) getInfo(remote string) (*FileInfo, error) {
|
|
|
|
fs.Debugf(f, "ENTER function 'getInfo' on file %s", remote)
|
|
|
|
defer fs.Debugf(f, "EXIT function 'getInfo'")
|
|
|
|
dir := filepath.Dir(remote)
|
|
|
|
base := filepath.Base(remote)
|
|
|
|
|
|
|
|
f.mu.Lock()
|
|
|
|
files, _ := f.c.List(dir)
|
|
|
|
f.mu.Unlock()
|
|
|
|
for i := range files {
|
|
|
|
if files[i].Name == base {
|
|
|
|
info := &FileInfo{
|
|
|
|
Name: remote,
|
|
|
|
Size: files[i].Size,
|
|
|
|
ModTime: files[i].Time,
|
|
|
|
IsDir: files[i].Type == ftp.EntryTypeFolder,
|
|
|
|
}
|
|
|
|
return info, nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil, fs.ErrorObjectNotFound
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
func (f *Fs) mkdir(abspath string) error {
|
|
|
|
_, err := f.getInfo(abspath)
|
|
|
|
if err != nil {
|
|
|
|
fs.Debugf(f, "Trying to create directory %s", abspath)
|
|
|
|
f.mu.Lock()
|
|
|
|
err := f.c.MakeDir(abspath)
|
|
|
|
f.mu.Unlock()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// Mkdir creates the container if it doesn't exist
|
|
|
|
func (f *Fs) Mkdir(dir string) error {
|
|
|
|
// This actually works as mkdir -p
|
|
|
|
fs.Debugf(f, "ENTER function 'Mkdir' on '%s/%s'", f.root, dir)
|
|
|
|
defer fs.Debugf(f, "EXIT function 'Mkdir' on '%s/%s'", f.root, dir)
|
|
|
|
abspath := filepath.Join(f.root, dir)
|
|
|
|
tokens := strings.Split(abspath, "/")
|
|
|
|
curdir := ""
|
|
|
|
for i := range tokens {
|
|
|
|
curdir += "/" + tokens[i]
|
|
|
|
err := f.mkdir(curdir)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
2016-12-27 20:52:30 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// Rmdir removes the directory (container, bucket) if empty
|
|
|
|
//
|
|
|
|
// Return an error if it doesn't exist or isn't empty
|
|
|
|
func (f *Fs) Rmdir(dir string) error {
|
|
|
|
// This is actually a recursive remove directory
|
|
|
|
f.mu.Lock()
|
|
|
|
files, err := f.c.List(filepath.Join(f.root, dir))
|
|
|
|
f.mu.Unlock()
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "rmdir")
|
|
|
|
}
|
|
|
|
for i := range files {
|
|
|
|
if files[i].Type == ftp.EntryTypeFolder {
|
|
|
|
err = f.Rmdir(filepath.Join(dir, files[i].Name))
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "rmdir")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
f.mu.Lock()
|
|
|
|
err = f.c.RemoveDir(filepath.Join(f.root, dir))
|
|
|
|
f.mu.Unlock()
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// ------------------------------------------------------------
|
|
|
|
|
|
|
|
// Fs returns the parent Fs
|
2016-12-27 20:52:30 +00:00
|
|
|
func (o *Object) Fs() fs.Info {
|
|
|
|
return o.fs
|
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// String version of o
|
|
|
|
func (o *Object) String() string {
|
|
|
|
if o == nil {
|
|
|
|
return "<nil>"
|
|
|
|
}
|
|
|
|
return o.remote
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// Remote returns the remote path
|
|
|
|
func (o *Object) Remote() string {
|
|
|
|
return o.remote
|
|
|
|
}
|
|
|
|
|
|
|
|
// Hash returns the hash of an object returning a lowercase hex string
|
|
|
|
func (o *Object) Hash(t fs.HashType) (string, error) {
|
|
|
|
return "", fs.ErrHashUnsupported
|
|
|
|
}
|
|
|
|
|
|
|
|
// Size returns the size of an object in bytes
|
2016-12-27 20:52:30 +00:00
|
|
|
func (o *Object) Size() int64 {
|
|
|
|
return int64(o.info.Size)
|
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// ModTime returns the modification time of the object
|
|
|
|
func (o *Object) ModTime() time.Time {
|
|
|
|
return o.info.ModTime
|
|
|
|
}
|
|
|
|
|
|
|
|
// SetModTime sets the modification time of the object
|
|
|
|
func (o *Object) SetModTime(modTime time.Time) error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Storable returns a boolean as to whether this object is storable
|
2016-12-27 20:52:30 +00:00
|
|
|
func (o *Object) Storable() bool {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// ftpReadCloser implements io.ReadCloser for FTP objects.
|
|
|
|
type ftpReadCloser struct {
|
|
|
|
io.ReadCloser
|
|
|
|
c *ftp.ServerConn
|
|
|
|
}
|
|
|
|
|
|
|
|
// Close the FTP reader
|
|
|
|
func (f *ftpReadCloser) Close() error {
|
|
|
|
err := f.ReadCloser.Close()
|
|
|
|
err2 := f.c.Quit()
|
|
|
|
if err == nil {
|
|
|
|
err = err2
|
|
|
|
}
|
|
|
|
return err
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// Open an object for read
|
|
|
|
func (o *Object) Open(options ...fs.OpenOption) (io.ReadCloser, error) {
|
|
|
|
path := filepath.Join(o.fs.root, o.remote)
|
|
|
|
fs.Debugf(o.fs, "ENTER function 'Open' on file '%s' in root '%s'", o.remote, o.fs.root)
|
|
|
|
defer fs.Debugf(o.fs, "EXIT function 'Open' %s", path)
|
|
|
|
c, _, err := ftpConnection(o.fs.name, o.fs.root)
|
|
|
|
if err != nil {
|
|
|
|
return nil, errors.Wrap(err, "open")
|
|
|
|
}
|
|
|
|
fd, err := c.Retr(path)
|
|
|
|
if err != nil {
|
|
|
|
return nil, errors.Wrap(err, "open")
|
|
|
|
}
|
|
|
|
return &ftpReadCloser{ReadCloser: fd, c: c}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// makeAllDir creates the parent directories for the object
|
|
|
|
func (o *Object) makeAllDir() error {
|
2016-12-27 20:52:30 +00:00
|
|
|
tokens := strings.Split(filepath.Dir(o.remote), "/")
|
|
|
|
dir := ""
|
2017-05-03 12:18:17 +00:00
|
|
|
for i := range tokens {
|
|
|
|
dir += tokens[i] + "/"
|
2017-05-03 12:51:03 +00:00
|
|
|
err := o.fs.Mkdir(dir)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
2017-05-03 12:51:03 +00:00
|
|
|
return nil
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
2017-05-03 12:51:03 +00:00
|
|
|
|
|
|
|
// Update the already existing object
|
|
|
|
//
|
|
|
|
// Copy the reader into the object updating modTime and size
|
|
|
|
//
|
|
|
|
// The new object may have been created if an error is returned
|
2016-12-27 20:52:30 +00:00
|
|
|
func (o *Object) Update(in io.Reader, src fs.ObjectInfo) error {
|
|
|
|
// Create all upper directory first...
|
2017-05-03 12:51:03 +00:00
|
|
|
err := o.makeAllDir()
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "update")
|
|
|
|
}
|
2016-12-27 20:52:30 +00:00
|
|
|
path := filepath.Join(o.fs.root, o.remote)
|
2017-05-03 12:51:03 +00:00
|
|
|
c, _, err := ftpConnection(o.fs.name, o.fs.root)
|
2016-12-27 20:52:30 +00:00
|
|
|
if err != nil {
|
2017-05-03 12:51:03 +00:00
|
|
|
return errors.Wrap(err, "update")
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
2017-05-03 12:51:03 +00:00
|
|
|
err = c.Stor(path, in)
|
2016-12-27 20:52:30 +00:00
|
|
|
if err != nil {
|
2017-05-03 12:51:03 +00:00
|
|
|
return errors.Wrap(err, "update")
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
2017-05-03 12:51:03 +00:00
|
|
|
o.info, err = o.fs.getInfo(path)
|
2016-12-27 20:52:30 +00:00
|
|
|
if err != nil {
|
2017-05-03 12:51:03 +00:00
|
|
|
return errors.Wrap(err, "update")
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
2017-05-03 12:51:03 +00:00
|
|
|
return nil
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
|
|
|
|
2017-05-03 12:51:03 +00:00
|
|
|
// Remove an object
|
|
|
|
func (o *Object) Remove() error {
|
|
|
|
path := filepath.Join(o.fs.root, o.remote)
|
|
|
|
fs.Debugf(o, "ENTER function 'Remove' for obejct at %s", path)
|
|
|
|
defer fs.Debugf(o, "EXIT function 'Remove' for obejct at %s", path)
|
|
|
|
// Check if it's a directory or a file
|
|
|
|
info, _ := o.fs.getInfo(path)
|
|
|
|
var err error
|
|
|
|
if info.IsDir {
|
|
|
|
err = o.fs.Rmdir(o.remote)
|
|
|
|
} else {
|
|
|
|
o.fs.mu.Lock()
|
|
|
|
err = o.fs.c.Delete(path)
|
|
|
|
o.fs.mu.Unlock()
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
2017-05-03 12:51:03 +00:00
|
|
|
return err
|
2016-12-27 20:52:30 +00:00
|
|
|
}
|
|
|
|
|
2017-05-03 12:18:17 +00:00
|
|
|
// Check the interfaces are satisfied
|
2016-12-27 20:52:30 +00:00
|
|
|
var (
|
2017-05-03 12:18:17 +00:00
|
|
|
_ fs.Fs = &Fs{}
|
|
|
|
_ fs.Object = &Object{}
|
2016-12-27 20:52:30 +00:00
|
|
|
)
|