← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ftp.py

Fix BzrDir.create_workingtree for NULL_REVISION

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