← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ftp.py

  • Committer: Robert Collins
  • Date: 2006-07-20 13:00:31 UTC
  • mto: (1852.9.1 Tree.compare().)
  • mto: This revision was merged to the branch mainline in revision 1890.
  • Revision ID: robertc@robertcollins.net-20060720130031-d26103a427ea10f3
Start tree implementation tests.

Show diffs side-by-side

added added

removed removed

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