← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ftp.py

  • Committer: Robey Pointer
  • Date: 2006-09-08 18:46:29 UTC
  • mto: This revision was merged to the branch mainline in revision 1996.
  • Revision ID: robey@lag.net-20060908184629-e3fc4c61ca21508c
pychecker is on crack; go back to using 'is None'.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/ftp.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
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
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
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
16
"""Implementation of Transport over ftp.
18
17
 
19
18
Written by Daniel Silverstone <dsilvers@digital-scurf.org> with serious
26
25
"""
27
26
 
28
27
from cStringIO import StringIO
 
28
import asyncore
 
29
import errno
29
30
import ftplib
30
 
import getpass
31
31
import os
32
 
import random
33
 
import socket
 
32
import urllib
 
33
import urlparse
34
34
import stat
 
35
import threading
35
36
import time
 
37
import random
 
38
from warnings import warn
36
39
 
37
40
from bzrlib import (
38
 
    config,
39
41
    errors,
40
 
    osutils,
41
42
    urlutils,
42
43
    )
43
44
from bzrlib.trace import mutter, warning
44
45
from bzrlib.transport import (
45
 
    AppendBasedFileStream,
46
 
    ConnectedTransport,
47
 
    _file_streams,
48
 
    register_urlparse_netloc_protocol,
49
46
    Server,
 
47
    split_url,
 
48
    Transport,
50
49
    )
51
 
 
52
 
 
53
 
register_urlparse_netloc_protocol('aftp')
 
50
import bzrlib.ui
 
51
 
 
52
_have_medusa = False
54
53
 
55
54
 
56
55
class FtpPathError(errors.PathError):
57
56
    """FTP failed for path: %(path)s%(extra)s"""
58
57
 
59
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]    
 
79
 
 
80
 
60
81
class FtpStatResult(object):
61
 
 
62
 
    def __init__(self, f, abspath):
 
82
    def __init__(self, f, relpath):
63
83
        try:
64
 
            self.st_size = f.size(abspath)
 
84
            self.st_size = f.size(relpath)
65
85
            self.st_mode = stat.S_IFREG
66
86
        except ftplib.error_perm:
67
87
            pwd = f.pwd()
68
88
            try:
69
 
                f.cwd(abspath)
 
89
                f.cwd(relpath)
70
90
                self.st_mode = stat.S_IFDIR
71
91
            finally:
72
92
                f.cwd(pwd)
75
95
_number_of_retries = 2
76
96
_sleep_between_retries = 5
77
97
 
78
 
# FIXME: there are inconsistencies in the way temporary errors are
79
 
# handled. Sometimes we reconnect, sometimes we raise an exception. Care should
80
 
# be taken to analyze the implications for write operations (read operations
81
 
# are safe to retry). Overall even some read operations are never
82
 
# retried. --vila 20070720 (Bug #127164)
83
 
class FtpTransport(ConnectedTransport):
 
98
class FtpTransport(Transport):
84
99
    """This is the transport agent for ftp:// access."""
85
100
 
86
 
    def __init__(self, base, _from_transport=None):
 
101
    def __init__(self, base, _provided_instance=None):
87
102
        """Set the base path where files will be stored."""
88
 
        if not (base.startswith('ftp://') or base.startswith('aftp://')):
89
 
            raise ValueError(base)
90
 
        super(FtpTransport, self).__init__(base,
91
 
                                           _from_transport=_from_transport)
92
 
        self._unqualified_scheme = 'ftp'
93
 
        if self._scheme == 'aftp':
94
 
            self.is_active = True
95
 
        else:
96
 
            self.is_active = False
97
 
 
98
 
        # Most modern FTP servers support the APPE command. If ours doesn't, we
99
 
        # (re)set this flag accordingly later.
100
 
        self._has_append = True
 
103
        assert base.startswith('ftp://') or base.startswith('aftp://')
 
104
 
 
105
        self.is_active = base.startswith('aftp://')
 
106
        if self.is_active:
 
107
            # urlparse won't handle aftp://
 
108
            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)
 
117
        self._FTP_instance = _provided_instance
 
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, '', '', ''))
101
132
 
102
133
    def _get_FTP(self):
103
134
        """Return the ftplib.FTP instance for this object."""
104
 
        # Ensures that a connection is established
105
 
        connection = self._get_connection()
106
 
        if connection is None:
107
 
            # First connection ever
108
 
            connection, credentials = self._create_connection()
109
 
            self._set_connection(connection, credentials)
110
 
        return connection
111
 
 
112
 
    connection_class = ftplib.FTP
113
 
 
114
 
    def _create_connection(self, credentials=None):
115
 
        """Create a new connection with the provided credentials.
116
 
 
117
 
        :param credentials: The credentials needed to establish the connection.
118
 
 
119
 
        :return: The created connection and its associated credentials.
120
 
 
121
 
        The input credentials are only the password as it may have been
122
 
        entered interactively by the user and may be different from the one
123
 
        provided in base url at transport creation time.  The returned
124
 
        credentials are username, password.
125
 
        """
126
 
        if credentials is None:
127
 
            user, password = self._user, self._password
128
 
        else:
129
 
            user, password = credentials
130
 
 
131
 
        auth = config.AuthenticationConfig()
132
 
        if user is None:
133
 
            user = auth.get_user('ftp', self._host, port=self._port,
134
 
                                 default=getpass.getuser())
135
 
        mutter("Constructing FTP instance against %r" %
136
 
               ((self._host, self._port, user, '********',
137
 
                self.is_active),))
 
135
        if self._FTP_instance is not None:
 
136
            return self._FTP_instance
 
137
        
138
138
        try:
139
 
            connection = self.connection_class()
140
 
            connection.connect(host=self._host, port=self._port)
141
 
            self._login(connection, auth, user, password)
142
 
            connection.set_pasv(not self.is_active)
143
 
            # binary mode is the default
144
 
            connection.voidcmd('TYPE I')
145
 
        except socket.error, e:
146
 
            raise errors.SocketConnectionError(self._host, self._port,
147
 
                                               msg='Unable to connect to',
148
 
                                               orig_error= e)
 
139
            self._FTP_instance = _find_FTP(self._host, self._port,
 
140
                                           self._username, self._password,
 
141
                                           self.is_active)
 
142
            return self._FTP_instance
149
143
        except ftplib.error_perm, e:
150
 
            raise errors.TransportError(msg="Error setting up connection:"
151
 
                                        " %s" % str(e), orig_error=e)
152
 
        return connection, (user, password)
153
 
 
154
 
    def _login(self, connection, auth, user, password):
155
 
        # '' is a valid password
156
 
        if user and user != 'anonymous' and password is None:
157
 
            password = auth.get_password('ftp', self._host,
158
 
                                         user, port=self._port)
159
 
        connection.login(user=user, passwd=password)
160
 
 
161
 
    def _reconnect(self):
162
 
        """Create a new connection with the previously used credentials"""
163
 
        credentials = self._get_credentials()
164
 
        connection, credentials = self._create_connection(credentials)
165
 
        self._set_connection(connection, credentials)
166
 
 
167
 
    def _translate_ftp_error(self, err, path, extra=None,
168
 
                              unknown_exc=FtpPathError):
169
 
        """Try to translate an ftplib exception to a bzrlib exception.
 
144
            raise errors.TransportError(msg="Error setting up connection: %s"
 
145
                                    % str(e), orig_error=e)
 
146
 
 
147
    def _translate_perm_error(self, err, path, extra=None, unknown_exc=FtpPathError):
 
148
        """Try to translate an ftplib.error_perm exception.
170
149
 
171
150
        :param err: The error to translate into a bzr error
172
151
        :param path: The path which had problems
174
153
        :param unknown_exc: If None, we will just raise the original exception
175
154
                    otherwise we raise unknown_exc(path, extra=extra)
176
155
        """
177
 
        # ftp error numbers are very generic, like "451: Requested action aborted,
178
 
        # local error in processing" so unfortunately we have to match by
179
 
        # strings.
180
156
        s = str(err).lower()
181
157
        if not extra:
182
158
            extra = str(err)
185
161
        if ('no such file' in s
186
162
            or 'could not open' in s
187
163
            or 'no such dir' in s
188
 
            or 'could not create file' in s # vsftpd
189
 
            or 'file doesn\'t exist' in s
190
 
            or 'rnfr command failed.' in s # vsftpd RNFR reply if file not found
191
 
            or 'file/directory not found' in s # filezilla server
192
 
            # Microsoft FTP-Service RNFR reply if file not found
193
 
            or (s.startswith('550 ') and 'unable to rename to' in extra)
194
164
            ):
195
165
            raise errors.NoSuchFile(path, extra=extra)
196
 
        elif ('file exists' in s):
 
166
        if ('file exists' in s):
197
167
            raise errors.FileExists(path, extra=extra)
198
 
        elif ('not a directory' in s):
 
168
        if ('not a directory' in s):
199
169
            raise errors.PathError(path, extra=extra)
200
 
        elif 'directory not empty' in s:
201
 
            raise errors.DirectoryNotEmpty(path, extra=extra)
202
170
 
203
171
        mutter('unable to understand error for path: %s: %s', path, err)
204
172
 
205
173
        if unknown_exc:
206
174
            raise unknown_exc(path, extra=extra)
207
 
        # TODO: jam 20060516 Consider re-raising the error wrapped in
 
175
        # TODO: jam 20060516 Consider re-raising the error wrapped in 
208
176
        #       something like TransportError, but this loses the traceback
209
177
        #       Also, 'sftp' has a generic 'Failure' mode, which we use failure_exc
210
178
        #       to handle. Consider doing something like that here.
211
179
        #raise TransportError(msg='Error for path: %s' % (path,), orig_error=e)
212
180
        raise
213
181
 
 
182
    def should_cache(self):
 
183
        """Return True if the data pulled across should be cached locally.
 
184
        """
 
185
        return True
 
186
 
 
187
    def clone(self, offset=None):
 
188
        """Return a new FtpTransport with root at self.base + offset.
 
189
        """
 
190
        mutter("FTP clone")
 
191
        if offset is None:
 
192
            return FtpTransport(self.base, self._FTP_instance)
 
193
        else:
 
194
            return FtpTransport(self.abspath(offset), self._FTP_instance)
 
195
 
 
196
    def _abspath(self, relpath):
 
197
        assert isinstance(relpath, basestring)
 
198
        relpath = urlutils.unescape(relpath)
 
199
        relpath_parts = relpath.split('/')
 
200
        if len(relpath_parts) > 1:
 
201
            if relpath_parts[0] == '':
 
202
                raise ValueError("path %r within branch %r seems to be absolute"
 
203
                                 % (relpath, self._path))
 
204
        basepath = self._path.split('/')
 
205
        if len(basepath) > 0 and basepath[-1] == '':
 
206
            basepath = basepath[:-1]
 
207
        for p in relpath_parts:
 
208
            if p == '..':
 
209
                if len(basepath) == 0:
 
210
                    # In most filesystems, a request for the parent
 
211
                    # of root, just returns root.
 
212
                    continue
 
213
                basepath.pop()
 
214
            elif p == '.' or p == '':
 
215
                continue # No-op
 
216
            else:
 
217
                basepath.append(p)
 
218
        # Possibly, we could use urlparse.urljoin() here, but
 
219
        # I'm concerned about when it chooses to strip the last
 
220
        # portion of the path, and when it doesn't.
 
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 '/')
 
228
    
 
229
    def abspath(self, relpath):
 
230
        """Return the full url to the given relative path.
 
231
        This can be supplied with a string or a list
 
232
        """
 
233
        path = self._abspath(relpath)
 
234
        return self._unparse_url(path)
 
235
 
214
236
    def has(self, relpath):
215
237
        """Does the target location exist?"""
216
238
        # FIXME jam 20060516 We *do* ask about directories in the test suite
218
240
        # XXX: I assume we're never asked has(dirname) and thus I use
219
241
        # the FTP size command and assume that if it doesn't raise,
220
242
        # all is good.
221
 
        abspath = self._remote_path(relpath)
 
243
        abspath = self._abspath(relpath)
222
244
        try:
223
245
            f = self._get_FTP()
224
246
            mutter('FTP has check: %s => %s', relpath, abspath)
244
266
        """
245
267
        # TODO: decode should be deprecated
246
268
        try:
247
 
            mutter("FTP get: %s", self._remote_path(relpath))
 
269
            mutter("FTP get: %s", self._abspath(relpath))
248
270
            f = self._get_FTP()
249
271
            ret = StringIO()
250
 
            f.retrbinary('RETR '+self._remote_path(relpath), ret.write, 8192)
 
272
            f.retrbinary('RETR '+self._abspath(relpath), ret.write, 8192)
251
273
            ret.seek(0)
252
274
            return ret
253
275
        except ftplib.error_perm, e:
259
281
                                     orig_error=e)
260
282
            else:
261
283
                warning("FTP temporary error: %s. Retrying.", str(e))
262
 
                self._reconnect()
 
284
                self._FTP_instance = None
263
285
                return self.get(relpath, decode, retries+1)
264
286
        except EOFError, e:
265
287
            if retries > _number_of_retries:
269
291
            else:
270
292
                warning("FTP control connection closed. Trying to reopen.")
271
293
                time.sleep(_sleep_between_retries)
272
 
                self._reconnect()
 
294
                self._FTP_instance = None
273
295
                return self.get(relpath, decode, retries+1)
274
296
 
275
 
    def put_file(self, relpath, fp, mode=None, retries=0):
 
297
    def put(self, relpath, fp, mode=None, retries=0):
276
298
        """Copy the file-like or string object into the location.
277
299
 
278
300
        :param relpath: Location to put the contents, relative to base.
280
302
        :param retries: Number of retries after temporary failures so far
281
303
                        for this operation.
282
304
 
283
 
        TODO: jam 20051215 ftp as a protocol seems to support chmod, but
284
 
        ftplib does not
 
305
        TODO: jam 20051215 ftp as a protocol seems to support chmod, but ftplib does not
285
306
        """
286
 
        abspath = self._remote_path(relpath)
 
307
        abspath = self._abspath(relpath)
287
308
        tmp_abspath = '%s.tmp.%.9f.%d.%d' % (abspath, time.time(),
288
309
                        os.getpid(), random.randint(0,0x7FFFFFFF))
289
 
        bytes = None
290
310
        if getattr(fp, 'read', None) is None:
291
 
            # hand in a string IO
292
 
            bytes = fp
293
 
            fp = StringIO(bytes)
294
 
        else:
295
 
            # capture the byte count; .read() may be read only so
296
 
            # decorate it.
297
 
            class byte_counter(object):
298
 
                def __init__(self, fp):
299
 
                    self.fp = fp
300
 
                    self.counted_bytes = 0
301
 
                def read(self, count):
302
 
                    result = self.fp.read(count)
303
 
                    self.counted_bytes += len(result)
304
 
                    return result
305
 
            fp = byte_counter(fp)
 
311
            fp = StringIO(fp)
306
312
        try:
307
313
            mutter("FTP put: %s", abspath)
308
314
            f = self._get_FTP()
309
315
            try:
310
316
                f.storbinary('STOR '+tmp_abspath, fp)
311
 
                self._rename_and_overwrite(tmp_abspath, abspath, f)
312
 
                self._setmode(relpath, mode)
313
 
                if bytes is not None:
314
 
                    return len(bytes)
315
 
                else:
316
 
                    return fp.counted_bytes
 
317
                f.rename(tmp_abspath, abspath)
317
318
            except (ftplib.error_temp,EOFError), e:
318
319
                warning("Failure during ftp PUT. Deleting temporary file.")
319
320
                try:
324
325
                    raise e
325
326
                raise
326
327
        except ftplib.error_perm, e:
327
 
            self._translate_ftp_error(e, abspath, extra='could not store',
328
 
                                       unknown_exc=errors.NoSuchFile)
 
328
            self._translate_perm_error(e, abspath, extra='could not store')
329
329
        except ftplib.error_temp, e:
330
330
            if retries > _number_of_retries:
331
331
                raise errors.TransportError("FTP temporary error during PUT %s. Aborting."
332
332
                                     % self.abspath(relpath), orig_error=e)
333
333
            else:
334
334
                warning("FTP temporary error: %s. Retrying.", str(e))
335
 
                self._reconnect()
336
 
                self.put_file(relpath, fp, mode, retries+1)
 
335
                self._FTP_instance = None
 
336
                self.put(relpath, fp, mode, retries+1)
337
337
        except EOFError:
338
338
            if retries > _number_of_retries:
339
339
                raise errors.TransportError("FTP control connection closed during PUT %s."
341
341
            else:
342
342
                warning("FTP control connection closed. Trying to reopen.")
343
343
                time.sleep(_sleep_between_retries)
344
 
                self._reconnect()
345
 
                self.put_file(relpath, fp, mode, retries+1)
 
344
                self._FTP_instance = None
 
345
                self.put(relpath, fp, mode, retries+1)
346
346
 
347
347
    def mkdir(self, relpath, mode=None):
348
348
        """Create a directory at the given path."""
349
 
        abspath = self._remote_path(relpath)
 
349
        abspath = self._abspath(relpath)
350
350
        try:
351
351
            mutter("FTP mkd: %s", abspath)
352
352
            f = self._get_FTP()
353
353
            f.mkd(abspath)
354
 
            self._setmode(relpath, mode)
355
354
        except ftplib.error_perm, e:
356
 
            self._translate_ftp_error(e, abspath,
 
355
            self._translate_perm_error(e, abspath,
357
356
                unknown_exc=errors.FileExists)
358
357
 
359
 
    def open_write_stream(self, relpath, mode=None):
360
 
        """See Transport.open_write_stream."""
361
 
        self.put_bytes(relpath, "", mode)
362
 
        result = AppendBasedFileStream(self, relpath)
363
 
        _file_streams[self.abspath(relpath)] = result
364
 
        return result
365
 
 
366
 
    def recommended_page_size(self):
367
 
        """See Transport.recommended_page_size().
368
 
 
369
 
        For FTP we suggest a large page size to reduce the overhead
370
 
        introduced by latency.
371
 
        """
372
 
        return 64 * 1024
373
 
 
374
358
    def rmdir(self, rel_path):
375
359
        """Delete the directory at rel_path"""
376
 
        abspath = self._remote_path(rel_path)
 
360
        abspath = self._abspath(rel_path)
377
361
        try:
378
362
            mutter("FTP rmd: %s", abspath)
379
363
            f = self._get_FTP()
380
364
            f.rmd(abspath)
381
365
        except ftplib.error_perm, e:
382
 
            self._translate_ftp_error(e, abspath, unknown_exc=errors.PathError)
 
366
            self._translate_perm_error(e, abspath, unknown_exc=errors.PathError)
383
367
 
384
 
    def append_file(self, relpath, f, mode=None):
 
368
    def append(self, relpath, f, mode=None):
385
369
        """Append the text in the file-like object into the final
386
370
        location.
387
371
        """
388
 
        text = f.read()
389
 
        abspath = self._remote_path(relpath)
 
372
        abspath = self._abspath(relpath)
390
373
        if self.has(relpath):
391
374
            ftp = self._get_FTP()
392
375
            result = ftp.size(abspath)
393
376
        else:
394
377
            result = 0
395
378
 
396
 
        if self._has_append:
397
 
            mutter("FTP appe to %s", abspath)
398
 
            self._try_append(relpath, text, mode)
399
 
        else:
400
 
            self._fallback_append(relpath, text, mode)
 
379
        mutter("FTP appe to %s", abspath)
 
380
        self._try_append(relpath, f.read(), mode)
401
381
 
402
382
        return result
403
383
 
404
384
    def _try_append(self, relpath, text, mode=None, retries=0):
405
385
        """Try repeatedly to append the given text to the file at relpath.
406
 
 
 
386
        
407
387
        This is a recursive function. On errors, it will be called until the
408
388
        number of retries is exceeded.
409
389
        """
410
390
        try:
411
 
            abspath = self._remote_path(relpath)
 
391
            abspath = self._abspath(relpath)
412
392
            mutter("FTP appe (try %d) to %s", retries, abspath)
413
393
            ftp = self._get_FTP()
 
394
            ftp.voidcmd("TYPE I")
414
395
            cmd = "APPE %s" % abspath
415
396
            conn = ftp.transfercmd(cmd)
416
397
            conn.sendall(text)
417
398
            conn.close()
418
 
            self._setmode(relpath, mode)
 
399
            if mode:
 
400
                self._setmode(relpath, mode)
419
401
            ftp.getresp()
420
402
        except ftplib.error_perm, e:
421
 
            # Check whether the command is not supported (reply code 502)
422
 
            if str(e).startswith('502 '):
423
 
                warning("FTP server does not support file appending natively. "
424
 
                        "Performance may be severely degraded! (%s)", e)
425
 
                self._has_append = False
426
 
                self._fallback_append(relpath, text, mode)
427
 
            else:
428
 
                self._translate_ftp_error(e, abspath, extra='error appending',
429
 
                    unknown_exc=errors.NoSuchFile)
 
403
            self._translate_perm_error(e, abspath, extra='error appending',
 
404
                unknown_exc=errors.NoSuchFile)
430
405
        except ftplib.error_temp, e:
431
406
            if retries > _number_of_retries:
432
 
                raise errors.TransportError(
433
 
                    "FTP temporary error during APPEND %s. Aborting."
434
 
                    % abspath, orig_error=e)
 
407
                raise errors.TransportError("FTP temporary error during APPEND %s." \
 
408
                        "Aborting." % abspath, orig_error=e)
435
409
            else:
436
410
                warning("FTP temporary error: %s. Retrying.", str(e))
437
 
                self._reconnect()
 
411
                self._FTP_instance = None
438
412
                self._try_append(relpath, text, mode, retries+1)
439
413
 
440
 
    def _fallback_append(self, relpath, text, mode = None):
441
 
        remote = self.get(relpath)
442
 
        remote.seek(0, os.SEEK_END)
443
 
        remote.write(text)
444
 
        remote.seek(0)
445
 
        return self.put_file(relpath, remote, mode)
446
 
 
447
414
    def _setmode(self, relpath, mode):
448
415
        """Set permissions on a path.
449
416
 
450
417
        Only set permissions if the FTP server supports the 'SITE CHMOD'
451
418
        extension.
452
419
        """
453
 
        if mode:
454
 
            try:
455
 
                mutter("FTP site chmod: setting permissions to %s on %s",
456
 
                       oct(mode), self._remote_path(relpath))
457
 
                ftp = self._get_FTP()
458
 
                cmd = "SITE CHMOD %s %s" % (oct(mode),
459
 
                                            self._remote_path(relpath))
460
 
                ftp.sendcmd(cmd)
461
 
            except ftplib.error_perm, e:
462
 
                # Command probably not available on this server
463
 
                warning("FTP Could not set permissions to %s on %s. %s",
464
 
                        oct(mode), self._remote_path(relpath), str(e))
 
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))
465
430
 
466
431
    # TODO: jam 20060516 I believe ftp allows you to tell an ftp server
467
432
    #       to copy something to another machine. And you may be able
468
433
    #       to give it its own address as the 'to' location.
469
434
    #       So implement a fancier 'copy()'
470
435
 
471
 
    def rename(self, rel_from, rel_to):
472
 
        abs_from = self._remote_path(rel_from)
473
 
        abs_to = self._remote_path(rel_to)
474
 
        mutter("FTP rename: %s => %s", abs_from, abs_to)
475
 
        f = self._get_FTP()
476
 
        return self._rename(abs_from, abs_to, f)
477
 
 
478
 
    def _rename(self, abs_from, abs_to, f):
479
 
        try:
480
 
            f.rename(abs_from, abs_to)
481
 
        except (ftplib.error_temp, ftplib.error_perm), e:
482
 
            self._translate_ftp_error(e, abs_from,
483
 
                ': unable to rename to %r' % (abs_to))
484
 
 
485
436
    def move(self, rel_from, rel_to):
486
437
        """Move the item at rel_from to the location at rel_to"""
487
 
        abs_from = self._remote_path(rel_from)
488
 
        abs_to = self._remote_path(rel_to)
 
438
        abs_from = self._abspath(rel_from)
 
439
        abs_to = self._abspath(rel_to)
489
440
        try:
490
441
            mutter("FTP mv: %s => %s", abs_from, abs_to)
491
442
            f = self._get_FTP()
492
 
            self._rename_and_overwrite(abs_from, abs_to, f)
 
443
            f.rename(abs_from, abs_to)
493
444
        except ftplib.error_perm, e:
494
 
            self._translate_ftp_error(e, abs_from,
495
 
                extra='unable to rename to %r' % (rel_to,),
 
445
            self._translate_perm_error(e, abs_from,
 
446
                extra='unable to rename to %r' % (rel_to,), 
496
447
                unknown_exc=errors.PathError)
497
448
 
498
 
    def _rename_and_overwrite(self, abs_from, abs_to, f):
499
 
        """Do a fancy rename on the remote server.
500
 
 
501
 
        Using the implementation provided by osutils.
502
 
        """
503
 
        osutils.fancy_rename(abs_from, abs_to,
504
 
            rename_func=lambda p1, p2: self._rename(p1, p2, f),
505
 
            unlink_func=lambda p: self._delete(p, f))
 
449
    rename = move
506
450
 
507
451
    def delete(self, relpath):
508
452
        """Delete the item at relpath"""
509
 
        abspath = self._remote_path(relpath)
510
 
        f = self._get_FTP()
511
 
        self._delete(abspath, f)
512
 
 
513
 
    def _delete(self, abspath, f):
 
453
        abspath = self._abspath(relpath)
514
454
        try:
515
455
            mutter("FTP rm: %s", abspath)
 
456
            f = self._get_FTP()
516
457
            f.delete(abspath)
517
458
        except ftplib.error_perm, e:
518
 
            self._translate_ftp_error(e, abspath, 'error deleting',
 
459
            self._translate_perm_error(e, abspath, 'error deleting',
519
460
                unknown_exc=errors.NoSuchFile)
520
461
 
521
 
    def external_url(self):
522
 
        """See bzrlib.transport.Transport.external_url."""
523
 
        # FTP URL's are externally usable.
524
 
        return self.base
525
 
 
526
462
    def listable(self):
527
463
        """See Transport.listable."""
528
464
        return True
529
465
 
530
466
    def list_dir(self, relpath):
531
467
        """See Transport.list_dir."""
532
 
        basepath = self._remote_path(relpath)
 
468
        basepath = self._abspath(relpath)
533
469
        mutter("FTP nlst: %s", basepath)
534
470
        f = self._get_FTP()
535
471
        try:
536
 
            try:
537
 
                paths = f.nlst(basepath)
538
 
            except ftplib.error_perm, e:
539
 
                self._translate_ftp_error(e, relpath,
540
 
                                           extra='error with list_dir')
541
 
            except ftplib.error_temp, e:
542
 
                # xs4all's ftp server raises a 450 temp error when listing an
543
 
                # empty directory. Check for that and just return an empty list
544
 
                # in that case. See bug #215522
545
 
                if str(e).lower().startswith('450 no files found'):
546
 
                    mutter('FTP Server returned "%s" for nlst.'
547
 
                           ' Assuming it means empty directory',
548
 
                           str(e))
549
 
                    return []
550
 
                raise
551
 
        finally:
552
 
            # Restore binary mode as nlst switch to ascii mode to retrieve file
553
 
            # list
554
 
            f.voidcmd('TYPE I')
555
 
 
 
472
            paths = f.nlst(basepath)
 
473
        except ftplib.error_perm, e:
 
474
            self._translate_perm_error(e, relpath, extra='error with list_dir')
556
475
        # If FTP.nlst returns paths prefixed by relpath, strip 'em
557
476
        if paths and paths[0].startswith(basepath):
558
477
            entries = [path[len(basepath)+1:] for path in paths]
579
498
 
580
499
    def stat(self, relpath):
581
500
        """Return the stat information for a file."""
582
 
        abspath = self._remote_path(relpath)
 
501
        abspath = self._abspath(relpath)
583
502
        try:
584
503
            mutter("FTP stat: %s", abspath)
585
504
            f = self._get_FTP()
586
505
            return FtpStatResult(f, abspath)
587
506
        except ftplib.error_perm, e:
588
 
            self._translate_ftp_error(e, abspath, extra='error w/ stat')
 
507
            self._translate_perm_error(e, abspath, extra='error w/ stat')
589
508
 
590
509
    def lock_read(self, relpath):
591
510
        """Lock the given file for shared (read) access.
609
528
        return self.lock_read(relpath)
610
529
 
611
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
 
612
728
def get_test_permutations():
613
729
    """Return the permutations to be used in testing."""
614
 
    from bzrlib.tests import ftp_server
615
 
    return [(FtpTransport, ftp_server.FTPTestServer)]
 
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)]