← 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-11-28 05:13:41 UTC
  • mfrom: (1185.33.54 merge-recovered)
  • Revision ID: robertc@robertcollins.net-20051128051341-059936f2f29a12c8
Merge from Martin. Adjust check to work with HTTP again.

Show diffs side-by-side

added added

removed removed

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