/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Wouter van Heyst
  • Date: 2006-06-07 17:23:59 UTC
  • mto: This revision was merged to the branch mainline in revision 1752.
  • Revision ID: larstiq@larstiq.dyndns.org-20060607172359-6023dec74344453d
more code cleanup

Show diffs side-by-side

added added

removed removed

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