← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ftp.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-06-06 22:59:58 UTC
  • mfrom: (1740.2.6 bzr.checkout)
  • Revision ID: pqm@pqm.ubuntu.com-20060606225958-17ab4431da6b44f6
Speed up checkout by using existing revision text when possible

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/ftp.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
16
"""Implementation of Transport over ftp.
18
17
 
19
18
Written by Daniel Silverstone <dsilvers@digital-scurf.org> with serious
26
25
"""
27
26
 
28
27
from cStringIO import StringIO
 
28
import asyncore
 
29
import errno
29
30
import ftplib
30
 
import getpass
31
31
import os
32
 
import random
33
 
import socket
 
32
import urllib
 
33
import urlparse
34
34
import stat
 
35
import threading
35
36
import time
 
37
import random
 
38
from warnings import warn
36
39
 
37
 
from bzrlib import (
38
 
    config,
39
 
    errors,
40
 
    osutils,
41
 
    urlutils,
42
 
    )
43
 
from bzrlib.trace import mutter, warning
44
40
from bzrlib.transport import (
45
 
    AppendBasedFileStream,
46
 
    ConnectedTransport,
47
 
    _file_streams,
48
 
    register_urlparse_netloc_protocol,
 
41
    Transport,
49
42
    Server,
 
43
    split_url,
50
44
    )
51
 
 
52
 
 
53
 
register_urlparse_netloc_protocol('aftp')
 
45
import bzrlib.errors as errors
 
46
from bzrlib.trace import mutter, warning
 
47
import bzrlib.ui
 
48
 
 
49
_have_medusa = False
54
50
 
55
51
 
56
52
class FtpPathError(errors.PathError):
57
53
    """FTP failed for path: %(path)s%(extra)s"""
58
54
 
59
55
 
 
56
_FTP_cache = {}
 
57
def _find_FTP(hostname, port, username, password, is_active):
 
58
    """Find an ftplib.FTP instance attached to this triplet."""
 
59
    key = (hostname, port, username, password, is_active)
 
60
    alt_key = (hostname, port, username, '********', is_active)
 
61
    if key not in _FTP_cache:
 
62
        mutter("Constructing FTP instance against %r" % (alt_key,))
 
63
        conn = ftplib.FTP()
 
64
 
 
65
        conn.connect(host=hostname, port=port)
 
66
        if username and username != 'anonymous' and not password:
 
67
            password = bzrlib.ui.ui_factory.get_password(
 
68
                prompt='FTP %(user)s@%(host)s password',
 
69
                user=username, host=hostname)
 
70
        conn.login(user=username, passwd=password)
 
71
        conn.set_pasv(not is_active)
 
72
 
 
73
        _FTP_cache[key] = conn
 
74
 
 
75
    return _FTP_cache[key]    
 
76
 
 
77
 
60
78
class FtpStatResult(object):
61
 
 
62
 
    def __init__(self, f, abspath):
 
79
    def __init__(self, f, relpath):
63
80
        try:
64
 
            self.st_size = f.size(abspath)
 
81
            self.st_size = f.size(relpath)
65
82
            self.st_mode = stat.S_IFREG
66
83
        except ftplib.error_perm:
67
84
            pwd = f.pwd()
68
85
            try:
69
 
                f.cwd(abspath)
 
86
                f.cwd(relpath)
70
87
                self.st_mode = stat.S_IFDIR
71
88
            finally:
72
89
                f.cwd(pwd)
75
92
_number_of_retries = 2
76
93
_sleep_between_retries = 5
77
94
 
78
 
# FIXME: there are inconsistencies in the way temporary errors are
79
 
# handled. Sometimes we reconnect, sometimes we raise an exception. Care should
80
 
# be taken to analyze the implications for write operations (read operations
81
 
# are safe to retry). Overall even some read operations are never
82
 
# retried. --vila 20070720 (Bug #127164)
83
 
class FtpTransport(ConnectedTransport):
 
95
class FtpTransport(Transport):
84
96
    """This is the transport agent for ftp:// access."""
85
97
 
86
 
    def __init__(self, base, _from_transport=None):
 
98
    def __init__(self, base, _provided_instance=None):
87
99
        """Set the base path where files will be stored."""
88
 
        if not (base.startswith('ftp://') or base.startswith('aftp://')):
89
 
            raise ValueError(base)
90
 
        super(FtpTransport, self).__init__(base,
91
 
                                           _from_transport=_from_transport)
92
 
        self._unqualified_scheme = 'ftp'
93
 
        if self._scheme == 'aftp':
94
 
            self.is_active = True
95
 
        else:
96
 
            self.is_active = False
97
 
 
98
 
        # Most modern FTP servers support the APPE command. If ours doesn't, we
99
 
        # (re)set this flag accordingly later.
100
 
        self._has_append = True
 
100
        assert base.startswith('ftp://') or base.startswith('aftp://')
 
101
 
 
102
        self.is_active = base.startswith('aftp://')
 
103
        if self.is_active:
 
104
            # urlparse won't handle aftp://
 
105
            base = base[1:]
 
106
        if not base.endswith('/'):
 
107
            base += '/'
 
108
        (self._proto, self._username,
 
109
            self._password, self._host,
 
110
            self._port, self._path) = split_url(base)
 
111
        base = self._unparse_url()
 
112
 
 
113
        super(FtpTransport, self).__init__(base)
 
114
        self._FTP_instance = _provided_instance
 
115
 
 
116
    def _unparse_url(self, path=None):
 
117
        if path is None:
 
118
            path = self._path
 
119
        path = urllib.quote(path)
 
120
        netloc = urllib.quote(self._host)
 
121
        if self._username is not None:
 
122
            netloc = '%s@%s' % (urllib.quote(self._username), netloc)
 
123
        if self._port is not None:
 
124
            netloc = '%s:%d' % (netloc, self._port)
 
125
        return urlparse.urlunparse(('ftp', netloc, path, '', '', ''))
101
126
 
102
127
    def _get_FTP(self):
103
128
        """Return the ftplib.FTP instance for this object."""
104
 
        # Ensures that a connection is established
105
 
        connection = self._get_connection()
106
 
        if connection is None:
107
 
            # First connection ever
108
 
            connection, credentials = self._create_connection()
109
 
            self._set_connection(connection, credentials)
110
 
        return connection
111
 
 
112
 
    connection_class = ftplib.FTP
113
 
 
114
 
    def _create_connection(self, credentials=None):
115
 
        """Create a new connection with the provided credentials.
116
 
 
117
 
        :param credentials: The credentials needed to establish the connection.
118
 
 
119
 
        :return: The created connection and its associated credentials.
120
 
 
121
 
        The input credentials are only the password as it may have been
122
 
        entered interactively by the user and may be different from the one
123
 
        provided in base url at transport creation time.  The returned
124
 
        credentials are username, password.
125
 
        """
126
 
        if credentials is None:
127
 
            user, password = self._user, self._password
128
 
        else:
129
 
            user, password = credentials
130
 
 
131
 
        auth = config.AuthenticationConfig()
132
 
        if user is None:
133
 
            user = auth.get_user('ftp', self._host, port=self._port,
134
 
                                 default=getpass.getuser())
135
 
        mutter("Constructing FTP instance against %r" %
136
 
               ((self._host, self._port, user, '********',
137
 
                self.is_active),))
 
129
        if self._FTP_instance is not None:
 
130
            return self._FTP_instance
 
131
        
138
132
        try:
139
 
            connection = self.connection_class()
140
 
            connection.connect(host=self._host, port=self._port)
141
 
            self._login(connection, auth, user, password)
142
 
            connection.set_pasv(not self.is_active)
143
 
            # binary mode is the default
144
 
            connection.voidcmd('TYPE I')
145
 
        except socket.error, e:
146
 
            raise errors.SocketConnectionError(self._host, self._port,
147
 
                                               msg='Unable to connect to',
148
 
                                               orig_error= e)
 
133
            self._FTP_instance = _find_FTP(self._host, self._port,
 
134
                                           self._username, self._password,
 
135
                                           self.is_active)
 
136
            return self._FTP_instance
149
137
        except ftplib.error_perm, e:
150
 
            raise errors.TransportError(msg="Error setting up connection:"
151
 
                                        " %s" % str(e), orig_error=e)
152
 
        return connection, (user, password)
153
 
 
154
 
    def _login(self, connection, auth, user, password):
155
 
        # '' is a valid password
156
 
        if user and user != 'anonymous' and password is None:
157
 
            password = auth.get_password('ftp', self._host,
158
 
                                         user, port=self._port)
159
 
        connection.login(user=user, passwd=password)
160
 
 
161
 
    def _reconnect(self):
162
 
        """Create a new connection with the previously used credentials"""
163
 
        credentials = self._get_credentials()
164
 
        connection, credentials = self._create_connection(credentials)
165
 
        self._set_connection(connection, credentials)
166
 
 
167
 
    def _translate_ftp_error(self, err, path, extra=None,
168
 
                              unknown_exc=FtpPathError):
169
 
        """Try to translate an ftplib exception to a bzrlib exception.
 
138
            raise errors.TransportError(msg="Error setting up connection: %s"
 
139
                                    % str(e), orig_error=e)
 
140
 
 
141
    def _translate_perm_error(self, err, path, extra=None, unknown_exc=FtpPathError):
 
142
        """Try to translate an ftplib.error_perm exception.
170
143
 
171
144
        :param err: The error to translate into a bzr error
172
145
        :param path: The path which had problems
174
147
        :param unknown_exc: If None, we will just raise the original exception
175
148
                    otherwise we raise unknown_exc(path, extra=extra)
176
149
        """
177
 
        # ftp error numbers are very generic, like "451: Requested action aborted,
178
 
        # local error in processing" so unfortunately we have to match by
179
 
        # strings.
180
150
        s = str(err).lower()
181
151
        if not extra:
182
152
            extra = str(err)
185
155
        if ('no such file' in s
186
156
            or 'could not open' in s
187
157
            or 'no such dir' in s
188
 
            or 'could not create file' in s # vsftpd
189
 
            or 'file doesn\'t exist' in s
190
 
            or 'rnfr command failed.' in s # vsftpd RNFR reply if file not found
191
 
            or 'file/directory not found' in s # filezilla server
192
 
            # Microsoft FTP-Service RNFR reply if file not found
193
 
            or (s.startswith('550 ') and 'unable to rename to' in extra)
194
158
            ):
195
159
            raise errors.NoSuchFile(path, extra=extra)
196
 
        elif ('file exists' in s):
 
160
        if ('file exists' in s):
197
161
            raise errors.FileExists(path, extra=extra)
198
 
        elif ('not a directory' in s):
 
162
        if ('not a directory' in s):
199
163
            raise errors.PathError(path, extra=extra)
200
 
        elif 'directory not empty' in s:
201
 
            raise errors.DirectoryNotEmpty(path, extra=extra)
202
164
 
203
165
        mutter('unable to understand error for path: %s: %s', path, err)
204
166
 
205
167
        if unknown_exc:
206
168
            raise unknown_exc(path, extra=extra)
207
 
        # TODO: jam 20060516 Consider re-raising the error wrapped in
 
169
        # TODO: jam 20060516 Consider re-raising the error wrapped in 
208
170
        #       something like TransportError, but this loses the traceback
209
171
        #       Also, 'sftp' has a generic 'Failure' mode, which we use failure_exc
210
172
        #       to handle. Consider doing something like that here.
211
173
        #raise TransportError(msg='Error for path: %s' % (path,), orig_error=e)
212
174
        raise
213
175
 
 
176
    def should_cache(self):
 
177
        """Return True if the data pulled across should be cached locally.
 
178
        """
 
179
        return True
 
180
 
 
181
    def clone(self, offset=None):
 
182
        """Return a new FtpTransport with root at self.base + offset.
 
183
        """
 
184
        mutter("FTP clone")
 
185
        if offset is None:
 
186
            return FtpTransport(self.base, self._FTP_instance)
 
187
        else:
 
188
            return FtpTransport(self.abspath(offset), self._FTP_instance)
 
189
 
 
190
    def _abspath(self, relpath):
 
191
        assert isinstance(relpath, basestring)
 
192
        relpath = urllib.unquote(relpath)
 
193
        relpath_parts = relpath.split('/')
 
194
        if len(relpath_parts) > 1:
 
195
            if relpath_parts[0] == '':
 
196
                raise ValueError("path %r within branch %r seems to be absolute"
 
197
                                 % (relpath, self._path))
 
198
        basepath = self._path.split('/')
 
199
        if len(basepath) > 0 and basepath[-1] == '':
 
200
            basepath = basepath[:-1]
 
201
        for p in relpath_parts:
 
202
            if p == '..':
 
203
                if len(basepath) == 0:
 
204
                    # In most filesystems, a request for the parent
 
205
                    # of root, just returns root.
 
206
                    continue
 
207
                basepath.pop()
 
208
            elif p == '.' or p == '':
 
209
                continue # No-op
 
210
            else:
 
211
                basepath.append(p)
 
212
        # Possibly, we could use urlparse.urljoin() here, but
 
213
        # I'm concerned about when it chooses to strip the last
 
214
        # portion of the path, and when it doesn't.
 
215
        return '/'.join(basepath) or '/'
 
216
    
 
217
    def abspath(self, relpath):
 
218
        """Return the full url to the given relative path.
 
219
        This can be supplied with a string or a list
 
220
        """
 
221
        path = self._abspath(relpath)
 
222
        return self._unparse_url(path)
 
223
 
214
224
    def has(self, relpath):
215
225
        """Does the target location exist?"""
216
226
        # FIXME jam 20060516 We *do* ask about directories in the test suite
218
228
        # XXX: I assume we're never asked has(dirname) and thus I use
219
229
        # the FTP size command and assume that if it doesn't raise,
220
230
        # all is good.
221
 
        abspath = self._remote_path(relpath)
 
231
        abspath = self._abspath(relpath)
222
232
        try:
223
233
            f = self._get_FTP()
224
234
            mutter('FTP has check: %s => %s', relpath, abspath)
244
254
        """
245
255
        # TODO: decode should be deprecated
246
256
        try:
247
 
            mutter("FTP get: %s", self._remote_path(relpath))
 
257
            mutter("FTP get: %s", self._abspath(relpath))
248
258
            f = self._get_FTP()
249
259
            ret = StringIO()
250
 
            f.retrbinary('RETR '+self._remote_path(relpath), ret.write, 8192)
 
260
            f.retrbinary('RETR '+self._abspath(relpath), ret.write, 8192)
251
261
            ret.seek(0)
252
262
            return ret
253
263
        except ftplib.error_perm, e:
259
269
                                     orig_error=e)
260
270
            else:
261
271
                warning("FTP temporary error: %s. Retrying.", str(e))
262
 
                self._reconnect()
 
272
                self._FTP_instance = None
263
273
                return self.get(relpath, decode, retries+1)
264
274
        except EOFError, e:
265
275
            if retries > _number_of_retries:
269
279
            else:
270
280
                warning("FTP control connection closed. Trying to reopen.")
271
281
                time.sleep(_sleep_between_retries)
272
 
                self._reconnect()
 
282
                self._FTP_instance = None
273
283
                return self.get(relpath, decode, retries+1)
274
284
 
275
 
    def put_file(self, relpath, fp, mode=None, retries=0):
 
285
    def put(self, relpath, fp, mode=None, retries=0):
276
286
        """Copy the file-like or string object into the location.
277
287
 
278
288
        :param relpath: Location to put the contents, relative to base.
280
290
        :param retries: Number of retries after temporary failures so far
281
291
                        for this operation.
282
292
 
283
 
        TODO: jam 20051215 ftp as a protocol seems to support chmod, but
284
 
        ftplib does not
 
293
        TODO: jam 20051215 ftp as a protocol seems to support chmod, but ftplib does not
285
294
        """
286
 
        abspath = self._remote_path(relpath)
 
295
        abspath = self._abspath(relpath)
287
296
        tmp_abspath = '%s.tmp.%.9f.%d.%d' % (abspath, time.time(),
288
297
                        os.getpid(), random.randint(0,0x7FFFFFFF))
289
 
        bytes = None
290
 
        if getattr(fp, 'read', None) is None:
291
 
            # hand in a string IO
292
 
            bytes = fp
293
 
            fp = StringIO(bytes)
294
 
        else:
295
 
            # capture the byte count; .read() may be read only so
296
 
            # decorate it.
297
 
            class byte_counter(object):
298
 
                def __init__(self, fp):
299
 
                    self.fp = fp
300
 
                    self.counted_bytes = 0
301
 
                def read(self, count):
302
 
                    result = self.fp.read(count)
303
 
                    self.counted_bytes += len(result)
304
 
                    return result
305
 
            fp = byte_counter(fp)
 
298
        if not hasattr(fp, 'read'):
 
299
            fp = StringIO(fp)
306
300
        try:
307
301
            mutter("FTP put: %s", abspath)
308
302
            f = self._get_FTP()
309
303
            try:
310
304
                f.storbinary('STOR '+tmp_abspath, fp)
311
 
                self._rename_and_overwrite(tmp_abspath, abspath, f)
312
 
                self._setmode(relpath, mode)
313
 
                if bytes is not None:
314
 
                    return len(bytes)
315
 
                else:
316
 
                    return fp.counted_bytes
 
305
                f.rename(tmp_abspath, abspath)
317
306
            except (ftplib.error_temp,EOFError), e:
318
307
                warning("Failure during ftp PUT. Deleting temporary file.")
319
308
                try:
324
313
                    raise e
325
314
                raise
326
315
        except ftplib.error_perm, e:
327
 
            self._translate_ftp_error(e, abspath, extra='could not store',
328
 
                                       unknown_exc=errors.NoSuchFile)
 
316
            self._translate_perm_error(e, abspath, extra='could not store')
329
317
        except ftplib.error_temp, e:
330
318
            if retries > _number_of_retries:
331
319
                raise errors.TransportError("FTP temporary error during PUT %s. Aborting."
332
320
                                     % self.abspath(relpath), orig_error=e)
333
321
            else:
334
322
                warning("FTP temporary error: %s. Retrying.", str(e))
335
 
                self._reconnect()
336
 
                self.put_file(relpath, fp, mode, retries+1)
 
323
                self._FTP_instance = None
 
324
                self.put(relpath, fp, mode, retries+1)
337
325
        except EOFError:
338
326
            if retries > _number_of_retries:
339
327
                raise errors.TransportError("FTP control connection closed during PUT %s."
341
329
            else:
342
330
                warning("FTP control connection closed. Trying to reopen.")
343
331
                time.sleep(_sleep_between_retries)
344
 
                self._reconnect()
345
 
                self.put_file(relpath, fp, mode, retries+1)
 
332
                self._FTP_instance = None
 
333
                self.put(relpath, fp, mode, retries+1)
346
334
 
347
335
    def mkdir(self, relpath, mode=None):
348
336
        """Create a directory at the given path."""
349
 
        abspath = self._remote_path(relpath)
 
337
        abspath = self._abspath(relpath)
350
338
        try:
351
339
            mutter("FTP mkd: %s", abspath)
352
340
            f = self._get_FTP()
353
341
            f.mkd(abspath)
354
 
            self._setmode(relpath, mode)
355
342
        except ftplib.error_perm, e:
356
 
            self._translate_ftp_error(e, abspath,
 
343
            self._translate_perm_error(e, abspath,
357
344
                unknown_exc=errors.FileExists)
358
345
 
359
 
    def open_write_stream(self, relpath, mode=None):
360
 
        """See Transport.open_write_stream."""
361
 
        self.put_bytes(relpath, "", mode)
362
 
        result = AppendBasedFileStream(self, relpath)
363
 
        _file_streams[self.abspath(relpath)] = result
364
 
        return result
365
 
 
366
 
    def recommended_page_size(self):
367
 
        """See Transport.recommended_page_size().
368
 
 
369
 
        For FTP we suggest a large page size to reduce the overhead
370
 
        introduced by latency.
371
 
        """
372
 
        return 64 * 1024
373
 
 
374
346
    def rmdir(self, rel_path):
375
347
        """Delete the directory at rel_path"""
376
 
        abspath = self._remote_path(rel_path)
 
348
        abspath = self._abspath(rel_path)
377
349
        try:
378
350
            mutter("FTP rmd: %s", abspath)
379
351
            f = self._get_FTP()
380
352
            f.rmd(abspath)
381
353
        except ftplib.error_perm, e:
382
 
            self._translate_ftp_error(e, abspath, unknown_exc=errors.PathError)
 
354
            self._translate_perm_error(e, abspath, unknown_exc=errors.PathError)
383
355
 
384
 
    def append_file(self, relpath, f, mode=None):
 
356
    def append(self, relpath, f, mode=None):
385
357
        """Append the text in the file-like object into the final
386
358
        location.
387
359
        """
388
 
        text = f.read()
389
 
        abspath = self._remote_path(relpath)
 
360
        abspath = self._abspath(relpath)
390
361
        if self.has(relpath):
391
362
            ftp = self._get_FTP()
392
363
            result = ftp.size(abspath)
393
364
        else:
394
365
            result = 0
395
366
 
396
 
        if self._has_append:
397
 
            mutter("FTP appe to %s", abspath)
398
 
            self._try_append(relpath, text, mode)
399
 
        else:
400
 
            self._fallback_append(relpath, text, mode)
 
367
        mutter("FTP appe to %s", abspath)
 
368
        self._try_append(relpath, f.read(), mode)
401
369
 
402
370
        return result
403
371
 
404
372
    def _try_append(self, relpath, text, mode=None, retries=0):
405
373
        """Try repeatedly to append the given text to the file at relpath.
406
 
 
 
374
        
407
375
        This is a recursive function. On errors, it will be called until the
408
376
        number of retries is exceeded.
409
377
        """
410
378
        try:
411
 
            abspath = self._remote_path(relpath)
 
379
            abspath = self._abspath(relpath)
412
380
            mutter("FTP appe (try %d) to %s", retries, abspath)
413
381
            ftp = self._get_FTP()
 
382
            ftp.voidcmd("TYPE I")
414
383
            cmd = "APPE %s" % abspath
415
384
            conn = ftp.transfercmd(cmd)
416
385
            conn.sendall(text)
417
386
            conn.close()
418
 
            self._setmode(relpath, mode)
 
387
            if mode:
 
388
                self._setmode(relpath, mode)
419
389
            ftp.getresp()
420
390
        except ftplib.error_perm, e:
421
 
            # Check whether the command is not supported (reply code 502)
422
 
            if str(e).startswith('502 '):
423
 
                warning("FTP server does not support file appending natively. "
424
 
                        "Performance may be severely degraded! (%s)", e)
425
 
                self._has_append = False
426
 
                self._fallback_append(relpath, text, mode)
427
 
            else:
428
 
                self._translate_ftp_error(e, abspath, extra='error appending',
429
 
                    unknown_exc=errors.NoSuchFile)
 
391
            self._translate_perm_error(e, abspath, extra='error appending',
 
392
                unknown_exc=errors.NoSuchFile)
430
393
        except ftplib.error_temp, e:
431
394
            if retries > _number_of_retries:
432
 
                raise errors.TransportError(
433
 
                    "FTP temporary error during APPEND %s. Aborting."
434
 
                    % abspath, orig_error=e)
 
395
                raise errors.TransportError("FTP temporary error during APPEND %s." \
 
396
                        "Aborting." % abspath, orig_error=e)
435
397
            else:
436
398
                warning("FTP temporary error: %s. Retrying.", str(e))
437
 
                self._reconnect()
 
399
                self._FTP_instance = None
438
400
                self._try_append(relpath, text, mode, retries+1)
439
401
 
440
 
    def _fallback_append(self, relpath, text, mode = None):
441
 
        remote = self.get(relpath)
442
 
        remote.seek(0, os.SEEK_END)
443
 
        remote.write(text)
444
 
        remote.seek(0)
445
 
        return self.put_file(relpath, remote, mode)
446
 
 
447
402
    def _setmode(self, relpath, mode):
448
403
        """Set permissions on a path.
449
404
 
450
405
        Only set permissions if the FTP server supports the 'SITE CHMOD'
451
406
        extension.
452
407
        """
453
 
        if mode:
454
 
            try:
455
 
                mutter("FTP site chmod: setting permissions to %s on %s",
456
 
                       oct(mode), self._remote_path(relpath))
457
 
                ftp = self._get_FTP()
458
 
                cmd = "SITE CHMOD %s %s" % (oct(mode),
459
 
                                            self._remote_path(relpath))
460
 
                ftp.sendcmd(cmd)
461
 
            except ftplib.error_perm, e:
462
 
                # Command probably not available on this server
463
 
                warning("FTP Could not set permissions to %s on %s. %s",
464
 
                        oct(mode), self._remote_path(relpath), str(e))
 
408
        try:
 
409
            mutter("FTP site chmod: setting permissions to %s on %s",
 
410
                str(mode), self._abspath(relpath))
 
411
            ftp = self._get_FTP()
 
412
            cmd = "SITE CHMOD %s %s" % (self._abspath(relpath), str(mode))
 
413
            ftp.sendcmd(cmd)
 
414
        except ftplib.error_perm, e:
 
415
            # Command probably not available on this server
 
416
            warning("FTP Could not set permissions to %s on %s. %s",
 
417
                    str(mode), self._abspath(relpath), str(e))
465
418
 
466
419
    # TODO: jam 20060516 I believe ftp allows you to tell an ftp server
467
420
    #       to copy something to another machine. And you may be able
468
421
    #       to give it its own address as the 'to' location.
469
422
    #       So implement a fancier 'copy()'
470
423
 
471
 
    def rename(self, rel_from, rel_to):
472
 
        abs_from = self._remote_path(rel_from)
473
 
        abs_to = self._remote_path(rel_to)
474
 
        mutter("FTP rename: %s => %s", abs_from, abs_to)
475
 
        f = self._get_FTP()
476
 
        return self._rename(abs_from, abs_to, f)
477
 
 
478
 
    def _rename(self, abs_from, abs_to, f):
479
 
        try:
480
 
            f.rename(abs_from, abs_to)
481
 
        except (ftplib.error_temp, ftplib.error_perm), e:
482
 
            self._translate_ftp_error(e, abs_from,
483
 
                ': unable to rename to %r' % (abs_to))
484
 
 
485
424
    def move(self, rel_from, rel_to):
486
425
        """Move the item at rel_from to the location at rel_to"""
487
 
        abs_from = self._remote_path(rel_from)
488
 
        abs_to = self._remote_path(rel_to)
 
426
        abs_from = self._abspath(rel_from)
 
427
        abs_to = self._abspath(rel_to)
489
428
        try:
490
429
            mutter("FTP mv: %s => %s", abs_from, abs_to)
491
430
            f = self._get_FTP()
492
 
            self._rename_and_overwrite(abs_from, abs_to, f)
 
431
            f.rename(abs_from, abs_to)
493
432
        except ftplib.error_perm, e:
494
 
            self._translate_ftp_error(e, abs_from,
495
 
                extra='unable to rename to %r' % (rel_to,),
 
433
            self._translate_perm_error(e, abs_from,
 
434
                extra='unable to rename to %r' % (rel_to,), 
496
435
                unknown_exc=errors.PathError)
497
436
 
498
 
    def _rename_and_overwrite(self, abs_from, abs_to, f):
499
 
        """Do a fancy rename on the remote server.
500
 
 
501
 
        Using the implementation provided by osutils.
502
 
        """
503
 
        osutils.fancy_rename(abs_from, abs_to,
504
 
            rename_func=lambda p1, p2: self._rename(p1, p2, f),
505
 
            unlink_func=lambda p: self._delete(p, f))
 
437
    rename = move
506
438
 
507
439
    def delete(self, relpath):
508
440
        """Delete the item at relpath"""
509
 
        abspath = self._remote_path(relpath)
510
 
        f = self._get_FTP()
511
 
        self._delete(abspath, f)
512
 
 
513
 
    def _delete(self, abspath, f):
 
441
        abspath = self._abspath(relpath)
514
442
        try:
515
443
            mutter("FTP rm: %s", abspath)
 
444
            f = self._get_FTP()
516
445
            f.delete(abspath)
517
446
        except ftplib.error_perm, e:
518
 
            self._translate_ftp_error(e, abspath, 'error deleting',
 
447
            self._translate_perm_error(e, abspath, 'error deleting',
519
448
                unknown_exc=errors.NoSuchFile)
520
449
 
521
 
    def external_url(self):
522
 
        """See bzrlib.transport.Transport.external_url."""
523
 
        # FTP URL's are externally usable.
524
 
        return self.base
525
 
 
526
450
    def listable(self):
527
451
        """See Transport.listable."""
528
452
        return True
529
453
 
530
454
    def list_dir(self, relpath):
531
455
        """See Transport.list_dir."""
532
 
        basepath = self._remote_path(relpath)
533
 
        mutter("FTP nlst: %s", basepath)
534
 
        f = self._get_FTP()
535
456
        try:
536
 
            try:
537
 
                paths = f.nlst(basepath)
538
 
            except ftplib.error_perm, e:
539
 
                self._translate_ftp_error(e, relpath,
540
 
                                           extra='error with list_dir')
541
 
            except ftplib.error_temp, e:
542
 
                # xs4all's ftp server raises a 450 temp error when listing an
543
 
                # empty directory. Check for that and just return an empty list
544
 
                # in that case. See bug #215522
545
 
                if str(e).lower().startswith('450 no files found'):
546
 
                    mutter('FTP Server returned "%s" for nlst.'
547
 
                           ' Assuming it means empty directory',
548
 
                           str(e))
549
 
                    return []
550
 
                raise
551
 
        finally:
552
 
            # Restore binary mode as nlst switch to ascii mode to retrieve file
553
 
            # list
554
 
            f.voidcmd('TYPE I')
555
 
 
556
 
        # If FTP.nlst returns paths prefixed by relpath, strip 'em
557
 
        if paths and paths[0].startswith(basepath):
558
 
            entries = [path[len(basepath)+1:] for path in paths]
559
 
        else:
560
 
            entries = paths
561
 
        # Remove . and .. if present
562
 
        return [urlutils.escape(entry) for entry in entries
563
 
                if entry not in ('.', '..')]
 
457
            mutter("FTP nlst: %s", self._abspath(relpath))
 
458
            f = self._get_FTP()
 
459
            basepath = self._abspath(relpath)
 
460
            paths = f.nlst(basepath)
 
461
            # If FTP.nlst returns paths prefixed by relpath, strip 'em
 
462
            if paths and paths[0].startswith(basepath):
 
463
                paths = [path[len(basepath)+1:] for path in paths]
 
464
            # Remove . and .. if present, and return
 
465
            return [path for path in paths if path not in (".", "..")]
 
466
        except ftplib.error_perm, e:
 
467
            self._translate_perm_error(e, relpath, extra='error with list_dir')
564
468
 
565
469
    def iter_files_recursive(self):
566
470
        """See Transport.iter_files_recursive.
569
473
        mutter("FTP iter_files_recursive")
570
474
        queue = list(self.list_dir("."))
571
475
        while queue:
572
 
            relpath = queue.pop(0)
 
476
            relpath = urllib.quote(queue.pop(0))
573
477
            st = self.stat(relpath)
574
478
            if stat.S_ISDIR(st.st_mode):
575
479
                for i, basename in enumerate(self.list_dir(relpath)):
579
483
 
580
484
    def stat(self, relpath):
581
485
        """Return the stat information for a file."""
582
 
        abspath = self._remote_path(relpath)
 
486
        abspath = self._abspath(relpath)
583
487
        try:
584
488
            mutter("FTP stat: %s", abspath)
585
489
            f = self._get_FTP()
586
490
            return FtpStatResult(f, abspath)
587
491
        except ftplib.error_perm, e:
588
 
            self._translate_ftp_error(e, abspath, extra='error w/ stat')
 
492
            self._translate_perm_error(e, abspath, extra='error w/ stat')
589
493
 
590
494
    def lock_read(self, relpath):
591
495
        """Lock the given file for shared (read) access.
609
513
        return self.lock_read(relpath)
610
514
 
611
515
 
 
516
class FtpServer(Server):
 
517
    """Common code for SFTP server facilities."""
 
518
 
 
519
    def __init__(self):
 
520
        self._root = None
 
521
        self._ftp_server = None
 
522
        self._port = None
 
523
        self._async_thread = None
 
524
        # ftp server logs
 
525
        self.logs = []
 
526
 
 
527
    def get_url(self):
 
528
        """Calculate an ftp url to this server."""
 
529
        return 'ftp://foo:bar@localhost:%d/' % (self._port)
 
530
 
 
531
#    def get_bogus_url(self):
 
532
#        """Return a URL which cannot be connected to."""
 
533
#        return 'ftp://127.0.0.1:1'
 
534
 
 
535
    def log(self, message):
 
536
        """This is used by medusa.ftp_server to log connections, etc."""
 
537
        self.logs.append(message)
 
538
 
 
539
    def setUp(self):
 
540
 
 
541
        if not _have_medusa:
 
542
            raise RuntimeError('Must have medusa to run the FtpServer')
 
543
 
 
544
        self._root = os.getcwdu()
 
545
        self._ftp_server = _ftp_server(
 
546
            authorizer=_test_authorizer(root=self._root),
 
547
            ip='localhost',
 
548
            port=0, # bind to a random port
 
549
            resolver=None,
 
550
            logger_object=self # Use FtpServer.log() for messages
 
551
            )
 
552
        self._port = self._ftp_server.getsockname()[1]
 
553
        # Don't let it loop forever, or handle an infinite number of requests.
 
554
        # In this case it will run for 100s, or 1000 requests
 
555
        self._async_thread = threading.Thread(target=asyncore.loop,
 
556
                kwargs={'timeout':0.1, 'count':1000})
 
557
        self._async_thread.setDaemon(True)
 
558
        self._async_thread.start()
 
559
 
 
560
    def tearDown(self):
 
561
        """See bzrlib.transport.Server.tearDown."""
 
562
        # have asyncore release the channel
 
563
        self._ftp_server.del_channel()
 
564
        asyncore.close_all()
 
565
        self._async_thread.join()
 
566
 
 
567
 
 
568
_ftp_channel = None
 
569
_ftp_server = None
 
570
_test_authorizer = None
 
571
 
 
572
 
 
573
def _setup_medusa():
 
574
    global _have_medusa, _ftp_channel, _ftp_server, _test_authorizer
 
575
    try:
 
576
        import medusa
 
577
        import medusa.filesys
 
578
        import medusa.ftp_server
 
579
    except ImportError:
 
580
        return False
 
581
 
 
582
    _have_medusa = True
 
583
 
 
584
    class test_authorizer(object):
 
585
        """A custom Authorizer object for running the test suite.
 
586
 
 
587
        The reason we cannot use dummy_authorizer, is because it sets the
 
588
        channel to readonly, which we don't always want to do.
 
589
        """
 
590
 
 
591
        def __init__(self, root):
 
592
            self.root = root
 
593
 
 
594
        def authorize(self, channel, username, password):
 
595
            """Return (success, reply_string, filesystem)"""
 
596
            if not _have_medusa:
 
597
                return 0, 'No Medusa.', None
 
598
 
 
599
            channel.persona = -1, -1
 
600
            if username == 'anonymous':
 
601
                channel.read_only = 1
 
602
            else:
 
603
                channel.read_only = 0
 
604
 
 
605
            return 1, 'OK.', medusa.filesys.os_filesystem(self.root)
 
606
 
 
607
 
 
608
    class ftp_channel(medusa.ftp_server.ftp_channel):
 
609
        """Customized ftp channel"""
 
610
 
 
611
        def log(self, message):
 
612
            """Redirect logging requests."""
 
613
            mutter('_ftp_channel: %s', message)
 
614
            
 
615
        def log_info(self, message, type='info'):
 
616
            """Redirect logging requests."""
 
617
            mutter('_ftp_channel %s: %s', type, message)
 
618
            
 
619
        def cmd_rnfr(self, line):
 
620
            """Prepare for renaming a file."""
 
621
            self._renaming = line[1]
 
622
            self.respond('350 Ready for RNTO')
 
623
            # TODO: jam 20060516 in testing, the ftp server seems to
 
624
            #       check that the file already exists, or it sends
 
625
            #       550 RNFR command failed
 
626
 
 
627
        def cmd_rnto(self, line):
 
628
            """Rename a file based on the target given.
 
629
 
 
630
            rnto must be called after calling rnfr.
 
631
            """
 
632
            if not self._renaming:
 
633
                self.respond('503 RNFR required first.')
 
634
            pfrom = self.filesystem.translate(self._renaming)
 
635
            self._renaming = None
 
636
            pto = self.filesystem.translate(line[1])
 
637
            try:
 
638
                os.rename(pfrom, pto)
 
639
            except (IOError, OSError), e:
 
640
                # TODO: jam 20060516 return custom responses based on
 
641
                #       why the command failed
 
642
                self.respond('550 RNTO failed: %s' % (e,))
 
643
            except:
 
644
                self.respond('550 RNTO failed')
 
645
                # For a test server, we will go ahead and just die
 
646
                raise
 
647
            else:
 
648
                self.respond('250 Rename successful.')
 
649
 
 
650
        def cmd_size(self, line):
 
651
            """Return the size of a file
 
652
 
 
653
            This is overloaded to help the test suite determine if the 
 
654
            target is a directory.
 
655
            """
 
656
            filename = line[1]
 
657
            if not self.filesystem.isfile(filename):
 
658
                if self.filesystem.isdir(filename):
 
659
                    self.respond('550 "%s" is a directory' % (filename,))
 
660
                else:
 
661
                    self.respond('550 "%s" is not a file' % (filename,))
 
662
            else:
 
663
                self.respond('213 %d' 
 
664
                    % (self.filesystem.stat(filename)[stat.ST_SIZE]),)
 
665
 
 
666
        def cmd_mkd(self, line):
 
667
            """Create a directory.
 
668
 
 
669
            Overloaded because default implementation does not distinguish
 
670
            *why* it cannot make a directory.
 
671
            """
 
672
            if len (line) != 2:
 
673
                self.command_not_understood (string.join (line))
 
674
            else:
 
675
                path = line[1]
 
676
                try:
 
677
                    self.filesystem.mkdir (path)
 
678
                    self.respond ('257 MKD command successful.')
 
679
                except (IOError, OSError), e:
 
680
                    self.respond ('550 error creating directory: %s' % (e,))
 
681
                except:
 
682
                    self.respond ('550 error creating directory.')
 
683
 
 
684
 
 
685
    class ftp_server(medusa.ftp_server.ftp_server):
 
686
        """Customize the behavior of the Medusa ftp_server.
 
687
 
 
688
        There are a few warts on the ftp_server, based on how it expects
 
689
        to be used.
 
690
        """
 
691
        _renaming = None
 
692
        ftp_channel_class = ftp_channel
 
693
 
 
694
        def __init__(self, *args, **kwargs):
 
695
            mutter('Initializing _ftp_server: %r, %r', args, kwargs)
 
696
            medusa.ftp_server.ftp_server.__init__(self, *args, **kwargs)
 
697
 
 
698
        def log(self, message):
 
699
            """Redirect logging requests."""
 
700
            mutter('_ftp_server: %s', message)
 
701
 
 
702
        def log_info(self, message, type='info'):
 
703
            """Override the asyncore.log_info so we don't stipple the screen."""
 
704
            mutter('_ftp_server %s: %s', type, message)
 
705
 
 
706
    _test_authorizer = test_authorizer
 
707
    _ftp_channel = ftp_channel
 
708
    _ftp_server = ftp_server
 
709
 
 
710
    return True
 
711
 
 
712
 
612
713
def get_test_permutations():
613
714
    """Return the permutations to be used in testing."""
614
 
    from bzrlib.tests import ftp_server
615
 
    return [(FtpTransport, ftp_server.FTPTestServer)]
 
715
    if not _setup_medusa():
 
716
        warn("You must install medusa (http://www.amk.ca/python/code/medusa.html) for FTP tests")
 
717
        return []
 
718
    else:
 
719
        return [(FtpTransport, FtpServer)]