← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ftp.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-08-01 20:07:49 UTC
  • mfrom: (1711.2.112 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060801200749-e0bd496331bb4d2b
(bialix) Create a nice win32 installer

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