← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ftp.py

[patch] use unicode literals for all hardcoded paths (Alexander Belchenko)

> When you use flat string on Windows for base part of file names then all
> derived file names is always representing as flat string. On Linux/Cygwin as
> I can see in situations when path cannot be represented as flat string (or in
> ascii encoding?) it silently converted to unicode. As result we have
> different behaviour with non-ascii (non-english) file names.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/ftp.py
26
26
 
27
27
from bzrlib.transport import Transport
28
28
 
29
 
from bzrlib.errors import (TransportNotPossible, TransportError,
30
 
                           NoSuchFile, FileExists)
 
29
from bzrlib.errors import (TransportNotPossible, NoSuchFile, 
 
30
                           NonRelativePath, TransportError, ConnectionError)
31
31
 
32
32
import os, errno
33
33
from cStringIO import StringIO
36
36
import urllib
37
37
import stat
38
38
 
 
39
from bzrlib.errors import BzrError, BzrCheckError
39
40
from bzrlib.branch import Branch
40
41
from bzrlib.trace import mutter
41
42
 
42
43
 
 
44
class FtpTransportError(TransportError):
 
45
    pass
 
46
 
 
47
 
43
48
class FtpStatResult(object):
44
49
    def __init__(self, f, relpath):
45
50
        try:
89
94
            self._FTP_instance.set_pasv(not self.is_active)
90
95
            return self._FTP_instance
91
96
        except ftplib.error_perm, e:
92
 
            raise TransportError(msg="Error setting up connection: %s"
 
97
            raise FtpTransportError(msg="Error setting up connection: %s"
93
98
                                    % str(e), orig_error=e)
94
99
 
95
100
    def should_cache(self):
177
182
            ret.seek(0)
178
183
            return ret
179
184
        except ftplib.error_perm, e:
180
 
            raise NoSuchFile(self.abspath(relpath), extra=extra)
 
185
            raise NoSuchFile(msg="Error retrieving %s: %s"
 
186
                             % (self.abspath(relpath), str(e)),
 
187
                             orig_error=e)
181
188
 
182
 
    def put(self, relpath, fp, mode=None):
 
189
    def put(self, relpath, fp):
183
190
        """Copy the file-like or string object into the location.
184
191
 
185
192
        :param relpath: Location to put the contents, relative to base.
186
193
        :param f:       File-like or string object.
187
 
        TODO: jam 20051215 This should be an atomic put, not overwritting files in place
188
 
        TODO: jam 20051215 ftp as a protocol seems to support chmod, but ftplib does not
189
194
        """
190
195
        if not hasattr(fp, 'read'):
191
196
            fp = StringIO(fp)
194
199
            f = self._get_FTP()
195
200
            f.storbinary('STOR '+self._abspath(relpath), fp, 8192)
196
201
        except ftplib.error_perm, e:
197
 
            raise TransportError(orig_error=e)
 
202
            raise FtpTransportError(orig_error=e)
198
203
 
199
 
    def mkdir(self, relpath, mode=None):
 
204
    def mkdir(self, relpath):
200
205
        """Create a directory at the given path."""
201
206
        try:
202
207
            mutter("FTP mkd: %s" % self._abspath(relpath))
206
211
            except ftplib.error_perm, e:
207
212
                s = str(e)
208
213
                if 'File exists' in s:
209
 
                    raise FileExists(self.abspath(relpath), extra=s)
 
214
                    # Swallow attempts to mkdir something which is already
 
215
                    # present. Hopefully this will shush some errors.
 
216
                    return
210
217
                else:
211
218
                    raise
212
219
        except ftplib.error_perm, e:
213
 
            raise TransportError(orig_error=e)
 
220
            raise FtpTransportError(orig_error=e)
214
221
 
215
222
    def append(self, relpath, f):
216
223
        """Append the text in the file-like object into the final
230
237
            f = self._get_FTP()
231
238
            f.rename(self._abspath(rel_from), self._abspath(rel_to))
232
239
        except ftplib.error_perm, e:
233
 
            raise TransportError(orig_error=e)
 
240
            raise FtpTransportError(orig_error=e)
234
241
 
235
242
    def delete(self, relpath):
236
243
        """Delete the item at relpath"""
239
246
            f = self._get_FTP()
240
247
            f.delete(self._abspath(relpath))
241
248
        except ftplib.error_perm, e:
242
 
            raise TransportError(orig_error=e)
 
249
            raise FtpTransportError(orig_error=e)
243
250
 
244
251
    def listable(self):
245
252
        """See Transport.listable."""
257
264
            # Remove . and .. if present, and return
258
265
            return [path for path in stripped if path not in (".", "..")]
259
266
        except ftplib.error_perm, e:
260
 
            raise TransportError(orig_error=e)
 
267
            raise FtpTransportError(orig_error=e)
261
268
 
262
269
    def iter_files_recursive(self):
263
270
        """See Transport.iter_files_recursive.
282
289
            f = self._get_FTP()
283
290
            return FtpStatResult(f, self._abspath(relpath))
284
291
        except ftplib.error_perm, e:
285
 
            raise TransportError(orig_error=e)
 
292
            raise FtpTransportError(orig_error=e)
286
293
 
287
294
    def lock_read(self, relpath):
288
295
        """Lock the given file for shared (read) access.