← 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: 2007-09-20 02:40:52 UTC
  • mfrom: (2835.1.1 ianc-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20070920024052-y2l7r5o00zrpnr73
No longer propagate index differences automatically (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/ftp.py
1
 
# Copyright (C) 2005 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
29
29
import errno
30
30
import ftplib
31
31
import os
 
32
import os.path
32
33
import urllib
33
34
import urlparse
 
35
import select
34
36
import stat
35
37
import threading
36
38
import time
37
39
import random
38
40
from warnings import warn
39
41
 
 
42
from bzrlib import (
 
43
    errors,
 
44
    osutils,
 
45
    urlutils,
 
46
    )
 
47
from bzrlib.trace import mutter, warning
40
48
from bzrlib.transport import (
41
 
    Transport,
 
49
    AppendBasedFileStream,
 
50
    _file_streams,
42
51
    Server,
43
 
    split_url,
 
52
    ConnectedTransport,
44
53
    )
45
 
import bzrlib.errors as errors
46
 
from bzrlib.trace import mutter, warning
 
54
from bzrlib.transport.local import LocalURLServer
47
55
import bzrlib.ui
48
56
 
49
57
_have_medusa = False
53
61
    """FTP failed for path: %(path)s%(extra)s"""
54
62
 
55
63
 
56
 
_FTP_cache = {}
57
 
def _find_FTP(hostname, port, username, password, is_active):
58
 
    """Find an ftplib.FTP instance attached to this triplet."""
59
 
    key = (hostname, port, username, password, is_active)
60
 
    alt_key = (hostname, port, username, '********', is_active)
61
 
    if key not in _FTP_cache:
62
 
        mutter("Constructing FTP instance against %r" % (alt_key,))
63
 
        conn = ftplib.FTP()
64
 
 
65
 
        conn.connect(host=hostname, port=port)
66
 
        if username and username != 'anonymous' and not password:
67
 
            password = bzrlib.ui.ui_factory.get_password(
68
 
                prompt='FTP %(user)s@%(host)s password',
69
 
                user=username, host=hostname)
70
 
        conn.login(user=username, passwd=password)
71
 
        conn.set_pasv(not is_active)
72
 
 
73
 
        _FTP_cache[key] = conn
74
 
 
75
 
    return _FTP_cache[key]    
76
 
 
77
 
 
78
64
class FtpStatResult(object):
79
65
    def __init__(self, f, relpath):
80
66
        try:
92
78
_number_of_retries = 2
93
79
_sleep_between_retries = 5
94
80
 
95
 
class FtpTransport(Transport):
 
81
# FIXME: there are inconsistencies in the way temporary errors are
 
82
# handled. Sometimes we reconnect, sometimes we raise an exception. Care should
 
83
# be taken to analyze the implications for write operations (read operations
 
84
# are safe to retry). Overall even some read operations are never
 
85
# retried. --vila 20070720 (Bug #127164)
 
86
class FtpTransport(ConnectedTransport):
96
87
    """This is the transport agent for ftp:// access."""
97
88
 
98
 
    def __init__(self, base, _provided_instance=None):
 
89
    def __init__(self, base, _from_transport=None):
99
90
        """Set the base path where files will be stored."""
100
91
        assert base.startswith('ftp://') or base.startswith('aftp://')
101
 
 
102
 
        self.is_active = base.startswith('aftp://')
103
 
        if self.is_active:
104
 
            # urlparse won't handle aftp://
105
 
            base = base[1:]
106
 
        if not base.endswith('/'):
107
 
            base += '/'
108
 
        (self._proto, self._username,
109
 
            self._password, self._host,
110
 
            self._port, self._path) = split_url(base)
111
 
        base = self._unparse_url()
112
 
 
113
 
        super(FtpTransport, self).__init__(base)
114
 
        self._FTP_instance = _provided_instance
115
 
 
116
 
    def _unparse_url(self, path=None):
117
 
        if path is None:
118
 
            path = self._path
119
 
        path = urllib.quote(path)
120
 
        netloc = urllib.quote(self._host)
121
 
        if self._username is not None:
122
 
            netloc = '%s@%s' % (urllib.quote(self._username), netloc)
123
 
        if self._port is not None:
124
 
            netloc = '%s:%d' % (netloc, self._port)
125
 
        return urlparse.urlunparse(('ftp', netloc, path, '', '', ''))
 
92
        super(FtpTransport, self).__init__(base,
 
93
                                           _from_transport=_from_transport)
 
94
        self._unqualified_scheme = 'ftp'
 
95
        if self._scheme == 'aftp':
 
96
            self.is_active = True
 
97
        else:
 
98
            self.is_active = False
126
99
 
127
100
    def _get_FTP(self):
128
101
        """Return the ftplib.FTP instance for this object."""
129
 
        if self._FTP_instance is not None:
130
 
            return self._FTP_instance
131
 
        
 
102
        # Ensures that a connection is established
 
103
        connection = self._get_connection()
 
104
        if connection is None:
 
105
            # First connection ever
 
106
            connection, credentials = self._create_connection()
 
107
            self._set_connection(connection, credentials)
 
108
        return connection
 
109
 
 
110
    def _create_connection(self, credentials=None):
 
111
        """Create a new connection with the provided credentials.
 
112
 
 
113
        :param credentials: The credentials needed to establish the connection.
 
114
 
 
115
        :return: The created connection and its associated credentials.
 
116
 
 
117
        The credentials are only the password as it may have been entered
 
118
        interactively by the user and may be different from the one provided
 
119
        in base url at transport creation time.
 
120
        """
 
121
        if credentials is None:
 
122
            password = self._password
 
123
        else:
 
124
            password = credentials
 
125
 
 
126
        mutter("Constructing FTP instance against %r" %
 
127
               ((self._host, self._port, self._user, '********',
 
128
                self.is_active),))
132
129
        try:
133
 
            self._FTP_instance = _find_FTP(self._host, self._port,
134
 
                                           self._username, self._password,
135
 
                                           self.is_active)
136
 
            return self._FTP_instance
 
130
            connection = ftplib.FTP()
 
131
            connection.connect(host=self._host, port=self._port)
 
132
            if self._user and self._user != 'anonymous' and \
 
133
                    password is None: # '' is a valid password
 
134
                get_password = bzrlib.ui.ui_factory.get_password
 
135
                password = get_password(prompt='FTP %(user)s@%(host)s password',
 
136
                                        user=self._user, host=self._host)
 
137
            connection.login(user=self._user, passwd=password)
 
138
            connection.set_pasv(not self.is_active)
137
139
        except ftplib.error_perm, e:
138
 
            raise errors.TransportError(msg="Error setting up connection: %s"
139
 
                                    % str(e), orig_error=e)
140
 
 
141
 
    def _translate_perm_error(self, err, path, extra=None, unknown_exc=FtpPathError):
 
140
            raise errors.TransportError(msg="Error setting up connection:"
 
141
                                        " %s" % str(e), orig_error=e)
 
142
        return connection, password
 
143
 
 
144
    def _reconnect(self):
 
145
        """Create a new connection with the previously used credentials"""
 
146
        credentials = self.get_credentials()
 
147
        connection, credentials = self._create_connection(credentials)
 
148
        self._set_connection(connection, credentials)
 
149
 
 
150
    def _translate_perm_error(self, err, path, extra=None,
 
151
                              unknown_exc=FtpPathError):
142
152
        """Try to translate an ftplib.error_perm exception.
143
153
 
144
154
        :param err: The error to translate into a bzr error
155
165
        if ('no such file' in s
156
166
            or 'could not open' in s
157
167
            or 'no such dir' in s
 
168
            or 'could not create file' in s # vsftpd
 
169
            or 'file doesn\'t exist' in s
158
170
            ):
159
171
            raise errors.NoSuchFile(path, extra=extra)
160
172
        if ('file exists' in s):
173
185
        #raise TransportError(msg='Error for path: %s' % (path,), orig_error=e)
174
186
        raise
175
187
 
176
 
    def should_cache(self):
177
 
        """Return True if the data pulled across should be cached locally.
178
 
        """
179
 
        return True
180
 
 
181
 
    def clone(self, offset=None):
182
 
        """Return a new FtpTransport with root at self.base + offset.
183
 
        """
184
 
        mutter("FTP clone")
185
 
        if offset is None:
186
 
            return FtpTransport(self.base, self._FTP_instance)
187
 
        else:
188
 
            return FtpTransport(self.abspath(offset), self._FTP_instance)
189
 
 
190
 
    def _abspath(self, relpath):
191
 
        assert isinstance(relpath, basestring)
192
 
        relpath = urllib.unquote(relpath)
193
 
        relpath_parts = relpath.split('/')
194
 
        if len(relpath_parts) > 1:
195
 
            if relpath_parts[0] == '':
196
 
                raise ValueError("path %r within branch %r seems to be absolute"
197
 
                                 % (relpath, self._path))
198
 
        basepath = self._path.split('/')
199
 
        if len(basepath) > 0 and basepath[-1] == '':
200
 
            basepath = basepath[:-1]
201
 
        for p in relpath_parts:
202
 
            if p == '..':
203
 
                if len(basepath) == 0:
204
 
                    # In most filesystems, a request for the parent
205
 
                    # of root, just returns root.
206
 
                    continue
207
 
                basepath.pop()
208
 
            elif p == '.' or p == '':
209
 
                continue # No-op
210
 
            else:
211
 
                basepath.append(p)
212
 
        # Possibly, we could use urlparse.urljoin() here, but
213
 
        # I'm concerned about when it chooses to strip the last
214
 
        # portion of the path, and when it doesn't.
215
 
        return '/'.join(basepath) or '/'
216
 
    
217
 
    def abspath(self, relpath):
218
 
        """Return the full url to the given relative path.
219
 
        This can be supplied with a string or a list
220
 
        """
221
 
        path = self._abspath(relpath)
222
 
        return self._unparse_url(path)
 
188
    def _remote_path(self, relpath):
 
189
        # XXX: It seems that ftplib does not handle Unicode paths
 
190
        # at the same time, medusa won't handle utf8 paths So if
 
191
        # we .encode(utf8) here (see ConnectedTransport
 
192
        # implementation), then we get a Server failure.  while
 
193
        # if we use str(), we get a UnicodeError, and the test
 
194
        # suite just skips testing UnicodePaths.
 
195
        relative = str(urlutils.unescape(relpath))
 
196
        remote_path = self._combine_paths(self._path, relative)
 
197
        return remote_path
223
198
 
224
199
    def has(self, relpath):
225
200
        """Does the target location exist?"""
228
203
        # XXX: I assume we're never asked has(dirname) and thus I use
229
204
        # the FTP size command and assume that if it doesn't raise,
230
205
        # all is good.
231
 
        abspath = self._abspath(relpath)
 
206
        abspath = self._remote_path(relpath)
232
207
        try:
233
208
            f = self._get_FTP()
234
209
            mutter('FTP has check: %s => %s', relpath, abspath)
254
229
        """
255
230
        # TODO: decode should be deprecated
256
231
        try:
257
 
            mutter("FTP get: %s", self._abspath(relpath))
 
232
            mutter("FTP get: %s", self._remote_path(relpath))
258
233
            f = self._get_FTP()
259
234
            ret = StringIO()
260
 
            f.retrbinary('RETR '+self._abspath(relpath), ret.write, 8192)
 
235
            f.retrbinary('RETR '+self._remote_path(relpath), ret.write, 8192)
261
236
            ret.seek(0)
262
237
            return ret
263
238
        except ftplib.error_perm, e:
269
244
                                     orig_error=e)
270
245
            else:
271
246
                warning("FTP temporary error: %s. Retrying.", str(e))
272
 
                self._FTP_instance = None
 
247
                self._reconnect()
273
248
                return self.get(relpath, decode, retries+1)
274
249
        except EOFError, e:
275
250
            if retries > _number_of_retries:
279
254
            else:
280
255
                warning("FTP control connection closed. Trying to reopen.")
281
256
                time.sleep(_sleep_between_retries)
282
 
                self._FTP_instance = None
 
257
                self._reconnect()
283
258
                return self.get(relpath, decode, retries+1)
284
259
 
285
 
    def put(self, relpath, fp, mode=None, retries=0):
 
260
    def put_file(self, relpath, fp, mode=None, retries=0):
286
261
        """Copy the file-like or string object into the location.
287
262
 
288
263
        :param relpath: Location to put the contents, relative to base.
290
265
        :param retries: Number of retries after temporary failures so far
291
266
                        for this operation.
292
267
 
293
 
        TODO: jam 20051215 ftp as a protocol seems to support chmod, but ftplib does not
 
268
        TODO: jam 20051215 ftp as a protocol seems to support chmod, but
 
269
        ftplib does not
294
270
        """
295
 
        abspath = self._abspath(relpath)
 
271
        abspath = self._remote_path(relpath)
296
272
        tmp_abspath = '%s.tmp.%.9f.%d.%d' % (abspath, time.time(),
297
273
                        os.getpid(), random.randint(0,0x7FFFFFFF))
298
 
        if not hasattr(fp, 'read'):
 
274
        if getattr(fp, 'read', None) is None:
299
275
            fp = StringIO(fp)
300
276
        try:
301
277
            mutter("FTP put: %s", abspath)
302
278
            f = self._get_FTP()
303
279
            try:
304
280
                f.storbinary('STOR '+tmp_abspath, fp)
305
 
                f.rename(tmp_abspath, abspath)
 
281
                self._rename_and_overwrite(tmp_abspath, abspath, f)
306
282
            except (ftplib.error_temp,EOFError), e:
307
283
                warning("Failure during ftp PUT. Deleting temporary file.")
308
284
                try:
313
289
                    raise e
314
290
                raise
315
291
        except ftplib.error_perm, e:
316
 
            self._translate_perm_error(e, abspath, extra='could not store')
 
292
            self._translate_perm_error(e, abspath, extra='could not store',
 
293
                                       unknown_exc=errors.NoSuchFile)
317
294
        except ftplib.error_temp, e:
318
295
            if retries > _number_of_retries:
319
296
                raise errors.TransportError("FTP temporary error during PUT %s. Aborting."
320
297
                                     % self.abspath(relpath), orig_error=e)
321
298
            else:
322
299
                warning("FTP temporary error: %s. Retrying.", str(e))
323
 
                self._FTP_instance = None
324
 
                self.put(relpath, fp, mode, retries+1)
 
300
                self._reconnect()
 
301
                self.put_file(relpath, fp, mode, retries+1)
325
302
        except EOFError:
326
303
            if retries > _number_of_retries:
327
304
                raise errors.TransportError("FTP control connection closed during PUT %s."
329
306
            else:
330
307
                warning("FTP control connection closed. Trying to reopen.")
331
308
                time.sleep(_sleep_between_retries)
332
 
                self._FTP_instance = None
333
 
                self.put(relpath, fp, mode, retries+1)
 
309
                self._reconnect()
 
310
                self.put_file(relpath, fp, mode, retries+1)
334
311
 
335
312
    def mkdir(self, relpath, mode=None):
336
313
        """Create a directory at the given path."""
337
 
        abspath = self._abspath(relpath)
 
314
        abspath = self._remote_path(relpath)
338
315
        try:
339
316
            mutter("FTP mkd: %s", abspath)
340
317
            f = self._get_FTP()
343
320
            self._translate_perm_error(e, abspath,
344
321
                unknown_exc=errors.FileExists)
345
322
 
 
323
    def open_write_stream(self, relpath, mode=None):
 
324
        """See Transport.open_write_stream."""
 
325
        self.put_bytes(relpath, "", mode)
 
326
        result = AppendBasedFileStream(self, relpath)
 
327
        _file_streams[self.abspath(relpath)] = result
 
328
        return result
 
329
 
 
330
    def recommended_page_size(self):
 
331
        """See Transport.recommended_page_size().
 
332
 
 
333
        For FTP we suggest a large page size to reduce the overhead
 
334
        introduced by latency.
 
335
        """
 
336
        return 64 * 1024
 
337
 
346
338
    def rmdir(self, rel_path):
347
339
        """Delete the directory at rel_path"""
348
 
        abspath = self._abspath(rel_path)
 
340
        abspath = self._remote_path(rel_path)
349
341
        try:
350
342
            mutter("FTP rmd: %s", abspath)
351
343
            f = self._get_FTP()
353
345
        except ftplib.error_perm, e:
354
346
            self._translate_perm_error(e, abspath, unknown_exc=errors.PathError)
355
347
 
356
 
    def append(self, relpath, f, mode=None):
 
348
    def append_file(self, relpath, f, mode=None):
357
349
        """Append the text in the file-like object into the final
358
350
        location.
359
351
        """
360
 
        abspath = self._abspath(relpath)
 
352
        abspath = self._remote_path(relpath)
361
353
        if self.has(relpath):
362
354
            ftp = self._get_FTP()
363
355
            result = ftp.size(abspath)
376
368
        number of retries is exceeded.
377
369
        """
378
370
        try:
379
 
            abspath = self._abspath(relpath)
 
371
            abspath = self._remote_path(relpath)
380
372
            mutter("FTP appe (try %d) to %s", retries, abspath)
381
373
            ftp = self._get_FTP()
382
374
            ftp.voidcmd("TYPE I")
396
388
                        "Aborting." % abspath, orig_error=e)
397
389
            else:
398
390
                warning("FTP temporary error: %s. Retrying.", str(e))
399
 
                self._FTP_instance = None
 
391
                self._reconnect()
400
392
                self._try_append(relpath, text, mode, retries+1)
401
393
 
402
394
    def _setmode(self, relpath, mode):
407
399
        """
408
400
        try:
409
401
            mutter("FTP site chmod: setting permissions to %s on %s",
410
 
                str(mode), self._abspath(relpath))
 
402
                str(mode), self._remote_path(relpath))
411
403
            ftp = self._get_FTP()
412
 
            cmd = "SITE CHMOD %s %s" % (self._abspath(relpath), str(mode))
 
404
            cmd = "SITE CHMOD %s %s" % (self._remote_path(relpath), str(mode))
413
405
            ftp.sendcmd(cmd)
414
406
        except ftplib.error_perm, e:
415
407
            # Command probably not available on this server
416
408
            warning("FTP Could not set permissions to %s on %s. %s",
417
 
                    str(mode), self._abspath(relpath), str(e))
 
409
                    str(mode), self._remote_path(relpath), str(e))
418
410
 
419
411
    # TODO: jam 20060516 I believe ftp allows you to tell an ftp server
420
412
    #       to copy something to another machine. And you may be able
421
413
    #       to give it its own address as the 'to' location.
422
414
    #       So implement a fancier 'copy()'
423
415
 
 
416
    def rename(self, rel_from, rel_to):
 
417
        abs_from = self._remote_path(rel_from)
 
418
        abs_to = self._remote_path(rel_to)
 
419
        mutter("FTP rename: %s => %s", abs_from, abs_to)
 
420
        f = self._get_FTP()
 
421
        return self._rename(abs_from, abs_to, f)
 
422
 
 
423
    def _rename(self, abs_from, abs_to, f):
 
424
        try:
 
425
            f.rename(abs_from, abs_to)
 
426
        except ftplib.error_perm, e:
 
427
            self._translate_perm_error(e, abs_from,
 
428
                ': unable to rename to %r' % (abs_to))
 
429
 
424
430
    def move(self, rel_from, rel_to):
425
431
        """Move the item at rel_from to the location at rel_to"""
426
 
        abs_from = self._abspath(rel_from)
427
 
        abs_to = self._abspath(rel_to)
 
432
        abs_from = self._remote_path(rel_from)
 
433
        abs_to = self._remote_path(rel_to)
428
434
        try:
429
435
            mutter("FTP mv: %s => %s", abs_from, abs_to)
430
436
            f = self._get_FTP()
431
 
            f.rename(abs_from, abs_to)
 
437
            self._rename_and_overwrite(abs_from, abs_to, f)
432
438
        except ftplib.error_perm, e:
433
439
            self._translate_perm_error(e, abs_from,
434
440
                extra='unable to rename to %r' % (rel_to,), 
435
441
                unknown_exc=errors.PathError)
436
442
 
437
 
    rename = move
 
443
    def _rename_and_overwrite(self, abs_from, abs_to, f):
 
444
        """Do a fancy rename on the remote server.
 
445
 
 
446
        Using the implementation provided by osutils.
 
447
        """
 
448
        osutils.fancy_rename(abs_from, abs_to,
 
449
            rename_func=lambda p1, p2: self._rename(p1, p2, f),
 
450
            unlink_func=lambda p: self._delete(p, f))
438
451
 
439
452
    def delete(self, relpath):
440
453
        """Delete the item at relpath"""
441
 
        abspath = self._abspath(relpath)
 
454
        abspath = self._remote_path(relpath)
 
455
        f = self._get_FTP()
 
456
        self._delete(abspath, f)
 
457
 
 
458
    def _delete(self, abspath, f):
442
459
        try:
443
460
            mutter("FTP rm: %s", abspath)
444
 
            f = self._get_FTP()
445
461
            f.delete(abspath)
446
462
        except ftplib.error_perm, e:
447
463
            self._translate_perm_error(e, abspath, 'error deleting',
448
464
                unknown_exc=errors.NoSuchFile)
449
465
 
 
466
    def external_url(self):
 
467
        """See bzrlib.transport.Transport.external_url."""
 
468
        # FTP URL's are externally usable.
 
469
        return self.base
 
470
 
450
471
    def listable(self):
451
472
        """See Transport.listable."""
452
473
        return True
453
474
 
454
475
    def list_dir(self, relpath):
455
476
        """See Transport.list_dir."""
 
477
        basepath = self._remote_path(relpath)
 
478
        mutter("FTP nlst: %s", basepath)
 
479
        f = self._get_FTP()
456
480
        try:
457
 
            mutter("FTP nlst: %s", self._abspath(relpath))
458
 
            f = self._get_FTP()
459
 
            basepath = self._abspath(relpath)
460
481
            paths = f.nlst(basepath)
461
 
            # If FTP.nlst returns paths prefixed by relpath, strip 'em
462
 
            if paths and paths[0].startswith(basepath):
463
 
                paths = [path[len(basepath)+1:] for path in paths]
464
 
            # Remove . and .. if present, and return
465
 
            return [path for path in paths if path not in (".", "..")]
466
482
        except ftplib.error_perm, e:
467
483
            self._translate_perm_error(e, relpath, extra='error with list_dir')
 
484
        # If FTP.nlst returns paths prefixed by relpath, strip 'em
 
485
        if paths and paths[0].startswith(basepath):
 
486
            entries = [path[len(basepath)+1:] for path in paths]
 
487
        else:
 
488
            entries = paths
 
489
        # Remove . and .. if present
 
490
        return [urlutils.escape(entry) for entry in entries
 
491
                if entry not in ('.', '..')]
468
492
 
469
493
    def iter_files_recursive(self):
470
494
        """See Transport.iter_files_recursive.
473
497
        mutter("FTP iter_files_recursive")
474
498
        queue = list(self.list_dir("."))
475
499
        while queue:
476
 
            relpath = urllib.quote(queue.pop(0))
 
500
            relpath = queue.pop(0)
477
501
            st = self.stat(relpath)
478
502
            if stat.S_ISDIR(st.st_mode):
479
503
                for i, basename in enumerate(self.list_dir(relpath)):
483
507
 
484
508
    def stat(self, relpath):
485
509
        """Return the stat information for a file."""
486
 
        abspath = self._abspath(relpath)
 
510
        abspath = self._remote_path(relpath)
487
511
        try:
488
512
            mutter("FTP stat: %s", abspath)
489
513
            f = self._get_FTP()
514
538
 
515
539
 
516
540
class FtpServer(Server):
517
 
    """Common code for SFTP server facilities."""
 
541
    """Common code for FTP server facilities."""
518
542
 
519
543
    def __init__(self):
520
544
        self._root = None
536
560
        """This is used by medusa.ftp_server to log connections, etc."""
537
561
        self.logs.append(message)
538
562
 
539
 
    def setUp(self):
540
 
 
 
563
    def setUp(self, vfs_server=None):
541
564
        if not _have_medusa:
542
565
            raise RuntimeError('Must have medusa to run the FtpServer')
543
566
 
 
567
        assert vfs_server is None or isinstance(vfs_server, LocalURLServer), \
 
568
            "FtpServer currently assumes local transport, got %s" % vfs_server
 
569
 
544
570
        self._root = os.getcwdu()
545
571
        self._ftp_server = _ftp_server(
546
572
            authorizer=_test_authorizer(root=self._root),
551
577
            )
552
578
        self._port = self._ftp_server.getsockname()[1]
553
579
        # Don't let it loop forever, or handle an infinite number of requests.
554
 
        # In this case it will run for 100s, or 1000 requests
555
 
        self._async_thread = threading.Thread(target=asyncore.loop,
556
 
                kwargs={'timeout':0.1, 'count':1000})
 
580
        # In this case it will run for 1000s, or 10000 requests
 
581
        self._async_thread = threading.Thread(
 
582
                target=FtpServer._asyncore_loop_ignore_EBADF,
 
583
                kwargs={'timeout':0.1, 'count':10000})
557
584
        self._async_thread.setDaemon(True)
558
585
        self._async_thread.start()
559
586
 
560
587
    def tearDown(self):
561
588
        """See bzrlib.transport.Server.tearDown."""
562
 
        # have asyncore release the channel
563
 
        self._ftp_server.del_channel()
 
589
        self._ftp_server.close()
564
590
        asyncore.close_all()
565
591
        self._async_thread.join()
566
592
 
 
593
    @staticmethod
 
594
    def _asyncore_loop_ignore_EBADF(*args, **kwargs):
 
595
        """Ignore EBADF during server shutdown.
 
596
 
 
597
        We close the socket to get the server to shutdown, but this causes
 
598
        select.select() to raise EBADF.
 
599
        """
 
600
        try:
 
601
            asyncore.loop(*args, **kwargs)
 
602
            # FIXME: If we reach that point, we should raise an exception
 
603
            # explaining that the 'count' parameter in setUp is too low or
 
604
            # testers may wonder why their test just sits there waiting for a
 
605
            # server that is already dead. Note that if the tester waits too
 
606
            # long under pdb the server will also die.
 
607
        except select.error, e:
 
608
            if e.args[0] != errno.EBADF:
 
609
                raise
 
610
 
567
611
 
568
612
_ftp_channel = None
569
613
_ftp_server = None
590
634
 
591
635
        def __init__(self, root):
592
636
            self.root = root
 
637
            # If secured_user is set secured_password will be checked
 
638
            self.secured_user = None
 
639
            self.secured_password = None
593
640
 
594
641
        def authorize(self, channel, username, password):
595
642
            """Return (success, reply_string, filesystem)"""
602
649
            else:
603
650
                channel.read_only = 0
604
651
 
605
 
            return 1, 'OK.', medusa.filesys.os_filesystem(self.root)
 
652
            # Check secured_user if set
 
653
            if (self.secured_user is not None
 
654
                and username == self.secured_user
 
655
                and password != self.secured_password):
 
656
                return 0, 'Password invalid.', None
 
657
            else:
 
658
                return 1, 'OK.', medusa.filesys.os_filesystem(self.root)
606
659
 
607
660
 
608
661
    class ftp_channel(medusa.ftp_server.ftp_channel):
611
664
        def log(self, message):
612
665
            """Redirect logging requests."""
613
666
            mutter('_ftp_channel: %s', message)
614
 
            
 
667
 
615
668
        def log_info(self, message, type='info'):
616
669
            """Redirect logging requests."""
617
670
            mutter('_ftp_channel %s: %s', type, message)
618
 
            
 
671
 
619
672
        def cmd_rnfr(self, line):
620
673
            """Prepare for renaming a file."""
621
674
            self._renaming = line[1]
634
687
            pfrom = self.filesystem.translate(self._renaming)
635
688
            self._renaming = None
636
689
            pto = self.filesystem.translate(line[1])
 
690
            if os.path.exists(pto):
 
691
                self.respond('550 RNTO failed: file exists')
 
692
                return
637
693
            try:
638
694
                os.rename(pfrom, pto)
639
695
            except (IOError, OSError), e:
640
696
                # TODO: jam 20060516 return custom responses based on
641
697
                #       why the command failed
642
 
                self.respond('550 RNTO failed: %s' % (e,))
 
698
                # (bialix 20070418) str(e) on Python 2.5 @ Windows
 
699
                # sometimes don't provide expected error message;
 
700
                # so we obtain such message via os.strerror()
 
701
                self.respond('550 RNTO failed: %s' % os.strerror(e.errno))
643
702
            except:
644
703
                self.respond('550 RNTO failed')
645
704
                # For a test server, we will go ahead and just die
670
729
            *why* it cannot make a directory.
671
730
            """
672
731
            if len (line) != 2:
673
 
                self.command_not_understood (string.join (line))
 
732
                self.command_not_understood(''.join(line))
674
733
            else:
675
734
                path = line[1]
676
735
                try:
677
736
                    self.filesystem.mkdir (path)
678
737
                    self.respond ('257 MKD command successful.')
679
738
                except (IOError, OSError), e:
680
 
                    self.respond ('550 error creating directory: %s' % (e,))
 
739
                    # (bialix 20070418) str(e) on Python 2.5 @ Windows
 
740
                    # sometimes don't provide expected error message;
 
741
                    # so we obtain such message via os.strerror()
 
742
                    self.respond ('550 error creating directory: %s' %
 
743
                                  os.strerror(e.errno))
681
744
                except:
682
745
                    self.respond ('550 error creating directory.')
683
746