~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ftp.py

  • Committer: Robert Collins
  • Date: 2007-04-19 02:27:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2426.
  • Revision ID: robertc@robertcollins.net-20070419022744-pfdqz42kp1wizh43
``make docs`` now creates a man page at ``man1/bzr.1`` fixing bug 107388.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
25
25
"""
26
26
 
27
27
from cStringIO import StringIO
 
28
import asyncore
28
29
import errno
29
30
import ftplib
30
 
import getpass
31
31
import os
32
32
import os.path
 
33
import urllib
33
34
import urlparse
34
 
import socket
 
35
import select
35
36
import stat
 
37
import threading
36
38
import time
37
39
import random
38
40
from warnings import warn
39
41
 
40
42
from bzrlib import (
41
 
    config,
42
43
    errors,
43
44
    osutils,
44
45
    urlutils,
45
46
    )
46
47
from bzrlib.trace import mutter, warning
47
48
from bzrlib.transport import (
48
 
    AppendBasedFileStream,
49
 
    ConnectedTransport,
50
 
    _file_streams,
51
 
    register_urlparse_netloc_protocol,
52
49
    Server,
 
50
    split_url,
 
51
    Transport,
53
52
    )
54
53
from bzrlib.transport.local import LocalURLServer
55
54
import bzrlib.ui
56
55
 
57
 
 
58
 
register_urlparse_netloc_protocol('aftp')
 
56
_have_medusa = False
59
57
 
60
58
 
61
59
class FtpPathError(errors.PathError):
62
60
    """FTP failed for path: %(path)s%(extra)s"""
63
61
 
64
62
 
 
63
_FTP_cache = {}
 
64
def _find_FTP(hostname, port, username, password, is_active):
 
65
    """Find an ftplib.FTP instance attached to this triplet."""
 
66
    key = (hostname, port, username, password, is_active)
 
67
    alt_key = (hostname, port, username, '********', is_active)
 
68
    if key not in _FTP_cache:
 
69
        mutter("Constructing FTP instance against %r" % (alt_key,))
 
70
        conn = ftplib.FTP()
 
71
 
 
72
        conn.connect(host=hostname, port=port)
 
73
        if username and username != 'anonymous' and not password:
 
74
            password = bzrlib.ui.ui_factory.get_password(
 
75
                prompt='FTP %(user)s@%(host)s password',
 
76
                user=username, host=hostname)
 
77
        conn.login(user=username, passwd=password)
 
78
        conn.set_pasv(not is_active)
 
79
 
 
80
        _FTP_cache[key] = conn
 
81
 
 
82
    return _FTP_cache[key]    
 
83
 
 
84
 
65
85
class FtpStatResult(object):
66
86
    def __init__(self, f, relpath):
67
87
        try:
79
99
_number_of_retries = 2
80
100
_sleep_between_retries = 5
81
101
 
82
 
# FIXME: there are inconsistencies in the way temporary errors are
83
 
# handled. Sometimes we reconnect, sometimes we raise an exception. Care should
84
 
# be taken to analyze the implications for write operations (read operations
85
 
# are safe to retry). Overall even some read operations are never
86
 
# retried. --vila 20070720 (Bug #127164)
87
 
class FtpTransport(ConnectedTransport):
 
102
class FtpTransport(Transport):
88
103
    """This is the transport agent for ftp:// access."""
89
104
 
90
 
    def __init__(self, base, _from_transport=None):
 
105
    def __init__(self, base, _provided_instance=None):
91
106
        """Set the base path where files will be stored."""
92
 
        if not (base.startswith('ftp://') or base.startswith('aftp://')):
93
 
            raise ValueError(base)
94
 
        super(FtpTransport, self).__init__(base,
95
 
                                           _from_transport=_from_transport)
96
 
        self._unqualified_scheme = 'ftp'
97
 
        if self._scheme == 'aftp':
98
 
            self.is_active = True
99
 
        else:
100
 
            self.is_active = False
 
107
        assert base.startswith('ftp://') or base.startswith('aftp://')
 
108
 
 
109
        self.is_active = base.startswith('aftp://')
 
110
        if self.is_active:
 
111
            # urlparse won't handle aftp://
 
112
            base = base[1:]
 
113
        if not base.endswith('/'):
 
114
            base += '/'
 
115
        (self._proto, self._username,
 
116
            self._password, self._host,
 
117
            self._port, self._path) = split_url(base)
 
118
        base = self._unparse_url()
 
119
 
 
120
        super(FtpTransport, self).__init__(base)
 
121
        self._FTP_instance = _provided_instance
 
122
 
 
123
    def _unparse_url(self, path=None):
 
124
        if path is None:
 
125
            path = self._path
 
126
        path = urllib.quote(path)
 
127
        netloc = urllib.quote(self._host)
 
128
        if self._username is not None:
 
129
            netloc = '%s@%s' % (urllib.quote(self._username), netloc)
 
130
        if self._port is not None:
 
131
            netloc = '%s:%d' % (netloc, self._port)
 
132
        proto = 'ftp'
 
133
        if self.is_active:
 
134
            proto = 'aftp'
 
135
        return urlparse.urlunparse((proto, netloc, path, '', '', ''))
101
136
 
102
137
    def _get_FTP(self):
103
138
        """Return the ftplib.FTP instance for this object."""
104
 
        # Ensures that a connection is established
105
 
        connection = self._get_connection()
106
 
        if connection is None:
107
 
            # First connection ever
108
 
            connection, credentials = self._create_connection()
109
 
            self._set_connection(connection, credentials)
110
 
        return connection
111
 
 
112
 
    def _create_connection(self, credentials=None):
113
 
        """Create a new connection with the provided credentials.
114
 
 
115
 
        :param credentials: The credentials needed to establish the connection.
116
 
 
117
 
        :return: The created connection and its associated credentials.
118
 
 
119
 
        The input credentials are only the password as it may have been
120
 
        entered interactively by the user and may be different from the one
121
 
        provided in base url at transport creation time.  The returned
122
 
        credentials are username, password.
123
 
        """
124
 
        if credentials is None:
125
 
            user, password = self._user, self._password
126
 
        else:
127
 
            user, password = credentials
128
 
 
129
 
        auth = config.AuthenticationConfig()
130
 
        if user is None:
131
 
            user = auth.get_user('ftp', self._host, port=self._port)
132
 
            if user is None:
133
 
                # Default to local user
134
 
                user = getpass.getuser()
135
 
 
136
 
        mutter("Constructing FTP instance against %r" %
137
 
               ((self._host, self._port, user, '********',
138
 
                self.is_active),))
 
139
        if self._FTP_instance is not None:
 
140
            return self._FTP_instance
 
141
        
139
142
        try:
140
 
            connection = ftplib.FTP()
141
 
            connection.connect(host=self._host, port=self._port)
142
 
            if user and user != 'anonymous' and \
143
 
                    password is None: # '' is a valid password
144
 
                password = auth.get_password('ftp', self._host, user,
145
 
                                             port=self._port)
146
 
            connection.login(user=user, passwd=password)
147
 
            connection.set_pasv(not self.is_active)
148
 
        except socket.error, e:
149
 
            raise errors.SocketConnectionError(self._host, self._port,
150
 
                                               msg='Unable to connect to',
151
 
                                               orig_error= e)
 
143
            self._FTP_instance = _find_FTP(self._host, self._port,
 
144
                                           self._username, self._password,
 
145
                                           self.is_active)
 
146
            return self._FTP_instance
152
147
        except ftplib.error_perm, e:
153
 
            raise errors.TransportError(msg="Error setting up connection:"
154
 
                                        " %s" % str(e), orig_error=e)
155
 
        return connection, (user, password)
156
 
 
157
 
    def _reconnect(self):
158
 
        """Create a new connection with the previously used credentials"""
159
 
        credentials = self._get_credentials()
160
 
        connection, credentials = self._create_connection(credentials)
161
 
        self._set_connection(connection, credentials)
162
 
 
163
 
    def _translate_perm_error(self, err, path, extra=None,
164
 
                              unknown_exc=FtpPathError):
 
148
            raise errors.TransportError(msg="Error setting up connection: %s"
 
149
                                    % str(e), orig_error=e)
 
150
 
 
151
    def _translate_perm_error(self, err, path, extra=None, unknown_exc=FtpPathError):
165
152
        """Try to translate an ftplib.error_perm exception.
166
153
 
167
154
        :param err: The error to translate into a bzr error
179
166
            or 'could not open' in s
180
167
            or 'no such dir' in s
181
168
            or 'could not create file' in s # vsftpd
182
 
            or 'file doesn\'t exist' in s
183
 
            or 'rnfr command failed.' in s # vsftpd RNFR reply if file not found
184
 
            or 'file/directory not found' in s # filezilla server
185
 
            # Microsoft FTP-Service RNFR reply if file not found
186
 
            or (s.startswith('550 ') and 'unable to rename to' in extra)
187
169
            ):
188
170
            raise errors.NoSuchFile(path, extra=extra)
189
171
        if ('file exists' in s):
202
184
        #raise TransportError(msg='Error for path: %s' % (path,), orig_error=e)
203
185
        raise
204
186
 
205
 
    def _remote_path(self, relpath):
 
187
    def should_cache(self):
 
188
        """Return True if the data pulled across should be cached locally.
 
189
        """
 
190
        return True
 
191
 
 
192
    def clone(self, offset=None):
 
193
        """Return a new FtpTransport with root at self.base + offset.
 
194
        """
 
195
        mutter("FTP clone")
 
196
        if offset is None:
 
197
            return FtpTransport(self.base, self._FTP_instance)
 
198
        else:
 
199
            return FtpTransport(self.abspath(offset), self._FTP_instance)
 
200
 
 
201
    def _abspath(self, relpath):
 
202
        assert isinstance(relpath, basestring)
 
203
        relpath = urlutils.unescape(relpath)
 
204
        if relpath.startswith('/'):
 
205
            basepath = []
 
206
        else:
 
207
            basepath = self._path.split('/')
 
208
        if len(basepath) > 0 and basepath[-1] == '':
 
209
            basepath = basepath[:-1]
 
210
        for p in relpath.split('/'):
 
211
            if p == '..':
 
212
                if len(basepath) == 0:
 
213
                    # In most filesystems, a request for the parent
 
214
                    # of root, just returns root.
 
215
                    continue
 
216
                basepath.pop()
 
217
            elif p == '.' or p == '':
 
218
                continue # No-op
 
219
            else:
 
220
                basepath.append(p)
 
221
        # Possibly, we could use urlparse.urljoin() here, but
 
222
        # I'm concerned about when it chooses to strip the last
 
223
        # portion of the path, and when it doesn't.
 
224
 
206
225
        # XXX: It seems that ftplib does not handle Unicode paths
207
 
        # at the same time, medusa won't handle utf8 paths So if
208
 
        # we .encode(utf8) here (see ConnectedTransport
209
 
        # implementation), then we get a Server failure.  while
210
 
        # if we use str(), we get a UnicodeError, and the test
211
 
        # suite just skips testing UnicodePaths.
212
 
        relative = str(urlutils.unescape(relpath))
213
 
        remote_path = self._combine_paths(self._path, relative)
214
 
        return remote_path
 
226
        # at the same time, medusa won't handle utf8 paths
 
227
        # So if we .encode(utf8) here, then we get a Server failure.
 
228
        # while if we use str(), we get a UnicodeError, and the test suite
 
229
        # just skips testing UnicodePaths.
 
230
        return str('/'.join(basepath) or '/')
 
231
    
 
232
    def abspath(self, relpath):
 
233
        """Return the full url to the given relative path.
 
234
        This can be supplied with a string or a list
 
235
        """
 
236
        path = self._abspath(relpath)
 
237
        return self._unparse_url(path)
215
238
 
216
239
    def has(self, relpath):
217
240
        """Does the target location exist?"""
220
243
        # XXX: I assume we're never asked has(dirname) and thus I use
221
244
        # the FTP size command and assume that if it doesn't raise,
222
245
        # all is good.
223
 
        abspath = self._remote_path(relpath)
 
246
        abspath = self._abspath(relpath)
224
247
        try:
225
248
            f = self._get_FTP()
226
249
            mutter('FTP has check: %s => %s', relpath, abspath)
246
269
        """
247
270
        # TODO: decode should be deprecated
248
271
        try:
249
 
            mutter("FTP get: %s", self._remote_path(relpath))
 
272
            mutter("FTP get: %s", self._abspath(relpath))
250
273
            f = self._get_FTP()
251
274
            ret = StringIO()
252
 
            f.retrbinary('RETR '+self._remote_path(relpath), ret.write, 8192)
 
275
            f.retrbinary('RETR '+self._abspath(relpath), ret.write, 8192)
253
276
            ret.seek(0)
254
277
            return ret
255
278
        except ftplib.error_perm, e:
261
284
                                     orig_error=e)
262
285
            else:
263
286
                warning("FTP temporary error: %s. Retrying.", str(e))
264
 
                self._reconnect()
 
287
                self._FTP_instance = None
265
288
                return self.get(relpath, decode, retries+1)
266
289
        except EOFError, e:
267
290
            if retries > _number_of_retries:
271
294
            else:
272
295
                warning("FTP control connection closed. Trying to reopen.")
273
296
                time.sleep(_sleep_between_retries)
274
 
                self._reconnect()
 
297
                self._FTP_instance = None
275
298
                return self.get(relpath, decode, retries+1)
276
299
 
277
300
    def put_file(self, relpath, fp, mode=None, retries=0):
285
308
        TODO: jam 20051215 ftp as a protocol seems to support chmod, but
286
309
        ftplib does not
287
310
        """
288
 
        abspath = self._remote_path(relpath)
 
311
        abspath = self._abspath(relpath)
289
312
        tmp_abspath = '%s.tmp.%.9f.%d.%d' % (abspath, time.time(),
290
313
                        os.getpid(), random.randint(0,0x7FFFFFFF))
291
 
        bytes = None
292
314
        if getattr(fp, 'read', None) is None:
293
 
            # hand in a string IO
294
 
            bytes = fp
295
 
            fp = StringIO(bytes)
296
 
        else:
297
 
            # capture the byte count; .read() may be read only so
298
 
            # decorate it.
299
 
            class byte_counter(object):
300
 
                def __init__(self, fp):
301
 
                    self.fp = fp
302
 
                    self.counted_bytes = 0
303
 
                def read(self, count):
304
 
                    result = self.fp.read(count)
305
 
                    self.counted_bytes += len(result)
306
 
                    return result
307
 
            fp = byte_counter(fp)
 
315
            fp = StringIO(fp)
308
316
        try:
309
317
            mutter("FTP put: %s", abspath)
310
318
            f = self._get_FTP()
311
319
            try:
312
320
                f.storbinary('STOR '+tmp_abspath, fp)
313
321
                self._rename_and_overwrite(tmp_abspath, abspath, f)
314
 
                self._setmode(relpath, mode)
315
 
                if bytes is not None:
316
 
                    return len(bytes)
317
 
                else:
318
 
                    return fp.counted_bytes
319
322
            except (ftplib.error_temp,EOFError), e:
320
323
                warning("Failure during ftp PUT. Deleting temporary file.")
321
324
                try:
326
329
                    raise e
327
330
                raise
328
331
        except ftplib.error_perm, e:
329
 
            self._translate_perm_error(e, abspath, extra='could not store',
330
 
                                       unknown_exc=errors.NoSuchFile)
 
332
            self._translate_perm_error(e, abspath, extra='could not store')
331
333
        except ftplib.error_temp, e:
332
334
            if retries > _number_of_retries:
333
335
                raise errors.TransportError("FTP temporary error during PUT %s. Aborting."
334
336
                                     % self.abspath(relpath), orig_error=e)
335
337
            else:
336
338
                warning("FTP temporary error: %s. Retrying.", str(e))
337
 
                self._reconnect()
 
339
                self._FTP_instance = None
338
340
                self.put_file(relpath, fp, mode, retries+1)
339
341
        except EOFError:
340
342
            if retries > _number_of_retries:
343
345
            else:
344
346
                warning("FTP control connection closed. Trying to reopen.")
345
347
                time.sleep(_sleep_between_retries)
346
 
                self._reconnect()
 
348
                self._FTP_instance = None
347
349
                self.put_file(relpath, fp, mode, retries+1)
348
350
 
349
351
    def mkdir(self, relpath, mode=None):
350
352
        """Create a directory at the given path."""
351
 
        abspath = self._remote_path(relpath)
 
353
        abspath = self._abspath(relpath)
352
354
        try:
353
355
            mutter("FTP mkd: %s", abspath)
354
356
            f = self._get_FTP()
355
357
            f.mkd(abspath)
356
 
            self._setmode(relpath, mode)
357
358
        except ftplib.error_perm, e:
358
359
            self._translate_perm_error(e, abspath,
359
360
                unknown_exc=errors.FileExists)
360
361
 
361
 
    def open_write_stream(self, relpath, mode=None):
362
 
        """See Transport.open_write_stream."""
363
 
        self.put_bytes(relpath, "", mode)
364
 
        result = AppendBasedFileStream(self, relpath)
365
 
        _file_streams[self.abspath(relpath)] = result
366
 
        return result
367
 
 
368
 
    def recommended_page_size(self):
369
 
        """See Transport.recommended_page_size().
370
 
 
371
 
        For FTP we suggest a large page size to reduce the overhead
372
 
        introduced by latency.
373
 
        """
374
 
        return 64 * 1024
375
 
 
376
362
    def rmdir(self, rel_path):
377
363
        """Delete the directory at rel_path"""
378
 
        abspath = self._remote_path(rel_path)
 
364
        abspath = self._abspath(rel_path)
379
365
        try:
380
366
            mutter("FTP rmd: %s", abspath)
381
367
            f = self._get_FTP()
387
373
        """Append the text in the file-like object into the final
388
374
        location.
389
375
        """
390
 
        abspath = self._remote_path(relpath)
 
376
        abspath = self._abspath(relpath)
391
377
        if self.has(relpath):
392
378
            ftp = self._get_FTP()
393
379
            result = ftp.size(abspath)
406
392
        number of retries is exceeded.
407
393
        """
408
394
        try:
409
 
            abspath = self._remote_path(relpath)
 
395
            abspath = self._abspath(relpath)
410
396
            mutter("FTP appe (try %d) to %s", retries, abspath)
411
397
            ftp = self._get_FTP()
412
398
            ftp.voidcmd("TYPE I")
414
400
            conn = ftp.transfercmd(cmd)
415
401
            conn.sendall(text)
416
402
            conn.close()
417
 
            self._setmode(relpath, mode)
 
403
            if mode:
 
404
                self._setmode(relpath, mode)
418
405
            ftp.getresp()
419
406
        except ftplib.error_perm, e:
420
407
            self._translate_perm_error(e, abspath, extra='error appending',
425
412
                        "Aborting." % abspath, orig_error=e)
426
413
            else:
427
414
                warning("FTP temporary error: %s. Retrying.", str(e))
428
 
                self._reconnect()
 
415
                self._FTP_instance = None
429
416
                self._try_append(relpath, text, mode, retries+1)
430
417
 
431
418
    def _setmode(self, relpath, mode):
434
421
        Only set permissions if the FTP server supports the 'SITE CHMOD'
435
422
        extension.
436
423
        """
437
 
        if mode:
438
 
            try:
439
 
                mutter("FTP site chmod: setting permissions to %s on %s",
440
 
                    str(mode), self._remote_path(relpath))
441
 
                ftp = self._get_FTP()
442
 
                cmd = "SITE CHMOD %s %s" % (oct(mode),
443
 
                                            self._remote_path(relpath))
444
 
                ftp.sendcmd(cmd)
445
 
            except ftplib.error_perm, e:
446
 
                # Command probably not available on this server
447
 
                warning("FTP Could not set permissions to %s on %s. %s",
448
 
                        str(mode), self._remote_path(relpath), str(e))
 
424
        try:
 
425
            mutter("FTP site chmod: setting permissions to %s on %s",
 
426
                str(mode), self._abspath(relpath))
 
427
            ftp = self._get_FTP()
 
428
            cmd = "SITE CHMOD %s %s" % (self._abspath(relpath), str(mode))
 
429
            ftp.sendcmd(cmd)
 
430
        except ftplib.error_perm, e:
 
431
            # Command probably not available on this server
 
432
            warning("FTP Could not set permissions to %s on %s. %s",
 
433
                    str(mode), self._abspath(relpath), str(e))
449
434
 
450
435
    # TODO: jam 20060516 I believe ftp allows you to tell an ftp server
451
436
    #       to copy something to another machine. And you may be able
453
438
    #       So implement a fancier 'copy()'
454
439
 
455
440
    def rename(self, rel_from, rel_to):
456
 
        abs_from = self._remote_path(rel_from)
457
 
        abs_to = self._remote_path(rel_to)
 
441
        abs_from = self._abspath(rel_from)
 
442
        abs_to = self._abspath(rel_to)
458
443
        mutter("FTP rename: %s => %s", abs_from, abs_to)
459
444
        f = self._get_FTP()
460
445
        return self._rename(abs_from, abs_to, f)
468
453
 
469
454
    def move(self, rel_from, rel_to):
470
455
        """Move the item at rel_from to the location at rel_to"""
471
 
        abs_from = self._remote_path(rel_from)
472
 
        abs_to = self._remote_path(rel_to)
 
456
        abs_from = self._abspath(rel_from)
 
457
        abs_to = self._abspath(rel_to)
473
458
        try:
474
459
            mutter("FTP mv: %s => %s", abs_from, abs_to)
475
460
            f = self._get_FTP()
490
475
 
491
476
    def delete(self, relpath):
492
477
        """Delete the item at relpath"""
493
 
        abspath = self._remote_path(relpath)
 
478
        abspath = self._abspath(relpath)
494
479
        f = self._get_FTP()
495
480
        self._delete(abspath, f)
496
481
 
502
487
            self._translate_perm_error(e, abspath, 'error deleting',
503
488
                unknown_exc=errors.NoSuchFile)
504
489
 
505
 
    def external_url(self):
506
 
        """See bzrlib.transport.Transport.external_url."""
507
 
        # FTP URL's are externally usable.
508
 
        return self.base
509
 
 
510
490
    def listable(self):
511
491
        """See Transport.listable."""
512
492
        return True
513
493
 
514
494
    def list_dir(self, relpath):
515
495
        """See Transport.list_dir."""
516
 
        basepath = self._remote_path(relpath)
 
496
        basepath = self._abspath(relpath)
517
497
        mutter("FTP nlst: %s", basepath)
518
498
        f = self._get_FTP()
519
499
        try:
520
500
            paths = f.nlst(basepath)
521
501
        except ftplib.error_perm, e:
522
502
            self._translate_perm_error(e, relpath, extra='error with list_dir')
523
 
        except ftplib.error_temp, e:
524
 
            # xs4all's ftp server raises a 450 temp error when listing an empty
525
 
            # directory. Check for that and just return an empty list in that
526
 
            # case. See bug #215522
527
 
            if str(e).lower().startswith('450 no files found'):
528
 
                mutter('FTP Server returned "%s" for nlst.'
529
 
                       ' Assuming it means empty directory',
530
 
                       str(e))
531
 
                return []
532
 
            raise
533
503
        # If FTP.nlst returns paths prefixed by relpath, strip 'em
534
504
        if paths and paths[0].startswith(basepath):
535
505
            entries = [path[len(basepath)+1:] for path in paths]
556
526
 
557
527
    def stat(self, relpath):
558
528
        """Return the stat information for a file."""
559
 
        abspath = self._remote_path(relpath)
 
529
        abspath = self._abspath(relpath)
560
530
        try:
561
531
            mutter("FTP stat: %s", abspath)
562
532
            f = self._get_FTP()
586
556
        return self.lock_read(relpath)
587
557
 
588
558
 
 
559
class FtpServer(Server):
 
560
    """Common code for SFTP server facilities."""
 
561
 
 
562
    def __init__(self):
 
563
        self._root = None
 
564
        self._ftp_server = None
 
565
        self._port = None
 
566
        self._async_thread = None
 
567
        # ftp server logs
 
568
        self.logs = []
 
569
 
 
570
    def get_url(self):
 
571
        """Calculate an ftp url to this server."""
 
572
        return 'ftp://foo:bar@localhost:%d/' % (self._port)
 
573
 
 
574
#    def get_bogus_url(self):
 
575
#        """Return a URL which cannot be connected to."""
 
576
#        return 'ftp://127.0.0.1:1'
 
577
 
 
578
    def log(self, message):
 
579
        """This is used by medusa.ftp_server to log connections, etc."""
 
580
        self.logs.append(message)
 
581
 
 
582
    def setUp(self, vfs_server=None):
 
583
        if not _have_medusa:
 
584
            raise RuntimeError('Must have medusa to run the FtpServer')
 
585
 
 
586
        assert vfs_server is None or isinstance(vfs_server, LocalURLServer), \
 
587
            "FtpServer currently assumes local transport, got %s" % vfs_server
 
588
 
 
589
        self._root = os.getcwdu()
 
590
        self._ftp_server = _ftp_server(
 
591
            authorizer=_test_authorizer(root=self._root),
 
592
            ip='localhost',
 
593
            port=0, # bind to a random port
 
594
            resolver=None,
 
595
            logger_object=self # Use FtpServer.log() for messages
 
596
            )
 
597
        self._port = self._ftp_server.getsockname()[1]
 
598
        # Don't let it loop forever, or handle an infinite number of requests.
 
599
        # In this case it will run for 100s, or 1000 requests
 
600
        self._async_thread = threading.Thread(
 
601
                target=FtpServer._asyncore_loop_ignore_EBADF,
 
602
                kwargs={'timeout':0.1, 'count':1000})
 
603
        self._async_thread.setDaemon(True)
 
604
        self._async_thread.start()
 
605
 
 
606
    def tearDown(self):
 
607
        """See bzrlib.transport.Server.tearDown."""
 
608
        # have asyncore release the channel
 
609
        self._ftp_server.del_channel()
 
610
        asyncore.close_all()
 
611
        self._async_thread.join()
 
612
 
 
613
    @staticmethod
 
614
    def _asyncore_loop_ignore_EBADF(*args, **kwargs):
 
615
        """Ignore EBADF during server shutdown.
 
616
 
 
617
        We close the socket to get the server to shutdown, but this causes
 
618
        select.select() to raise EBADF.
 
619
        """
 
620
        try:
 
621
            asyncore.loop(*args, **kwargs)
 
622
        except select.error, e:
 
623
            if e.args[0] != errno.EBADF:
 
624
                raise
 
625
 
 
626
 
 
627
_ftp_channel = None
 
628
_ftp_server = None
 
629
_test_authorizer = None
 
630
 
 
631
 
 
632
def _setup_medusa():
 
633
    global _have_medusa, _ftp_channel, _ftp_server, _test_authorizer
 
634
    try:
 
635
        import medusa
 
636
        import medusa.filesys
 
637
        import medusa.ftp_server
 
638
    except ImportError:
 
639
        return False
 
640
 
 
641
    _have_medusa = True
 
642
 
 
643
    class test_authorizer(object):
 
644
        """A custom Authorizer object for running the test suite.
 
645
 
 
646
        The reason we cannot use dummy_authorizer, is because it sets the
 
647
        channel to readonly, which we don't always want to do.
 
648
        """
 
649
 
 
650
        def __init__(self, root):
 
651
            self.root = root
 
652
 
 
653
        def authorize(self, channel, username, password):
 
654
            """Return (success, reply_string, filesystem)"""
 
655
            if not _have_medusa:
 
656
                return 0, 'No Medusa.', None
 
657
 
 
658
            channel.persona = -1, -1
 
659
            if username == 'anonymous':
 
660
                channel.read_only = 1
 
661
            else:
 
662
                channel.read_only = 0
 
663
 
 
664
            return 1, 'OK.', medusa.filesys.os_filesystem(self.root)
 
665
 
 
666
 
 
667
    class ftp_channel(medusa.ftp_server.ftp_channel):
 
668
        """Customized ftp channel"""
 
669
 
 
670
        def log(self, message):
 
671
            """Redirect logging requests."""
 
672
            mutter('_ftp_channel: %s', message)
 
673
            
 
674
        def log_info(self, message, type='info'):
 
675
            """Redirect logging requests."""
 
676
            mutter('_ftp_channel %s: %s', type, message)
 
677
            
 
678
        def cmd_rnfr(self, line):
 
679
            """Prepare for renaming a file."""
 
680
            self._renaming = line[1]
 
681
            self.respond('350 Ready for RNTO')
 
682
            # TODO: jam 20060516 in testing, the ftp server seems to
 
683
            #       check that the file already exists, or it sends
 
684
            #       550 RNFR command failed
 
685
 
 
686
        def cmd_rnto(self, line):
 
687
            """Rename a file based on the target given.
 
688
 
 
689
            rnto must be called after calling rnfr.
 
690
            """
 
691
            if not self._renaming:
 
692
                self.respond('503 RNFR required first.')
 
693
            pfrom = self.filesystem.translate(self._renaming)
 
694
            self._renaming = None
 
695
            pto = self.filesystem.translate(line[1])
 
696
            if os.path.exists(pto):
 
697
                self.respond('550 RNTO failed: file exists')
 
698
                return
 
699
            try:
 
700
                os.rename(pfrom, pto)
 
701
            except (IOError, OSError), e:
 
702
                # TODO: jam 20060516 return custom responses based on
 
703
                #       why the command failed
 
704
                self.respond('550 RNTO failed: %s' % (e,))
 
705
            except:
 
706
                self.respond('550 RNTO failed')
 
707
                # For a test server, we will go ahead and just die
 
708
                raise
 
709
            else:
 
710
                self.respond('250 Rename successful.')
 
711
 
 
712
        def cmd_size(self, line):
 
713
            """Return the size of a file
 
714
 
 
715
            This is overloaded to help the test suite determine if the 
 
716
            target is a directory.
 
717
            """
 
718
            filename = line[1]
 
719
            if not self.filesystem.isfile(filename):
 
720
                if self.filesystem.isdir(filename):
 
721
                    self.respond('550 "%s" is a directory' % (filename,))
 
722
                else:
 
723
                    self.respond('550 "%s" is not a file' % (filename,))
 
724
            else:
 
725
                self.respond('213 %d' 
 
726
                    % (self.filesystem.stat(filename)[stat.ST_SIZE]),)
 
727
 
 
728
        def cmd_mkd(self, line):
 
729
            """Create a directory.
 
730
 
 
731
            Overloaded because default implementation does not distinguish
 
732
            *why* it cannot make a directory.
 
733
            """
 
734
            if len (line) != 2:
 
735
                self.command_not_understood(''.join(line))
 
736
            else:
 
737
                path = line[1]
 
738
                try:
 
739
                    self.filesystem.mkdir (path)
 
740
                    self.respond ('257 MKD command successful.')
 
741
                except (IOError, OSError), e:
 
742
                    self.respond ('550 error creating directory: %s' % (e,))
 
743
                except:
 
744
                    self.respond ('550 error creating directory.')
 
745
 
 
746
 
 
747
    class ftp_server(medusa.ftp_server.ftp_server):
 
748
        """Customize the behavior of the Medusa ftp_server.
 
749
 
 
750
        There are a few warts on the ftp_server, based on how it expects
 
751
        to be used.
 
752
        """
 
753
        _renaming = None
 
754
        ftp_channel_class = ftp_channel
 
755
 
 
756
        def __init__(self, *args, **kwargs):
 
757
            mutter('Initializing _ftp_server: %r, %r', args, kwargs)
 
758
            medusa.ftp_server.ftp_server.__init__(self, *args, **kwargs)
 
759
 
 
760
        def log(self, message):
 
761
            """Redirect logging requests."""
 
762
            mutter('_ftp_server: %s', message)
 
763
 
 
764
        def log_info(self, message, type='info'):
 
765
            """Override the asyncore.log_info so we don't stipple the screen."""
 
766
            mutter('_ftp_server %s: %s', type, message)
 
767
 
 
768
    _test_authorizer = test_authorizer
 
769
    _ftp_channel = ftp_channel
 
770
    _ftp_server = ftp_server
 
771
 
 
772
    return True
 
773
 
 
774
 
589
775
def get_test_permutations():
590
776
    """Return the permutations to be used in testing."""
591
 
    from bzrlib import tests
592
 
    if tests.FTPServerFeature.available():
593
 
        from bzrlib.tests import ftp_server
594
 
        return [(FtpTransport, ftp_server.FTPServer)]
 
777
    if not _setup_medusa():
 
778
        warn("You must install medusa (http://www.amk.ca/python/code/medusa.html) for FTP tests")
 
779
        return []
595
780
    else:
596
 
        # Dummy server to have the test suite report the number of tests
597
 
        # needing that feature. We raise UnavailableFeature from methods before
598
 
        # the test server is being used. Doing so in the setUp method has bad
599
 
        # side-effects (tearDown is never called).
600
 
        class UnavailableFTPServer(object):
601
 
 
602
 
            def setUp(self):
603
 
                pass
604
 
 
605
 
            def tearDown(self):
606
 
                pass
607
 
 
608
 
            def get_url(self):
609
 
                raise tests.UnavailableFeature(tests.FTPServerFeature)
610
 
 
611
 
            def get_bogus_url(self):
612
 
                raise tests.UnavailableFeature(tests.FTPServerFeature)
613
 
 
614
 
        return [(FtpTransport, UnavailableFTPServer)]
 
781
        return [(FtpTransport, FtpServer)]