← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ftp.py

Don't encode unicode messages to UTF-8 in mutter() (the stream writer does it).

Use a codec wrapped log file in tests to match the real environment.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/ftp.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005 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
24
24
active, in which case aftp:// will be your friend.
25
25
"""
26
26
 
 
27
from bzrlib.transport import Transport
 
28
 
 
29
from bzrlib.errors import (TransportNotPossible, NoSuchFile, 
 
30
                           NonRelativePath, TransportError, ConnectionError)
 
31
 
 
32
import os, errno
27
33
from cStringIO import StringIO
28
 
import asyncore
29
 
import errno
30
34
import ftplib
31
 
import os
32
 
import os.path
 
35
import urlparse
33
36
import urllib
34
 
import urlparse
35
 
import select
36
37
import stat
37
 
import threading
38
 
import time
39
 
import random
40
 
from warnings import warn
41
 
 
42
 
from bzrlib import (
43
 
    errors,
44
 
    osutils,
45
 
    urlutils,
46
 
    )
47
 
from bzrlib.trace import mutter, warning
48
 
from bzrlib.transport import (
49
 
    Server,
50
 
    split_url,
51
 
    Transport,
52
 
    )
53
 
from bzrlib.transport.local import LocalURLServer
54
 
import bzrlib.ui
55
 
 
56
 
_have_medusa = False
57
 
 
58
 
 
59
 
class FtpPathError(errors.PathError):
60
 
    """FTP failed for path: %(path)s%(extra)s"""
61
 
 
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]    
 
38
 
 
39
from bzrlib.errors import BzrError, BzrCheckError
 
40
from bzrlib.branch import Branch
 
41
from bzrlib.trace import mutter
 
42
 
 
43
 
 
44
class FtpTransportError(TransportError):
 
45
    pass
83
46
 
84
47
 
85
48
class FtpStatResult(object):
96
59
                f.cwd(pwd)
97
60
 
98
61
 
99
 
_number_of_retries = 2
100
 
_sleep_between_retries = 5
101
 
 
102
62
class FtpTransport(Transport):
103
63
    """This is the transport agent for ftp:// access."""
104
64
 
105
65
    def __init__(self, base, _provided_instance=None):
106
66
        """Set the base path where files will be stored."""
107
67
        assert base.startswith('ftp://') or base.startswith('aftp://')
108
 
 
 
68
        super(FtpTransport, self).__init__(base)
109
69
        self.is_active = base.startswith('aftp://')
110
70
        if self.is_active:
111
 
            # urlparse won't handle aftp://
112
71
            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)
 
72
        (self._proto, self._host,
 
73
            self._path, self._parameters,
 
74
            self._query, self._fragment) = urlparse.urlparse(self.base)
121
75
        self._FTP_instance = _provided_instance
122
76
 
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, '', '', ''))
136
77
 
137
78
    def _get_FTP(self):
138
79
        """Return the ftplib.FTP instance for this object."""
140
81
            return self._FTP_instance
141
82
        
142
83
        try:
143
 
            self._FTP_instance = _find_FTP(self._host, self._port,
144
 
                                           self._username, self._password,
145
 
                                           self.is_active)
 
84
            username = ''
 
85
            password = ''
 
86
            hostname = self._host
 
87
            if '@' in hostname:
 
88
                username, hostname = hostname.split("@", 1)
 
89
            if ':' in username:
 
90
                username, password = username.split(":", 1)
 
91
 
 
92
            mutter("Constructing FTP instance")
 
93
            self._FTP_instance = ftplib.FTP(hostname, username, password)
 
94
            self._FTP_instance.set_pasv(not self.is_active)
146
95
            return self._FTP_instance
147
96
        except ftplib.error_perm, e:
148
 
            raise errors.TransportError(msg="Error setting up connection: %s"
 
97
            raise FtpTransportError(msg="Error setting up connection: %s"
149
98
                                    % str(e), orig_error=e)
150
99
 
151
 
    def _translate_perm_error(self, err, path, extra=None, unknown_exc=FtpPathError):
152
 
        """Try to translate an ftplib.error_perm exception.
153
 
 
154
 
        :param err: The error to translate into a bzr error
155
 
        :param path: The path which had problems
156
 
        :param extra: Extra information which can be included
157
 
        :param unknown_exc: If None, we will just raise the original exception
158
 
                    otherwise we raise unknown_exc(path, extra=extra)
159
 
        """
160
 
        s = str(err).lower()
161
 
        if not extra:
162
 
            extra = str(err)
163
 
        else:
164
 
            extra += ': ' + str(err)
165
 
        if ('no such file' in s
166
 
            or 'could not open' in s
167
 
            or 'no such dir' in s
168
 
            or 'could not create file' in s # vsftpd
169
 
            ):
170
 
            raise errors.NoSuchFile(path, extra=extra)
171
 
        if ('file exists' in s):
172
 
            raise errors.FileExists(path, extra=extra)
173
 
        if ('not a directory' in s):
174
 
            raise errors.PathError(path, extra=extra)
175
 
 
176
 
        mutter('unable to understand error for path: %s: %s', path, err)
177
 
 
178
 
        if unknown_exc:
179
 
            raise unknown_exc(path, extra=extra)
180
 
        # TODO: jam 20060516 Consider re-raising the error wrapped in 
181
 
        #       something like TransportError, but this loses the traceback
182
 
        #       Also, 'sftp' has a generic 'Failure' mode, which we use failure_exc
183
 
        #       to handle. Consider doing something like that here.
184
 
        #raise TransportError(msg='Error for path: %s' % (path,), orig_error=e)
185
 
        raise
186
 
 
187
100
    def should_cache(self):
188
101
        """Return True if the data pulled across should be cached locally.
189
102
        """
200
113
 
201
114
    def _abspath(self, relpath):
202
115
        assert isinstance(relpath, basestring)
203
 
        relpath = urlutils.unescape(relpath)
204
 
        if relpath.startswith('/'):
205
 
            basepath = []
 
116
        relpath = urllib.unquote(relpath)
 
117
        if isinstance(relpath, basestring):
 
118
            relpath_parts = relpath.split('/')
206
119
        else:
207
 
            basepath = self._path.split('/')
 
120
            # TODO: Don't call this with an array - no magic interfaces
 
121
            relpath_parts = relpath[:]
 
122
        if len(relpath_parts) > 1:
 
123
            if relpath_parts[0] == '':
 
124
                raise ValueError("path %r within branch %r seems to be absolute"
 
125
                                 % (relpath, self._path))
 
126
        basepath = self._path.split('/')
208
127
        if len(basepath) > 0 and basepath[-1] == '':
209
128
            basepath = basepath[:-1]
210
 
        for p in relpath.split('/'):
 
129
        for p in relpath_parts:
211
130
            if p == '..':
212
131
                if len(basepath) == 0:
213
132
                    # In most filesystems, a request for the parent
221
140
        # Possibly, we could use urlparse.urljoin() here, but
222
141
        # I'm concerned about when it chooses to strip the last
223
142
        # portion of the path, and when it doesn't.
224
 
 
225
 
        # XXX: It seems that ftplib does not handle Unicode paths
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 '/')
 
143
        return '/'.join(basepath)
231
144
    
232
145
    def abspath(self, relpath):
233
146
        """Return the full url to the given relative path.
234
147
        This can be supplied with a string or a list
235
148
        """
236
149
        path = self._abspath(relpath)
237
 
        return self._unparse_url(path)
 
150
        return urlparse.urlunparse((self._proto,
 
151
                self._host, path, '', '', ''))
238
152
 
239
153
    def has(self, relpath):
240
 
        """Does the target location exist?"""
241
 
        # FIXME jam 20060516 We *do* ask about directories in the test suite
242
 
        #       We don't seem to in the actual codebase
243
 
        # XXX: I assume we're never asked has(dirname) and thus I use
244
 
        # the FTP size command and assume that if it doesn't raise,
245
 
        # all is good.
246
 
        abspath = self._abspath(relpath)
 
154
        """Does the target location exist?
 
155
 
 
156
        XXX: I assume we're never asked has(dirname) and thus I use
 
157
        the FTP size command and assume that if it doesn't raise,
 
158
        all is good.
 
159
        """
247
160
        try:
248
161
            f = self._get_FTP()
249
 
            mutter('FTP has check: %s => %s', relpath, abspath)
250
 
            s = f.size(abspath)
251
 
            mutter("FTP has: %s", abspath)
 
162
            s = f.size(self._abspath(relpath))
 
163
            mutter("FTP has: %s" % self._abspath(relpath))
252
164
            return True
253
 
        except ftplib.error_perm, e:
254
 
            if ('is a directory' in str(e).lower()):
255
 
                mutter("FTP has dir: %s: %s", abspath, e)
256
 
                return True
257
 
            mutter("FTP has not: %s: %s", abspath, e)
 
165
        except ftplib.error_perm:
 
166
            mutter("FTP has not: %s" % self._abspath(relpath))
258
167
            return False
259
168
 
260
 
    def get(self, relpath, decode=False, retries=0):
 
169
    def get(self, relpath, decode=False):
261
170
        """Get the file at the given relative path.
262
171
 
263
172
        :param relpath: The relative path to the file
264
 
        :param retries: Number of retries after temporary failures so far
265
 
                        for this operation.
266
173
 
267
174
        We're meant to return a file-like object which bzr will
268
175
        then read from. For now we do this via the magic of StringIO
269
176
        """
270
 
        # TODO: decode should be deprecated
271
177
        try:
272
 
            mutter("FTP get: %s", self._abspath(relpath))
 
178
            mutter("FTP get: %s" % self._abspath(relpath))
273
179
            f = self._get_FTP()
274
180
            ret = StringIO()
275
181
            f.retrbinary('RETR '+self._abspath(relpath), ret.write, 8192)
276
182
            ret.seek(0)
277
183
            return ret
278
184
        except ftplib.error_perm, e:
279
 
            raise errors.NoSuchFile(self.abspath(relpath), extra=str(e))
280
 
        except ftplib.error_temp, e:
281
 
            if retries > _number_of_retries:
282
 
                raise errors.TransportError(msg="FTP temporary error during GET %s. Aborting."
283
 
                                     % self.abspath(relpath),
284
 
                                     orig_error=e)
285
 
            else:
286
 
                warning("FTP temporary error: %s. Retrying.", str(e))
287
 
                self._FTP_instance = None
288
 
                return self.get(relpath, decode, retries+1)
289
 
        except EOFError, e:
290
 
            if retries > _number_of_retries:
291
 
                raise errors.TransportError("FTP control connection closed during GET %s."
292
 
                                     % self.abspath(relpath),
293
 
                                     orig_error=e)
294
 
            else:
295
 
                warning("FTP control connection closed. Trying to reopen.")
296
 
                time.sleep(_sleep_between_retries)
297
 
                self._FTP_instance = None
298
 
                return self.get(relpath, decode, retries+1)
 
185
            raise NoSuchFile(msg="Error retrieving %s: %s"
 
186
                             % (self.abspath(relpath), str(e)),
 
187
                             orig_error=e)
299
188
 
300
 
    def put_file(self, relpath, fp, mode=None, retries=0):
 
189
    def put(self, relpath, fp):
301
190
        """Copy the file-like or string object into the location.
302
191
 
303
192
        :param relpath: Location to put the contents, relative to base.
304
 
        :param fp:       File-like or string object.
305
 
        :param retries: Number of retries after temporary failures so far
306
 
                        for this operation.
307
 
 
308
 
        TODO: jam 20051215 ftp as a protocol seems to support chmod, but
309
 
        ftplib does not
 
193
        :param f:       File-like or string object.
310
194
        """
311
 
        abspath = self._abspath(relpath)
312
 
        tmp_abspath = '%s.tmp.%.9f.%d.%d' % (abspath, time.time(),
313
 
                        os.getpid(), random.randint(0,0x7FFFFFFF))
314
 
        if getattr(fp, 'read', None) is None:
 
195
        if not hasattr(fp, 'read'):
315
196
            fp = StringIO(fp)
316
197
        try:
317
 
            mutter("FTP put: %s", abspath)
 
198
            mutter("FTP put: %s" % self._abspath(relpath))
318
199
            f = self._get_FTP()
319
 
            try:
320
 
                f.storbinary('STOR '+tmp_abspath, fp)
321
 
                self._rename_and_overwrite(tmp_abspath, abspath, f)
322
 
            except (ftplib.error_temp,EOFError), e:
323
 
                warning("Failure during ftp PUT. Deleting temporary file.")
324
 
                try:
325
 
                    f.delete(tmp_abspath)
326
 
                except:
327
 
                    warning("Failed to delete temporary file on the"
328
 
                            " server.\nFile: %s", tmp_abspath)
329
 
                    raise e
330
 
                raise
 
200
            f.storbinary('STOR '+self._abspath(relpath), fp, 8192)
331
201
        except ftplib.error_perm, e:
332
 
            self._translate_perm_error(e, abspath, extra='could not store')
333
 
        except ftplib.error_temp, e:
334
 
            if retries > _number_of_retries:
335
 
                raise errors.TransportError("FTP temporary error during PUT %s. Aborting."
336
 
                                     % self.abspath(relpath), orig_error=e)
337
 
            else:
338
 
                warning("FTP temporary error: %s. Retrying.", str(e))
339
 
                self._FTP_instance = None
340
 
                self.put_file(relpath, fp, mode, retries+1)
341
 
        except EOFError:
342
 
            if retries > _number_of_retries:
343
 
                raise errors.TransportError("FTP control connection closed during PUT %s."
344
 
                                     % self.abspath(relpath), orig_error=e)
345
 
            else:
346
 
                warning("FTP control connection closed. Trying to reopen.")
347
 
                time.sleep(_sleep_between_retries)
348
 
                self._FTP_instance = None
349
 
                self.put_file(relpath, fp, mode, retries+1)
 
202
            raise FtpTransportError(orig_error=e)
350
203
 
351
 
    def mkdir(self, relpath, mode=None):
 
204
    def mkdir(self, relpath):
352
205
        """Create a directory at the given path."""
353
 
        abspath = self._abspath(relpath)
354
 
        try:
355
 
            mutter("FTP mkd: %s", abspath)
356
 
            f = self._get_FTP()
357
 
            f.mkd(abspath)
358
 
        except ftplib.error_perm, e:
359
 
            self._translate_perm_error(e, abspath,
360
 
                unknown_exc=errors.FileExists)
361
 
 
362
 
    def rmdir(self, rel_path):
363
 
        """Delete the directory at rel_path"""
364
 
        abspath = self._abspath(rel_path)
365
 
        try:
366
 
            mutter("FTP rmd: %s", abspath)
367
 
            f = self._get_FTP()
368
 
            f.rmd(abspath)
369
 
        except ftplib.error_perm, e:
370
 
            self._translate_perm_error(e, abspath, unknown_exc=errors.PathError)
371
 
 
372
 
    def append_file(self, relpath, f, mode=None):
 
206
        try:
 
207
            mutter("FTP mkd: %s" % self._abspath(relpath))
 
208
            f = self._get_FTP()
 
209
            try:
 
210
                f.mkd(self._abspath(relpath))
 
211
            except ftplib.error_perm, e:
 
212
                s = str(e)
 
213
                if 'File exists' in s:
 
214
                    # Swallow attempts to mkdir something which is already
 
215
                    # present. Hopefully this will shush some errors.
 
216
                    return
 
217
                else:
 
218
                    raise
 
219
        except ftplib.error_perm, e:
 
220
            raise FtpTransportError(orig_error=e)
 
221
 
 
222
    def append(self, relpath, f):
373
223
        """Append the text in the file-like object into the final
374
224
        location.
375
225
        """
376
 
        abspath = self._abspath(relpath)
377
 
        if self.has(relpath):
378
 
            ftp = self._get_FTP()
379
 
            result = ftp.size(abspath)
380
 
        else:
381
 
            result = 0
382
 
 
383
 
        mutter("FTP appe to %s", abspath)
384
 
        self._try_append(relpath, f.read(), mode)
385
 
 
386
 
        return result
387
 
 
388
 
    def _try_append(self, relpath, text, mode=None, retries=0):
389
 
        """Try repeatedly to append the given text to the file at relpath.
390
 
        
391
 
        This is a recursive function. On errors, it will be called until the
392
 
        number of retries is exceeded.
393
 
        """
394
 
        try:
395
 
            abspath = self._abspath(relpath)
396
 
            mutter("FTP appe (try %d) to %s", retries, abspath)
397
 
            ftp = self._get_FTP()
398
 
            ftp.voidcmd("TYPE I")
399
 
            cmd = "APPE %s" % abspath
400
 
            conn = ftp.transfercmd(cmd)
401
 
            conn.sendall(text)
402
 
            conn.close()
403
 
            if mode:
404
 
                self._setmode(relpath, mode)
405
 
            ftp.getresp()
406
 
        except ftplib.error_perm, e:
407
 
            self._translate_perm_error(e, abspath, extra='error appending',
408
 
                unknown_exc=errors.NoSuchFile)
409
 
        except ftplib.error_temp, e:
410
 
            if retries > _number_of_retries:
411
 
                raise errors.TransportError("FTP temporary error during APPEND %s." \
412
 
                        "Aborting." % abspath, orig_error=e)
413
 
            else:
414
 
                warning("FTP temporary error: %s. Retrying.", str(e))
415
 
                self._FTP_instance = None
416
 
                self._try_append(relpath, text, mode, retries+1)
417
 
 
418
 
    def _setmode(self, relpath, mode):
419
 
        """Set permissions on a path.
420
 
 
421
 
        Only set permissions if the FTP server supports the 'SITE CHMOD'
422
 
        extension.
423
 
        """
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))
434
 
 
435
 
    # TODO: jam 20060516 I believe ftp allows you to tell an ftp server
436
 
    #       to copy something to another machine. And you may be able
437
 
    #       to give it its own address as the 'to' location.
438
 
    #       So implement a fancier 'copy()'
439
 
 
440
 
    def rename(self, rel_from, rel_to):
441
 
        abs_from = self._abspath(rel_from)
442
 
        abs_to = self._abspath(rel_to)
443
 
        mutter("FTP rename: %s => %s", abs_from, abs_to)
444
 
        f = self._get_FTP()
445
 
        return self._rename(abs_from, abs_to, f)
446
 
 
447
 
    def _rename(self, abs_from, abs_to, f):
448
 
        try:
449
 
            f.rename(abs_from, abs_to)
450
 
        except ftplib.error_perm, e:
451
 
            self._translate_perm_error(e, abs_from,
452
 
                ': unable to rename to %r' % (abs_to))
 
226
        raise TransportNotPossible('ftp does not support append()')
 
227
 
 
228
    def copy(self, rel_from, rel_to):
 
229
        """Copy the item at rel_from to the location at rel_to"""
 
230
        raise TransportNotPossible('ftp does not (yet) support copy()')
453
231
 
454
232
    def move(self, rel_from, rel_to):
455
233
        """Move the item at rel_from to the location at rel_to"""
456
 
        abs_from = self._abspath(rel_from)
457
 
        abs_to = self._abspath(rel_to)
458
234
        try:
459
 
            mutter("FTP mv: %s => %s", abs_from, abs_to)
 
235
            mutter("FTP mv: %s => %s" % (self._abspath(rel_from),
 
236
                                         self._abspath(rel_to)))
460
237
            f = self._get_FTP()
461
 
            self._rename_and_overwrite(abs_from, abs_to, f)
 
238
            f.rename(self._abspath(rel_from), self._abspath(rel_to))
462
239
        except ftplib.error_perm, e:
463
 
            self._translate_perm_error(e, abs_from,
464
 
                extra='unable to rename to %r' % (rel_to,), 
465
 
                unknown_exc=errors.PathError)
466
 
 
467
 
    def _rename_and_overwrite(self, abs_from, abs_to, f):
468
 
        """Do a fancy rename on the remote server.
469
 
 
470
 
        Using the implementation provided by osutils.
471
 
        """
472
 
        osutils.fancy_rename(abs_from, abs_to,
473
 
            rename_func=lambda p1, p2: self._rename(p1, p2, f),
474
 
            unlink_func=lambda p: self._delete(p, f))
 
240
            raise FtpTransportError(orig_error=e)
475
241
 
476
242
    def delete(self, relpath):
477
243
        """Delete the item at relpath"""
478
 
        abspath = self._abspath(relpath)
479
 
        f = self._get_FTP()
480
 
        self._delete(abspath, f)
481
 
 
482
 
    def _delete(self, abspath, f):
483
244
        try:
484
 
            mutter("FTP rm: %s", abspath)
485
 
            f.delete(abspath)
 
245
            mutter("FTP rm: %s" % self._abspath(relpath))
 
246
            f = self._get_FTP()
 
247
            f.delete(self._abspath(relpath))
486
248
        except ftplib.error_perm, e:
487
 
            self._translate_perm_error(e, abspath, 'error deleting',
488
 
                unknown_exc=errors.NoSuchFile)
 
249
            raise FtpTransportError(orig_error=e)
489
250
 
490
251
    def listable(self):
491
252
        """See Transport.listable."""
493
254
 
494
255
    def list_dir(self, relpath):
495
256
        """See Transport.list_dir."""
496
 
        basepath = self._abspath(relpath)
497
 
        mutter("FTP nlst: %s", basepath)
498
 
        f = self._get_FTP()
499
257
        try:
500
 
            paths = f.nlst(basepath)
 
258
            mutter("FTP nlst: %s" % self._abspath(relpath))
 
259
            f = self._get_FTP()
 
260
            basepath = self._abspath(relpath)
 
261
            # FTP.nlst returns paths prefixed by relpath, strip 'em
 
262
            the_list = f.nlst(basepath)
 
263
            stripped = [path[len(basepath)+1:] for path in the_list]
 
264
            # Remove . and .. if present, and return
 
265
            return [path for path in stripped if path not in (".", "..")]
501
266
        except ftplib.error_perm, e:
502
 
            self._translate_perm_error(e, relpath, extra='error with list_dir')
503
 
        # If FTP.nlst returns paths prefixed by relpath, strip 'em
504
 
        if paths and paths[0].startswith(basepath):
505
 
            entries = [path[len(basepath)+1:] for path in paths]
506
 
        else:
507
 
            entries = paths
508
 
        # Remove . and .. if present
509
 
        return [urlutils.escape(entry) for entry in entries
510
 
                if entry not in ('.', '..')]
 
267
            raise FtpTransportError(orig_error=e)
511
268
 
512
269
    def iter_files_recursive(self):
513
270
        """See Transport.iter_files_recursive.
516
273
        mutter("FTP iter_files_recursive")
517
274
        queue = list(self.list_dir("."))
518
275
        while queue:
519
 
            relpath = queue.pop(0)
 
276
            relpath = urllib.quote(queue.pop(0))
520
277
            st = self.stat(relpath)
521
278
            if stat.S_ISDIR(st.st_mode):
522
279
                for i, basename in enumerate(self.list_dir(relpath)):
525
282
                yield relpath
526
283
 
527
284
    def stat(self, relpath):
528
 
        """Return the stat information for a file."""
529
 
        abspath = self._abspath(relpath)
 
285
        """Return the stat information for a file.
 
286
        """
530
287
        try:
531
 
            mutter("FTP stat: %s", abspath)
 
288
            mutter("FTP stat: %s" % self._abspath(relpath))
532
289
            f = self._get_FTP()
533
 
            return FtpStatResult(f, abspath)
 
290
            return FtpStatResult(f, self._abspath(relpath))
534
291
        except ftplib.error_perm, e:
535
 
            self._translate_perm_error(e, abspath, extra='error w/ stat')
 
292
            raise FtpTransportError(orig_error=e)
536
293
 
537
294
    def lock_read(self, relpath):
538
295
        """Lock the given file for shared (read) access.
554
311
        :return: A lock object, which should be passed to Transport.unlock()
555
312
        """
556
313
        return self.lock_read(relpath)
557
 
 
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
 
                # (bialix 20070418) str(e) on Python 2.5 @ Windows
705
 
                # sometimes don't provide expected error message;
706
 
                # so we obtain such message via os.strerror()
707
 
                self.respond('550 RNTO failed: %s' % os.strerror(e.errno))
708
 
            except:
709
 
                self.respond('550 RNTO failed')
710
 
                # For a test server, we will go ahead and just die
711
 
                raise
712
 
            else:
713
 
                self.respond('250 Rename successful.')
714
 
 
715
 
        def cmd_size(self, line):
716
 
            """Return the size of a file
717
 
 
718
 
            This is overloaded to help the test suite determine if the 
719
 
            target is a directory.
720
 
            """
721
 
            filename = line[1]
722
 
            if not self.filesystem.isfile(filename):
723
 
                if self.filesystem.isdir(filename):
724
 
                    self.respond('550 "%s" is a directory' % (filename,))
725
 
                else:
726
 
                    self.respond('550 "%s" is not a file' % (filename,))
727
 
            else:
728
 
                self.respond('213 %d' 
729
 
                    % (self.filesystem.stat(filename)[stat.ST_SIZE]),)
730
 
 
731
 
        def cmd_mkd(self, line):
732
 
            """Create a directory.
733
 
 
734
 
            Overloaded because default implementation does not distinguish
735
 
            *why* it cannot make a directory.
736
 
            """
737
 
            if len (line) != 2:
738
 
                self.command_not_understood(''.join(line))
739
 
            else:
740
 
                path = line[1]
741
 
                try:
742
 
                    self.filesystem.mkdir (path)
743
 
                    self.respond ('257 MKD command successful.')
744
 
                except (IOError, OSError), e:
745
 
                    # (bialix 20070418) str(e) on Python 2.5 @ Windows
746
 
                    # sometimes don't provide expected error message;
747
 
                    # so we obtain such message via os.strerror()
748
 
                    self.respond ('550 error creating directory: %s' %
749
 
                                  os.strerror(e.errno))
750
 
                except:
751
 
                    self.respond ('550 error creating directory.')
752
 
 
753
 
 
754
 
    class ftp_server(medusa.ftp_server.ftp_server):
755
 
        """Customize the behavior of the Medusa ftp_server.
756
 
 
757
 
        There are a few warts on the ftp_server, based on how it expects
758
 
        to be used.
759
 
        """
760
 
        _renaming = None
761
 
        ftp_channel_class = ftp_channel
762
 
 
763
 
        def __init__(self, *args, **kwargs):
764
 
            mutter('Initializing _ftp_server: %r, %r', args, kwargs)
765
 
            medusa.ftp_server.ftp_server.__init__(self, *args, **kwargs)
766
 
 
767
 
        def log(self, message):
768
 
            """Redirect logging requests."""
769
 
            mutter('_ftp_server: %s', message)
770
 
 
771
 
        def log_info(self, message, type='info'):
772
 
            """Override the asyncore.log_info so we don't stipple the screen."""
773
 
            mutter('_ftp_server %s: %s', type, message)
774
 
 
775
 
    _test_authorizer = test_authorizer
776
 
    _ftp_channel = ftp_channel
777
 
    _ftp_server = ftp_server
778
 
 
779
 
    return True
780
 
 
781
 
 
782
 
def get_test_permutations():
783
 
    """Return the permutations to be used in testing."""
784
 
    if not _setup_medusa():
785
 
        warn("You must install medusa (http://www.amk.ca/python/code/medusa.html) for FTP tests")
786
 
        return []
787
 
    else:
788
 
        return [(FtpTransport, FtpServer)]