← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-03-12 17:30:53 UTC
  • mfrom: (2338.3.1 hide-nested)
  • Revision ID: pqm@pqm.ubuntu.com-20070312173053-4cdb4cd14190d29e
Hide nested-tree commands and improve their docs

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/local.py
1
 
# Copyright (C) 2005 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
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."""
 
19
This is a fairly thin wrapper on regular file IO.
 
20
"""
20
21
 
21
22
import os
 
23
from stat import ST_MODE, S_ISDIR, ST_SIZE, S_IMODE
 
24
import sys
 
25
 
 
26
from bzrlib.lazy_import import lazy_import
 
27
lazy_import(globals(), """
 
28
import errno
22
29
import shutil
23
 
from stat import ST_MODE, S_ISDIR, ST_SIZE
24
 
import tempfile
25
 
import urllib
26
30
 
 
31
from bzrlib import (
 
32
    atomicfile,
 
33
    osutils,
 
34
    urlutils,
 
35
    symbol_versioning,
 
36
    )
27
37
from bzrlib.trace import mutter
 
38
""")
 
39
 
28
40
from bzrlib.transport import Transport, Server
29
 
from bzrlib.osutils import abspath, realpath, normpath, pathjoin, rename
 
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
45
 
31
46
 
32
47
class LocalTransport(Transport):
34
49
 
35
50
    def __init__(self, base):
36
51
        """Set the base path where files will be stored."""
37
 
        if base.startswith('file://'):
38
 
            base = base[7:]
39
 
        # realpath is incompatible with symlinks. When we traverse
40
 
        # up we might be able to normpath stuff. RBC 20051003
41
 
        base = normpath(abspath(base))
 
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)
42
62
        if base[-1] != '/':
43
63
            base = base + '/'
44
64
        super(LocalTransport, self).__init__(base)
 
65
        self._local_base = urlutils.local_path_from_url(base)
45
66
 
46
67
    def should_cache(self):
47
68
        return False
54
75
        if offset is None:
55
76
            return LocalTransport(self.base)
56
77
        else:
57
 
            return LocalTransport(self.abspath(offset))
 
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
96
 
59
97
    def abspath(self, relpath):
60
 
        """Return the full url to the given relative URL.
61
 
        This can be supplied with a string or a list
62
 
        """
 
98
        """Return the full url to the given relative URL."""
 
99
        # TODO: url escape the result. RBC 20060523.
63
100
        assert isinstance(relpath, basestring), (type(relpath), relpath)
64
 
        return pathjoin(self.base, urllib.unquote(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)
65
121
 
66
122
    def relpath(self, abspath):
67
123
        """Return the local path portion from a given absolute path.
68
124
        """
69
 
        from bzrlib.osutils import relpath
70
125
        if abspath is None:
71
126
            abspath = u'.'
72
 
        if abspath.endswith('/'):
73
 
            abspath = abspath[:-1]
74
 
        return relpath(self.base[:-1], abspath)
 
127
 
 
128
        return urlutils.file_relpath(
 
129
            urlutils.strip_trailing_slash(self.base), 
 
130
            urlutils.strip_trailing_slash(abspath))
75
131
 
76
132
    def has(self, relpath):
77
 
        return os.access(self.abspath(relpath), os.F_OK)
 
133
        return os.access(self._abspath(relpath), os.F_OK)
78
134
 
79
135
    def get(self, relpath):
80
136
        """Get the file at the given relative path.
82
138
        :param relpath: The relative path to the file
83
139
        """
84
140
        try:
85
 
            path = self.abspath(relpath)
 
141
            path = self._abspath(relpath)
86
142
            return open(path, 'rb')
87
143
        except (IOError, OSError),e:
88
144
            self._translate_error(e, path)
89
145
 
90
 
    def put(self, relpath, f, mode=None):
91
 
        """Copy the file-like or string object into the location.
 
146
    def put_file(self, relpath, f, mode=None):
 
147
        """Copy the file-like object into the location.
92
148
 
93
149
        :param relpath: Location to put the contents, relative to base.
94
 
        :param f:       File-like or string object.
 
150
        :param f:       File-like object.
 
151
        :param mode: The mode for the newly created file, 
 
152
                     None means just use the default
95
153
        """
96
 
        from bzrlib.atomicfile import AtomicFile
97
154
 
98
155
        path = relpath
99
156
        try:
100
 
            path = self.abspath(relpath)
101
 
            fp = AtomicFile(path, 'wb', new_mode=mode)
 
157
            path = self._abspath(relpath)
 
158
            osutils.check_legal_path(path)
 
159
            fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
102
160
        except (IOError, OSError),e:
103
161
            self._translate_error(e, path)
104
162
        try:
107
165
        finally:
108
166
            fp.close()
109
167
 
 
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
 
110
269
    def iter_files_recursive(self):
111
270
        """Iter the relative paths of files in the transports sub-tree."""
112
271
        queue = list(self.list_dir(u'.'))
113
272
        while queue:
114
 
            relpath = urllib.quote(queue.pop(0))
 
273
            relpath = queue.pop(0)
115
274
            st = self.stat(relpath)
116
275
            if S_ISDIR(st[ST_MODE]):
117
276
                for i, basename in enumerate(self.list_dir(relpath)):
119
278
            else:
120
279
                yield relpath
121
280
 
 
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
 
122
297
    def mkdir(self, relpath, mode=None):
123
298
        """Create a directory at the given path."""
124
 
        path = relpath
125
 
        try:
126
 
            path = self.abspath(relpath)
127
 
            os.mkdir(path)
128
 
            if mode is not None:
129
 
                os.chmod(path, mode)
130
 
        except (IOError, OSError),e:
131
 
            self._translate_error(e, path)
 
299
        self._mkdir(self._abspath(relpath), mode=mode)
132
300
 
133
 
    def append(self, relpath, f):
134
 
        """Append the text in the file-like object into the final
135
 
        location.
136
 
        """
 
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
137
309
        try:
138
 
            fp = open(self.abspath(relpath), 'ab')
 
310
            return file_abspath, os.open(file_abspath, _append_flags, local_mode)
139
311
        except (IOError, OSError),e:
140
312
            self._translate_error(e, relpath)
141
 
        self._pump(f, fp)
 
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)
142
351
 
143
352
    def copy(self, rel_from, rel_to):
144
353
        """Copy the item at rel_from to the location at rel_to"""
145
 
        import shutil
146
 
        path_from = self.abspath(rel_from)
147
 
        path_to = self.abspath(rel_to)
 
354
        path_from = self._abspath(rel_from)
 
355
        path_to = self._abspath(rel_to)
148
356
        try:
149
357
            shutil.copy(path_from, path_to)
150
358
        except (IOError, OSError),e:
151
359
            # TODO: What about path_to?
152
360
            self._translate_error(e, path_from)
153
361
 
 
362
    def rename(self, rel_from, rel_to):
 
363
        path_from = self._abspath(rel_from)
 
364
        try:
 
365
            # *don't* call bzrlib.osutils.rename, because we want to 
 
366
            # detect errors on rename
 
367
            os.rename(path_from, self._abspath(rel_to))
 
368
        except (IOError, OSError),e:
 
369
            # TODO: What about path_to?
 
370
            self._translate_error(e, path_from)
 
371
 
154
372
    def move(self, rel_from, rel_to):
155
373
        """Move the item at rel_from to the location at rel_to"""
156
 
        path_from = self.abspath(rel_from)
157
 
        path_to = self.abspath(rel_to)
 
374
        path_from = self._abspath(rel_from)
 
375
        path_to = self._abspath(rel_to)
158
376
 
159
377
        try:
160
 
            rename(path_from, path_to)
 
378
            # this version will delete the destination if necessary
 
379
            osutils.rename(path_from, path_to)
161
380
        except (IOError, OSError),e:
162
381
            # TODO: What about path_to?
163
382
            self._translate_error(e, path_from)
166
385
        """Delete the item at relpath"""
167
386
        path = relpath
168
387
        try:
169
 
            path = self.abspath(relpath)
 
388
            path = self._abspath(relpath)
170
389
            os.remove(path)
171
390
        except (IOError, OSError),e:
172
 
            # TODO: What about path_to?
173
391
            self._translate_error(e, path)
174
392
 
175
393
    def copy_to(self, relpaths, other, mode=None, pb=None):
181
399
            # Both from & to are on the local filesystem
182
400
            # Unfortunately, I can't think of anything faster than just
183
401
            # copying them across, one by one :(
184
 
            import shutil
185
 
 
186
402
            total = self._get_total(relpaths)
187
403
            count = 0
188
404
            for path in relpaths:
189
405
                self._update_pb(pb, 'copy-to', count, total)
190
406
                try:
191
 
                    mypath = self.abspath(path)
192
 
                    otherpath = other.abspath(path)
 
407
                    mypath = self._abspath(path)
 
408
                    otherpath = other._abspath(path)
193
409
                    shutil.copy(mypath, otherpath)
194
410
                    if mode is not None:
195
411
                        os.chmod(otherpath, mode)
209
425
        WARNING: many transports do not support this, so trying avoid using
210
426
        it if at all possible.
211
427
        """
212
 
        path = relpath
 
428
        path = self._abspath(relpath)
213
429
        try:
214
 
            path = self.abspath(relpath)
215
 
            return os.listdir(path)
216
 
        except (IOError, OSError),e:
 
430
            entries = os.listdir(path)
 
431
        except (IOError, OSError), e:
217
432
            self._translate_error(e, path)
 
433
        return [urlutils.escape(entry) for entry in entries]
218
434
 
219
435
    def stat(self, relpath):
220
436
        """Return the stat information for a file.
221
437
        """
222
438
        path = relpath
223
439
        try:
224
 
            path = self.abspath(relpath)
 
440
            path = self._abspath(relpath)
225
441
            return os.stat(path)
226
442
        except (IOError, OSError),e:
227
443
            self._translate_error(e, path)
233
449
        from bzrlib.lock import ReadLock
234
450
        path = relpath
235
451
        try:
236
 
            path = self.abspath(relpath)
 
452
            path = self._abspath(relpath)
237
453
            return ReadLock(path)
238
454
        except (IOError, OSError), e:
239
455
            self._translate_error(e, path)
245
461
        :return: A lock object, which should be passed to Transport.unlock()
246
462
        """
247
463
        from bzrlib.lock import WriteLock
248
 
        return WriteLock(self.abspath(relpath))
249
 
 
250
 
 
251
 
class ScratchTransport(LocalTransport):
252
 
    """A transport that works in a temporary dir and cleans up after itself.
 
464
        return WriteLock(self._abspath(relpath))
 
465
 
 
466
    def rmdir(self, relpath):
 
467
        """See Transport.rmdir."""
 
468
        path = relpath
 
469
        try:
 
470
            path = self._abspath(relpath)
 
471
            os.rmdir(path)
 
472
        except (IOError, OSError),e:
 
473
            self._translate_error(e, path)
 
474
 
 
475
    def _can_roundtrip_unix_modebits(self):
 
476
        if sys.platform == 'win32':
 
477
            # anyone else?
 
478
            return False
 
479
        else:
 
480
            return True
 
481
 
 
482
 
 
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.
253
517
    
254
 
    The dir only exists for the lifetime of the Python object.
255
 
    Obviously you should not put anything precious in it.
 
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.
256
520
    """
257
521
 
258
 
    def __init__(self, base=None):
259
 
        if base is None:
260
 
            base = tempfile.mkdtemp()
261
 
        super(ScratchTransport, self).__init__(base)
262
 
 
263
 
    def __del__(self):
264
 
        shutil.rmtree(self.base, ignore_errors=True)
265
 
        mutter("%r destroyed" % self)
266
 
 
267
 
 
268
 
class LocalRelpathServer(Server):
269
 
    """A pretend server for local transports, using relpaths."""
270
 
 
271
 
    def get_url(self):
272
 
        """See Transport.Server.get_url."""
273
 
        return "."
274
 
 
275
 
 
276
 
class LocalAbspathServer(Server):
277
 
    """A pretend server for local transports, using absolute paths."""
278
 
 
279
 
    def get_url(self):
280
 
        """See Transport.Server.get_url."""
281
 
        return os.path.abspath("")
282
 
 
283
 
 
284
 
class LocalURLServer(Server):
285
 
    """A pretend server for local transports, using file:// urls."""
286
 
 
287
 
    def get_url(self):
288
 
        """See Transport.Server.get_url."""
289
 
        # FIXME: \ to / on windows
290
 
        return "file://%s" % os.path.abspath("")
 
522
    def get_url(self):
 
523
        """See Transport.Server.get_url."""
 
524
        return urlutils.local_path_to_url('')
291
525
 
292
526
 
293
527
def get_test_permutations():
294
528
    """Return the permutations to be used in testing."""
295
 
    return [(LocalTransport, LocalRelpathServer),
296
 
            (LocalTransport, LocalAbspathServer),
 
529
    return [
297
530
            (LocalTransport, LocalURLServer),
298
531
            ]