← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: John Arbash Meinel
  • Date: 2011-05-11 11:35:28 UTC
  • mto: This revision was merged to the branch mainline in revision 5851.
  • Revision ID: john@arbash-meinel.com-20110511113528-qepibuwxicjrbb2h
Break compatibility with python <2.6.

This includes auditing the code for places where we were doing
explicit 'sys.version' checks and removing them as appropriate.

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
        # initialise the file
 
331
        self.put_bytes_non_atomic(relpath, "", mode=mode)
 
332
        abspath = self._abspath(relpath)
 
333
        handle = osutils.open_file(abspath, 'wb')
 
334
        if mode is not None:
 
335
            self._check_mode_and_size(abspath, handle.fileno(), mode)
 
336
        transport._file_streams[self.abspath(relpath)] = handle
 
337
        return transport.FileFileStream(self, relpath, handle)
 
338
 
 
339
    def _get_append_file(self, relpath, mode=None):
 
340
        """Call os.open() for the given relpath"""
 
341
        file_abspath = self._abspath(relpath)
 
342
        if mode is None:
 
343
            # os.open() will automatically use the umask
 
344
            local_mode = 0666
 
345
        else:
 
346
            local_mode = mode
 
347
        try:
 
348
            return file_abspath, os.open(file_abspath, _append_flags, local_mode)
 
349
        except (IOError, OSError),e:
 
350
            self._translate_error(e, relpath)
 
351
 
 
352
    def _check_mode_and_size(self, file_abspath, fd, mode=None):
 
353
        """Check the mode of the file, and return the current size"""
 
354
        st = os.fstat(fd)
 
355
        if mode is not None and mode != S_IMODE(st.st_mode):
 
356
            # Because of umask, we may still need to chmod the file.
 
357
            # But in the general case, we won't have to
 
358
            os.chmod(file_abspath, mode)
 
359
        return st.st_size
 
360
 
 
361
    def append_file(self, relpath, f, mode=None):
 
362
        """Append the text in the file-like object into the final location."""
 
363
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
 
364
        try:
 
365
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
 
366
            self._pump_to_fd(f, fd)
 
367
        finally:
 
368
            os.close(fd)
 
369
        return result
 
370
 
 
371
    def append_bytes(self, relpath, bytes, mode=None):
 
372
        """Append the text in the string into the final location."""
 
373
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
 
374
        try:
 
375
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
 
376
            if bytes:
 
377
                os.write(fd, bytes)
 
378
        finally:
 
379
            os.close(fd)
 
380
        return result
 
381
 
 
382
    def _pump_to_fd(self, fromfile, to_fd):
 
383
        """Copy contents of one file to another."""
 
384
        BUFSIZE = 32768
 
385
        while True:
 
386
            b = fromfile.read(BUFSIZE)
 
387
            if not b:
 
388
                break
 
389
            os.write(to_fd, b)
 
390
 
 
391
    def copy(self, rel_from, rel_to):
 
392
        """Copy the item at rel_from to the location at rel_to"""
 
393
        path_from = self._abspath(rel_from)
 
394
        path_to = self._abspath(rel_to)
 
395
        try:
 
396
            shutil.copy(path_from, path_to)
 
397
        except (IOError, OSError),e:
 
398
            # TODO: What about path_to?
 
399
            self._translate_error(e, path_from)
 
400
 
 
401
    def rename(self, rel_from, rel_to):
 
402
        path_from = self._abspath(rel_from)
 
403
        path_to = self._abspath(rel_to)
 
404
        try:
 
405
            # *don't* call bzrlib.osutils.rename, because we want to
 
406
            # detect conflicting names on rename, and osutils.rename tries to
 
407
            # mask cross-platform differences there
 
408
            os.rename(path_from, path_to)
 
409
        except (IOError, OSError),e:
 
410
            # TODO: What about path_to?
 
411
            self._translate_error(e, path_from)
 
412
 
 
413
    def move(self, rel_from, rel_to):
 
414
        """Move the item at rel_from to the location at rel_to"""
 
415
        path_from = self._abspath(rel_from)
 
416
        path_to = self._abspath(rel_to)
 
417
 
 
418
        try:
 
419
            # this version will delete the destination if necessary
 
420
            osutils.rename(path_from, path_to)
 
421
        except (IOError, OSError),e:
 
422
            # TODO: What about path_to?
 
423
            self._translate_error(e, path_from)
 
424
 
 
425
    def delete(self, relpath):
 
426
        """Delete the item at relpath"""
 
427
        path = relpath
 
428
        try:
 
429
            path = self._abspath(relpath)
 
430
            os.remove(path)
 
431
        except (IOError, OSError),e:
 
432
            self._translate_error(e, path)
 
433
 
 
434
    def external_url(self):
 
435
        """See bzrlib.transport.Transport.external_url."""
 
436
        # File URL's are externally usable.
 
437
        return self.base
 
438
 
 
439
    def copy_to(self, relpaths, other, mode=None, pb=None):
 
440
        """Copy a set of entries from self into another Transport.
 
441
 
 
442
        :param relpaths: A list/generator of entries to be copied.
 
443
        """
 
444
        if isinstance(other, LocalTransport):
 
445
            # Both from & to are on the local filesystem
 
446
            # Unfortunately, I can't think of anything faster than just
 
447
            # copying them across, one by one :(
 
448
            total = self._get_total(relpaths)
 
449
            count = 0
 
450
            for path in relpaths:
 
451
                self._update_pb(pb, 'copy-to', count, total)
 
452
                try:
 
453
                    mypath = self._abspath(path)
 
454
                    otherpath = other._abspath(path)
 
455
                    shutil.copy(mypath, otherpath)
 
456
                    if mode is not None:
 
457
                        os.chmod(otherpath, mode)
 
458
                except (IOError, OSError),e:
 
459
                    self._translate_error(e, path)
 
460
                count += 1
 
461
            return count
 
462
        else:
 
463
            return super(LocalTransport, self).copy_to(relpaths, other, mode=mode, pb=pb)
 
464
 
 
465
    def listable(self):
 
466
        """See Transport.listable."""
 
467
        return True
 
468
 
 
469
    def list_dir(self, relpath):
 
470
        """Return a list of all files at the given location.
 
471
        WARNING: many transports do not support this, so trying avoid using
 
472
        it if at all possible.
 
473
        """
 
474
        path = self._abspath(relpath)
 
475
        try:
 
476
            entries = os.listdir(path)
 
477
        except (IOError, OSError), e:
 
478
            self._translate_error(e, path)
 
479
        return [urlutils.escape(entry) for entry in entries]
 
480
 
 
481
    def stat(self, relpath):
 
482
        """Return the stat information for a file.
 
483
        """
 
484
        path = relpath
 
485
        try:
 
486
            path = self._abspath(relpath)
 
487
            return os.lstat(path)
 
488
        except (IOError, OSError),e:
 
489
            self._translate_error(e, path)
 
490
 
 
491
    def lock_read(self, relpath):
 
492
        """Lock the given file for shared (read) access.
 
493
        :return: A lock object, which should be passed to Transport.unlock()
 
494
        """
 
495
        from bzrlib.lock import ReadLock
 
496
        path = relpath
 
497
        try:
 
498
            path = self._abspath(relpath)
 
499
            return ReadLock(path)
 
500
        except (IOError, OSError), e:
 
501
            self._translate_error(e, path)
 
502
 
 
503
    def lock_write(self, relpath):
 
504
        """Lock the given file for exclusive (write) access.
 
505
        WARNING: many transports do not support this, so trying avoid using it
 
506
 
 
507
        :return: A lock object, which should be passed to Transport.unlock()
 
508
        """
 
509
        from bzrlib.lock import WriteLock
 
510
        return WriteLock(self._abspath(relpath))
 
511
 
 
512
    def rmdir(self, relpath):
 
513
        """See Transport.rmdir."""
 
514
        path = relpath
 
515
        try:
 
516
            path = self._abspath(relpath)
 
517
            os.rmdir(path)
 
518
        except (IOError, OSError),e:
 
519
            self._translate_error(e, path)
 
520
 
 
521
    if osutils.host_os_dereferences_symlinks():
 
522
        def readlink(self, relpath):
 
523
            """See Transport.readlink."""
 
524
            return osutils.readlink(self._abspath(relpath))
 
525
 
 
526
    if osutils.hardlinks_good():
 
527
        def hardlink(self, source, link_name):
 
528
            """See Transport.link."""
 
529
            try:
 
530
                os.link(self._abspath(source), self._abspath(link_name))
 
531
            except (IOError, OSError), e:
 
532
                self._translate_error(e, source)
 
533
 
 
534
    if osutils.has_symlinks():
 
535
        def symlink(self, source, link_name):
 
536
            """See Transport.symlink."""
 
537
            abs_link_dirpath = urlutils.dirname(self.abspath(link_name))
 
538
            source_rel = urlutils.file_relpath(
 
539
                urlutils.strip_trailing_slash(abs_link_dirpath),
 
540
                urlutils.strip_trailing_slash(self.abspath(source))
 
541
            )
 
542
 
 
543
            try:
 
544
                os.symlink(source_rel, self._abspath(link_name))
 
545
            except (IOError, OSError), e:
 
546
                self._translate_error(e, source_rel)
 
547
 
 
548
    def _can_roundtrip_unix_modebits(self):
 
549
        if sys.platform == 'win32':
 
550
            # anyone else?
 
551
            return False
 
552
        else:
 
553
            return True
 
554
 
 
555
 
 
556
class EmulatedWin32LocalTransport(LocalTransport):
 
557
    """Special transport for testing Win32 [UNC] paths on non-windows"""
 
558
 
 
559
    def __init__(self, base):
 
560
        if base[-1] != '/':
 
561
            base = base + '/'
 
562
        super(LocalTransport, self).__init__(base)
 
563
        self._local_base = urlutils._win32_local_path_from_url(base)
 
564
 
 
565
    def abspath(self, relpath):
 
566
        path = osutils.normpath(osutils.pathjoin(
 
567
                    self._local_base, urlutils.unescape(relpath)))
 
568
        return urlutils._win32_local_path_to_url(path)
 
569
 
 
570
    def clone(self, offset=None):
 
571
        """Return a new LocalTransport with root at self.base + offset
 
572
        Because the local filesystem does not require a connection,
 
573
        we can just return a new object.
 
574
        """
 
575
        if offset is None:
 
576
            return EmulatedWin32LocalTransport(self.base)
 
577
        else:
 
578
            abspath = self.abspath(offset)
 
579
            if abspath == 'file://':
 
580
                # fix upwalk for UNC path
 
581
                # when clone from //HOST/path updir recursively
 
582
                # we should stop at least at //HOST part
 
583
                abspath = self.base
 
584
            return EmulatedWin32LocalTransport(abspath)
 
585
 
 
586
 
 
587
def get_test_permutations():
 
588
    """Return the permutations to be used in testing."""
 
589
    from bzrlib.tests import test_server
 
590
    return [(LocalTransport, test_server.LocalURLServer),]