← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ftp.py

Merge up bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/ftp.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
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
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
25
24
active, in which case aftp:// will be your friend.
26
25
"""
27
26
 
28
 
from __future__ import absolute_import
29
 
 
30
27
from cStringIO import StringIO
 
28
import errno
31
29
import ftplib
32
30
import getpass
33
31
import os
34
 
import random
 
32
import os.path
 
33
import urlparse
35
34
import socket
36
35
import stat
37
36
import time
 
37
import random
 
38
from warnings import warn
38
39
 
39
40
from bzrlib import (
40
41
    config,
42
43
    osutils,
43
44
    urlutils,
44
45
    )
45
 
from bzrlib.symbol_versioning import (
46
 
    DEPRECATED_PARAMETER,
47
 
    deprecated_in,
48
 
    deprecated_passed,
49
 
    warn,
50
 
    )
51
46
from bzrlib.trace import mutter, warning
52
47
from bzrlib.transport import (
53
48
    AppendBasedFileStream,
56
51
    register_urlparse_netloc_protocol,
57
52
    Server,
58
53
    )
 
54
from bzrlib.transport.local import LocalURLServer
 
55
import bzrlib.ui
59
56
 
60
57
 
61
58
register_urlparse_netloc_protocol('aftp')
66
63
 
67
64
 
68
65
class FtpStatResult(object):
69
 
 
70
 
    def __init__(self, f, abspath):
 
66
    def __init__(self, f, relpath):
71
67
        try:
72
 
            self.st_size = f.size(abspath)
 
68
            self.st_size = f.size(relpath)
73
69
            self.st_mode = stat.S_IFREG
74
70
        except ftplib.error_perm:
75
71
            pwd = f.pwd()
76
72
            try:
77
 
                f.cwd(abspath)
 
73
                f.cwd(relpath)
78
74
                self.st_mode = stat.S_IFDIR
79
75
            finally:
80
76
                f.cwd(pwd)
98
94
        super(FtpTransport, self).__init__(base,
99
95
                                           _from_transport=_from_transport)
100
96
        self._unqualified_scheme = 'ftp'
101
 
        if self._parsed_url.scheme == 'aftp':
 
97
        if self._scheme == 'aftp':
102
98
            self.is_active = True
103
99
        else:
104
100
            self.is_active = False
105
101
 
106
 
        # Most modern FTP servers support the APPE command. If ours doesn't, we
107
 
        # (re)set this flag accordingly later.
108
 
        self._has_append = True
109
 
 
110
102
    def _get_FTP(self):
111
103
        """Return the ftplib.FTP instance for this object."""
112
104
        # Ensures that a connection is established
117
109
            self._set_connection(connection, credentials)
118
110
        return connection
119
111
 
120
 
    connection_class = ftplib.FTP
121
 
 
122
112
    def _create_connection(self, credentials=None):
123
113
        """Create a new connection with the provided credentials.
124
114
 
126
116
 
127
117
        :return: The created connection and its associated credentials.
128
118
 
129
 
        The input credentials are only the password as it may have been
130
 
        entered interactively by the user and may be different from the one
131
 
        provided in base url at transport creation time.  The returned
132
 
        credentials are username, password.
 
119
        The credentials are only the password as it may have been entered
 
120
        interactively by the user and may be different from the one provided
 
121
        in base url at transport creation time.
133
122
        """
134
123
        if credentials is None:
135
124
            user, password = self._user, self._password
138
127
 
139
128
        auth = config.AuthenticationConfig()
140
129
        if user is None:
141
 
            user = auth.get_user('ftp', self._host, port=self._port,
142
 
                                 default=getpass.getuser())
 
130
            user = auth.get_user('ftp', self._host, port=self._port)
 
131
            if user is None:
 
132
                # Default to local user
 
133
                user = getpass.getuser()
 
134
 
143
135
        mutter("Constructing FTP instance against %r" %
144
136
               ((self._host, self._port, user, '********',
145
137
                self.is_active),))
146
138
        try:
147
 
            connection = self.connection_class()
 
139
            connection = ftplib.FTP()
148
140
            connection.connect(host=self._host, port=self._port)
149
 
            self._login(connection, auth, user, password)
 
141
            if user and user != 'anonymous' and \
 
142
                    password is None: # '' is a valid password
 
143
                password = auth.get_password('ftp', self._host, user,
 
144
                                             port=self._port)
 
145
            connection.login(user=user, passwd=password)
150
146
            connection.set_pasv(not self.is_active)
151
 
            # binary mode is the default
152
 
            connection.voidcmd('TYPE I')
153
147
        except socket.error, e:
154
148
            raise errors.SocketConnectionError(self._host, self._port,
155
149
                                               msg='Unable to connect to',
159
153
                                        " %s" % str(e), orig_error=e)
160
154
        return connection, (user, password)
161
155
 
162
 
    def _login(self, connection, auth, user, password):
163
 
        # '' is a valid password
164
 
        if user and user != 'anonymous' and password is None:
165
 
            password = auth.get_password('ftp', self._host,
166
 
                                         user, port=self._port)
167
 
        connection.login(user=user, passwd=password)
168
 
 
169
156
    def _reconnect(self):
170
157
        """Create a new connection with the previously used credentials"""
171
158
        credentials = self._get_credentials()
172
159
        connection, credentials = self._create_connection(credentials)
173
160
        self._set_connection(connection, credentials)
174
161
 
175
 
    def disconnect(self):
176
 
        connection = self._get_connection()
177
 
        if connection is not None:
178
 
            connection.close()
179
 
 
180
 
    def _translate_ftp_error(self, err, path, extra=None,
 
162
    def _translate_perm_error(self, err, path, extra=None,
181
163
                              unknown_exc=FtpPathError):
182
 
        """Try to translate an ftplib exception to a bzrlib exception.
 
164
        """Try to translate an ftplib.error_perm exception.
183
165
 
184
166
        :param err: The error to translate into a bzr error
185
167
        :param path: The path which had problems
187
169
        :param unknown_exc: If None, we will just raise the original exception
188
170
                    otherwise we raise unknown_exc(path, extra=extra)
189
171
        """
190
 
        # ftp error numbers are very generic, like "451: Requested action aborted,
191
 
        # local error in processing" so unfortunately we have to match by
192
 
        # strings.
193
172
        s = str(err).lower()
194
173
        if not extra:
195
174
            extra = str(err)
204
183
            or 'file/directory not found' in s # filezilla server
205
184
            # Microsoft FTP-Service RNFR reply if file not found
206
185
            or (s.startswith('550 ') and 'unable to rename to' in extra)
207
 
            # if containing directory doesn't exist, suggested by
208
 
            # <https://bugs.launchpad.net/bzr/+bug/224373>
209
 
            or (s.startswith('550 ') and "can't find folder" in s)
210
186
            ):
211
187
            raise errors.NoSuchFile(path, extra=extra)
212
 
        elif ('file exists' in s):
 
188
        if ('file exists' in s):
213
189
            raise errors.FileExists(path, extra=extra)
214
 
        elif ('not a directory' in s):
 
190
        if ('not a directory' in s):
215
191
            raise errors.PathError(path, extra=extra)
216
 
        elif 'directory not empty' in s:
217
 
            raise errors.DirectoryNotEmpty(path, extra=extra)
218
192
 
219
193
        mutter('unable to understand error for path: %s: %s', path, err)
220
194
 
221
195
        if unknown_exc:
222
196
            raise unknown_exc(path, extra=extra)
223
 
        # TODO: jam 20060516 Consider re-raising the error wrapped in
 
197
        # TODO: jam 20060516 Consider re-raising the error wrapped in 
224
198
        #       something like TransportError, but this loses the traceback
225
199
        #       Also, 'sftp' has a generic 'Failure' mode, which we use failure_exc
226
200
        #       to handle. Consider doing something like that here.
227
201
        #raise TransportError(msg='Error for path: %s' % (path,), orig_error=e)
228
202
        raise
229
203
 
 
204
    def _remote_path(self, relpath):
 
205
        # XXX: It seems that ftplib does not handle Unicode paths
 
206
        # at the same time, medusa won't handle utf8 paths So if
 
207
        # we .encode(utf8) here (see ConnectedTransport
 
208
        # implementation), then we get a Server failure.  while
 
209
        # if we use str(), we get a UnicodeError, and the test
 
210
        # suite just skips testing UnicodePaths.
 
211
        relative = str(urlutils.unescape(relpath))
 
212
        remote_path = self._combine_paths(self._path, relative)
 
213
        return remote_path
 
214
 
230
215
    def has(self, relpath):
231
216
        """Does the target location exist?"""
232
217
        # FIXME jam 20060516 We *do* ask about directories in the test suite
248
233
            mutter("FTP has not: %s: %s", abspath, e)
249
234
            return False
250
235
 
251
 
    def get(self, relpath, retries=0):
 
236
    def get(self, relpath, decode=False, retries=0):
252
237
        """Get the file at the given relative path.
253
238
 
254
239
        :param relpath: The relative path to the file
258
243
        We're meant to return a file-like object which bzr will
259
244
        then read from. For now we do this via the magic of StringIO
260
245
        """
 
246
        # TODO: decode should be deprecated
261
247
        try:
262
248
            mutter("FTP get: %s", self._remote_path(relpath))
263
249
            f = self._get_FTP()
275
261
            else:
276
262
                warning("FTP temporary error: %s. Retrying.", str(e))
277
263
                self._reconnect()
278
 
                return self.get(relpath, retries+1)
 
264
                return self.get(relpath, decode, retries+1)
279
265
        except EOFError, e:
280
266
            if retries > _number_of_retries:
281
267
                raise errors.TransportError("FTP control connection closed during GET %s."
285
271
                warning("FTP control connection closed. Trying to reopen.")
286
272
                time.sleep(_sleep_between_retries)
287
273
                self._reconnect()
288
 
                return self.get(relpath, retries+1)
 
274
                return self.get(relpath, decode, retries+1)
289
275
 
290
276
    def put_file(self, relpath, fp, mode=None, retries=0):
291
277
        """Copy the file-like or string object into the location.
324
310
            try:
325
311
                f.storbinary('STOR '+tmp_abspath, fp)
326
312
                self._rename_and_overwrite(tmp_abspath, abspath, f)
327
 
                self._setmode(relpath, mode)
328
313
                if bytes is not None:
329
314
                    return len(bytes)
330
315
                else:
331
316
                    return fp.counted_bytes
332
 
            except (ftplib.error_temp, EOFError), e:
333
 
                warning("Failure during ftp PUT of %s: %s. Deleting temporary file."
334
 
                    % (tmp_abspath, e, ))
 
317
            except (ftplib.error_temp,EOFError), e:
 
318
                warning("Failure during ftp PUT. Deleting temporary file.")
335
319
                try:
336
320
                    f.delete(tmp_abspath)
337
321
                except:
340
324
                    raise e
341
325
                raise
342
326
        except ftplib.error_perm, e:
343
 
            self._translate_ftp_error(e, abspath, extra='could not store',
 
327
            self._translate_perm_error(e, abspath, extra='could not store',
344
328
                                       unknown_exc=errors.NoSuchFile)
345
329
        except ftplib.error_temp, e:
346
330
            if retries > _number_of_retries:
347
 
                raise errors.TransportError(
348
 
                    "FTP temporary error during PUT %s: %s. Aborting."
349
 
                    % (self.abspath(relpath), e), orig_error=e)
 
331
                raise errors.TransportError("FTP temporary error during PUT %s. Aborting."
 
332
                                     % self.abspath(relpath), orig_error=e)
350
333
            else:
351
334
                warning("FTP temporary error: %s. Retrying.", str(e))
352
335
                self._reconnect()
367
350
        try:
368
351
            mutter("FTP mkd: %s", abspath)
369
352
            f = self._get_FTP()
370
 
            try:
371
 
                f.mkd(abspath)
372
 
            except ftplib.error_reply, e:
373
 
                # <https://bugs.launchpad.net/bzr/+bug/224373> Microsoft FTP
374
 
                # server returns "250 Directory created." which is kind of
375
 
                # reasonable, 250 meaning "requested file action OK", but not what
376
 
                # Python's ftplib expects.
377
 
                if e[0][:3] == '250':
378
 
                    pass
379
 
                else:
380
 
                    raise
381
 
            self._setmode(relpath, mode)
 
353
            f.mkd(abspath)
382
354
        except ftplib.error_perm, e:
383
 
            self._translate_ftp_error(e, abspath,
 
355
            self._translate_perm_error(e, abspath,
384
356
                unknown_exc=errors.FileExists)
385
357
 
386
358
    def open_write_stream(self, relpath, mode=None):
406
378
            f = self._get_FTP()
407
379
            f.rmd(abspath)
408
380
        except ftplib.error_perm, e:
409
 
            self._translate_ftp_error(e, abspath, unknown_exc=errors.PathError)
 
381
            self._translate_perm_error(e, abspath, unknown_exc=errors.PathError)
410
382
 
411
383
    def append_file(self, relpath, f, mode=None):
412
384
        """Append the text in the file-like object into the final
413
385
        location.
414
386
        """
415
 
        text = f.read()
416
387
        abspath = self._remote_path(relpath)
417
388
        if self.has(relpath):
418
389
            ftp = self._get_FTP()
420
391
        else:
421
392
            result = 0
422
393
 
423
 
        if self._has_append:
424
 
            mutter("FTP appe to %s", abspath)
425
 
            self._try_append(relpath, text, mode)
426
 
        else:
427
 
            self._fallback_append(relpath, text, mode)
 
394
        mutter("FTP appe to %s", abspath)
 
395
        self._try_append(relpath, f.read(), mode)
428
396
 
429
397
        return result
430
398
 
431
399
    def _try_append(self, relpath, text, mode=None, retries=0):
432
400
        """Try repeatedly to append the given text to the file at relpath.
433
 
 
 
401
        
434
402
        This is a recursive function. On errors, it will be called until the
435
403
        number of retries is exceeded.
436
404
        """
438
406
            abspath = self._remote_path(relpath)
439
407
            mutter("FTP appe (try %d) to %s", retries, abspath)
440
408
            ftp = self._get_FTP()
 
409
            ftp.voidcmd("TYPE I")
441
410
            cmd = "APPE %s" % abspath
442
411
            conn = ftp.transfercmd(cmd)
443
412
            conn.sendall(text)
444
413
            conn.close()
445
 
            self._setmode(relpath, mode)
 
414
            if mode:
 
415
                self._setmode(relpath, mode)
446
416
            ftp.getresp()
447
417
        except ftplib.error_perm, e:
448
 
            # Check whether the command is not supported (reply code 502)
449
 
            if str(e).startswith('502 '):
450
 
                warning("FTP server does not support file appending natively. "
451
 
                        "Performance may be severely degraded! (%s)", e)
452
 
                self._has_append = False
453
 
                self._fallback_append(relpath, text, mode)
454
 
            else:
455
 
                self._translate_ftp_error(e, abspath, extra='error appending',
456
 
                    unknown_exc=errors.NoSuchFile)
 
418
            self._translate_perm_error(e, abspath, extra='error appending',
 
419
                unknown_exc=errors.NoSuchFile)
457
420
        except ftplib.error_temp, e:
458
421
            if retries > _number_of_retries:
459
 
                raise errors.TransportError(
460
 
                    "FTP temporary error during APPEND %s. Aborting."
461
 
                    % abspath, orig_error=e)
 
422
                raise errors.TransportError("FTP temporary error during APPEND %s." \
 
423
                        "Aborting." % abspath, orig_error=e)
462
424
            else:
463
425
                warning("FTP temporary error: %s. Retrying.", str(e))
464
426
                self._reconnect()
465
427
                self._try_append(relpath, text, mode, retries+1)
466
428
 
467
 
    def _fallback_append(self, relpath, text, mode = None):
468
 
        remote = self.get(relpath)
469
 
        remote.seek(0, os.SEEK_END)
470
 
        remote.write(text)
471
 
        remote.seek(0)
472
 
        return self.put_file(relpath, remote, mode)
473
 
 
474
429
    def _setmode(self, relpath, mode):
475
430
        """Set permissions on a path.
476
431
 
477
432
        Only set permissions if the FTP server supports the 'SITE CHMOD'
478
433
        extension.
479
434
        """
480
 
        if mode:
481
 
            try:
482
 
                mutter("FTP site chmod: setting permissions to %s on %s",
483
 
                       oct(mode), self._remote_path(relpath))
484
 
                ftp = self._get_FTP()
485
 
                cmd = "SITE CHMOD %s %s" % (oct(mode),
486
 
                                            self._remote_path(relpath))
487
 
                ftp.sendcmd(cmd)
488
 
            except ftplib.error_perm, e:
489
 
                # Command probably not available on this server
490
 
                warning("FTP Could not set permissions to %s on %s. %s",
491
 
                        oct(mode), self._remote_path(relpath), str(e))
 
435
        try:
 
436
            mutter("FTP site chmod: setting permissions to %s on %s",
 
437
                str(mode), self._remote_path(relpath))
 
438
            ftp = self._get_FTP()
 
439
            cmd = "SITE CHMOD %s %s" % (self._remote_path(relpath), str(mode))
 
440
            ftp.sendcmd(cmd)
 
441
        except ftplib.error_perm, e:
 
442
            # Command probably not available on this server
 
443
            warning("FTP Could not set permissions to %s on %s. %s",
 
444
                    str(mode), self._remote_path(relpath), str(e))
492
445
 
493
446
    # TODO: jam 20060516 I believe ftp allows you to tell an ftp server
494
447
    #       to copy something to another machine. And you may be able
505
458
    def _rename(self, abs_from, abs_to, f):
506
459
        try:
507
460
            f.rename(abs_from, abs_to)
508
 
        except (ftplib.error_temp, ftplib.error_perm), e:
509
 
            self._translate_ftp_error(e, abs_from,
 
461
        except ftplib.error_perm, e:
 
462
            self._translate_perm_error(e, abs_from,
510
463
                ': unable to rename to %r' % (abs_to))
511
464
 
512
465
    def move(self, rel_from, rel_to):
518
471
            f = self._get_FTP()
519
472
            self._rename_and_overwrite(abs_from, abs_to, f)
520
473
        except ftplib.error_perm, e:
521
 
            self._translate_ftp_error(e, abs_from,
522
 
                extra='unable to rename to %r' % (rel_to,),
 
474
            self._translate_perm_error(e, abs_from,
 
475
                extra='unable to rename to %r' % (rel_to,), 
523
476
                unknown_exc=errors.PathError)
524
477
 
525
478
    def _rename_and_overwrite(self, abs_from, abs_to, f):
542
495
            mutter("FTP rm: %s", abspath)
543
496
            f.delete(abspath)
544
497
        except ftplib.error_perm, e:
545
 
            self._translate_ftp_error(e, abspath, 'error deleting',
 
498
            self._translate_perm_error(e, abspath, 'error deleting',
546
499
                unknown_exc=errors.NoSuchFile)
547
500
 
548
501
    def external_url(self):
560
513
        mutter("FTP nlst: %s", basepath)
561
514
        f = self._get_FTP()
562
515
        try:
563
 
            try:
564
 
                paths = f.nlst(basepath)
565
 
            except ftplib.error_perm, e:
566
 
                self._translate_ftp_error(e, relpath,
567
 
                                           extra='error with list_dir')
568
 
            except ftplib.error_temp, e:
569
 
                # xs4all's ftp server raises a 450 temp error when listing an
570
 
                # empty directory. Check for that and just return an empty list
571
 
                # in that case. See bug #215522
572
 
                if str(e).lower().startswith('450 no files found'):
573
 
                    mutter('FTP Server returned "%s" for nlst.'
574
 
                           ' Assuming it means empty directory',
575
 
                           str(e))
576
 
                    return []
577
 
                raise
578
 
        finally:
579
 
            # Restore binary mode as nlst switch to ascii mode to retrieve file
580
 
            # list
581
 
            f.voidcmd('TYPE I')
582
 
 
 
516
            paths = f.nlst(basepath)
 
517
        except ftplib.error_perm, e:
 
518
            self._translate_perm_error(e, relpath, extra='error with list_dir')
583
519
        # If FTP.nlst returns paths prefixed by relpath, strip 'em
584
520
        if paths and paths[0].startswith(basepath):
585
521
            entries = [path[len(basepath)+1:] for path in paths]
612
548
            f = self._get_FTP()
613
549
            return FtpStatResult(f, abspath)
614
550
        except ftplib.error_perm, e:
615
 
            self._translate_ftp_error(e, abspath, extra='error w/ stat')
 
551
            self._translate_perm_error(e, abspath, extra='error w/ stat')
616
552
 
617
553
    def lock_read(self, relpath):
618
554
        """Lock the given file for shared (read) access.
638
574
 
639
575
def get_test_permutations():
640
576
    """Return the permutations to be used in testing."""
641
 
    from bzrlib.tests import ftp_server
642
 
    return [(FtpTransport, ftp_server.FTPTestServer)]
 
577
    from bzrlib import tests
 
578
    if tests.FTPServerFeature.available():
 
579
        from bzrlib.tests import ftp_server
 
580
        return [(FtpTransport, ftp_server.FTPServer)]
 
581
    else:
 
582
        # Dummy server to have the test suite report the number of tests
 
583
        # needing that feature. We raise UnavailableFeature from methods before
 
584
        # the test server is being used. Doing so in the setUp method has bad
 
585
        # side-effects (tearDown is never called).
 
586
        class UnavailableFTPServer(object):
 
587
 
 
588
            def setUp(self):
 
589
                pass
 
590
 
 
591
            def tearDown(self):
 
592
                pass
 
593
 
 
594
            def get_url(self):
 
595
                raise tests.UnavailableFeature(tests.FTPServerFeature)
 
596
 
 
597
            def get_bogus_url(self):
 
598
                raise tests.UnavailableFeature(tests.FTPServerFeature)
 
599
 
 
600
        return [(FtpTransport, UnavailableFTPServer)]