← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ftp.py

  • Committer: Robert Collins
  • Date: 2005-12-24 02:20:45 UTC
  • mto: (1185.50.57 bzr-jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1550.
  • Revision ID: robertc@robertcollins.net-20051224022045-14efc8dfa0e1a4e9
Start tests for api usage.

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, TransportError,
 
30
                           NoSuchFile, FileExists)
 
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.branch import Branch
 
40
from bzrlib.trace import mutter
83
41
 
84
42
 
85
43
class FtpStatResult(object):
96
54
                f.cwd(pwd)
97
55
 
98
56
 
99
 
_number_of_retries = 2
100
 
_sleep_between_retries = 5
101
 
 
102
57
class FtpTransport(Transport):
103
58
    """This is the transport agent for ftp:// access."""
104
59
 
105
60
    def __init__(self, base, _provided_instance=None):
106
61
        """Set the base path where files will be stored."""
107
62
        assert base.startswith('ftp://') or base.startswith('aftp://')
108
 
 
 
63
        super(FtpTransport, self).__init__(base)
109
64
        self.is_active = base.startswith('aftp://')
110
65
        if self.is_active:
111
 
            # urlparse won't handle aftp://
112
66
            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)
 
67
        (self._proto, self._host,
 
68
            self._path, self._parameters,
 
69
            self._query, self._fragment) = urlparse.urlparse(self.base)
121
70
        self._FTP_instance = _provided_instance
122
71
 
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
72
 
137
73
    def _get_FTP(self):
138
74
        """Return the ftplib.FTP instance for this object."""
140
76
            return self._FTP_instance
141
77
        
142
78
        try:
143
 
            self._FTP_instance = _find_FTP(self._host, self._port,
144
 
                                           self._username, self._password,
145
 
                                           self.is_active)
 
79
            username = ''
 
80
            password = ''
 
81
            hostname = self._host
 
82
            if '@' in hostname:
 
83
                username, hostname = hostname.split("@", 1)
 
84
            if ':' in username:
 
85
                username, password = username.split(":", 1)
 
86
 
 
87
            mutter("Constructing FTP instance")
 
88
            self._FTP_instance = ftplib.FTP(hostname, username, password)
 
89
            self._FTP_instance.set_pasv(not self.is_active)
146
90
            return self._FTP_instance
147
91
        except ftplib.error_perm, e:
148
 
            raise errors.TransportError(msg="Error setting up connection: %s"
 
92
            raise TransportError(msg="Error setting up connection: %s"
149
93
                                    % str(e), orig_error=e)
150
94
 
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
95
    def should_cache(self):
188
96
        """Return True if the data pulled across should be cached locally.
189
97
        """
200
108
 
201
109
    def _abspath(self, relpath):
202
110
        assert isinstance(relpath, basestring)
203
 
        relpath = urlutils.unescape(relpath)
204
 
        if relpath.startswith('/'):
205
 
            basepath = []
 
111
        relpath = urllib.unquote(relpath)
 
112
        if isinstance(relpath, basestring):
 
113
            relpath_parts = relpath.split('/')
206
114
        else:
207
 
            basepath = self._path.split('/')
 
115
            # TODO: Don't call this with an array - no magic interfaces
 
116
            relpath_parts = relpath[:]
 
117
        if len(relpath_parts) > 1:
 
118
            if relpath_parts[0] == '':
 
119
                raise ValueError("path %r within branch %r seems to be absolute"
 
120
                                 % (relpath, self._path))
 
121
        basepath = self._path.split('/')
208
122
        if len(basepath) > 0 and basepath[-1] == '':
209
123
            basepath = basepath[:-1]
210
 
        for p in relpath.split('/'):
 
124
        for p in relpath_parts:
211
125
            if p == '..':
212
126
                if len(basepath) == 0:
213
127
                    # In most filesystems, a request for the parent
221
135
        # Possibly, we could use urlparse.urljoin() here, but
222
136
        # I'm concerned about when it chooses to strip the last
223
137
        # 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 '/')
 
138
        return '/'.join(basepath)
231
139
    
232
140
    def abspath(self, relpath):
233
141
        """Return the full url to the given relative path.
234
142
        This can be supplied with a string or a list
235
143
        """
236
144
        path = self._abspath(relpath)
237
 
        return self._unparse_url(path)
 
145
        return urlparse.urlunparse((self._proto,
 
146
                self._host, path, '', '', ''))
238
147
 
239
148
    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)
 
149
        """Does the target location exist?
 
150
 
 
151
        XXX: I assume we're never asked has(dirname) and thus I use
 
152
        the FTP size command and assume that if it doesn't raise,
 
153
        all is good.
 
154
        """
247
155
        try:
248
156
            f = self._get_FTP()
249
 
            mutter('FTP has check: %s => %s', relpath, abspath)
250
 
            s = f.size(abspath)
251
 
            mutter("FTP has: %s", abspath)
 
157
            s = f.size(self._abspath(relpath))
 
158
            mutter("FTP has: %s" % self._abspath(relpath))
252
159
            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)
 
160
        except ftplib.error_perm:
 
161
            mutter("FTP has not: %s" % self._abspath(relpath))
258
162
            return False
259
163
 
260
 
    def get(self, relpath, decode=False, retries=0):
 
164
    def get(self, relpath, decode=False):
261
165
        """Get the file at the given relative path.
262
166
 
263
167
        :param relpath: The relative path to the file
264
 
        :param retries: Number of retries after temporary failures so far
265
 
                        for this operation.
266
168
 
267
169
        We're meant to return a file-like object which bzr will
268
170
        then read from. For now we do this via the magic of StringIO
269
171
        """
270
 
        # TODO: decode should be deprecated
271
172
        try:
272
 
            mutter("FTP get: %s", self._abspath(relpath))
 
173
            mutter("FTP get: %s" % self._abspath(relpath))
273
174
            f = self._get_FTP()
274
175
            ret = StringIO()
275
176
            f.retrbinary('RETR '+self._abspath(relpath), ret.write, 8192)
276
177
            ret.seek(0)
277
178
            return ret
278
179
        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)
 
180
            raise NoSuchFile(self.abspath(relpath), extra=extra)
299
181
 
300
 
    def put_file(self, relpath, fp, mode=None, retries=0):
 
182
    def put(self, relpath, fp):
301
183
        """Copy the file-like or string object into the location.
302
184
 
303
185
        :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
 
186
        :param f:       File-like or string object.
310
187
        """
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:
 
188
        if not hasattr(fp, 'read'):
315
189
            fp = StringIO(fp)
316
190
        try:
317
 
            mutter("FTP put: %s", abspath)
 
191
            mutter("FTP put: %s" % self._abspath(relpath))
318
192
            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
 
193
            f.storbinary('STOR '+self._abspath(relpath), fp, 8192)
331
194
        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)
 
195
            raise TransportError(orig_error=e)
350
196
 
351
 
    def mkdir(self, relpath, mode=None):
 
197
    def mkdir(self, relpath):
352
198
        """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):
 
199
        try:
 
200
            mutter("FTP mkd: %s" % self._abspath(relpath))
 
201
            f = self._get_FTP()
 
202
            try:
 
203
                f.mkd(self._abspath(relpath))
 
204
            except ftplib.error_perm, e:
 
205
                s = str(e)
 
206
                if 'File exists' in s:
 
207
                    raise FileExists(self.abspath(relpath), extra=s)
 
208
                else:
 
209
                    raise
 
210
        except ftplib.error_perm, e:
 
211
            raise TransportError(orig_error=e)
 
212
 
 
213
    def append(self, relpath, f):
373
214
        """Append the text in the file-like object into the final
374
215
        location.
375
216
        """
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))
 
217
        raise TransportNotPossible('ftp does not support append()')
 
218
 
 
219
    def copy(self, rel_from, rel_to):
 
220
        """Copy the item at rel_from to the location at rel_to"""
 
221
        raise TransportNotPossible('ftp does not (yet) support copy()')
453
222
 
454
223
    def move(self, rel_from, rel_to):
455
224
        """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
225
        try:
459
 
            mutter("FTP mv: %s => %s", abs_from, abs_to)
 
226
            mutter("FTP mv: %s => %s" % (self._abspath(rel_from),
 
227
                                         self._abspath(rel_to)))
460
228
            f = self._get_FTP()
461
 
            self._rename_and_overwrite(abs_from, abs_to, f)
 
229
            f.rename(self._abspath(rel_from), self._abspath(rel_to))
462
230
        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))
 
231
            raise TransportError(orig_error=e)
475
232
 
476
233
    def delete(self, relpath):
477
234
        """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
235
        try:
484
 
            mutter("FTP rm: %s", abspath)
485
 
            f.delete(abspath)
 
236
            mutter("FTP rm: %s" % self._abspath(relpath))
 
237
            f = self._get_FTP()
 
238
            f.delete(self._abspath(relpath))
486
239
        except ftplib.error_perm, e:
487
 
            self._translate_perm_error(e, abspath, 'error deleting',
488
 
                unknown_exc=errors.NoSuchFile)
 
240
            raise TransportError(orig_error=e)
489
241
 
490
242
    def listable(self):
491
243
        """See Transport.listable."""
493
245
 
494
246
    def list_dir(self, relpath):
495
247
        """See Transport.list_dir."""
496
 
        basepath = self._abspath(relpath)
497
 
        mutter("FTP nlst: %s", basepath)
498
 
        f = self._get_FTP()
499
248
        try:
500
 
            paths = f.nlst(basepath)
 
249
            mutter("FTP nlst: %s" % self._abspath(relpath))
 
250
            f = self._get_FTP()
 
251
            basepath = self._abspath(relpath)
 
252
            # FTP.nlst returns paths prefixed by relpath, strip 'em
 
253
            the_list = f.nlst(basepath)
 
254
            stripped = [path[len(basepath)+1:] for path in the_list]
 
255
            # Remove . and .. if present, and return
 
256
            return [path for path in stripped if path not in (".", "..")]
501
257
        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 ('.', '..')]
 
258
            raise TransportError(orig_error=e)
511
259
 
512
260
    def iter_files_recursive(self):
513
261
        """See Transport.iter_files_recursive.
516
264
        mutter("FTP iter_files_recursive")
517
265
        queue = list(self.list_dir("."))
518
266
        while queue:
519
 
            relpath = queue.pop(0)
 
267
            relpath = urllib.quote(queue.pop(0))
520
268
            st = self.stat(relpath)
521
269
            if stat.S_ISDIR(st.st_mode):
522
270
                for i, basename in enumerate(self.list_dir(relpath)):
525
273
                yield relpath
526
274
 
527
275
    def stat(self, relpath):
528
 
        """Return the stat information for a file."""
529
 
        abspath = self._abspath(relpath)
 
276
        """Return the stat information for a file.
 
277
        """
530
278
        try:
531
 
            mutter("FTP stat: %s", abspath)
 
279
            mutter("FTP stat: %s" % self._abspath(relpath))
532
280
            f = self._get_FTP()
533
 
            return FtpStatResult(f, abspath)
 
281
            return FtpStatResult(f, self._abspath(relpath))
534
282
        except ftplib.error_perm, e:
535
 
            self._translate_perm_error(e, abspath, extra='error w/ stat')
 
283
            raise TransportError(orig_error=e)
536
284
 
537
285
    def lock_read(self, relpath):
538
286
        """Lock the given file for shared (read) access.
554
302
        :return: A lock object, which should be passed to Transport.unlock()
555
303
        """
556
304
        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)]