/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/transport/ftp.py

  • Committer: Aaron Bentley
  • Date: 2008-04-12 05:48:07 UTC
  • mto: This revision was merged to the branch mainline in revision 3364.
  • Revision ID: aaron@aaronbentley.com-20080412054807-47yd7dgjufa0nf98
rename 'sharing' to 'use-shared'

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,
48
51
    register_urlparse_netloc_protocol,
49
52
    Server,
50
53
    )
 
54
from bzrlib.transport.local import LocalURLServer
 
55
import bzrlib.ui
51
56
 
52
57
 
53
58
register_urlparse_netloc_protocol('aftp')
58
63
 
59
64
 
60
65
class FtpStatResult(object):
61
 
 
62
 
    def __init__(self, f, abspath):
 
66
    def __init__(self, f, relpath):
63
67
        try:
64
 
            self.st_size = f.size(abspath)
 
68
            self.st_size = f.size(relpath)
65
69
            self.st_mode = stat.S_IFREG
66
70
        except ftplib.error_perm:
67
71
            pwd = f.pwd()
68
72
            try:
69
 
                f.cwd(abspath)
 
73
                f.cwd(relpath)
70
74
                self.st_mode = stat.S_IFDIR
71
75
            finally:
72
76
                f.cwd(pwd)
85
89
 
86
90
    def __init__(self, base, _from_transport=None):
87
91
        """Set the base path where files will be stored."""
88
 
        if not (base.startswith('ftp://') or base.startswith('aftp://')):
89
 
            raise ValueError(base)
 
92
        assert base.startswith('ftp://') or base.startswith('aftp://')
90
93
        super(FtpTransport, self).__init__(base,
91
94
                                           _from_transport=_from_transport)
92
95
        self._unqualified_scheme = 'ftp'
95
98
        else:
96
99
            self.is_active = False
97
100
 
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
101
 
 
102
101
    def _get_FTP(self):
103
102
        """Return the ftplib.FTP instance for this object."""
104
103
        # Ensures that a connection is established
109
108
            self._set_connection(connection, credentials)
110
109
        return connection
111
110
 
112
 
    connection_class = ftplib.FTP
113
 
 
114
111
    def _create_connection(self, credentials=None):
115
112
        """Create a new connection with the provided credentials.
116
113
 
118
115
 
119
116
        :return: The created connection and its associated credentials.
120
117
 
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.
 
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.
125
121
        """
126
122
        if credentials is None:
127
123
            user, password = self._user, self._password
130
126
 
131
127
        auth = config.AuthenticationConfig()
132
128
        if user is None:
133
 
            user = auth.get_user('ftp', self._host, port=self._port,
134
 
                                 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
 
135
134
        mutter("Constructing FTP instance against %r" %
136
135
               ((self._host, self._port, user, '********',
137
136
                self.is_active),))
138
137
        try:
139
 
            connection = self.connection_class()
 
138
            connection = ftplib.FTP()
140
139
            connection.connect(host=self._host, port=self._port)
141
 
            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)
142
145
            connection.set_pasv(not self.is_active)
143
 
            # binary mode is the default
144
 
            connection.voidcmd('TYPE I')
145
146
        except socket.error, e:
146
147
            raise errors.SocketConnectionError(self._host, self._port,
147
148
                                               msg='Unable to connect to',
151
152
                                        " %s" % str(e), orig_error=e)
152
153
        return connection, (user, password)
153
154
 
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
155
    def _reconnect(self):
162
156
        """Create a new connection with the previously used credentials"""
163
157
        credentials = self._get_credentials()
164
158
        connection, credentials = self._create_connection(credentials)
165
159
        self._set_connection(connection, credentials)
166
160
 
167
 
    def _translate_ftp_error(self, err, path, extra=None,
 
161
    def _translate_perm_error(self, err, path, extra=None,
168
162
                              unknown_exc=FtpPathError):
169
 
        """Try to translate an ftplib exception to a bzrlib exception.
 
163
        """Try to translate an ftplib.error_perm exception.
170
164
 
171
165
        :param err: The error to translate into a bzr error
172
166
        :param path: The path which had problems
174
168
        :param unknown_exc: If None, we will just raise the original exception
175
169
                    otherwise we raise unknown_exc(path, extra=extra)
176
170
        """
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
171
        s = str(err).lower()
181
172
        if not extra:
182
173
            extra = str(err)
189
180
            or 'file doesn\'t exist' in s
190
181
            or 'rnfr command failed.' in s # vsftpd RNFR reply if file not found
191
182
            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
183
            ):
195
184
            raise errors.NoSuchFile(path, extra=extra)
196
 
        elif ('file exists' in s):
 
185
        if ('file exists' in s):
197
186
            raise errors.FileExists(path, extra=extra)
198
 
        elif ('not a directory' in s):
 
187
        if ('not a directory' in s):
199
188
            raise errors.PathError(path, extra=extra)
200
 
        elif 'directory not empty' in s:
201
 
            raise errors.DirectoryNotEmpty(path, extra=extra)
202
189
 
203
190
        mutter('unable to understand error for path: %s: %s', path, err)
204
191
 
205
192
        if unknown_exc:
206
193
            raise unknown_exc(path, extra=extra)
207
 
        # TODO: jam 20060516 Consider re-raising the error wrapped in
 
194
        # TODO: jam 20060516 Consider re-raising the error wrapped in 
208
195
        #       something like TransportError, but this loses the traceback
209
196
        #       Also, 'sftp' has a generic 'Failure' mode, which we use failure_exc
210
197
        #       to handle. Consider doing something like that here.
211
198
        #raise TransportError(msg='Error for path: %s' % (path,), orig_error=e)
212
199
        raise
213
200
 
 
201
    def _remote_path(self, relpath):
 
202
        # XXX: It seems that ftplib does not handle Unicode paths
 
203
        # at the same time, medusa won't handle utf8 paths So if
 
204
        # we .encode(utf8) here (see ConnectedTransport
 
205
        # implementation), then we get a Server failure.  while
 
206
        # if we use str(), we get a UnicodeError, and the test
 
207
        # suite just skips testing UnicodePaths.
 
208
        relative = str(urlutils.unescape(relpath))
 
209
        remote_path = self._combine_paths(self._path, relative)
 
210
        return remote_path
 
211
 
214
212
    def has(self, relpath):
215
213
        """Does the target location exist?"""
216
214
        # FIXME jam 20060516 We *do* ask about directories in the test suite
309
307
            try:
310
308
                f.storbinary('STOR '+tmp_abspath, fp)
311
309
                self._rename_and_overwrite(tmp_abspath, abspath, f)
312
 
                self._setmode(relpath, mode)
313
310
                if bytes is not None:
314
311
                    return len(bytes)
315
312
                else:
324
321
                    raise e
325
322
                raise
326
323
        except ftplib.error_perm, e:
327
 
            self._translate_ftp_error(e, abspath, extra='could not store',
 
324
            self._translate_perm_error(e, abspath, extra='could not store',
328
325
                                       unknown_exc=errors.NoSuchFile)
329
326
        except ftplib.error_temp, e:
330
327
            if retries > _number_of_retries:
351
348
            mutter("FTP mkd: %s", abspath)
352
349
            f = self._get_FTP()
353
350
            f.mkd(abspath)
354
 
            self._setmode(relpath, mode)
355
351
        except ftplib.error_perm, e:
356
 
            self._translate_ftp_error(e, abspath,
 
352
            self._translate_perm_error(e, abspath,
357
353
                unknown_exc=errors.FileExists)
358
354
 
359
355
    def open_write_stream(self, relpath, mode=None):
379
375
            f = self._get_FTP()
380
376
            f.rmd(abspath)
381
377
        except ftplib.error_perm, e:
382
 
            self._translate_ftp_error(e, abspath, unknown_exc=errors.PathError)
 
378
            self._translate_perm_error(e, abspath, unknown_exc=errors.PathError)
383
379
 
384
380
    def append_file(self, relpath, f, mode=None):
385
381
        """Append the text in the file-like object into the final
386
382
        location.
387
383
        """
388
 
        text = f.read()
389
384
        abspath = self._remote_path(relpath)
390
385
        if self.has(relpath):
391
386
            ftp = self._get_FTP()
393
388
        else:
394
389
            result = 0
395
390
 
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)
 
391
        mutter("FTP appe to %s", abspath)
 
392
        self._try_append(relpath, f.read(), mode)
401
393
 
402
394
        return result
403
395
 
404
396
    def _try_append(self, relpath, text, mode=None, retries=0):
405
397
        """Try repeatedly to append the given text to the file at relpath.
406
 
 
 
398
        
407
399
        This is a recursive function. On errors, it will be called until the
408
400
        number of retries is exceeded.
409
401
        """
411
403
            abspath = self._remote_path(relpath)
412
404
            mutter("FTP appe (try %d) to %s", retries, abspath)
413
405
            ftp = self._get_FTP()
 
406
            ftp.voidcmd("TYPE I")
414
407
            cmd = "APPE %s" % abspath
415
408
            conn = ftp.transfercmd(cmd)
416
409
            conn.sendall(text)
417
410
            conn.close()
418
 
            self._setmode(relpath, mode)
 
411
            if mode:
 
412
                self._setmode(relpath, mode)
419
413
            ftp.getresp()
420
414
        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)
 
415
            self._translate_perm_error(e, abspath, extra='error appending',
 
416
                unknown_exc=errors.NoSuchFile)
430
417
        except ftplib.error_temp, e:
431
418
            if retries > _number_of_retries:
432
 
                raise errors.TransportError(
433
 
                    "FTP temporary error during APPEND %s. Aborting."
434
 
                    % abspath, orig_error=e)
 
419
                raise errors.TransportError("FTP temporary error during APPEND %s." \
 
420
                        "Aborting." % abspath, orig_error=e)
435
421
            else:
436
422
                warning("FTP temporary error: %s. Retrying.", str(e))
437
423
                self._reconnect()
438
424
                self._try_append(relpath, text, mode, retries+1)
439
425
 
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
426
    def _setmode(self, relpath, mode):
448
427
        """Set permissions on a path.
449
428
 
450
429
        Only set permissions if the FTP server supports the 'SITE CHMOD'
451
430
        extension.
452
431
        """
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))
 
432
        try:
 
433
            mutter("FTP site chmod: setting permissions to %s on %s",
 
434
                str(mode), self._remote_path(relpath))
 
435
            ftp = self._get_FTP()
 
436
            cmd = "SITE CHMOD %s %s" % (self._remote_path(relpath), str(mode))
 
437
            ftp.sendcmd(cmd)
 
438
        except ftplib.error_perm, e:
 
439
            # Command probably not available on this server
 
440
            warning("FTP Could not set permissions to %s on %s. %s",
 
441
                    str(mode), self._remote_path(relpath), str(e))
465
442
 
466
443
    # TODO: jam 20060516 I believe ftp allows you to tell an ftp server
467
444
    #       to copy something to another machine. And you may be able
478
455
    def _rename(self, abs_from, abs_to, f):
479
456
        try:
480
457
            f.rename(abs_from, abs_to)
481
 
        except (ftplib.error_temp, ftplib.error_perm), e:
482
 
            self._translate_ftp_error(e, abs_from,
 
458
        except ftplib.error_perm, e:
 
459
            self._translate_perm_error(e, abs_from,
483
460
                ': unable to rename to %r' % (abs_to))
484
461
 
485
462
    def move(self, rel_from, rel_to):
491
468
            f = self._get_FTP()
492
469
            self._rename_and_overwrite(abs_from, abs_to, f)
493
470
        except ftplib.error_perm, e:
494
 
            self._translate_ftp_error(e, abs_from,
495
 
                extra='unable to rename to %r' % (rel_to,),
 
471
            self._translate_perm_error(e, abs_from,
 
472
                extra='unable to rename to %r' % (rel_to,), 
496
473
                unknown_exc=errors.PathError)
497
474
 
498
475
    def _rename_and_overwrite(self, abs_from, abs_to, f):
515
492
            mutter("FTP rm: %s", abspath)
516
493
            f.delete(abspath)
517
494
        except ftplib.error_perm, e:
518
 
            self._translate_ftp_error(e, abspath, 'error deleting',
 
495
            self._translate_perm_error(e, abspath, 'error deleting',
519
496
                unknown_exc=errors.NoSuchFile)
520
497
 
521
498
    def external_url(self):
533
510
        mutter("FTP nlst: %s", basepath)
534
511
        f = self._get_FTP()
535
512
        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
 
 
 
513
            paths = f.nlst(basepath)
 
514
        except ftplib.error_perm, e:
 
515
            self._translate_perm_error(e, relpath, extra='error with list_dir')
556
516
        # If FTP.nlst returns paths prefixed by relpath, strip 'em
557
517
        if paths and paths[0].startswith(basepath):
558
518
            entries = [path[len(basepath)+1:] for path in paths]
585
545
            f = self._get_FTP()
586
546
            return FtpStatResult(f, abspath)
587
547
        except ftplib.error_perm, e:
588
 
            self._translate_ftp_error(e, abspath, extra='error w/ stat')
 
548
            self._translate_perm_error(e, abspath, extra='error w/ stat')
589
549
 
590
550
    def lock_read(self, relpath):
591
551
        """Lock the given file for shared (read) access.
611
571
 
612
572
def get_test_permutations():
613
573
    """Return the permutations to be used in testing."""
614
 
    from bzrlib.tests import ftp_server
615
 
    return [(FtpTransport, ftp_server.FTPTestServer)]
 
574
    from bzrlib import tests
 
575
    if tests.FTPServerFeature.available():
 
576
        from bzrlib.tests import ftp_server
 
577
        return [(FtpTransport, ftp_server.FTPServer)]
 
578
    else:
 
579
        # Dummy server to have the test suite report the number of tests
 
580
        # needing that feature. We raise UnavailableFeature from methods before
 
581
        # the test server is being used. Doing so in the setUp method has bad
 
582
        # side-effects (tearDown is never called).
 
583
        class UnavailableFTPServer(object):
 
584
 
 
585
            def setUp(self):
 
586
                pass
 
587
 
 
588
            def tearDown(self):
 
589
                pass
 
590
 
 
591
            def get_url(self):
 
592
                raise tests.UnavailableFeature(tests.FTPServerFeature)
 
593
 
 
594
            def get_bogus_url(self):
 
595
                raise tests.UnavailableFeature(tests.FTPServerFeature)
 
596
 
 
597
        return [(FtpTransport, UnavailableFTPServer)]