← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ftp.py

  • Committer: Ian Clatworthy
  • Date: 2007-08-10 05:17:09 UTC
  • mto: (2733.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 2734.
  • Revision ID: ian.clatworthy@internode.on.net-20070810051709-0rnxlur94samh192
move most existing topics into the User Guide dir for English

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 asyncore
 
29
import errno
29
30
import ftplib
30
 
import getpass
31
31
import os
32
 
import random
33
 
import socket
 
32
import os.path
 
33
import urllib
 
34
import urlparse
 
35
import select
34
36
import stat
 
37
import threading
35
38
import time
 
39
import random
 
40
from warnings import warn
36
41
 
37
42
from bzrlib import (
38
 
    config,
39
43
    errors,
40
44
    osutils,
41
45
    urlutils,
42
46
    )
43
47
from bzrlib.trace import mutter, warning
44
48
from bzrlib.transport import (
45
 
    AppendBasedFileStream,
 
49
    Server,
46
50
    ConnectedTransport,
47
 
    _file_streams,
48
 
    register_urlparse_netloc_protocol,
49
 
    Server,
50
51
    )
51
 
 
52
 
 
53
 
register_urlparse_netloc_protocol('aftp')
 
52
from bzrlib.transport.local import LocalURLServer
 
53
import bzrlib.ui
 
54
 
 
55
_have_medusa = False
54
56
 
55
57
 
56
58
class FtpPathError(errors.PathError):
58
60
 
59
61
 
60
62
class FtpStatResult(object):
61
 
 
62
 
    def __init__(self, f, abspath):
 
63
    def __init__(self, f, relpath):
63
64
        try:
64
 
            self.st_size = f.size(abspath)
 
65
            self.st_size = f.size(relpath)
65
66
            self.st_mode = stat.S_IFREG
66
67
        except ftplib.error_perm:
67
68
            pwd = f.pwd()
68
69
            try:
69
 
                f.cwd(abspath)
 
70
                f.cwd(relpath)
70
71
                self.st_mode = stat.S_IFDIR
71
72
            finally:
72
73
                f.cwd(pwd)
85
86
 
86
87
    def __init__(self, base, _from_transport=None):
87
88
        """Set the base path where files will be stored."""
88
 
        if not (base.startswith('ftp://') or base.startswith('aftp://')):
89
 
            raise ValueError(base)
 
89
        assert base.startswith('ftp://') or base.startswith('aftp://')
90
90
        super(FtpTransport, self).__init__(base,
91
91
                                           _from_transport=_from_transport)
92
92
        self._unqualified_scheme = 'ftp'
95
95
        else:
96
96
            self.is_active = False
97
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
101
 
 
102
98
    def _get_FTP(self):
103
99
        """Return the ftplib.FTP instance for this object."""
104
100
        # Ensures that a connection is established
109
105
            self._set_connection(connection, credentials)
110
106
        return connection
111
107
 
112
 
    connection_class = ftplib.FTP
113
 
 
114
108
    def _create_connection(self, credentials=None):
115
109
        """Create a new connection with the provided credentials.
116
110
 
118
112
 
119
113
        :return: The created connection and its associated credentials.
120
114
 
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.
 
115
        The credentials are only the password as it may have been entered
 
116
        interactively by the user and may be different from the one provided
 
117
        in base url at transport creation time.
125
118
        """
126
119
        if credentials is None:
127
 
            user, password = self._user, self._password
 
120
            password = self._password
128
121
        else:
129
 
            user, password = credentials
 
122
            password = credentials
130
123
 
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
124
        mutter("Constructing FTP instance against %r" %
136
 
               ((self._host, self._port, user, '********',
 
125
               ((self._host, self._port, self._user, '********',
137
126
                self.is_active),))
138
127
        try:
139
 
            connection = self.connection_class()
 
128
            connection = ftplib.FTP()
140
129
            connection.connect(host=self._host, port=self._port)
141
 
            self._login(connection, auth, user, password)
 
130
            if self._user and self._user != 'anonymous' and \
 
131
                    password is not None: # '' is a valid password
 
132
                get_password = bzrlib.ui.ui_factory.get_password
 
133
                password = get_password(prompt='FTP %(user)s@%(host)s password',
 
134
                                        user=self._user, host=self._host)
 
135
            connection.login(user=self._user, passwd=password)
142
136
            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)
149
137
        except ftplib.error_perm, e:
150
138
            raise errors.TransportError(msg="Error setting up connection:"
151
139
                                        " %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)
 
140
        return connection, password
160
141
 
161
142
    def _reconnect(self):
162
143
        """Create a new connection with the previously used credentials"""
163
 
        credentials = self._get_credentials()
 
144
        credentials = self.get_credentials()
164
145
        connection, credentials = self._create_connection(credentials)
165
146
        self._set_connection(connection, credentials)
166
147
 
167
 
    def _translate_ftp_error(self, err, path, extra=None,
 
148
    def _translate_perm_error(self, err, path, extra=None,
168
149
                              unknown_exc=FtpPathError):
169
 
        """Try to translate an ftplib exception to a bzrlib exception.
 
150
        """Try to translate an ftplib.error_perm exception.
170
151
 
171
152
        :param err: The error to translate into a bzr error
172
153
        :param path: The path which had problems
174
155
        :param unknown_exc: If None, we will just raise the original exception
175
156
                    otherwise we raise unknown_exc(path, extra=extra)
176
157
        """
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
158
        s = str(err).lower()
181
159
        if not extra:
182
160
            extra = str(err)
187
165
            or 'no such dir' in s
188
166
            or 'could not create file' in s # vsftpd
189
167
            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
168
            ):
195
169
            raise errors.NoSuchFile(path, extra=extra)
196
 
        elif ('file exists' in s):
 
170
        if ('file exists' in s):
197
171
            raise errors.FileExists(path, extra=extra)
198
 
        elif ('not a directory' in s):
 
172
        if ('not a directory' in s):
199
173
            raise errors.PathError(path, extra=extra)
200
 
        elif 'directory not empty' in s:
201
 
            raise errors.DirectoryNotEmpty(path, extra=extra)
202
174
 
203
175
        mutter('unable to understand error for path: %s: %s', path, err)
204
176
 
205
177
        if unknown_exc:
206
178
            raise unknown_exc(path, extra=extra)
207
 
        # TODO: jam 20060516 Consider re-raising the error wrapped in
 
179
        # TODO: jam 20060516 Consider re-raising the error wrapped in 
208
180
        #       something like TransportError, but this loses the traceback
209
181
        #       Also, 'sftp' has a generic 'Failure' mode, which we use failure_exc
210
182
        #       to handle. Consider doing something like that here.
211
183
        #raise TransportError(msg='Error for path: %s' % (path,), orig_error=e)
212
184
        raise
213
185
 
 
186
    def should_cache(self):
 
187
        """Return True if the data pulled across should be cached locally.
 
188
        """
 
189
        return True
 
190
 
 
191
    def _remote_path(self, relpath):
 
192
        # XXX: It seems that ftplib does not handle Unicode paths
 
193
        # at the same time, medusa won't handle utf8 paths So if
 
194
        # we .encode(utf8) here (see ConnectedTransport
 
195
        # implementation), then we get a Server failure.  while
 
196
        # if we use str(), we get a UnicodeError, and the test
 
197
        # suite just skips testing UnicodePaths.
 
198
        relative = str(urlutils.unescape(relpath))
 
199
        remote_path = self._combine_paths(self._path, relative)
 
200
        return remote_path
 
201
 
214
202
    def has(self, relpath):
215
203
        """Does the target location exist?"""
216
204
        # FIXME jam 20060516 We *do* ask about directories in the test suite
286
274
        abspath = self._remote_path(relpath)
287
275
        tmp_abspath = '%s.tmp.%.9f.%d.%d' % (abspath, time.time(),
288
276
                        os.getpid(), random.randint(0,0x7FFFFFFF))
289
 
        bytes = None
290
277
        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)
 
278
            fp = StringIO(fp)
306
279
        try:
307
280
            mutter("FTP put: %s", abspath)
308
281
            f = self._get_FTP()
309
282
            try:
310
283
                f.storbinary('STOR '+tmp_abspath, fp)
311
284
                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
317
285
            except (ftplib.error_temp,EOFError), e:
318
286
                warning("Failure during ftp PUT. Deleting temporary file.")
319
287
                try:
324
292
                    raise e
325
293
                raise
326
294
        except ftplib.error_perm, e:
327
 
            self._translate_ftp_error(e, abspath, extra='could not store',
 
295
            self._translate_perm_error(e, abspath, extra='could not store',
328
296
                                       unknown_exc=errors.NoSuchFile)
329
297
        except ftplib.error_temp, e:
330
298
            if retries > _number_of_retries:
351
319
            mutter("FTP mkd: %s", abspath)
352
320
            f = self._get_FTP()
353
321
            f.mkd(abspath)
354
 
            self._setmode(relpath, mode)
355
322
        except ftplib.error_perm, e:
356
 
            self._translate_ftp_error(e, abspath,
 
323
            self._translate_perm_error(e, abspath,
357
324
                unknown_exc=errors.FileExists)
358
325
 
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
326
    def rmdir(self, rel_path):
375
327
        """Delete the directory at rel_path"""
376
328
        abspath = self._remote_path(rel_path)
379
331
            f = self._get_FTP()
380
332
            f.rmd(abspath)
381
333
        except ftplib.error_perm, e:
382
 
            self._translate_ftp_error(e, abspath, unknown_exc=errors.PathError)
 
334
            self._translate_perm_error(e, abspath, unknown_exc=errors.PathError)
383
335
 
384
336
    def append_file(self, relpath, f, mode=None):
385
337
        """Append the text in the file-like object into the final
386
338
        location.
387
339
        """
388
 
        text = f.read()
389
340
        abspath = self._remote_path(relpath)
390
341
        if self.has(relpath):
391
342
            ftp = self._get_FTP()
393
344
        else:
394
345
            result = 0
395
346
 
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)
 
347
        mutter("FTP appe to %s", abspath)
 
348
        self._try_append(relpath, f.read(), mode)
401
349
 
402
350
        return result
403
351
 
404
352
    def _try_append(self, relpath, text, mode=None, retries=0):
405
353
        """Try repeatedly to append the given text to the file at relpath.
406
 
 
 
354
        
407
355
        This is a recursive function. On errors, it will be called until the
408
356
        number of retries is exceeded.
409
357
        """
411
359
            abspath = self._remote_path(relpath)
412
360
            mutter("FTP appe (try %d) to %s", retries, abspath)
413
361
            ftp = self._get_FTP()
 
362
            ftp.voidcmd("TYPE I")
414
363
            cmd = "APPE %s" % abspath
415
364
            conn = ftp.transfercmd(cmd)
416
365
            conn.sendall(text)
417
366
            conn.close()
418
 
            self._setmode(relpath, mode)
 
367
            if mode:
 
368
                self._setmode(relpath, mode)
419
369
            ftp.getresp()
420
370
        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)
 
371
            self._translate_perm_error(e, abspath, extra='error appending',
 
372
                unknown_exc=errors.NoSuchFile)
430
373
        except ftplib.error_temp, e:
431
374
            if retries > _number_of_retries:
432
 
                raise errors.TransportError(
433
 
                    "FTP temporary error during APPEND %s. Aborting."
434
 
                    % abspath, orig_error=e)
 
375
                raise errors.TransportError("FTP temporary error during APPEND %s." \
 
376
                        "Aborting." % abspath, orig_error=e)
435
377
            else:
436
378
                warning("FTP temporary error: %s. Retrying.", str(e))
437
379
                self._reconnect()
438
380
                self._try_append(relpath, text, mode, retries+1)
439
381
 
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
382
    def _setmode(self, relpath, mode):
448
383
        """Set permissions on a path.
449
384
 
450
385
        Only set permissions if the FTP server supports the 'SITE CHMOD'
451
386
        extension.
452
387
        """
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))
 
388
        try:
 
389
            mutter("FTP site chmod: setting permissions to %s on %s",
 
390
                str(mode), self._remote_path(relpath))
 
391
            ftp = self._get_FTP()
 
392
            cmd = "SITE CHMOD %s %s" % (self._remote_path(relpath), str(mode))
 
393
            ftp.sendcmd(cmd)
 
394
        except ftplib.error_perm, e:
 
395
            # Command probably not available on this server
 
396
            warning("FTP Could not set permissions to %s on %s. %s",
 
397
                    str(mode), self._remote_path(relpath), str(e))
465
398
 
466
399
    # TODO: jam 20060516 I believe ftp allows you to tell an ftp server
467
400
    #       to copy something to another machine. And you may be able
478
411
    def _rename(self, abs_from, abs_to, f):
479
412
        try:
480
413
            f.rename(abs_from, abs_to)
481
 
        except (ftplib.error_temp, ftplib.error_perm), e:
482
 
            self._translate_ftp_error(e, abs_from,
 
414
        except ftplib.error_perm, e:
 
415
            self._translate_perm_error(e, abs_from,
483
416
                ': unable to rename to %r' % (abs_to))
484
417
 
485
418
    def move(self, rel_from, rel_to):
491
424
            f = self._get_FTP()
492
425
            self._rename_and_overwrite(abs_from, abs_to, f)
493
426
        except ftplib.error_perm, e:
494
 
            self._translate_ftp_error(e, abs_from,
495
 
                extra='unable to rename to %r' % (rel_to,),
 
427
            self._translate_perm_error(e, abs_from,
 
428
                extra='unable to rename to %r' % (rel_to,), 
496
429
                unknown_exc=errors.PathError)
497
430
 
498
431
    def _rename_and_overwrite(self, abs_from, abs_to, f):
515
448
            mutter("FTP rm: %s", abspath)
516
449
            f.delete(abspath)
517
450
        except ftplib.error_perm, e:
518
 
            self._translate_ftp_error(e, abspath, 'error deleting',
 
451
            self._translate_perm_error(e, abspath, 'error deleting',
519
452
                unknown_exc=errors.NoSuchFile)
520
453
 
521
454
    def external_url(self):
533
466
        mutter("FTP nlst: %s", basepath)
534
467
        f = self._get_FTP()
535
468
        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
 
 
 
469
            paths = f.nlst(basepath)
 
470
        except ftplib.error_perm, e:
 
471
            self._translate_perm_error(e, relpath, extra='error with list_dir')
556
472
        # If FTP.nlst returns paths prefixed by relpath, strip 'em
557
473
        if paths and paths[0].startswith(basepath):
558
474
            entries = [path[len(basepath)+1:] for path in paths]
585
501
            f = self._get_FTP()
586
502
            return FtpStatResult(f, abspath)
587
503
        except ftplib.error_perm, e:
588
 
            self._translate_ftp_error(e, abspath, extra='error w/ stat')
 
504
            self._translate_perm_error(e, abspath, extra='error w/ stat')
589
505
 
590
506
    def lock_read(self, relpath):
591
507
        """Lock the given file for shared (read) access.
609
525
        return self.lock_read(relpath)
610
526
 
611
527
 
 
528
class FtpServer(Server):
 
529
    """Common code for FTP server facilities."""
 
530
 
 
531
    def __init__(self):
 
532
        self._root = None
 
533
        self._ftp_server = None
 
534
        self._port = None
 
535
        self._async_thread = None
 
536
        # ftp server logs
 
537
        self.logs = []
 
538
 
 
539
    def get_url(self):
 
540
        """Calculate an ftp url to this server."""
 
541
        return 'ftp://foo:bar@localhost:%d/' % (self._port)
 
542
 
 
543
#    def get_bogus_url(self):
 
544
#        """Return a URL which cannot be connected to."""
 
545
#        return 'ftp://127.0.0.1:1'
 
546
 
 
547
    def log(self, message):
 
548
        """This is used by medusa.ftp_server to log connections, etc."""
 
549
        self.logs.append(message)
 
550
 
 
551
    def setUp(self, vfs_server=None):
 
552
        if not _have_medusa:
 
553
            raise RuntimeError('Must have medusa to run the FtpServer')
 
554
 
 
555
        assert vfs_server is None or isinstance(vfs_server, LocalURLServer), \
 
556
            "FtpServer currently assumes local transport, got %s" % vfs_server
 
557
 
 
558
        self._root = os.getcwdu()
 
559
        self._ftp_server = _ftp_server(
 
560
            authorizer=_test_authorizer(root=self._root),
 
561
            ip='localhost',
 
562
            port=0, # bind to a random port
 
563
            resolver=None,
 
564
            logger_object=self # Use FtpServer.log() for messages
 
565
            )
 
566
        self._port = self._ftp_server.getsockname()[1]
 
567
        # Don't let it loop forever, or handle an infinite number of requests.
 
568
        # In this case it will run for 1000s, or 10000 requests
 
569
        self._async_thread = threading.Thread(
 
570
                target=FtpServer._asyncore_loop_ignore_EBADF,
 
571
                kwargs={'timeout':0.1, 'count':10000})
 
572
        self._async_thread.setDaemon(True)
 
573
        self._async_thread.start()
 
574
 
 
575
    def tearDown(self):
 
576
        """See bzrlib.transport.Server.tearDown."""
 
577
        # have asyncore release the channel
 
578
        self._ftp_server.del_channel()
 
579
        asyncore.close_all()
 
580
        self._async_thread.join()
 
581
 
 
582
    @staticmethod
 
583
    def _asyncore_loop_ignore_EBADF(*args, **kwargs):
 
584
        """Ignore EBADF during server shutdown.
 
585
 
 
586
        We close the socket to get the server to shutdown, but this causes
 
587
        select.select() to raise EBADF.
 
588
        """
 
589
        try:
 
590
            asyncore.loop(*args, **kwargs)
 
591
            # FIXME: If we reach that point, we should raise an exception
 
592
            # explaining that the 'count' parameter in setUp is too low or
 
593
            # testers may wonder why their test just sits there waiting for a
 
594
            # server that is already dead. Note that if the tester waits too
 
595
            # long under pdb the server will also die.
 
596
        except select.error, e:
 
597
            if e.args[0] != errno.EBADF:
 
598
                raise
 
599
 
 
600
 
 
601
_ftp_channel = None
 
602
_ftp_server = None
 
603
_test_authorizer = None
 
604
 
 
605
 
 
606
def _setup_medusa():
 
607
    global _have_medusa, _ftp_channel, _ftp_server, _test_authorizer
 
608
    try:
 
609
        import medusa
 
610
        import medusa.filesys
 
611
        import medusa.ftp_server
 
612
    except ImportError:
 
613
        return False
 
614
 
 
615
    _have_medusa = True
 
616
 
 
617
    class test_authorizer(object):
 
618
        """A custom Authorizer object for running the test suite.
 
619
 
 
620
        The reason we cannot use dummy_authorizer, is because it sets the
 
621
        channel to readonly, which we don't always want to do.
 
622
        """
 
623
 
 
624
        def __init__(self, root):
 
625
            self.root = root
 
626
 
 
627
        def authorize(self, channel, username, password):
 
628
            """Return (success, reply_string, filesystem)"""
 
629
            if not _have_medusa:
 
630
                return 0, 'No Medusa.', None
 
631
 
 
632
            channel.persona = -1, -1
 
633
            if username == 'anonymous':
 
634
                channel.read_only = 1
 
635
            else:
 
636
                channel.read_only = 0
 
637
 
 
638
            return 1, 'OK.', medusa.filesys.os_filesystem(self.root)
 
639
 
 
640
 
 
641
    class ftp_channel(medusa.ftp_server.ftp_channel):
 
642
        """Customized ftp channel"""
 
643
 
 
644
        def log(self, message):
 
645
            """Redirect logging requests."""
 
646
            mutter('_ftp_channel: %s', message)
 
647
 
 
648
        def log_info(self, message, type='info'):
 
649
            """Redirect logging requests."""
 
650
            mutter('_ftp_channel %s: %s', type, message)
 
651
 
 
652
        def cmd_rnfr(self, line):
 
653
            """Prepare for renaming a file."""
 
654
            self._renaming = line[1]
 
655
            self.respond('350 Ready for RNTO')
 
656
            # TODO: jam 20060516 in testing, the ftp server seems to
 
657
            #       check that the file already exists, or it sends
 
658
            #       550 RNFR command failed
 
659
 
 
660
        def cmd_rnto(self, line):
 
661
            """Rename a file based on the target given.
 
662
 
 
663
            rnto must be called after calling rnfr.
 
664
            """
 
665
            if not self._renaming:
 
666
                self.respond('503 RNFR required first.')
 
667
            pfrom = self.filesystem.translate(self._renaming)
 
668
            self._renaming = None
 
669
            pto = self.filesystem.translate(line[1])
 
670
            if os.path.exists(pto):
 
671
                self.respond('550 RNTO failed: file exists')
 
672
                return
 
673
            try:
 
674
                os.rename(pfrom, pto)
 
675
            except (IOError, OSError), e:
 
676
                # TODO: jam 20060516 return custom responses based on
 
677
                #       why the command failed
 
678
                # (bialix 20070418) str(e) on Python 2.5 @ Windows
 
679
                # sometimes don't provide expected error message;
 
680
                # so we obtain such message via os.strerror()
 
681
                self.respond('550 RNTO failed: %s' % os.strerror(e.errno))
 
682
            except:
 
683
                self.respond('550 RNTO failed')
 
684
                # For a test server, we will go ahead and just die
 
685
                raise
 
686
            else:
 
687
                self.respond('250 Rename successful.')
 
688
 
 
689
        def cmd_size(self, line):
 
690
            """Return the size of a file
 
691
 
 
692
            This is overloaded to help the test suite determine if the 
 
693
            target is a directory.
 
694
            """
 
695
            filename = line[1]
 
696
            if not self.filesystem.isfile(filename):
 
697
                if self.filesystem.isdir(filename):
 
698
                    self.respond('550 "%s" is a directory' % (filename,))
 
699
                else:
 
700
                    self.respond('550 "%s" is not a file' % (filename,))
 
701
            else:
 
702
                self.respond('213 %d' 
 
703
                    % (self.filesystem.stat(filename)[stat.ST_SIZE]),)
 
704
 
 
705
        def cmd_mkd(self, line):
 
706
            """Create a directory.
 
707
 
 
708
            Overloaded because default implementation does not distinguish
 
709
            *why* it cannot make a directory.
 
710
            """
 
711
            if len (line) != 2:
 
712
                self.command_not_understood(''.join(line))
 
713
            else:
 
714
                path = line[1]
 
715
                try:
 
716
                    self.filesystem.mkdir (path)
 
717
                    self.respond ('257 MKD command successful.')
 
718
                except (IOError, OSError), e:
 
719
                    # (bialix 20070418) str(e) on Python 2.5 @ Windows
 
720
                    # sometimes don't provide expected error message;
 
721
                    # so we obtain such message via os.strerror()
 
722
                    self.respond ('550 error creating directory: %s' %
 
723
                                  os.strerror(e.errno))
 
724
                except:
 
725
                    self.respond ('550 error creating directory.')
 
726
 
 
727
 
 
728
    class ftp_server(medusa.ftp_server.ftp_server):
 
729
        """Customize the behavior of the Medusa ftp_server.
 
730
 
 
731
        There are a few warts on the ftp_server, based on how it expects
 
732
        to be used.
 
733
        """
 
734
        _renaming = None
 
735
        ftp_channel_class = ftp_channel
 
736
 
 
737
        def __init__(self, *args, **kwargs):
 
738
            mutter('Initializing _ftp_server: %r, %r', args, kwargs)
 
739
            medusa.ftp_server.ftp_server.__init__(self, *args, **kwargs)
 
740
 
 
741
        def log(self, message):
 
742
            """Redirect logging requests."""
 
743
            mutter('_ftp_server: %s', message)
 
744
 
 
745
        def log_info(self, message, type='info'):
 
746
            """Override the asyncore.log_info so we don't stipple the screen."""
 
747
            mutter('_ftp_server %s: %s', type, message)
 
748
 
 
749
    _test_authorizer = test_authorizer
 
750
    _ftp_channel = ftp_channel
 
751
    _ftp_server = ftp_server
 
752
 
 
753
    return True
 
754
 
 
755
 
612
756
def get_test_permutations():
613
757
    """Return the permutations to be used in testing."""
614
 
    from bzrlib.tests import ftp_server
615
 
    return [(FtpTransport, ftp_server.FTPTestServer)]
 
758
    if not _setup_medusa():
 
759
        warn("You must install medusa (http://www.amk.ca/python/code/medusa.html) for FTP tests")
 
760
        return []
 
761
    else:
 
762
        return [(FtpTransport, FtpServer)]