← 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-03-12 17:30:53 UTC
  • mfrom: (2338.3.1 hide-nested)
  • Revision ID: pqm@pqm.ubuntu.com-20070312173053-4cdb4cd14190d29e
Hide nested-tree commands and improve their docs

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
25
25
"""
26
26
 
27
27
from cStringIO import StringIO
 
28
import asyncore
28
29
import errno
29
30
import ftplib
30
31
import os
31
32
import urllib
32
33
import urlparse
33
34
import stat
 
35
import threading
 
36
import time
 
37
import random
34
38
from warnings import warn
35
39
 
36
 
 
37
 
from bzrlib.transport import Transport
38
 
from bzrlib.errors import (TransportNotPossible, TransportError,
39
 
                           NoSuchFile, FileExists)
 
40
from bzrlib import (
 
41
    errors,
 
42
    urlutils,
 
43
    )
40
44
from bzrlib.trace import mutter, warning
 
45
from bzrlib.transport import (
 
46
    Server,
 
47
    split_url,
 
48
    Transport,
 
49
    )
 
50
import bzrlib.ui
 
51
 
 
52
_have_medusa = False
 
53
 
 
54
 
 
55
class FtpPathError(errors.PathError):
 
56
    """FTP failed for path: %(path)s%(extra)s"""
41
57
 
42
58
 
43
59
_FTP_cache = {}
44
 
def _find_FTP(hostname, username, password, is_active):
 
60
def _find_FTP(hostname, port, username, password, is_active):
45
61
    """Find an ftplib.FTP instance attached to this triplet."""
46
 
    key = "%s|%s|%s|%s" % (hostname, username, password, is_active)
 
62
    key = (hostname, port, username, password, is_active)
 
63
    alt_key = (hostname, port, username, '********', is_active)
47
64
    if key not in _FTP_cache:
48
 
        mutter("Constructing FTP instance against %r" % key)
49
 
        _FTP_cache[key] = ftplib.FTP(hostname, username, password)
50
 
        _FTP_cache[key].set_pasv(not is_active)
 
65
        mutter("Constructing FTP instance against %r" % (alt_key,))
 
66
        conn = ftplib.FTP()
 
67
 
 
68
        conn.connect(host=hostname, port=port)
 
69
        if username and username != 'anonymous' and not password:
 
70
            password = bzrlib.ui.ui_factory.get_password(
 
71
                prompt='FTP %(user)s@%(host)s password',
 
72
                user=username, host=hostname)
 
73
        conn.login(user=username, passwd=password)
 
74
        conn.set_pasv(not is_active)
 
75
 
 
76
        _FTP_cache[key] = conn
 
77
 
51
78
    return _FTP_cache[key]    
52
79
 
53
80
 
54
 
class FtpTransportError(TransportError):
55
 
    pass
56
 
 
57
 
 
58
81
class FtpStatResult(object):
59
82
    def __init__(self, f, relpath):
60
83
        try:
69
92
                f.cwd(pwd)
70
93
 
71
94
 
72
 
_number_of_retries = 1
 
95
_number_of_retries = 2
 
96
_sleep_between_retries = 5
73
97
 
74
98
class FtpTransport(Transport):
75
99
    """This is the transport agent for ftp:// access."""
77
101
    def __init__(self, base, _provided_instance=None):
78
102
        """Set the base path where files will be stored."""
79
103
        assert base.startswith('ftp://') or base.startswith('aftp://')
80
 
        super(FtpTransport, self).__init__(base)
 
104
 
81
105
        self.is_active = base.startswith('aftp://')
82
106
        if self.is_active:
 
107
            # urlparse won't handle aftp://
83
108
            base = base[1:]
84
 
        (self._proto, self._host,
85
 
            self._path, self._parameters,
86
 
            self._query, self._fragment) = urlparse.urlparse(self.base)
 
109
        if not base.endswith('/'):
 
110
            base += '/'
 
111
        (self._proto, self._username,
 
112
            self._password, self._host,
 
113
            self._port, self._path) = split_url(base)
 
114
        base = self._unparse_url()
 
115
 
 
116
        super(FtpTransport, self).__init__(base)
87
117
        self._FTP_instance = _provided_instance
88
118
 
 
119
    def _unparse_url(self, path=None):
 
120
        if path is None:
 
121
            path = self._path
 
122
        path = urllib.quote(path)
 
123
        netloc = urllib.quote(self._host)
 
124
        if self._username is not None:
 
125
            netloc = '%s@%s' % (urllib.quote(self._username), netloc)
 
126
        if self._port is not None:
 
127
            netloc = '%s:%d' % (netloc, self._port)
 
128
        proto = 'ftp'
 
129
        if self.is_active:
 
130
            proto = 'aftp'
 
131
        return urlparse.urlunparse((proto, netloc, path, '', '', ''))
 
132
 
89
133
    def _get_FTP(self):
90
134
        """Return the ftplib.FTP instance for this object."""
91
135
        if self._FTP_instance is not None:
92
136
            return self._FTP_instance
93
137
        
94
138
        try:
95
 
            username = ''
96
 
            password = ''
97
 
            hostname = self._host
98
 
            if '@' in hostname:
99
 
                username, hostname = hostname.split("@", 1)
100
 
            if ':' in username:
101
 
                username, password = username.split(":", 1)
102
 
 
103
 
            self._FTP_instance = _find_FTP(hostname, username, password,
 
139
            self._FTP_instance = _find_FTP(self._host, self._port,
 
140
                                           self._username, self._password,
104
141
                                           self.is_active)
105
142
            return self._FTP_instance
106
143
        except ftplib.error_perm, e:
107
 
            raise TransportError(msg="Error setting up connection: %s"
 
144
            raise errors.TransportError(msg="Error setting up connection: %s"
108
145
                                    % str(e), orig_error=e)
109
146
 
 
147
    def _translate_perm_error(self, err, path, extra=None, unknown_exc=FtpPathError):
 
148
        """Try to translate an ftplib.error_perm exception.
 
149
 
 
150
        :param err: The error to translate into a bzr error
 
151
        :param path: The path which had problems
 
152
        :param extra: Extra information which can be included
 
153
        :param unknown_exc: If None, we will just raise the original exception
 
154
                    otherwise we raise unknown_exc(path, extra=extra)
 
155
        """
 
156
        s = str(err).lower()
 
157
        if not extra:
 
158
            extra = str(err)
 
159
        else:
 
160
            extra += ': ' + str(err)
 
161
        if ('no such file' in s
 
162
            or 'could not open' in s
 
163
            or 'no such dir' in s
 
164
            or 'could not create file' in s # vsftpd
 
165
            ):
 
166
            raise errors.NoSuchFile(path, extra=extra)
 
167
        if ('file exists' in s):
 
168
            raise errors.FileExists(path, extra=extra)
 
169
        if ('not a directory' in s):
 
170
            raise errors.PathError(path, extra=extra)
 
171
 
 
172
        mutter('unable to understand error for path: %s: %s', path, err)
 
173
 
 
174
        if unknown_exc:
 
175
            raise unknown_exc(path, extra=extra)
 
176
        # TODO: jam 20060516 Consider re-raising the error wrapped in 
 
177
        #       something like TransportError, but this loses the traceback
 
178
        #       Also, 'sftp' has a generic 'Failure' mode, which we use failure_exc
 
179
        #       to handle. Consider doing something like that here.
 
180
        #raise TransportError(msg='Error for path: %s' % (path,), orig_error=e)
 
181
        raise
 
182
 
110
183
    def should_cache(self):
111
184
        """Return True if the data pulled across should be cached locally.
112
185
        """
123
196
 
124
197
    def _abspath(self, relpath):
125
198
        assert isinstance(relpath, basestring)
126
 
        relpath = urllib.unquote(relpath)
127
 
        if isinstance(relpath, basestring):
128
 
            relpath_parts = relpath.split('/')
 
199
        relpath = urlutils.unescape(relpath)
 
200
        if relpath.startswith('/'):
 
201
            basepath = []
129
202
        else:
130
 
            # TODO: Don't call this with an array - no magic interfaces
131
 
            relpath_parts = relpath[:]
132
 
        if len(relpath_parts) > 1:
133
 
            if relpath_parts[0] == '':
134
 
                raise ValueError("path %r within branch %r seems to be absolute"
135
 
                                 % (relpath, self._path))
136
 
        basepath = self._path.split('/')
 
203
            basepath = self._path.split('/')
137
204
        if len(basepath) > 0 and basepath[-1] == '':
138
205
            basepath = basepath[:-1]
139
 
        for p in relpath_parts:
 
206
        for p in relpath.split('/'):
140
207
            if p == '..':
141
208
                if len(basepath) == 0:
142
209
                    # In most filesystems, a request for the parent
150
217
        # Possibly, we could use urlparse.urljoin() here, but
151
218
        # I'm concerned about when it chooses to strip the last
152
219
        # portion of the path, and when it doesn't.
153
 
        return '/'.join(basepath)
 
220
 
 
221
        # XXX: It seems that ftplib does not handle Unicode paths
 
222
        # at the same time, medusa won't handle utf8 paths
 
223
        # So if we .encode(utf8) here, then we get a Server failure.
 
224
        # while if we use str(), we get a UnicodeError, and the test suite
 
225
        # just skips testing UnicodePaths.
 
226
        return str('/'.join(basepath) or '/')
154
227
    
155
228
    def abspath(self, relpath):
156
229
        """Return the full url to the given relative path.
157
230
        This can be supplied with a string or a list
158
231
        """
159
232
        path = self._abspath(relpath)
160
 
        return urlparse.urlunparse((self._proto,
161
 
                self._host, path, '', '', ''))
 
233
        return self._unparse_url(path)
162
234
 
163
235
    def has(self, relpath):
164
 
        """Does the target location exist?
165
 
 
166
 
        XXX: I assume we're never asked has(dirname) and thus I use
167
 
        the FTP size command and assume that if it doesn't raise,
168
 
        all is good.
169
 
        """
 
236
        """Does the target location exist?"""
 
237
        # FIXME jam 20060516 We *do* ask about directories in the test suite
 
238
        #       We don't seem to in the actual codebase
 
239
        # XXX: I assume we're never asked has(dirname) and thus I use
 
240
        # the FTP size command and assume that if it doesn't raise,
 
241
        # all is good.
 
242
        abspath = self._abspath(relpath)
170
243
        try:
171
244
            f = self._get_FTP()
172
 
            s = f.size(self._abspath(relpath))
173
 
            mutter("FTP has: %s" % self._abspath(relpath))
 
245
            mutter('FTP has check: %s => %s', relpath, abspath)
 
246
            s = f.size(abspath)
 
247
            mutter("FTP has: %s", abspath)
174
248
            return True
175
 
        except ftplib.error_perm:
176
 
            mutter("FTP has not: %s" % self._abspath(relpath))
 
249
        except ftplib.error_perm, e:
 
250
            if ('is a directory' in str(e).lower()):
 
251
                mutter("FTP has dir: %s: %s", abspath, e)
 
252
                return True
 
253
            mutter("FTP has not: %s: %s", abspath, e)
177
254
            return False
178
255
 
179
256
    def get(self, relpath, decode=False, retries=0):
186
263
        We're meant to return a file-like object which bzr will
187
264
        then read from. For now we do this via the magic of StringIO
188
265
        """
 
266
        # TODO: decode should be deprecated
189
267
        try:
190
 
            mutter("FTP get: %s" % self._abspath(relpath))
 
268
            mutter("FTP get: %s", self._abspath(relpath))
191
269
            f = self._get_FTP()
192
270
            ret = StringIO()
193
271
            f.retrbinary('RETR '+self._abspath(relpath), ret.write, 8192)
194
272
            ret.seek(0)
195
273
            return ret
196
274
        except ftplib.error_perm, e:
197
 
            raise NoSuchFile(self.abspath(relpath), extra=str(e))
 
275
            raise errors.NoSuchFile(self.abspath(relpath), extra=str(e))
198
276
        except ftplib.error_temp, e:
199
 
            if retries > 1:
200
 
                raise
 
277
            if retries > _number_of_retries:
 
278
                raise errors.TransportError(msg="FTP temporary error during GET %s. Aborting."
 
279
                                     % self.abspath(relpath),
 
280
                                     orig_error=e)
201
281
            else:
202
 
                warning("FTP temporary error: %s. Retrying." % str(e))
 
282
                warning("FTP temporary error: %s. Retrying.", str(e))
203
283
                self._FTP_instance = None
204
284
                return self.get(relpath, decode, retries+1)
205
 
        except EOFError:
 
285
        except EOFError, e:
206
286
            if retries > _number_of_retries:
207
 
                raise
 
287
                raise errors.TransportError("FTP control connection closed during GET %s."
 
288
                                     % self.abspath(relpath),
 
289
                                     orig_error=e)
208
290
            else:
209
291
                warning("FTP control connection closed. Trying to reopen.")
 
292
                time.sleep(_sleep_between_retries)
210
293
                self._FTP_instance = None
211
294
                return self.get(relpath, decode, retries+1)
212
295
 
213
 
    def put(self, relpath, fp, mode=None, retries=0):
 
296
    def put_file(self, relpath, fp, mode=None, retries=0):
214
297
        """Copy the file-like or string object into the location.
215
298
 
216
299
        :param relpath: Location to put the contents, relative to base.
217
 
        :param f:       File-like or string object.
 
300
        :param fp:       File-like or string object.
218
301
        :param retries: Number of retries after temporary failures so far
219
302
                        for this operation.
220
303
 
221
 
        TODO: jam 20051215 This should be an atomic put, not overwritting files in place
222
304
        TODO: jam 20051215 ftp as a protocol seems to support chmod, but ftplib does not
223
305
        """
224
 
        if not hasattr(fp, 'read'):
 
306
        abspath = self._abspath(relpath)
 
307
        tmp_abspath = '%s.tmp.%.9f.%d.%d' % (abspath, time.time(),
 
308
                        os.getpid(), random.randint(0,0x7FFFFFFF))
 
309
        if getattr(fp, 'read', None) is None:
225
310
            fp = StringIO(fp)
226
311
        try:
227
 
            mutter("FTP put: %s" % self._abspath(relpath))
 
312
            mutter("FTP put: %s", abspath)
228
313
            f = self._get_FTP()
229
 
            f.storbinary('STOR '+self._abspath(relpath), fp, 8192)
 
314
            try:
 
315
                f.storbinary('STOR '+tmp_abspath, fp)
 
316
                f.rename(tmp_abspath, abspath)
 
317
            except (ftplib.error_temp,EOFError), e:
 
318
                warning("Failure during ftp PUT. Deleting temporary file.")
 
319
                try:
 
320
                    f.delete(tmp_abspath)
 
321
                except:
 
322
                    warning("Failed to delete temporary file on the"
 
323
                            " server.\nFile: %s", tmp_abspath)
 
324
                    raise e
 
325
                raise
230
326
        except ftplib.error_perm, e:
231
 
            if "no such file" in str(e).lower():
232
 
                raise NoSuchFile("Error storing %s: %s"
233
 
                                 % (self.abspath(relpath), str(e)), extra=e)
234
 
            else:
235
 
                raise FtpTransportError(orig_error=e)
 
327
            self._translate_perm_error(e, abspath, extra='could not store')
236
328
        except ftplib.error_temp, e:
237
329
            if retries > _number_of_retries:
238
 
                raise
 
330
                raise errors.TransportError("FTP temporary error during PUT %s. Aborting."
 
331
                                     % self.abspath(relpath), orig_error=e)
239
332
            else:
240
 
                warning("FTP temporary error: %s. Retrying." % str(e))
 
333
                warning("FTP temporary error: %s. Retrying.", str(e))
241
334
                self._FTP_instance = None
242
 
                self.put(relpath, fp, mode, retries+1)
 
335
                self.put_file(relpath, fp, mode, retries+1)
243
336
        except EOFError:
244
337
            if retries > _number_of_retries:
245
 
                raise
 
338
                raise errors.TransportError("FTP control connection closed during PUT %s."
 
339
                                     % self.abspath(relpath), orig_error=e)
246
340
            else:
247
 
                warning("FTP connection closed. Trying to reopen.")
 
341
                warning("FTP control connection closed. Trying to reopen.")
 
342
                time.sleep(_sleep_between_retries)
248
343
                self._FTP_instance = None
249
 
                self.put(relpath, fp, mode, retries+1)
250
 
 
 
344
                self.put_file(relpath, fp, mode, retries+1)
251
345
 
252
346
    def mkdir(self, relpath, mode=None):
253
347
        """Create a directory at the given path."""
254
 
        try:
255
 
            mutter("FTP mkd: %s" % self._abspath(relpath))
256
 
            f = self._get_FTP()
257
 
            try:
258
 
                f.mkd(self._abspath(relpath))
259
 
            except ftplib.error_perm, e:
260
 
                s = str(e)
261
 
                if 'File exists' in s:
262
 
                    raise FileExists(self.abspath(relpath), extra=s)
263
 
                else:
264
 
                    raise
265
 
        except ftplib.error_perm, e:
266
 
            raise TransportError(orig_error=e)
267
 
 
268
 
    def append(self, relpath, f):
 
348
        abspath = self._abspath(relpath)
 
349
        try:
 
350
            mutter("FTP mkd: %s", abspath)
 
351
            f = self._get_FTP()
 
352
            f.mkd(abspath)
 
353
        except ftplib.error_perm, e:
 
354
            self._translate_perm_error(e, abspath,
 
355
                unknown_exc=errors.FileExists)
 
356
 
 
357
    def rmdir(self, rel_path):
 
358
        """Delete the directory at rel_path"""
 
359
        abspath = self._abspath(rel_path)
 
360
        try:
 
361
            mutter("FTP rmd: %s", abspath)
 
362
            f = self._get_FTP()
 
363
            f.rmd(abspath)
 
364
        except ftplib.error_perm, e:
 
365
            self._translate_perm_error(e, abspath, unknown_exc=errors.PathError)
 
366
 
 
367
    def append_file(self, relpath, f, mode=None):
269
368
        """Append the text in the file-like object into the final
270
369
        location.
271
370
        """
272
 
        raise TransportNotPossible('ftp does not support append()')
273
 
 
274
 
    def copy(self, rel_from, rel_to):
275
 
        """Copy the item at rel_from to the location at rel_to"""
276
 
        raise TransportNotPossible('ftp does not (yet) support copy()')
 
371
        abspath = self._abspath(relpath)
 
372
        if self.has(relpath):
 
373
            ftp = self._get_FTP()
 
374
            result = ftp.size(abspath)
 
375
        else:
 
376
            result = 0
 
377
 
 
378
        mutter("FTP appe to %s", abspath)
 
379
        self._try_append(relpath, f.read(), mode)
 
380
 
 
381
        return result
 
382
 
 
383
    def _try_append(self, relpath, text, mode=None, retries=0):
 
384
        """Try repeatedly to append the given text to the file at relpath.
 
385
        
 
386
        This is a recursive function. On errors, it will be called until the
 
387
        number of retries is exceeded.
 
388
        """
 
389
        try:
 
390
            abspath = self._abspath(relpath)
 
391
            mutter("FTP appe (try %d) to %s", retries, abspath)
 
392
            ftp = self._get_FTP()
 
393
            ftp.voidcmd("TYPE I")
 
394
            cmd = "APPE %s" % abspath
 
395
            conn = ftp.transfercmd(cmd)
 
396
            conn.sendall(text)
 
397
            conn.close()
 
398
            if mode:
 
399
                self._setmode(relpath, mode)
 
400
            ftp.getresp()
 
401
        except ftplib.error_perm, e:
 
402
            self._translate_perm_error(e, abspath, extra='error appending',
 
403
                unknown_exc=errors.NoSuchFile)
 
404
        except ftplib.error_temp, e:
 
405
            if retries > _number_of_retries:
 
406
                raise errors.TransportError("FTP temporary error during APPEND %s." \
 
407
                        "Aborting." % abspath, orig_error=e)
 
408
            else:
 
409
                warning("FTP temporary error: %s. Retrying.", str(e))
 
410
                self._FTP_instance = None
 
411
                self._try_append(relpath, text, mode, retries+1)
 
412
 
 
413
    def _setmode(self, relpath, mode):
 
414
        """Set permissions on a path.
 
415
 
 
416
        Only set permissions if the FTP server supports the 'SITE CHMOD'
 
417
        extension.
 
418
        """
 
419
        try:
 
420
            mutter("FTP site chmod: setting permissions to %s on %s",
 
421
                str(mode), self._abspath(relpath))
 
422
            ftp = self._get_FTP()
 
423
            cmd = "SITE CHMOD %s %s" % (self._abspath(relpath), str(mode))
 
424
            ftp.sendcmd(cmd)
 
425
        except ftplib.error_perm, e:
 
426
            # Command probably not available on this server
 
427
            warning("FTP Could not set permissions to %s on %s. %s",
 
428
                    str(mode), self._abspath(relpath), str(e))
 
429
 
 
430
    # TODO: jam 20060516 I believe ftp allows you to tell an ftp server
 
431
    #       to copy something to another machine. And you may be able
 
432
    #       to give it its own address as the 'to' location.
 
433
    #       So implement a fancier 'copy()'
277
434
 
278
435
    def move(self, rel_from, rel_to):
279
436
        """Move the item at rel_from to the location at rel_to"""
 
437
        abs_from = self._abspath(rel_from)
 
438
        abs_to = self._abspath(rel_to)
280
439
        try:
281
 
            mutter("FTP mv: %s => %s" % (self._abspath(rel_from),
282
 
                                         self._abspath(rel_to)))
 
440
            mutter("FTP mv: %s => %s", abs_from, abs_to)
283
441
            f = self._get_FTP()
284
 
            f.rename(self._abspath(rel_from), self._abspath(rel_to))
 
442
            f.rename(abs_from, abs_to)
285
443
        except ftplib.error_perm, e:
286
 
            raise TransportError(orig_error=e)
 
444
            self._translate_perm_error(e, abs_from,
 
445
                extra='unable to rename to %r' % (rel_to,), 
 
446
                unknown_exc=errors.PathError)
 
447
 
 
448
    rename = move
287
449
 
288
450
    def delete(self, relpath):
289
451
        """Delete the item at relpath"""
 
452
        abspath = self._abspath(relpath)
290
453
        try:
291
 
            mutter("FTP rm: %s" % self._abspath(relpath))
 
454
            mutter("FTP rm: %s", abspath)
292
455
            f = self._get_FTP()
293
 
            f.delete(self._abspath(relpath))
 
456
            f.delete(abspath)
294
457
        except ftplib.error_perm, e:
295
 
            raise TransportError(orig_error=e)
 
458
            self._translate_perm_error(e, abspath, 'error deleting',
 
459
                unknown_exc=errors.NoSuchFile)
296
460
 
297
461
    def listable(self):
298
462
        """See Transport.listable."""
300
464
 
301
465
    def list_dir(self, relpath):
302
466
        """See Transport.list_dir."""
 
467
        basepath = self._abspath(relpath)
 
468
        mutter("FTP nlst: %s", basepath)
 
469
        f = self._get_FTP()
303
470
        try:
304
 
            mutter("FTP nlst: %s" % self._abspath(relpath))
305
 
            f = self._get_FTP()
306
 
            basepath = self._abspath(relpath)
307
 
            # FTP.nlst returns paths prefixed by relpath, strip 'em
308
 
            the_list = f.nlst(basepath)
309
 
            stripped = [path[len(basepath)+1:] for path in the_list]
310
 
            # Remove . and .. if present, and return
311
 
            return [path for path in stripped if path not in (".", "..")]
 
471
            paths = f.nlst(basepath)
312
472
        except ftplib.error_perm, e:
313
 
            raise TransportError(orig_error=e)
 
473
            self._translate_perm_error(e, relpath, extra='error with list_dir')
 
474
        # If FTP.nlst returns paths prefixed by relpath, strip 'em
 
475
        if paths and paths[0].startswith(basepath):
 
476
            entries = [path[len(basepath)+1:] for path in paths]
 
477
        else:
 
478
            entries = paths
 
479
        # Remove . and .. if present
 
480
        return [urlutils.escape(entry) for entry in entries
 
481
                if entry not in ('.', '..')]
314
482
 
315
483
    def iter_files_recursive(self):
316
484
        """See Transport.iter_files_recursive.
319
487
        mutter("FTP iter_files_recursive")
320
488
        queue = list(self.list_dir("."))
321
489
        while queue:
322
 
            relpath = urllib.quote(queue.pop(0))
 
490
            relpath = queue.pop(0)
323
491
            st = self.stat(relpath)
324
492
            if stat.S_ISDIR(st.st_mode):
325
493
                for i, basename in enumerate(self.list_dir(relpath)):
328
496
                yield relpath
329
497
 
330
498
    def stat(self, relpath):
331
 
        """Return the stat information for a file.
332
 
        """
 
499
        """Return the stat information for a file."""
 
500
        abspath = self._abspath(relpath)
333
501
        try:
334
 
            mutter("FTP stat: %s" % self._abspath(relpath))
 
502
            mutter("FTP stat: %s", abspath)
335
503
            f = self._get_FTP()
336
 
            return FtpStatResult(f, self._abspath(relpath))
 
504
            return FtpStatResult(f, abspath)
337
505
        except ftplib.error_perm, e:
338
 
            raise TransportError(orig_error=e)
 
506
            self._translate_perm_error(e, abspath, extra='error w/ stat')
339
507
 
340
508
    def lock_read(self, relpath):
341
509
        """Lock the given file for shared (read) access.
359
527
        return self.lock_read(relpath)
360
528
 
361
529
 
 
530
class FtpServer(Server):
 
531
    """Common code for SFTP server facilities."""
 
532
 
 
533
    def __init__(self):
 
534
        self._root = None
 
535
        self._ftp_server = None
 
536
        self._port = None
 
537
        self._async_thread = None
 
538
        # ftp server logs
 
539
        self.logs = []
 
540
 
 
541
    def get_url(self):
 
542
        """Calculate an ftp url to this server."""
 
543
        return 'ftp://foo:bar@localhost:%d/' % (self._port)
 
544
 
 
545
#    def get_bogus_url(self):
 
546
#        """Return a URL which cannot be connected to."""
 
547
#        return 'ftp://127.0.0.1:1'
 
548
 
 
549
    def log(self, message):
 
550
        """This is used by medusa.ftp_server to log connections, etc."""
 
551
        self.logs.append(message)
 
552
 
 
553
    def setUp(self):
 
554
 
 
555
        if not _have_medusa:
 
556
            raise RuntimeError('Must have medusa to run the FtpServer')
 
557
 
 
558
        self._root = os.getcwdu()
 
559
        self._ftp_server = _ftp_server(
 
560
            authorizer=_test_authorizer(root=self._root),
 
561
            ip='localhost',
 
562
            port=0, # bind to a random port
 
563
            resolver=None,
 
564
            logger_object=self # Use FtpServer.log() for messages
 
565
            )
 
566
        self._port = self._ftp_server.getsockname()[1]
 
567
        # Don't let it loop forever, or handle an infinite number of requests.
 
568
        # In this case it will run for 100s, or 1000 requests
 
569
        self._async_thread = threading.Thread(target=asyncore.loop,
 
570
                kwargs={'timeout':0.1, 'count':1000})
 
571
        self._async_thread.setDaemon(True)
 
572
        self._async_thread.start()
 
573
 
 
574
    def tearDown(self):
 
575
        """See bzrlib.transport.Server.tearDown."""
 
576
        # have asyncore release the channel
 
577
        self._ftp_server.del_channel()
 
578
        asyncore.close_all()
 
579
        self._async_thread.join()
 
580
 
 
581
 
 
582
_ftp_channel = None
 
583
_ftp_server = None
 
584
_test_authorizer = None
 
585
 
 
586
 
 
587
def _setup_medusa():
 
588
    global _have_medusa, _ftp_channel, _ftp_server, _test_authorizer
 
589
    try:
 
590
        import medusa
 
591
        import medusa.filesys
 
592
        import medusa.ftp_server
 
593
    except ImportError:
 
594
        return False
 
595
 
 
596
    _have_medusa = True
 
597
 
 
598
    class test_authorizer(object):
 
599
        """A custom Authorizer object for running the test suite.
 
600
 
 
601
        The reason we cannot use dummy_authorizer, is because it sets the
 
602
        channel to readonly, which we don't always want to do.
 
603
        """
 
604
 
 
605
        def __init__(self, root):
 
606
            self.root = root
 
607
 
 
608
        def authorize(self, channel, username, password):
 
609
            """Return (success, reply_string, filesystem)"""
 
610
            if not _have_medusa:
 
611
                return 0, 'No Medusa.', None
 
612
 
 
613
            channel.persona = -1, -1
 
614
            if username == 'anonymous':
 
615
                channel.read_only = 1
 
616
            else:
 
617
                channel.read_only = 0
 
618
 
 
619
            return 1, 'OK.', medusa.filesys.os_filesystem(self.root)
 
620
 
 
621
 
 
622
    class ftp_channel(medusa.ftp_server.ftp_channel):
 
623
        """Customized ftp channel"""
 
624
 
 
625
        def log(self, message):
 
626
            """Redirect logging requests."""
 
627
            mutter('_ftp_channel: %s', message)
 
628
            
 
629
        def log_info(self, message, type='info'):
 
630
            """Redirect logging requests."""
 
631
            mutter('_ftp_channel %s: %s', type, message)
 
632
            
 
633
        def cmd_rnfr(self, line):
 
634
            """Prepare for renaming a file."""
 
635
            self._renaming = line[1]
 
636
            self.respond('350 Ready for RNTO')
 
637
            # TODO: jam 20060516 in testing, the ftp server seems to
 
638
            #       check that the file already exists, or it sends
 
639
            #       550 RNFR command failed
 
640
 
 
641
        def cmd_rnto(self, line):
 
642
            """Rename a file based on the target given.
 
643
 
 
644
            rnto must be called after calling rnfr.
 
645
            """
 
646
            if not self._renaming:
 
647
                self.respond('503 RNFR required first.')
 
648
            pfrom = self.filesystem.translate(self._renaming)
 
649
            self._renaming = None
 
650
            pto = self.filesystem.translate(line[1])
 
651
            try:
 
652
                os.rename(pfrom, pto)
 
653
            except (IOError, OSError), e:
 
654
                # TODO: jam 20060516 return custom responses based on
 
655
                #       why the command failed
 
656
                self.respond('550 RNTO failed: %s' % (e,))
 
657
            except:
 
658
                self.respond('550 RNTO failed')
 
659
                # For a test server, we will go ahead and just die
 
660
                raise
 
661
            else:
 
662
                self.respond('250 Rename successful.')
 
663
 
 
664
        def cmd_size(self, line):
 
665
            """Return the size of a file
 
666
 
 
667
            This is overloaded to help the test suite determine if the 
 
668
            target is a directory.
 
669
            """
 
670
            filename = line[1]
 
671
            if not self.filesystem.isfile(filename):
 
672
                if self.filesystem.isdir(filename):
 
673
                    self.respond('550 "%s" is a directory' % (filename,))
 
674
                else:
 
675
                    self.respond('550 "%s" is not a file' % (filename,))
 
676
            else:
 
677
                self.respond('213 %d' 
 
678
                    % (self.filesystem.stat(filename)[stat.ST_SIZE]),)
 
679
 
 
680
        def cmd_mkd(self, line):
 
681
            """Create a directory.
 
682
 
 
683
            Overloaded because default implementation does not distinguish
 
684
            *why* it cannot make a directory.
 
685
            """
 
686
            if len (line) != 2:
 
687
                self.command_not_understood(''.join(line))
 
688
            else:
 
689
                path = line[1]
 
690
                try:
 
691
                    self.filesystem.mkdir (path)
 
692
                    self.respond ('257 MKD command successful.')
 
693
                except (IOError, OSError), e:
 
694
                    self.respond ('550 error creating directory: %s' % (e,))
 
695
                except:
 
696
                    self.respond ('550 error creating directory.')
 
697
 
 
698
 
 
699
    class ftp_server(medusa.ftp_server.ftp_server):
 
700
        """Customize the behavior of the Medusa ftp_server.
 
701
 
 
702
        There are a few warts on the ftp_server, based on how it expects
 
703
        to be used.
 
704
        """
 
705
        _renaming = None
 
706
        ftp_channel_class = ftp_channel
 
707
 
 
708
        def __init__(self, *args, **kwargs):
 
709
            mutter('Initializing _ftp_server: %r, %r', args, kwargs)
 
710
            medusa.ftp_server.ftp_server.__init__(self, *args, **kwargs)
 
711
 
 
712
        def log(self, message):
 
713
            """Redirect logging requests."""
 
714
            mutter('_ftp_server: %s', message)
 
715
 
 
716
        def log_info(self, message, type='info'):
 
717
            """Override the asyncore.log_info so we don't stipple the screen."""
 
718
            mutter('_ftp_server %s: %s', type, message)
 
719
 
 
720
    _test_authorizer = test_authorizer
 
721
    _ftp_channel = ftp_channel
 
722
    _ftp_server = ftp_server
 
723
 
 
724
    return True
 
725
 
 
726
 
362
727
def get_test_permutations():
363
728
    """Return the permutations to be used in testing."""
364
 
    warn("There are no FTP transport provider tests yet.")
365
 
    return []
 
729
    if not _setup_medusa():
 
730
        warn("You must install medusa (http://www.amk.ca/python/code/medusa.html) for FTP tests")
 
731
        return []
 
732
    else:
 
733
        return [(FtpTransport, FtpServer)]