← 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-12-21 14:25:26 UTC
  • mto: This revision was merged to the branch mainline in revision 6397.
  • Revision ID: v.ladeuil+lp@free.fr-20111221142526-pnwau0xnalimujts
Provides MemoryStack to simplify configuration setup in tests

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