← 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
  • Author(s): Mark Hammond
  • Date: 2008-09-09 17:02:21 UTC
  • mto: This revision was merged to the branch mainline in revision 3697.
  • Revision ID: john@arbash-meinel.com-20080909170221-svim3jw2mrz0amp3
An updated transparent icon for bzr.

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