~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-05-19 06:14:38 UTC
  • mfrom: (1704.2.23 bzr.mbp.integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060519061438-6300caf3926c3cff
(mbp) small fixes

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
 
#
 
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# 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
 
17
17
"""Transport for the local filesystem.
18
18
 
19
 
This is a fairly thin wrapper on regular file IO.
20
 
"""
 
19
This is a fairly thin wrapper on regular file IO."""
21
20
 
22
21
import os
23
 
from stat import ST_MODE, S_ISDIR, ST_SIZE, S_IMODE
 
22
import shutil
24
23
import sys
25
 
 
26
 
from bzrlib.lazy_import import lazy_import
27
 
lazy_import(globals(), """
28
 
import errno
29
 
import shutil
30
 
 
31
 
from bzrlib import (
32
 
    atomicfile,
33
 
    osutils,
34
 
    urlutils,
35
 
    symbol_versioning,
36
 
    transport,
37
 
    )
 
24
from stat import ST_MODE, S_ISDIR, ST_SIZE
 
25
import tempfile
 
26
import urllib
 
27
 
38
28
from bzrlib.trace import mutter
39
 
from bzrlib.transport import LateReadError
40
 
""")
41
 
 
42
29
from bzrlib.transport import Transport, Server
43
 
 
44
 
 
45
 
_append_flags = os.O_CREAT | os.O_APPEND | os.O_WRONLY | osutils.O_BINARY
46
 
_put_non_atomic_flags = os.O_CREAT | os.O_TRUNC | os.O_WRONLY | osutils.O_BINARY
 
30
from bzrlib.osutils import (abspath, realpath, normpath, pathjoin, rename, 
 
31
                            check_legal_path, rmtree)
47
32
 
48
33
 
49
34
class LocalTransport(Transport):
51
36
 
52
37
    def __init__(self, base):
53
38
        """Set the base path where files will be stored."""
54
 
        if not base.startswith('file://'):
55
 
            symbol_versioning.warn(
56
 
                "Instantiating LocalTransport with a filesystem path"
57
 
                " is deprecated as of bzr 0.8."
58
 
                " Please use bzrlib.transport.get_transport()"
59
 
                " or pass in a file:// url.",
60
 
                 DeprecationWarning,
61
 
                 stacklevel=2
62
 
                 )
63
 
            base = urlutils.local_path_to_url(base)
 
39
        if base.startswith('file://'):
 
40
            base = base[len('file://'):]
 
41
        # realpath is incompatible with symlinks. When we traverse
 
42
        # up we might be able to normpath stuff. RBC 20051003
 
43
        base = normpath(abspath(base))
64
44
        if base[-1] != '/':
65
45
            base = base + '/'
66
 
 
67
 
        # Special case : windows has no "root", but does have
68
 
        # multiple lettered drives inside it. #240910
69
 
        if sys.platform == 'win32' and base == 'file:///':
70
 
            base = ''
71
 
            self._local_base = ''
72
 
            super(LocalTransport, self).__init__(base)
73
 
            return
74
 
 
75
46
        super(LocalTransport, self).__init__(base)
76
 
        self._local_base = urlutils.local_path_from_url(base)
 
47
 
 
48
    def should_cache(self):
 
49
        return False
77
50
 
78
51
    def clone(self, offset=None):
79
52
        """Return a new LocalTransport with root at self.base + offset
80
 
        Because the local filesystem does not require a connection,
 
53
        Because the local filesystem does not require a connection, 
81
54
        we can just return a new object.
82
55
        """
83
56
        if offset is None:
84
57
            return LocalTransport(self.base)
85
58
        else:
86
 
            abspath = self.abspath(offset)
87
 
            if abspath == 'file://':
88
 
                # fix upwalk for UNC path
89
 
                # when clone from //HOST/path updir recursively
90
 
                # we should stop at least at //HOST part
91
 
                abspath = self.base
92
 
            return LocalTransport(abspath)
93
 
 
94
 
    def _abspath(self, relative_reference):
95
 
        """Return a path for use in os calls.
96
 
 
97
 
        Several assumptions are made:
98
 
         - relative_reference does not contain '..'
99
 
         - relative_reference is url escaped.
100
 
        """
101
 
        if relative_reference in ('.', ''):
102
 
            return self._local_base
103
 
        return self._local_base + urlutils.unescape(relative_reference)
 
59
            return LocalTransport(self.abspath(offset))
104
60
 
105
61
    def abspath(self, relpath):
106
62
        """Return the full url to the given relative URL."""
107
 
        # TODO: url escape the result. RBC 20060523.
108
 
        # jam 20060426 Using normpath on the real path, because that ensures
109
 
        #       proper handling of stuff like
110
 
        path = osutils.normpath(osutils.pathjoin(
111
 
                    self._local_base, urlutils.unescape(relpath)))
112
 
        # on windows, our _local_base may or may not have a drive specified
113
 
        # (ie, it may be "/" or "c:/foo").
114
 
        # If 'relpath' is '/' we *always* get back an abspath without
115
 
        # the drive letter - but if our transport already has a drive letter,
116
 
        # we want our abspaths to have a drive letter too - so handle that
117
 
        # here.
118
 
        if (sys.platform == "win32" and self._local_base[1:2] == ":"
119
 
            and path == '/'):
120
 
            path = self._local_base[:3]
121
 
 
122
 
        return urlutils.local_path_to_url(path)
123
 
 
124
 
    def local_abspath(self, relpath):
125
 
        """Transform the given relative path URL into the actual path on disk
126
 
 
127
 
        This function only exists for the LocalTransport, since it is
128
 
        the only one that has direct local access.
129
 
        This is mostly for stuff like WorkingTree which needs to know
130
 
        the local working directory.  The returned path will always contain
131
 
        forward slashes as the path separator, regardless of the platform.
132
 
 
133
 
        This function is quite expensive: it calls realpath which resolves
134
 
        symlinks.
135
 
        """
136
 
        absurl = self.abspath(relpath)
137
 
        # mutter(u'relpath %s => base: %s, absurl %s', relpath, self.base, absurl)
138
 
        return urlutils.local_path_from_url(absurl)
 
63
        assert isinstance(relpath, basestring), (type(relpath), relpath)
 
64
        result = normpath(pathjoin(self.base, urllib.unquote(relpath)))
 
65
        #if result[-1] != '/':
 
66
        #    result += '/'
 
67
        return result
139
68
 
140
69
    def relpath(self, abspath):
141
70
        """Return the local path portion from a given absolute path.
142
71
        """
 
72
        from bzrlib.osutils import relpath, strip_trailing_slash
143
73
        if abspath is None:
144
74
            abspath = u'.'
145
75
 
146
 
        return urlutils.file_relpath(
147
 
            urlutils.strip_trailing_slash(self.base),
148
 
            urlutils.strip_trailing_slash(abspath))
 
76
        return relpath(strip_trailing_slash(self.base), 
 
77
                       strip_trailing_slash(abspath))
149
78
 
150
79
    def has(self, relpath):
151
 
        return os.access(self._abspath(relpath), os.F_OK)
 
80
        return os.access(self.abspath(relpath), os.F_OK)
152
81
 
153
82
    def get(self, relpath):
154
83
        """Get the file at the given relative path.
155
84
 
156
85
        :param relpath: The relative path to the file
157
86
        """
158
 
        canonical_url = self.abspath(relpath)
159
 
        if canonical_url in transport._file_streams:
160
 
            transport._file_streams[canonical_url].flush()
161
87
        try:
162
 
            path = self._abspath(relpath)
 
88
            path = self.abspath(relpath)
163
89
            return open(path, 'rb')
164
90
        except (IOError, OSError),e:
165
 
            if e.errno == errno.EISDIR:
166
 
                return LateReadError(relpath)
167
 
            self._translate_error(e, path)
168
 
 
169
 
    def put_file(self, relpath, f, mode=None):
170
 
        """Copy the file-like object into the location.
171
 
 
172
 
        :param relpath: Location to put the contents, relative to base.
173
 
        :param f:       File-like object.
174
 
        :param mode: The mode for the newly created file,
175
 
                     None means just use the default
176
 
        """
177
 
 
178
 
        path = relpath
179
 
        try:
180
 
            path = self._abspath(relpath)
181
 
            osutils.check_legal_path(path)
182
 
            fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
183
 
        except (IOError, OSError),e:
184
 
            self._translate_error(e, path)
185
 
        try:
186
 
            length = self._pump(f, fp)
187
 
            fp.commit()
188
 
        finally:
189
 
            fp.close()
190
 
        return length
191
 
 
192
 
    def put_bytes(self, relpath, bytes, mode=None):
193
 
        """Copy the string into the location.
194
 
 
195
 
        :param relpath: Location to put the contents, relative to base.
196
 
        :param bytes:   String
197
 
        """
198
 
 
199
 
        path = relpath
200
 
        try:
201
 
            path = self._abspath(relpath)
202
 
            osutils.check_legal_path(path)
203
 
            fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
204
 
        except (IOError, OSError),e:
205
 
            self._translate_error(e, path)
206
 
        try:
207
 
            if bytes:
208
 
                fp.write(bytes)
209
 
            fp.commit()
210
 
        finally:
211
 
            fp.close()
212
 
 
213
 
    def _put_non_atomic_helper(self, relpath, writer,
214
 
                               mode=None,
215
 
                               create_parent_dir=False,
216
 
                               dir_mode=None):
217
 
        """Common functionality information for the put_*_non_atomic.
218
 
 
219
 
        This tracks all the create_parent_dir stuff.
220
 
 
221
 
        :param relpath: the path we are putting to.
222
 
        :param writer: A function that takes an os level file descriptor
223
 
            and writes whatever data it needs to write there.
224
 
        :param mode: The final file mode.
225
 
        :param create_parent_dir: Should we be creating the parent directory
226
 
            if it doesn't exist?
227
 
        """
228
 
        abspath = self._abspath(relpath)
229
 
        if mode is None:
230
 
            # os.open() will automatically use the umask
231
 
            local_mode = 0666
232
 
        else:
233
 
            local_mode = mode
234
 
        try:
235
 
            fd = os.open(abspath, _put_non_atomic_flags, local_mode)
236
 
        except (IOError, OSError),e:
237
 
            # We couldn't create the file, maybe we need to create
238
 
            # the parent directory, and try again
239
 
            if (not create_parent_dir
240
 
                or e.errno not in (errno.ENOENT,errno.ENOTDIR)):
241
 
                self._translate_error(e, relpath)
242
 
            parent_dir = os.path.dirname(abspath)
243
 
            if not parent_dir:
244
 
                self._translate_error(e, relpath)
245
 
            self._mkdir(parent_dir, mode=dir_mode)
246
 
            # We created the parent directory, lets try to open the
247
 
            # file again
248
 
            try:
249
 
                fd = os.open(abspath, _put_non_atomic_flags, local_mode)
250
 
            except (IOError, OSError), e:
251
 
                self._translate_error(e, relpath)
252
 
        try:
253
 
            st = os.fstat(fd)
254
 
            if mode is not None and mode != S_IMODE(st.st_mode):
255
 
                # Because of umask, we may still need to chmod the file.
256
 
                # But in the general case, we won't have to
257
 
                os.chmod(abspath, mode)
258
 
            writer(fd)
259
 
        finally:
260
 
            os.close(fd)
261
 
 
262
 
    def put_file_non_atomic(self, relpath, f, mode=None,
263
 
                            create_parent_dir=False,
264
 
                            dir_mode=None):
265
 
        """Copy the file-like object into the target location.
266
 
 
267
 
        This function is not strictly safe to use. It is only meant to
268
 
        be used when you already know that the target does not exist.
269
 
        It is not safe, because it will open and truncate the remote
270
 
        file. So there may be a time when the file has invalid contents.
271
 
 
272
 
        :param relpath: The remote location to put the contents.
273
 
        :param f:       File-like object.
274
 
        :param mode:    Possible access permissions for new file.
275
 
                        None means do not set remote permissions.
276
 
        :param create_parent_dir: If we cannot create the target file because
277
 
                        the parent directory does not exist, go ahead and
278
 
                        create it, and then try again.
279
 
        """
280
 
        def writer(fd):
281
 
            self._pump_to_fd(f, fd)
282
 
        self._put_non_atomic_helper(relpath, writer, mode=mode,
283
 
                                    create_parent_dir=create_parent_dir,
284
 
                                    dir_mode=dir_mode)
285
 
 
286
 
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
287
 
                             create_parent_dir=False, dir_mode=None):
288
 
        def writer(fd):
289
 
            if bytes:
290
 
                os.write(fd, bytes)
291
 
        self._put_non_atomic_helper(relpath, writer, mode=mode,
292
 
                                    create_parent_dir=create_parent_dir,
293
 
                                    dir_mode=dir_mode)
 
91
            self._translate_error(e, path)
 
92
 
 
93
    def put(self, relpath, f, mode=None):
 
94
        """Copy the file-like or string object into the location.
 
95
 
 
96
        :param relpath: Location to put the contents, relative to base.
 
97
        :param f:       File-like or string object.
 
98
        """
 
99
        from bzrlib.atomicfile import AtomicFile
 
100
 
 
101
        path = relpath
 
102
        try:
 
103
            path = self.abspath(relpath)
 
104
            check_legal_path(path)
 
105
            fp = AtomicFile(path, 'wb', new_mode=mode)
 
106
        except (IOError, OSError),e:
 
107
            self._translate_error(e, path)
 
108
        try:
 
109
            self._pump(f, fp)
 
110
            fp.commit()
 
111
        finally:
 
112
            fp.close()
294
113
 
295
114
    def iter_files_recursive(self):
296
115
        """Iter the relative paths of files in the transports sub-tree."""
304
123
            else:
305
124
                yield relpath
306
125
 
307
 
    def _mkdir(self, abspath, mode=None):
308
 
        """Create a real directory, filtering through mode"""
309
 
        if mode is None:
310
 
            # os.mkdir() will filter through umask
311
 
            local_mode = 0777
312
 
        else:
313
 
            local_mode = mode
314
 
        try:
315
 
            os.mkdir(abspath, local_mode)
316
 
            if mode is not None:
317
 
                # It is probably faster to just do the chmod, rather than
318
 
                # doing a stat, and then trying to compare
319
 
                os.chmod(abspath, mode)
320
 
        except (IOError, OSError),e:
321
 
            self._translate_error(e, abspath)
322
 
 
323
126
    def mkdir(self, relpath, mode=None):
324
127
        """Create a directory at the given path."""
325
 
        self._mkdir(self._abspath(relpath), mode=mode)
326
 
 
327
 
    def open_write_stream(self, relpath, mode=None):
328
 
        """See Transport.open_write_stream."""
329
 
        # initialise the file
330
 
        self.put_bytes_non_atomic(relpath, "", mode=mode)
331
 
        abspath = self._abspath(relpath)
332
 
        handle = open(abspath, 'wb')
333
 
        if mode is not None:
334
 
            self._check_mode_and_size(abspath, handle.fileno(), mode)
335
 
        transport._file_streams[self.abspath(relpath)] = handle
336
 
        return transport.FileFileStream(self, relpath, handle)
337
 
 
338
 
    def _get_append_file(self, relpath, mode=None):
339
 
        """Call os.open() for the given relpath"""
340
 
        file_abspath = self._abspath(relpath)
341
 
        if mode is None:
342
 
            # os.open() will automatically use the umask
343
 
            local_mode = 0666
344
 
        else:
345
 
            local_mode = mode
346
 
        try:
347
 
            return file_abspath, os.open(file_abspath, _append_flags, local_mode)
 
128
        path = relpath
 
129
        try:
 
130
            path = self.abspath(relpath)
 
131
            os.mkdir(path)
 
132
            if mode is not None:
 
133
                os.chmod(path, mode)
 
134
        except (IOError, OSError),e:
 
135
            self._translate_error(e, path)
 
136
 
 
137
    def append(self, relpath, f, mode=None):
 
138
        """Append the text in the file-like object into the final
 
139
        location.
 
140
        """
 
141
        try:
 
142
            fp = open(self.abspath(relpath), 'ab')
 
143
            if mode is not None:
 
144
                os.chmod(self.abspath(relpath), mode)
348
145
        except (IOError, OSError),e:
349
146
            self._translate_error(e, relpath)
350
 
 
351
 
    def _check_mode_and_size(self, file_abspath, fd, mode=None):
352
 
        """Check the mode of the file, and return the current size"""
353
 
        st = os.fstat(fd)
354
 
        if mode is not None and mode != S_IMODE(st.st_mode):
355
 
            # Because of umask, we may still need to chmod the file.
356
 
            # But in the general case, we won't have to
357
 
            os.chmod(file_abspath, mode)
358
 
        return st.st_size
359
 
 
360
 
    def append_file(self, relpath, f, mode=None):
361
 
        """Append the text in the file-like object into the final location."""
362
 
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
363
 
        try:
364
 
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
365
 
            self._pump_to_fd(f, fd)
366
 
        finally:
367
 
            os.close(fd)
368
 
        return result
369
 
 
370
 
    def append_bytes(self, relpath, bytes, mode=None):
371
 
        """Append the text in the string into the final location."""
372
 
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
373
 
        try:
374
 
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
375
 
            if bytes:
376
 
                os.write(fd, bytes)
377
 
        finally:
378
 
            os.close(fd)
379
 
        return result
380
 
 
381
 
    def _pump_to_fd(self, fromfile, to_fd):
382
 
        """Copy contents of one file to another."""
383
 
        BUFSIZE = 32768
384
 
        while True:
385
 
            b = fromfile.read(BUFSIZE)
386
 
            if not b:
387
 
                break
388
 
            os.write(to_fd, b)
 
147
        # win32 workaround (tell on an unwritten file returns 0)
 
148
        fp.seek(0, 2)
 
149
        result = fp.tell()
 
150
        self._pump(f, fp)
 
151
        return result
389
152
 
390
153
    def copy(self, rel_from, rel_to):
391
154
        """Copy the item at rel_from to the location at rel_to"""
392
 
        path_from = self._abspath(rel_from)
393
 
        path_to = self._abspath(rel_to)
 
155
        path_from = self.abspath(rel_from)
 
156
        path_to = self.abspath(rel_to)
394
157
        try:
395
158
            shutil.copy(path_from, path_to)
396
159
        except (IOError, OSError),e:
398
161
            self._translate_error(e, path_from)
399
162
 
400
163
    def rename(self, rel_from, rel_to):
401
 
        path_from = self._abspath(rel_from)
 
164
        path_from = self.abspath(rel_from)
402
165
        try:
403
 
            # *don't* call bzrlib.osutils.rename, because we want to
 
166
            # *don't* call bzrlib.osutils.rename, because we want to 
404
167
            # detect errors on rename
405
 
            os.rename(path_from, self._abspath(rel_to))
 
168
            os.rename(path_from, self.abspath(rel_to))
406
169
        except (IOError, OSError),e:
407
170
            # TODO: What about path_to?
408
171
            self._translate_error(e, path_from)
409
172
 
410
173
    def move(self, rel_from, rel_to):
411
174
        """Move the item at rel_from to the location at rel_to"""
412
 
        path_from = self._abspath(rel_from)
413
 
        path_to = self._abspath(rel_to)
 
175
        path_from = self.abspath(rel_from)
 
176
        path_to = self.abspath(rel_to)
414
177
 
415
178
        try:
416
179
            # this version will delete the destination if necessary
417
 
            osutils.rename(path_from, path_to)
 
180
            rename(path_from, path_to)
418
181
        except (IOError, OSError),e:
419
182
            # TODO: What about path_to?
420
183
            self._translate_error(e, path_from)
423
186
        """Delete the item at relpath"""
424
187
        path = relpath
425
188
        try:
426
 
            path = self._abspath(relpath)
 
189
            path = self.abspath(relpath)
427
190
            os.remove(path)
428
191
        except (IOError, OSError),e:
 
192
            # TODO: What about path_to?
429
193
            self._translate_error(e, path)
430
194
 
431
 
    def external_url(self):
432
 
        """See bzrlib.transport.Transport.external_url."""
433
 
        # File URL's are externally usable.
434
 
        return self.base
435
 
 
436
195
    def copy_to(self, relpaths, other, mode=None, pb=None):
437
196
        """Copy a set of entries from self into another Transport.
438
197
 
447
206
            for path in relpaths:
448
207
                self._update_pb(pb, 'copy-to', count, total)
449
208
                try:
450
 
                    mypath = self._abspath(path)
451
 
                    otherpath = other._abspath(path)
 
209
                    mypath = self.abspath(path)
 
210
                    otherpath = other.abspath(path)
452
211
                    shutil.copy(mypath, otherpath)
453
212
                    if mode is not None:
454
213
                        os.chmod(otherpath, mode)
468
227
        WARNING: many transports do not support this, so trying avoid using
469
228
        it if at all possible.
470
229
        """
471
 
        path = self._abspath(relpath)
 
230
        path = self.abspath(relpath)
472
231
        try:
473
 
            entries = os.listdir(path)
 
232
            return [urllib.quote(entry) for entry in os.listdir(path)]
474
233
        except (IOError, OSError), e:
475
234
            self._translate_error(e, path)
476
 
        return [urlutils.escape(entry) for entry in entries]
477
235
 
478
236
    def stat(self, relpath):
479
237
        """Return the stat information for a file.
480
238
        """
481
239
        path = relpath
482
240
        try:
483
 
            path = self._abspath(relpath)
 
241
            path = self.abspath(relpath)
484
242
            return os.stat(path)
485
243
        except (IOError, OSError),e:
486
244
            self._translate_error(e, path)
492
250
        from bzrlib.lock import ReadLock
493
251
        path = relpath
494
252
        try:
495
 
            path = self._abspath(relpath)
 
253
            path = self.abspath(relpath)
496
254
            return ReadLock(path)
497
255
        except (IOError, OSError), e:
498
256
            self._translate_error(e, path)
504
262
        :return: A lock object, which should be passed to Transport.unlock()
505
263
        """
506
264
        from bzrlib.lock import WriteLock
507
 
        return WriteLock(self._abspath(relpath))
 
265
        return WriteLock(self.abspath(relpath))
508
266
 
509
267
    def rmdir(self, relpath):
510
268
        """See Transport.rmdir."""
511
269
        path = relpath
512
270
        try:
513
 
            path = self._abspath(relpath)
 
271
            path = self.abspath(relpath)
514
272
            os.rmdir(path)
515
273
        except (IOError, OSError),e:
516
274
            self._translate_error(e, path)
523
281
            return True
524
282
 
525
283
 
526
 
class EmulatedWin32LocalTransport(LocalTransport):
527
 
    """Special transport for testing Win32 [UNC] paths on non-windows"""
528
 
 
529
 
    def __init__(self, base):
530
 
        if base[-1] != '/':
531
 
            base = base + '/'
532
 
        super(LocalTransport, self).__init__(base)
533
 
        self._local_base = urlutils._win32_local_path_from_url(base)
534
 
 
535
 
    def abspath(self, relpath):
536
 
        path = osutils.normpath(osutils.pathjoin(
537
 
                    self._local_base, urlutils.unescape(relpath)))
538
 
        return urlutils._win32_local_path_to_url(path)
539
 
 
540
 
    def clone(self, offset=None):
541
 
        """Return a new LocalTransport with root at self.base + offset
542
 
        Because the local filesystem does not require a connection,
543
 
        we can just return a new object.
544
 
        """
545
 
        if offset is None:
546
 
            return EmulatedWin32LocalTransport(self.base)
547
 
        else:
548
 
            abspath = self.abspath(offset)
549
 
            if abspath == 'file://':
550
 
                # fix upwalk for UNC path
551
 
                # when clone from //HOST/path updir recursively
552
 
                # we should stop at least at //HOST part
553
 
                abspath = self.base
554
 
            return EmulatedWin32LocalTransport(abspath)
 
284
class ScratchTransport(LocalTransport):
 
285
    """A transport that works in a temporary dir and cleans up after itself.
 
286
    
 
287
    The dir only exists for the lifetime of the Python object.
 
288
    Obviously you should not put anything precious in it.
 
289
    """
 
290
 
 
291
    def __init__(self, base=None):
 
292
        if base is None:
 
293
            base = tempfile.mkdtemp()
 
294
        super(ScratchTransport, self).__init__(base)
 
295
 
 
296
    def __del__(self):
 
297
        rmtree(self.base, ignore_errors=True)
 
298
        mutter("%r destroyed" % self)
 
299
 
 
300
 
 
301
class LocalRelpathServer(Server):
 
302
    """A pretend server for local transports, using relpaths."""
 
303
 
 
304
    def get_url(self):
 
305
        """See Transport.Server.get_url."""
 
306
        return "."
 
307
 
 
308
 
 
309
class LocalAbspathServer(Server):
 
310
    """A pretend server for local transports, using absolute paths."""
 
311
 
 
312
    def get_url(self):
 
313
        """See Transport.Server.get_url."""
 
314
        return os.path.abspath("")
555
315
 
556
316
 
557
317
class LocalURLServer(Server):
558
 
    """A pretend server for local transports, using file:// urls.
559
 
 
560
 
    Of course no actual server is required to access the local filesystem, so
561
 
    this just exists to tell the test code how to get to it.
562
 
    """
563
 
 
564
 
    def start_server(self):
565
 
        pass
 
318
    """A pretend server for local transports, using file:// urls."""
566
319
 
567
320
    def get_url(self):
568
321
        """See Transport.Server.get_url."""
569
 
        return urlutils.local_path_to_url('')
 
322
        # FIXME: \ to / on windows
 
323
        return "file://%s" % os.path.abspath("")
570
324
 
571
325
 
572
326
def get_test_permutations():
573
327
    """Return the permutations to be used in testing."""
574
 
    return [
 
328
    return [(LocalTransport, LocalRelpathServer),
 
329
            (LocalTransport, LocalAbspathServer),
575
330
            (LocalTransport, LocalURLServer),
576
331
            ]