TrueCloudLab/rclone
16
0
Fork 4
Code Issues 1 Pull requests Projects Releases 4 Packages Wiki Activity Actions

vendor: update all dependencies

Browse source
This commit is contained in:
Nick Craig-Wood 2019-02-09 12:50:35 +00:00
parent fb5ee22112
commit 43bc381e90
324 changed files with 37701 additions and 10005 deletions
Download patch file Download diff file Expand all files Collapse all files

1
vendor/github.com/pkg/sftp/client.go generated vendored
View file

@ -122,6 +122,7 @@ func NewClientPipe(rd io.Reader, wr io.WriteCloser, opts ...ClientOption) (*Clie
WriteCloser: wr,
},
inflight: make(map[uint32]chan<- result),
closed: make(chan struct{}),
},
maxPacket: 1 << 15,
maxConcurrentRequests: 64,

13
vendor/github.com/pkg/sftp/conn.go generated vendored
View file

@ -36,6 +36,17 @@ type clientConn struct {
wg sync.WaitGroup
sync.Mutex // protects inflight
inflight map[uint32]chan<- result // outstanding requests
closed chan struct{}
err error
}
// Wait blocks until the conn has shut down, and return the error
// causing the shutdown. It can be called concurrently from multiple
// goroutines.
func (c *clientConn) Wait() error {
<-c.closed
return c.err
}
// Close closes the SFTP session.
@ -122,6 +133,8 @@ func (c *clientConn) broadcastErr(err error) {
for _, ch := range listeners {
ch <- result{err: err}
}
c.err = err
close(c.closed)
}
type serverConn struct {

2
vendor/github.com/pkg/sftp/packet-manager.go generated vendored
View file

@ -176,8 +176,10 @@ func (s *packetManager) maybeSendPackets() {
s.sender.sendPacket(out.(encoding.BinaryMarshaler))
// pop off heads
copy(s.incoming, s.incoming[1:]) // shift left
s.incoming[len(s.incoming)-1] = nil // clear last
s.incoming = s.incoming[:len(s.incoming)-1] // remove last
copy(s.outgoing, s.outgoing[1:]) // shift left
s.outgoing[len(s.outgoing)-1] = nil // clear last
s.outgoing = s.outgoing[:len(s.outgoing)-1] // remove last
} else {
break

21
vendor/github.com/pkg/sftp/request-example.go generated vendored
View file

@ -12,6 +12,7 @@ import (
"path/filepath"
"sort"
"sync"
"syscall"
"time"
)
@ -29,6 +30,7 @@ func (fs *root) Fileread(r *Request) (io.ReaderAt, error) {
if fs.mockErr != nil {
return nil, fs.mockErr
}
_ = r.WithContext(r.Context()) // initialize context for deadlock testing
fs.filesLock.Lock()
defer fs.filesLock.Unlock()
file, err := fs.fetch(r.Filepath)
@ -48,6 +50,7 @@ func (fs *root) Filewrite(r *Request) (io.WriterAt, error) {
if fs.mockErr != nil {
return nil, fs.mockErr
}
_ = r.WithContext(r.Context()) // initialize context for deadlock testing
fs.filesLock.Lock()
defer fs.filesLock.Unlock()
file, err := fs.fetch(r.Filepath)
@ -69,6 +72,7 @@ func (fs *root) Filecmd(r *Request) error {
if fs.mockErr != nil {
return fs.mockErr
}
_ = r.WithContext(r.Context()) // initialize context for deadlock testing
fs.filesLock.Lock()
defer fs.filesLock.Unlock()
switch r.Method {
@ -129,11 +133,20 @@ func (fs *root) Filelist(r *Request) (ListerAt, error) {
if fs.mockErr != nil {
return nil, fs.mockErr
}
_ = r.WithContext(r.Context()) // initialize context for deadlock testing
fs.filesLock.Lock()
defer fs.filesLock.Unlock()
file, err := fs.fetch(r.Filepath)
if err != nil {
return nil, err
}
switch r.Method {
case "List":
if !file.IsDir() {
return nil, syscall.ENOTDIR
}
ordered_names := []string{}
for fn, _ := range fs.files {
if filepath.Dir(fn) == r.Filepath {
@ -147,16 +160,8 @@ func (fs *root) Filelist(r *Request) (ListerAt, error) {
}
return listerat(list), nil
case "Stat":
file, err := fs.fetch(r.Filepath)
if err != nil {
return nil, err
}
return listerat([]os.FileInfo{file}), nil
case "Readlink":
file, err := fs.fetch(r.Filepath)
if err != nil {
return nil, err
}
if file.symlink != "" {
file, err = fs.fetch(file.symlink)
if err != nil {

62
vendor/github.com/pkg/sftp/request-server.go generated vendored
View file

@ -3,7 +3,6 @@ package sftp
import (
"context"
"io"
"os"
"path"
"path/filepath"
"strconv"
@ -56,37 +55,24 @@ func (rs *RequestServer) nextRequest(r *Request) string {
defer rs.openRequestLock.Unlock()
rs.handleCount++
handle := strconv.Itoa(rs.handleCount)
r.handle = handle
rs.openRequests[handle] = r
return handle
}
// Returns Request from openRequests, bool is false if it is missing
// If the method is different, save/return a new Request w/ that Method.
// Returns Request from openRequests, bool is false if it is missing.
//
// The Requests in openRequests work essentially as open file descriptors that
// you can do different things with. What you are doing with it are denoted by
// the first packet of that type (read/write/etc). We create a new Request when
// it changes to set the request.Method attribute in a thread safe way.
func (rs *RequestServer) getRequest(handle, method string) (*Request, bool) {
// the first packet of that type (read/write/etc).
func (rs *RequestServer) getRequest(handle string) (*Request, bool) {
rs.openRequestLock.RLock()
defer rs.openRequestLock.RUnlock()
r, ok := rs.openRequests[handle]
rs.openRequestLock.RUnlock()
if !ok || r.Method == method {
return r, ok
}
// if we make it here we need to replace the request
rs.openRequestLock.Lock()
defer rs.openRequestLock.Unlock()
r, ok = rs.openRequests[handle]
if !ok || r.Method == method { // re-check needed b/c lock race
return r, ok
}
r = r.copy()
r.Method = method
rs.openRequests[handle] = r
return r, ok
}
// Close the Request and clear from openRequests map
func (rs *RequestServer) closeRequest(handle string) error {
rs.openRequestLock.Lock()
defer rs.openRequestLock.Unlock()
@ -173,28 +159,24 @@ func (rs *RequestServer) packetWorker(
rpkt = cleanPacketPath(pkt)
case *sshFxpOpendirPacket:
request := requestFromPacket(ctx, pkt)
rpkt = request.call(rs.Handlers, pkt)
if stat, ok := rpkt.(*sshFxpStatResponse); ok {
if stat.info.IsDir() {
handle := rs.nextRequest(request)
rpkt = sshFxpHandlePacket{ID: pkt.id(), Handle: handle}
} else {
rpkt = statusFromError(pkt, &os.PathError{
Path: request.Filepath, Err: syscall.ENOTDIR})
}
}
rs.nextRequest(request)
rpkt = request.opendir(rs.Handlers, pkt)
case *sshFxpOpenPacket:
request := requestFromPacket(ctx, pkt)
handle := rs.nextRequest(request)
rpkt = sshFxpHandlePacket{ID: pkt.id(), Handle: handle}
if pkt.hasPflags(ssh_FXF_CREAT) {
if p := request.call(rs.Handlers, pkt); !statusOk(p) {
rpkt = p // if error in write, return it
}
rs.nextRequest(request)
rpkt = request.open(rs.Handlers, pkt)
case *sshFxpFstatPacket:
handle := pkt.getHandle()
request, ok := rs.getRequest(handle)
if !ok {
rpkt = statusFromError(pkt, syscall.EBADF)
} else {
request = NewRequest("Stat", request.Filepath)
rpkt = request.call(rs.Handlers, pkt)
}
case hasHandle:
handle := pkt.getHandle()
request, ok := rs.getRequest(handle, requestMethod(pkt))
request, ok := rs.getRequest(handle)
if !ok {
rpkt = statusFromError(pkt, syscall.EBADF)
} else {
@ -214,12 +196,6 @@ func (rs *RequestServer) packetWorker(
return nil
}
// True is responsePacket is an OK status packet
func statusOk(rpkt responsePacket) bool {
p, ok := rpkt.(sshFxpStatusPacket)
return ok && p.StatusError.Code == ssh_FX_OK
}
// clean and return name packet for file
func cleanPacketPath(pkt *sshFxpRealpathPacket) responsePacket {
path := cleanPath(pkt.getPath())

106
vendor/github.com/pkg/sftp/request.go generated vendored
View file

@ -24,6 +24,7 @@ type Request struct {
Flags uint32
Attrs []byte // convert to sub-struct
Target string // for renames and sym-links
handle string
// reader/writer/readdir from handlers
state state
// context lasts duration of request
@ -155,7 +156,7 @@ func (r *Request) call(handlers Handlers, pkt requestPacket) responsePacket {
switch r.Method {
case "Get":
return fileget(handlers.FileGet, r, pkt)
case "Put", "Open":
case "Put":
return fileput(handlers.FilePut, r, pkt)
case "Setstat", "Rename", "Rmdir", "Mkdir", "Symlink", "Remove":
return filecmd(handlers.FileCmd, r, pkt)
@ -169,37 +170,47 @@ func (r *Request) call(handlers Handlers, pkt requestPacket) responsePacket {
}
}
// file data for additional read/write packets
func packetData(p requestPacket) (data []byte, offset int64, length uint32) {
switch p := p.(type) {
case *sshFxpReadPacket:
length = p.Len
offset = int64(p.Offset)
case *sshFxpWritePacket:
data = p.Data
length = p.Length
offset = int64(p.Offset)
// Additional initialization for Open packets
func (r *Request) open(h Handlers, pkt requestPacket) responsePacket {
flags := r.Pflags()
var err error
switch {
case flags.Write, flags.Append, flags.Creat, flags.Trunc:
r.Method = "Put"
r.state.writerAt, err = h.FilePut.Filewrite(r)
case flags.Read:
r.Method = "Get"
r.state.readerAt, err = h.FileGet.Fileread(r)
default:
return statusFromError(pkt, errors.New("bad file flags"))
}
return
if err != nil {
return statusFromError(pkt, err)
}
return &sshFxpHandlePacket{ID: pkt.id(), Handle: r.handle}
}
func (r *Request) opendir(h Handlers, pkt requestPacket) responsePacket {
var err error
r.Method = "List"
r.state.listerAt, err = h.FileList.Filelist(r)
if err != nil {
switch err.(type) {
case syscall.Errno:
err = &os.PathError{Path: r.Filepath, Err: err}
}
return statusFromError(pkt, err)
}
return &sshFxpHandlePacket{ID: pkt.id(), Handle: r.handle}
}
// wrap FileReader handler
func fileget(h FileReader, r *Request, pkt requestPacket) responsePacket {
var err error
//fmt.Println("fileget", r)
r.state.RLock()
reader := r.state.readerAt
r.state.RUnlock()
if reader == nil {
r.state.Lock()
if r.state.readerAt == nil {
r.state.readerAt, err = h.Fileread(r)
if err != nil {
r.state.Unlock()
return statusFromError(pkt, err)
}
}
reader = r.state.readerAt
r.state.Unlock()
return statusFromError(pkt, errors.New("unexpected read packet"))
}
_, offset, length := packetData(pkt)
@ -218,28 +229,33 @@ func fileget(h FileReader, r *Request, pkt requestPacket) responsePacket {
// wrap FileWriter handler
func fileput(h FileWriter, r *Request, pkt requestPacket) responsePacket {
var err error
//fmt.Println("fileput", r)
r.state.RLock()
writer := r.state.writerAt
r.state.RUnlock()
if writer == nil {
r.state.Lock()
if r.state.writerAt == nil {
r.state.writerAt, err = h.Filewrite(r)
if err != nil {
r.state.Unlock()
return statusFromError(pkt, err)
}
}
writer = r.state.writerAt
r.state.Unlock()
return statusFromError(pkt, errors.New("unexpected write packet"))
}
data, offset, _ := packetData(pkt)
_, err = writer.WriteAt(data, offset)
_, err := writer.WriteAt(data, offset)
return statusFromError(pkt, err)
}
// file data for additional read/write packets
func packetData(p requestPacket) (data []byte, offset int64, length uint32) {
switch p := p.(type) {
case *sshFxpReadPacket:
length = p.Len
offset = int64(p.Offset)
case *sshFxpWritePacket:
data = p.Data
length = p.Length
offset = int64(p.Offset)
}
return
}
// wrap FileCmder handler
func filecmd(h FileCmder, r *Request, pkt requestPacket) responsePacket {
@ -257,11 +273,7 @@ func filelist(h FileLister, r *Request, pkt requestPacket) responsePacket {
var err error
lister := r.getLister()
if lister == nil {
lister, err = h.Filelist(r)
if err != nil {
return statusFromError(pkt, err)
}
r.setListerState(lister)
return statusFromError(pkt, errors.New("unexpected dir packet"))
}
offset := r.lsNext()
@ -346,16 +358,10 @@ func filestat(h FileLister, r *Request, pkt requestPacket) responsePacket {
// init attributes of request object from packet data
func requestMethod(p requestPacket) (method string) {
switch p.(type) {
case *sshFxpReadPacket:
method = "Get"
case *sshFxpWritePacket:
method = "Put"
case *sshFxpReaddirPacket:
method = "List"
case *sshFxpOpenPacket:
method = "Open"
case *sshFxpOpendirPacket:
method = "Stat"
case *sshFxpReadPacket, *sshFxpWritePacket, *sshFxpOpenPacket:
// set in open() above
case *sshFxpOpendirPacket, *sshFxpReaddirPacket:
// set in opendir() above
case *sshFxpSetstatPacket, *sshFxpFsetstatPacket:
method = "Setstat"
case *sshFxpRenamePacket: