← 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: 2008-03-16 16:58:03 UTC
  • mfrom: (3224.3.1 news-typo)
  • Revision ID: pqm@pqm.ubuntu.com-20080316165803-tisoc9mpob9z544o
(Matt Nordhoff) Trivial NEWS typo fix

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