← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Robert Collins
  • Date: 2006-04-18 22:41:16 UTC
  • mto: (1711.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 1671.
  • Revision ID: robertc@robertcollins.net-20060418224116-9b723440fa56e404
 * 'Metadir' is now the default disk format. This improves behaviour in
   SFTP using circumstances and allows binding and rebinding and easier
   use of repositories. (Robert Collins, Aaron Bentley).

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/local.py
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
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
 
    )
 
24
from stat import ST_MODE, S_ISDIR, ST_SIZE
 
25
import tempfile
 
26
import urllib
 
27
 
37
28
from bzrlib.trace import mutter
38
 
""")
39
 
 
40
29
from bzrlib.transport import Transport, Server
41
 
 
42
 
 
43
 
_append_flags = os.O_CREAT | os.O_APPEND | os.O_WRONLY | osutils.O_BINARY
44
 
_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
45
31
 
46
32
 
47
33
class LocalTransport(Transport):
49
35
 
50
36
    def __init__(self, base):
51
37
        """Set the base path where files will be stored."""
52
 
        if not base.startswith('file://'):
53
 
            symbol_versioning.warn(
54
 
                "Instantiating LocalTransport with a filesystem path"
55
 
                " is deprecated as of bzr 0.8."
56
 
                " Please use bzrlib.transport.get_transport()"
57
 
                " or pass in a file:// url.",
58
 
                 DeprecationWarning,
59
 
                 stacklevel=2
60
 
                 )
61
 
            base = urlutils.local_path_to_url(base)
 
38
        if base.startswith('file://'):
 
39
            base = base[len('file://'):]
 
40
        # realpath is incompatible with symlinks. When we traverse
 
41
        # up we might be able to normpath stuff. RBC 20051003
 
42
        base = normpath(abspath(base))
62
43
        if base[-1] != '/':
63
44
            base = base + '/'
64
45
        super(LocalTransport, self).__init__(base)
65
 
        self._local_base = urlutils.local_path_from_url(base)
66
46
 
67
47
    def should_cache(self):
68
48
        return False
75
55
        if offset is None:
76
56
            return LocalTransport(self.base)
77
57
        else:
78
 
            abspath = self.abspath(offset)
79
 
            if abspath == 'file://':
80
 
                # fix upwalk for UNC path
81
 
                # when clone from //HOST/path updir recursively
82
 
                # we should stop at least at //HOST part
83
 
                abspath = self.base
84
 
            return LocalTransport(abspath)
85
 
 
86
 
    def _abspath(self, relative_reference):
87
 
        """Return a path for use in os calls.
88
 
 
89
 
        Several assumptions are made:
90
 
         - relative_reference does not contain '..'
91
 
         - relative_reference is url escaped.
92
 
        """
93
 
        if relative_reference in ('.', ''):
94
 
            return self._local_base
95
 
        return self._local_base + urlutils.unescape(relative_reference)
 
58
            return LocalTransport(self.abspath(offset))
96
59
 
97
60
    def abspath(self, relpath):
98
61
        """Return the full url to the given relative URL."""
99
 
        # TODO: url escape the result. RBC 20060523.
100
62
        assert isinstance(relpath, basestring), (type(relpath), relpath)
101
 
        # jam 20060426 Using normpath on the real path, because that ensures
102
 
        #       proper handling of stuff like
103
 
        path = osutils.normpath(osutils.pathjoin(
104
 
                    self._local_base, urlutils.unescape(relpath)))
105
 
        return urlutils.local_path_to_url(path)
106
 
 
107
 
    def local_abspath(self, relpath):
108
 
        """Transform the given relative path URL into the actual path on disk
109
 
 
110
 
        This function only exists for the LocalTransport, since it is
111
 
        the only one that has direct local access.
112
 
        This is mostly for stuff like WorkingTree which needs to know
113
 
        the local working directory.
114
 
        
115
 
        This function is quite expensive: it calls realpath which resolves
116
 
        symlinks.
117
 
        """
118
 
        absurl = self.abspath(relpath)
119
 
        # mutter(u'relpath %s => base: %s, absurl %s', relpath, self.base, absurl)
120
 
        return urlutils.local_path_from_url(absurl)
 
63
        result = normpath(pathjoin(self.base, urllib.unquote(relpath)))
 
64
        #if result[-1] != '/':
 
65
        #    result += '/'
 
66
        return result
121
67
 
122
68
    def relpath(self, abspath):
123
69
        """Return the local path portion from a given absolute path.
124
70
        """
 
71
        from bzrlib.osutils import relpath
125
72
        if abspath is None:
126
73
            abspath = u'.'
127
 
 
128
 
        return urlutils.file_relpath(
129
 
            urlutils.strip_trailing_slash(self.base), 
130
 
            urlutils.strip_trailing_slash(abspath))
 
74
        if len(abspath) > 1 and abspath.endswith('/'):
 
75
            abspath = abspath[:-1]
 
76
        if self.base == '/':
 
77
            root = '/'
 
78
        else:
 
79
            root = self.base[:-1]
 
80
        return relpath(root, abspath)
131
81
 
132
82
    def has(self, relpath):
133
 
        return os.access(self._abspath(relpath), os.F_OK)
 
83
        return os.access(self.abspath(relpath), os.F_OK)
134
84
 
135
85
    def get(self, relpath):
136
86
        """Get the file at the given relative path.
138
88
        :param relpath: The relative path to the file
139
89
        """
140
90
        try:
141
 
            path = self._abspath(relpath)
 
91
            path = self.abspath(relpath)
142
92
            return open(path, 'rb')
143
93
        except (IOError, OSError),e:
144
94
            self._translate_error(e, path)
145
95
 
146
 
    def put_file(self, relpath, f, mode=None):
147
 
        """Copy the file-like object into the location.
 
96
    def put(self, relpath, f, mode=None):
 
97
        """Copy the file-like or string object into the location.
148
98
 
149
99
        :param relpath: Location to put the contents, relative to base.
150
 
        :param f:       File-like object.
151
 
        :param mode: The mode for the newly created file, 
152
 
                     None means just use the default
 
100
        :param f:       File-like or string object.
153
101
        """
 
102
        from bzrlib.atomicfile import AtomicFile
154
103
 
155
104
        path = relpath
156
105
        try:
157
 
            path = self._abspath(relpath)
158
 
            osutils.check_legal_path(path)
159
 
            fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
 
106
            path = self.abspath(relpath)
 
107
            fp = AtomicFile(path, 'wb', new_mode=mode)
160
108
        except (IOError, OSError),e:
161
109
            self._translate_error(e, path)
162
110
        try:
165
113
        finally:
166
114
            fp.close()
167
115
 
168
 
    def put_bytes(self, relpath, bytes, mode=None):
169
 
        """Copy the string into the location.
170
 
 
171
 
        :param relpath: Location to put the contents, relative to base.
172
 
        :param bytes:   String
173
 
        """
174
 
 
175
 
        path = relpath
176
 
        try:
177
 
            path = self._abspath(relpath)
178
 
            osutils.check_legal_path(path)
179
 
            fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
180
 
        except (IOError, OSError),e:
181
 
            self._translate_error(e, path)
182
 
        try:
183
 
            fp.write(bytes)
184
 
            fp.commit()
185
 
        finally:
186
 
            fp.close()
187
 
 
188
 
    def _put_non_atomic_helper(self, relpath, writer,
189
 
                               mode=None,
190
 
                               create_parent_dir=False,
191
 
                               dir_mode=None):
192
 
        """Common functionality information for the put_*_non_atomic.
193
 
 
194
 
        This tracks all the create_parent_dir stuff.
195
 
 
196
 
        :param relpath: the path we are putting to.
197
 
        :param writer: A function that takes an os level file descriptor
198
 
            and writes whatever data it needs to write there.
199
 
        :param mode: The final file mode.
200
 
        :param create_parent_dir: Should we be creating the parent directory
201
 
            if it doesn't exist?
202
 
        """
203
 
        abspath = self._abspath(relpath)
204
 
        if mode is None:
205
 
            # os.open() will automatically use the umask
206
 
            local_mode = 0666
207
 
        else:
208
 
            local_mode = mode
209
 
        try:
210
 
            fd = os.open(abspath, _put_non_atomic_flags, local_mode)
211
 
        except (IOError, OSError),e:
212
 
            # We couldn't create the file, maybe we need to create
213
 
            # the parent directory, and try again
214
 
            if (not create_parent_dir
215
 
                or e.errno not in (errno.ENOENT,errno.ENOTDIR)):
216
 
                self._translate_error(e, relpath)
217
 
            parent_dir = os.path.dirname(abspath)
218
 
            if not parent_dir:
219
 
                self._translate_error(e, relpath)
220
 
            self._mkdir(parent_dir, mode=dir_mode)
221
 
            # We created the parent directory, lets try to open the
222
 
            # file again
223
 
            try:
224
 
                fd = os.open(abspath, _put_non_atomic_flags, local_mode)
225
 
            except (IOError, OSError), e:
226
 
                self._translate_error(e, relpath)
227
 
        try:
228
 
            st = os.fstat(fd)
229
 
            if mode is not None and mode != S_IMODE(st.st_mode):
230
 
                # Because of umask, we may still need to chmod the file.
231
 
                # But in the general case, we won't have to
232
 
                os.chmod(abspath, mode)
233
 
            writer(fd)
234
 
        finally:
235
 
            os.close(fd)
236
 
 
237
 
    def put_file_non_atomic(self, relpath, f, mode=None,
238
 
                            create_parent_dir=False,
239
 
                            dir_mode=None):
240
 
        """Copy the file-like object into the target location.
241
 
 
242
 
        This function is not strictly safe to use. It is only meant to
243
 
        be used when you already know that the target does not exist.
244
 
        It is not safe, because it will open and truncate the remote
245
 
        file. So there may be a time when the file has invalid contents.
246
 
 
247
 
        :param relpath: The remote location to put the contents.
248
 
        :param f:       File-like object.
249
 
        :param mode:    Possible access permissions for new file.
250
 
                        None means do not set remote permissions.
251
 
        :param create_parent_dir: If we cannot create the target file because
252
 
                        the parent directory does not exist, go ahead and
253
 
                        create it, and then try again.
254
 
        """
255
 
        def writer(fd):
256
 
            self._pump_to_fd(f, fd)
257
 
        self._put_non_atomic_helper(relpath, writer, mode=mode,
258
 
                                    create_parent_dir=create_parent_dir,
259
 
                                    dir_mode=dir_mode)
260
 
 
261
 
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
262
 
                             create_parent_dir=False, dir_mode=None):
263
 
        def writer(fd):
264
 
            os.write(fd, bytes)
265
 
        self._put_non_atomic_helper(relpath, writer, mode=mode,
266
 
                                    create_parent_dir=create_parent_dir,
267
 
                                    dir_mode=dir_mode)
268
 
 
269
116
    def iter_files_recursive(self):
270
117
        """Iter the relative paths of files in the transports sub-tree."""
271
118
        queue = list(self.list_dir(u'.'))
278
125
            else:
279
126
                yield relpath
280
127
 
281
 
    def _mkdir(self, abspath, mode=None):
282
 
        """Create a real directory, filtering through mode"""
283
 
        if mode is None:
284
 
            # os.mkdir() will filter through umask
285
 
            local_mode = 0777
286
 
        else:
287
 
            local_mode = mode
288
 
        try:
289
 
            os.mkdir(abspath, local_mode)
290
 
            if mode is not None:
291
 
                # It is probably faster to just do the chmod, rather than
292
 
                # doing a stat, and then trying to compare
293
 
                os.chmod(abspath, mode)
294
 
        except (IOError, OSError),e:
295
 
            self._translate_error(e, abspath)
296
 
 
297
128
    def mkdir(self, relpath, mode=None):
298
129
        """Create a directory at the given path."""
299
 
        self._mkdir(self._abspath(relpath), mode=mode)
 
130
        path = relpath
 
131
        try:
 
132
            path = self.abspath(relpath)
 
133
            os.mkdir(path)
 
134
            if mode is not None:
 
135
                os.chmod(path, mode)
 
136
        except (IOError, OSError),e:
 
137
            self._translate_error(e, path)
300
138
 
301
 
    def _get_append_file(self, relpath, mode=None):
302
 
        """Call os.open() for the given relpath"""
303
 
        file_abspath = self._abspath(relpath)
304
 
        if mode is None:
305
 
            # os.open() will automatically use the umask
306
 
            local_mode = 0666
307
 
        else:
308
 
            local_mode = mode
 
139
    def append(self, relpath, f):
 
140
        """Append the text in the file-like object into the final
 
141
        location.
 
142
        """
309
143
        try:
310
 
            return file_abspath, os.open(file_abspath, _append_flags, local_mode)
 
144
            fp = open(self.abspath(relpath), 'ab')
311
145
        except (IOError, OSError),e:
312
146
            self._translate_error(e, relpath)
313
 
 
314
 
    def _check_mode_and_size(self, file_abspath, fd, mode=None):
315
 
        """Check the mode of the file, and return the current size"""
316
 
        st = os.fstat(fd)
317
 
        if mode is not None and mode != S_IMODE(st.st_mode):
318
 
            # Because of umask, we may still need to chmod the file.
319
 
            # But in the general case, we won't have to
320
 
            os.chmod(file_abspath, mode)
321
 
        return st.st_size
322
 
 
323
 
    def append_file(self, relpath, f, mode=None):
324
 
        """Append the text in the file-like object into the final location."""
325
 
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
326
 
        try:
327
 
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
328
 
            self._pump_to_fd(f, fd)
329
 
        finally:
330
 
            os.close(fd)
331
 
        return result
332
 
 
333
 
    def append_bytes(self, relpath, bytes, mode=None):
334
 
        """Append the text in the string into the final location."""
335
 
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
336
 
        try:
337
 
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
338
 
            os.write(fd, bytes)
339
 
        finally:
340
 
            os.close(fd)
341
 
        return result
342
 
 
343
 
    def _pump_to_fd(self, fromfile, to_fd):
344
 
        """Copy contents of one file to another."""
345
 
        BUFSIZE = 32768
346
 
        while True:
347
 
            b = fromfile.read(BUFSIZE)
348
 
            if not b:
349
 
                break
350
 
            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
351
152
 
352
153
    def copy(self, rel_from, rel_to):
353
154
        """Copy the item at rel_from to the location at rel_to"""
354
 
        path_from = self._abspath(rel_from)
355
 
        path_to = self._abspath(rel_to)
 
155
        import shutil
 
156
        path_from = self.abspath(rel_from)
 
157
        path_to = self.abspath(rel_to)
356
158
        try:
357
159
            shutil.copy(path_from, path_to)
358
160
        except (IOError, OSError),e:
360
162
            self._translate_error(e, path_from)
361
163
 
362
164
    def rename(self, rel_from, rel_to):
363
 
        path_from = self._abspath(rel_from)
 
165
        path_from = self.abspath(rel_from)
364
166
        try:
365
167
            # *don't* call bzrlib.osutils.rename, because we want to 
366
168
            # detect errors on rename
367
 
            os.rename(path_from, self._abspath(rel_to))
 
169
            os.rename(path_from, self.abspath(rel_to))
368
170
        except (IOError, OSError),e:
369
171
            # TODO: What about path_to?
370
172
            self._translate_error(e, path_from)
371
173
 
372
174
    def move(self, rel_from, rel_to):
373
175
        """Move the item at rel_from to the location at rel_to"""
374
 
        path_from = self._abspath(rel_from)
375
 
        path_to = self._abspath(rel_to)
 
176
        path_from = self.abspath(rel_from)
 
177
        path_to = self.abspath(rel_to)
376
178
 
377
179
        try:
378
180
            # this version will delete the destination if necessary
379
 
            osutils.rename(path_from, path_to)
 
181
            rename(path_from, path_to)
380
182
        except (IOError, OSError),e:
381
183
            # TODO: What about path_to?
382
184
            self._translate_error(e, path_from)
385
187
        """Delete the item at relpath"""
386
188
        path = relpath
387
189
        try:
388
 
            path = self._abspath(relpath)
 
190
            path = self.abspath(relpath)
389
191
            os.remove(path)
390
192
        except (IOError, OSError),e:
 
193
            # TODO: What about path_to?
391
194
            self._translate_error(e, path)
392
195
 
393
196
    def copy_to(self, relpaths, other, mode=None, pb=None):
399
202
            # Both from & to are on the local filesystem
400
203
            # Unfortunately, I can't think of anything faster than just
401
204
            # copying them across, one by one :(
 
205
            import shutil
 
206
 
402
207
            total = self._get_total(relpaths)
403
208
            count = 0
404
209
            for path in relpaths:
405
210
                self._update_pb(pb, 'copy-to', count, total)
406
211
                try:
407
 
                    mypath = self._abspath(path)
408
 
                    otherpath = other._abspath(path)
 
212
                    mypath = self.abspath(path)
 
213
                    otherpath = other.abspath(path)
409
214
                    shutil.copy(mypath, otherpath)
410
215
                    if mode is not None:
411
216
                        os.chmod(otherpath, mode)
425
230
        WARNING: many transports do not support this, so trying avoid using
426
231
        it if at all possible.
427
232
        """
428
 
        path = self._abspath(relpath)
 
233
        path = self.abspath(relpath)
429
234
        try:
430
 
            entries = os.listdir(path)
 
235
            return [urllib.quote(entry) for entry in os.listdir(path)]
431
236
        except (IOError, OSError), e:
432
237
            self._translate_error(e, path)
433
 
        return [urlutils.escape(entry) for entry in entries]
434
238
 
435
239
    def stat(self, relpath):
436
240
        """Return the stat information for a file.
437
241
        """
438
242
        path = relpath
439
243
        try:
440
 
            path = self._abspath(relpath)
 
244
            path = self.abspath(relpath)
441
245
            return os.stat(path)
442
246
        except (IOError, OSError),e:
443
247
            self._translate_error(e, path)
449
253
        from bzrlib.lock import ReadLock
450
254
        path = relpath
451
255
        try:
452
 
            path = self._abspath(relpath)
 
256
            path = self.abspath(relpath)
453
257
            return ReadLock(path)
454
258
        except (IOError, OSError), e:
455
259
            self._translate_error(e, path)
461
265
        :return: A lock object, which should be passed to Transport.unlock()
462
266
        """
463
267
        from bzrlib.lock import WriteLock
464
 
        return WriteLock(self._abspath(relpath))
 
268
        return WriteLock(self.abspath(relpath))
465
269
 
466
270
    def rmdir(self, relpath):
467
271
        """See Transport.rmdir."""
468
272
        path = relpath
469
273
        try:
470
 
            path = self._abspath(relpath)
 
274
            path = self.abspath(relpath)
471
275
            os.rmdir(path)
472
276
        except (IOError, OSError),e:
473
277
            self._translate_error(e, path)
480
284
            return True
481
285
 
482
286
 
483
 
class EmulatedWin32LocalTransport(LocalTransport):
484
 
    """Special transport for testing Win32 [UNC] paths on non-windows"""
485
 
 
486
 
    def __init__(self, base):
487
 
        if base[-1] != '/':
488
 
            base = base + '/'
489
 
        super(LocalTransport, self).__init__(base)
490
 
        self._local_base = urlutils._win32_local_path_from_url(base)
491
 
 
492
 
    def abspath(self, relpath):
493
 
        assert isinstance(relpath, basestring), (type(relpath), relpath)
494
 
        path = osutils.normpath(osutils.pathjoin(
495
 
                    self._local_base, urlutils.unescape(relpath)))
496
 
        return urlutils._win32_local_path_to_url(path)
497
 
 
498
 
    def clone(self, offset=None):
499
 
        """Return a new LocalTransport with root at self.base + offset
500
 
        Because the local filesystem does not require a connection, 
501
 
        we can just return a new object.
502
 
        """
503
 
        if offset is None:
504
 
            return EmulatedWin32LocalTransport(self.base)
505
 
        else:
506
 
            abspath = self.abspath(offset)
507
 
            if abspath == 'file://':
508
 
                # fix upwalk for UNC path
509
 
                # when clone from //HOST/path updir recursively
510
 
                # we should stop at least at //HOST part
511
 
                abspath = self.base
512
 
            return EmulatedWin32LocalTransport(abspath)
513
 
 
514
 
 
515
 
class LocalURLServer(Server):
516
 
    """A pretend server for local transports, using file:// urls.
 
287
class ScratchTransport(LocalTransport):
 
288
    """A transport that works in a temporary dir and cleans up after itself.
517
289
    
518
 
    Of course no actual server is required to access the local filesystem, so
519
 
    this just exists to tell the test code how to get to it.
 
290
    The dir only exists for the lifetime of the Python object.
 
291
    Obviously you should not put anything precious in it.
520
292
    """
521
293
 
522
 
    def setUp(self):
523
 
        """Setup the server to service requests.
524
 
        
525
 
        :param decorated_transport: ignored by this implementation.
526
 
        """
527
 
 
528
 
    def get_url(self):
529
 
        """See Transport.Server.get_url."""
530
 
        return urlutils.local_path_to_url('')
 
294
    def __init__(self, base=None):
 
295
        if base is None:
 
296
            base = tempfile.mkdtemp()
 
297
        super(ScratchTransport, self).__init__(base)
 
298
 
 
299
    def __del__(self):
 
300
        shutil.rmtree(self.base, ignore_errors=True)
 
301
        mutter("%r destroyed" % self)
 
302
 
 
303
 
 
304
class LocalRelpathServer(Server):
 
305
    """A pretend server for local transports, using relpaths."""
 
306
 
 
307
    def get_url(self):
 
308
        """See Transport.Server.get_url."""
 
309
        return "."
 
310
 
 
311
 
 
312
class LocalAbspathServer(Server):
 
313
    """A pretend server for local transports, using absolute paths."""
 
314
 
 
315
    def get_url(self):
 
316
        """See Transport.Server.get_url."""
 
317
        return os.path.abspath("")
 
318
 
 
319
 
 
320
class LocalURLServer(Server):
 
321
    """A pretend server for local transports, using file:// urls."""
 
322
 
 
323
    def get_url(self):
 
324
        """See Transport.Server.get_url."""
 
325
        # FIXME: \ to / on windows
 
326
        return "file://%s" % os.path.abspath("")
531
327
 
532
328
 
533
329
def get_test_permutations():
534
330
    """Return the permutations to be used in testing."""
535
 
    return [
 
331
    return [(LocalTransport, LocalRelpathServer),
 
332
            (LocalTransport, LocalAbspathServer),
536
333
            (LocalTransport, LocalURLServer),
537
334
            ]