← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Vincent Ladeuil
  • Date: 2011-10-07 14:51:42 UTC
  • mto: (6015.33.11 2.4)
  • mto: This revision was merged to the branch mainline in revision 6206.
  • Revision ID: v.ladeuil+lp@free.fr-20111007145142-oyvn7y3fhz174gs5
Here are the useful print statements used to debug the previous commit.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/local.py
 
1
# Copyright (C) 2005-2011 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Transport for the local filesystem.
 
18
 
 
19
This is a fairly thin wrapper on regular file IO.
 
20
"""
 
21
 
 
22
import os
 
23
from stat import ST_MODE, S_ISDIR, S_IMODE
 
24
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
    )
 
37
from bzrlib.transport import LateReadError
 
38
""")
 
39
 
 
40
from bzrlib import transport
 
41
 
 
42
 
 
43
_append_flags = os.O_CREAT | os.O_APPEND | os.O_WRONLY | osutils.O_BINARY | osutils.O_NOINHERIT
 
44
_put_non_atomic_flags = os.O_CREAT | os.O_TRUNC | os.O_WRONLY | osutils.O_BINARY | osutils.O_NOINHERIT
 
45
 
 
46
 
 
47
class LocalTransport(transport.Transport):
 
48
    """This is the transport agent for local filesystem access."""
 
49
 
 
50
    def __init__(self, base):
 
51
        """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)
 
62
        if base[-1] != '/':
 
63
            base = base + '/'
 
64
 
 
65
        # Special case : windows has no "root", but does have
 
66
        # multiple lettered drives inside it. #240910
 
67
        if sys.platform == 'win32' and base == 'file:///':
 
68
            base = ''
 
69
            self._local_base = ''
 
70
            super(LocalTransport, self).__init__(base)
 
71
            return
 
72
 
 
73
        super(LocalTransport, self).__init__(base)
 
74
        self._local_base = urlutils.local_path_from_url(base)
 
75
 
 
76
    def clone(self, offset=None):
 
77
        """Return a new LocalTransport with root at self.base + offset
 
78
        Because the local filesystem does not require a connection,
 
79
        we can just return a new object.
 
80
        """
 
81
        if offset is None:
 
82
            return LocalTransport(self.base)
 
83
        else:
 
84
            abspath = self.abspath(offset)
 
85
            if abspath == 'file://':
 
86
                # fix upwalk for UNC path
 
87
                # when clone from //HOST/path updir recursively
 
88
                # we should stop at least at //HOST part
 
89
                abspath = self.base
 
90
            return LocalTransport(abspath)
 
91
 
 
92
    def _abspath(self, relative_reference):
 
93
        """Return a path for use in os calls.
 
94
 
 
95
        Several assumptions are made:
 
96
         - relative_reference does not contain '..'
 
97
         - relative_reference is url escaped.
 
98
        """
 
99
        if relative_reference in ('.', ''):
 
100
            # _local_base normally has a trailing slash; strip it so that stat
 
101
            # on a transport pointing to a symlink reads the link not the
 
102
            # referent but be careful of / and c:\
 
103
            return osutils.split(self._local_base)[0]
 
104
        return self._local_base + urlutils.unescape(relative_reference)
 
105
 
 
106
    def abspath(self, relpath):
 
107
        """Return the full url to the given relative URL."""
 
108
        # TODO: url escape the result. RBC 20060523.
 
109
        # jam 20060426 Using normpath on the real path, because that ensures
 
110
        #       proper handling of stuff like
 
111
        path = osutils.normpath(osutils.pathjoin(
 
112
                    self._local_base, urlutils.unescape(relpath)))
 
113
        # on windows, our _local_base may or may not have a drive specified
 
114
        # (ie, it may be "/" or "c:/foo").
 
115
        # If 'relpath' is '/' we *always* get back an abspath without
 
116
        # the drive letter - but if our transport already has a drive letter,
 
117
        # we want our abspaths to have a drive letter too - so handle that
 
118
        # here.
 
119
        if (sys.platform == "win32" and self._local_base[1:2] == ":"
 
120
            and path == '/'):
 
121
            path = self._local_base[:3]
 
122
 
 
123
        return urlutils.local_path_to_url(path)
 
124
 
 
125
    def local_abspath(self, relpath):
 
126
        """Transform the given relative path URL into the actual path on disk
 
127
 
 
128
        This function only exists for the LocalTransport, since it is
 
129
        the only one that has direct local access.
 
130
        This is mostly for stuff like WorkingTree which needs to know
 
131
        the local working directory.  The returned path will always contain
 
132
        forward slashes as the path separator, regardless of the platform.
 
133
 
 
134
        This function is quite expensive: it calls realpath which resolves
 
135
        symlinks.
 
136
        """
 
137
        absurl = self.abspath(relpath)
 
138
        # mutter(u'relpath %s => base: %s, absurl %s', relpath, self.base, absurl)
 
139
        return urlutils.local_path_from_url(absurl)
 
140
 
 
141
    def relpath(self, abspath):
 
142
        """Return the local path portion from a given absolute path.
 
143
        """
 
144
        if abspath is None:
 
145
            abspath = u'.'
 
146
 
 
147
        return urlutils.file_relpath(
 
148
            urlutils.strip_trailing_slash(self.base),
 
149
            urlutils.strip_trailing_slash(abspath))
 
150
 
 
151
    def has(self, relpath):
 
152
        return os.access(self._abspath(relpath), os.F_OK)
 
153
 
 
154
    def get(self, relpath):
 
155
        """Get the file at the given relative path.
 
156
 
 
157
        :param relpath: The relative path to the file
 
158
        """
 
159
        canonical_url = self.abspath(relpath)
 
160
        if canonical_url in transport._file_streams:
 
161
            transport._file_streams[canonical_url].flush()
 
162
        try:
 
163
            path = self._abspath(relpath)
 
164
            return osutils.open_file(path, 'rb')
 
165
        except (IOError, OSError),e:
 
166
            if e.errno == errno.EISDIR:
 
167
                return LateReadError(relpath)
 
168
            self._translate_error(e, path)
 
169
 
 
170
    def put_file(self, relpath, f, mode=None):
 
171
        """Copy the file-like object into the location.
 
172
 
 
173
        :param relpath: Location to put the contents, relative to base.
 
174
        :param f:       File-like object.
 
175
        :param mode: The mode for the newly created file,
 
176
                     None means just use the default
 
177
        """
 
178
 
 
179
        path = relpath
 
180
        try:
 
181
            path = self._abspath(relpath)
 
182
            osutils.check_legal_path(path)
 
183
            fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
 
184
        except (IOError, OSError),e:
 
185
            self._translate_error(e, path)
 
186
        try:
 
187
            length = self._pump(f, fp)
 
188
            fp.commit()
 
189
        finally:
 
190
            fp.close()
 
191
        return length
 
192
 
 
193
    def put_bytes(self, relpath, bytes, mode=None):
 
194
        """Copy the string into the location.
 
195
 
 
196
        :param relpath: Location to put the contents, relative to base.
 
197
        :param bytes:   String
 
198
        """
 
199
 
 
200
        path = relpath
 
201
        try:
 
202
            path = self._abspath(relpath)
 
203
            osutils.check_legal_path(path)
 
204
            fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
 
205
        except (IOError, OSError),e:
 
206
            self._translate_error(e, path)
 
207
        try:
 
208
            if bytes:
 
209
                fp.write(bytes)
 
210
            fp.commit()
 
211
        finally:
 
212
            fp.close()
 
213
 
 
214
    def _put_non_atomic_helper(self, relpath, writer,
 
215
                               mode=None,
 
216
                               create_parent_dir=False,
 
217
                               dir_mode=None):
 
218
        """Common functionality information for the put_*_non_atomic.
 
219
 
 
220
        This tracks all the create_parent_dir stuff.
 
221
 
 
222
        :param relpath: the path we are putting to.
 
223
        :param writer: A function that takes an os level file descriptor
 
224
            and writes whatever data it needs to write there.
 
225
        :param mode: The final file mode.
 
226
        :param create_parent_dir: Should we be creating the parent directory
 
227
            if it doesn't exist?
 
228
        """
 
229
        abspath = self._abspath(relpath)
 
230
        if mode is None:
 
231
            # os.open() will automatically use the umask
 
232
            local_mode = 0666
 
233
        else:
 
234
            local_mode = mode
 
235
        try:
 
236
            fd = os.open(abspath, _put_non_atomic_flags, local_mode)
 
237
        except (IOError, OSError),e:
 
238
            # We couldn't create the file, maybe we need to create
 
239
            # the parent directory, and try again
 
240
            if (not create_parent_dir
 
241
                or e.errno not in (errno.ENOENT,errno.ENOTDIR)):
 
242
                self._translate_error(e, relpath)
 
243
            parent_dir = os.path.dirname(abspath)
 
244
            if not parent_dir:
 
245
                self._translate_error(e, relpath)
 
246
            self._mkdir(parent_dir, mode=dir_mode)
 
247
            # We created the parent directory, lets try to open the
 
248
            # file again
 
249
            try:
 
250
                fd = os.open(abspath, _put_non_atomic_flags, local_mode)
 
251
            except (IOError, OSError), e:
 
252
                self._translate_error(e, relpath)
 
253
        try:
 
254
            st = os.fstat(fd)
 
255
            if mode is not None and mode != S_IMODE(st.st_mode):
 
256
                # Because of umask, we may still need to chmod the file.
 
257
                # But in the general case, we won't have to
 
258
                os.chmod(abspath, mode)
 
259
            writer(fd)
 
260
        finally:
 
261
            os.close(fd)
 
262
 
 
263
    def put_file_non_atomic(self, relpath, f, mode=None,
 
264
                            create_parent_dir=False,
 
265
                            dir_mode=None):
 
266
        """Copy the file-like object into the target location.
 
267
 
 
268
        This function is not strictly safe to use. It is only meant to
 
269
        be used when you already know that the target does not exist.
 
270
        It is not safe, because it will open and truncate the remote
 
271
        file. So there may be a time when the file has invalid contents.
 
272
 
 
273
        :param relpath: The remote location to put the contents.
 
274
        :param f:       File-like object.
 
275
        :param mode:    Possible access permissions for new file.
 
276
                        None means do not set remote permissions.
 
277
        :param create_parent_dir: If we cannot create the target file because
 
278
                        the parent directory does not exist, go ahead and
 
279
                        create it, and then try again.
 
280
        """
 
281
        def writer(fd):
 
282
            self._pump_to_fd(f, fd)
 
283
        self._put_non_atomic_helper(relpath, writer, mode=mode,
 
284
                                    create_parent_dir=create_parent_dir,
 
285
                                    dir_mode=dir_mode)
 
286
 
 
287
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
 
288
                             create_parent_dir=False, dir_mode=None):
 
289
        def writer(fd):
 
290
            if bytes:
 
291
                os.write(fd, bytes)
 
292
        self._put_non_atomic_helper(relpath, writer, mode=mode,
 
293
                                    create_parent_dir=create_parent_dir,
 
294
                                    dir_mode=dir_mode)
 
295
 
 
296
    def iter_files_recursive(self):
 
297
        """Iter the relative paths of files in the transports sub-tree."""
 
298
        queue = list(self.list_dir(u'.'))
 
299
        while queue:
 
300
            relpath = queue.pop(0)
 
301
            st = self.stat(relpath)
 
302
            if S_ISDIR(st[ST_MODE]):
 
303
                for i, basename in enumerate(self.list_dir(relpath)):
 
304
                    queue.insert(i, relpath+'/'+basename)
 
305
            else:
 
306
                yield relpath
 
307
 
 
308
    def _mkdir(self, abspath, mode=None):
 
309
        """Create a real directory, filtering through mode"""
 
310
        if mode is None:
 
311
            # os.mkdir() will filter through umask
 
312
            local_mode = 0777
 
313
        else:
 
314
            local_mode = mode
 
315
        try:
 
316
            os.mkdir(abspath, local_mode)
 
317
            if mode is not None:
 
318
                # It is probably faster to just do the chmod, rather than
 
319
                # doing a stat, and then trying to compare
 
320
                os.chmod(abspath, mode)
 
321
        except (IOError, OSError),e:
 
322
            self._translate_error(e, abspath)
 
323
 
 
324
    def mkdir(self, relpath, mode=None):
 
325
        """Create a directory at the given path."""
 
326
        self._mkdir(self._abspath(relpath), mode=mode)
 
327
 
 
328
    def open_write_stream(self, relpath, mode=None):
 
329
        """See Transport.open_write_stream."""
 
330
        abspath = self._abspath(relpath)
 
331
        handle = osutils.open_file(abspath, 'wb')
 
332
        handle.truncate()
 
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)
 
348
        except (IOError, OSError),e:
 
349
            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)
 
389
 
 
390
    def copy(self, rel_from, rel_to):
 
391
        """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)
 
394
        try:
 
395
            shutil.copy(path_from, path_to)
 
396
        except (IOError, OSError),e:
 
397
            # TODO: What about path_to?
 
398
            self._translate_error(e, path_from)
 
399
 
 
400
    def rename(self, rel_from, rel_to):
 
401
        path_from = self._abspath(rel_from)
 
402
        path_to = self._abspath(rel_to)
 
403
        try:
 
404
            # *don't* call bzrlib.osutils.rename, because we want to
 
405
            # detect conflicting names on rename, and osutils.rename tries to
 
406
            # mask cross-platform differences there
 
407
            os.rename(path_from, path_to)
 
408
        except (IOError, OSError),e:
 
409
            # TODO: What about path_to?
 
410
            self._translate_error(e, path_from)
 
411
 
 
412
    def move(self, rel_from, rel_to):
 
413
        """Move the item at rel_from to the location at rel_to"""
 
414
        path_from = self._abspath(rel_from)
 
415
        path_to = self._abspath(rel_to)
 
416
 
 
417
        try:
 
418
            # this version will delete the destination if necessary
 
419
            osutils.rename(path_from, path_to)
 
420
        except (IOError, OSError),e:
 
421
            # TODO: What about path_to?
 
422
            self._translate_error(e, path_from)
 
423
 
 
424
    def delete(self, relpath):
 
425
        """Delete the item at relpath"""
 
426
        path = relpath
 
427
        try:
 
428
            path = self._abspath(relpath)
 
429
            os.remove(path)
 
430
        except (IOError, OSError),e:
 
431
            self._translate_error(e, path)
 
432
 
 
433
    def external_url(self):
 
434
        """See bzrlib.transport.Transport.external_url."""
 
435
        # File URL's are externally usable.
 
436
        return self.base
 
437
 
 
438
    def copy_to(self, relpaths, other, mode=None, pb=None):
 
439
        """Copy a set of entries from self into another Transport.
 
440
 
 
441
        :param relpaths: A list/generator of entries to be copied.
 
442
        """
 
443
        if isinstance(other, LocalTransport):
 
444
            # Both from & to are on the local filesystem
 
445
            # Unfortunately, I can't think of anything faster than just
 
446
            # copying them across, one by one :(
 
447
            total = self._get_total(relpaths)
 
448
            count = 0
 
449
            for path in relpaths:
 
450
                self._update_pb(pb, 'copy-to', count, total)
 
451
                try:
 
452
                    mypath = self._abspath(path)
 
453
                    otherpath = other._abspath(path)
 
454
                    shutil.copy(mypath, otherpath)
 
455
                    if mode is not None:
 
456
                        os.chmod(otherpath, mode)
 
457
                except (IOError, OSError),e:
 
458
                    self._translate_error(e, path)
 
459
                count += 1
 
460
            return count
 
461
        else:
 
462
            return super(LocalTransport, self).copy_to(relpaths, other, mode=mode, pb=pb)
 
463
 
 
464
    def listable(self):
 
465
        """See Transport.listable."""
 
466
        return True
 
467
 
 
468
    def list_dir(self, relpath):
 
469
        """Return a list of all files at the given location.
 
470
        WARNING: many transports do not support this, so trying avoid using
 
471
        it if at all possible.
 
472
        """
 
473
        path = self._abspath(relpath)
 
474
        try:
 
475
            entries = os.listdir(path)
 
476
        except (IOError, OSError), e:
 
477
            self._translate_error(e, path)
 
478
        return [urlutils.escape(entry) for entry in entries]
 
479
 
 
480
    def stat(self, relpath):
 
481
        """Return the stat information for a file.
 
482
        """
 
483
        path = relpath
 
484
        try:
 
485
            path = self._abspath(relpath)
 
486
            return os.lstat(path)
 
487
        except (IOError, OSError),e:
 
488
            self._translate_error(e, path)
 
489
 
 
490
    def lock_read(self, relpath):
 
491
        """Lock the given file for shared (read) access.
 
492
        :return: A lock object, which should be passed to Transport.unlock()
 
493
        """
 
494
        from bzrlib.lock import ReadLock
 
495
        path = relpath
 
496
        try:
 
497
            path = self._abspath(relpath)
 
498
            return ReadLock(path)
 
499
        except (IOError, OSError), e:
 
500
            self._translate_error(e, path)
 
501
 
 
502
    def lock_write(self, relpath):
 
503
        """Lock the given file for exclusive (write) access.
 
504
        WARNING: many transports do not support this, so trying avoid using it
 
505
 
 
506
        :return: A lock object, which should be passed to Transport.unlock()
 
507
        """
 
508
        from bzrlib.lock import WriteLock
 
509
        return WriteLock(self._abspath(relpath))
 
510
 
 
511
    def rmdir(self, relpath):
 
512
        """See Transport.rmdir."""
 
513
        path = relpath
 
514
        try:
 
515
            path = self._abspath(relpath)
 
516
            os.rmdir(path)
 
517
        except (IOError, OSError),e:
 
518
            self._translate_error(e, path)
 
519
 
 
520
    if osutils.host_os_dereferences_symlinks():
 
521
        def readlink(self, relpath):
 
522
            """See Transport.readlink."""
 
523
            return osutils.readlink(self._abspath(relpath))
 
524
 
 
525
    if osutils.hardlinks_good():
 
526
        def hardlink(self, source, link_name):
 
527
            """See Transport.link."""
 
528
            try:
 
529
                os.link(self._abspath(source), self._abspath(link_name))
 
530
            except (IOError, OSError), e:
 
531
                self._translate_error(e, source)
 
532
 
 
533
    if osutils.has_symlinks():
 
534
        def symlink(self, source, link_name):
 
535
            """See Transport.symlink."""
 
536
            abs_link_dirpath = urlutils.dirname(self.abspath(link_name))
 
537
            source_rel = urlutils.file_relpath(
 
538
                urlutils.strip_trailing_slash(abs_link_dirpath),
 
539
                urlutils.strip_trailing_slash(self.abspath(source))
 
540
            )
 
541
 
 
542
            try:
 
543
                os.symlink(source_rel, self._abspath(link_name))
 
544
            except (IOError, OSError), e:
 
545
                self._translate_error(e, source_rel)
 
546
 
 
547
    def _can_roundtrip_unix_modebits(self):
 
548
        if sys.platform == 'win32':
 
549
            # anyone else?
 
550
            return False
 
551
        else:
 
552
            return True
 
553
 
 
554
 
 
555
class EmulatedWin32LocalTransport(LocalTransport):
 
556
    """Special transport for testing Win32 [UNC] paths on non-windows"""
 
557
 
 
558
    def __init__(self, base):
 
559
        if base[-1] != '/':
 
560
            base = base + '/'
 
561
        super(LocalTransport, self).__init__(base)
 
562
        self._local_base = urlutils._win32_local_path_from_url(base)
 
563
 
 
564
    def abspath(self, relpath):
 
565
        path = osutils._win32_normpath(osutils.pathjoin(
 
566
                    self._local_base, urlutils.unescape(relpath)))
 
567
        return urlutils._win32_local_path_to_url(path)
 
568
 
 
569
    def clone(self, offset=None):
 
570
        """Return a new LocalTransport with root at self.base + offset
 
571
        Because the local filesystem does not require a connection,
 
572
        we can just return a new object.
 
573
        """
 
574
        if offset is None:
 
575
            return EmulatedWin32LocalTransport(self.base)
 
576
        else:
 
577
            abspath = self.abspath(offset)
 
578
            if abspath == 'file://':
 
579
                # fix upwalk for UNC path
 
580
                # when clone from //HOST/path updir recursively
 
581
                # we should stop at least at //HOST part
 
582
                abspath = self.base
 
583
            return EmulatedWin32LocalTransport(abspath)
 
584
 
 
585
 
 
586
def get_test_permutations():
 
587
    """Return the permutations to be used in testing."""
 
588
    from bzrlib.tests import test_server
 
589
    return [(LocalTransport, test_server.LocalURLServer),]