← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Robert Collins
  • Date: 2005-10-30 00:00:09 UTC
  • mfrom: (1185.16.134)
  • Revision ID: robertc@robertcollins.net-20051030000009-9db99a338a0dfdac
Merge from Martin.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/local.py
19
19
This is a fairly thin wrapper on regular file IO."""
20
20
 
21
21
import os
 
22
import errno
22
23
import shutil
23
24
from stat import ST_MODE, S_ISDIR, ST_SIZE
24
25
import tempfile
25
26
import urllib
26
27
 
27
28
from bzrlib.trace import mutter
28
 
from bzrlib.transport import Transport
29
 
from bzrlib.osutils import abspath, realpath, normpath, pathjoin, rename
 
29
from bzrlib.transport import Transport, register_transport, \
 
30
    TransportError, NoSuchFile, FileExists
 
31
from bzrlib.osutils import abspath
 
32
 
 
33
class LocalTransportError(TransportError):
 
34
    pass
30
35
 
31
36
 
32
37
class LocalTransport(Transport):
38
43
            base = base[7:]
39
44
        # realpath is incompatible with symlinks. When we traverse
40
45
        # up we might be able to normpath stuff. RBC 20051003
41
 
        super(LocalTransport, self).__init__(normpath(abspath(base)))
 
46
        super(LocalTransport, self).__init__(
 
47
            os.path.normpath(abspath(base)))
42
48
 
43
49
    def should_cache(self):
44
50
        return False
58
64
        This can be supplied with a string or a list
59
65
        """
60
66
        assert isinstance(relpath, basestring), (type(relpath), relpath)
61
 
        return pathjoin(self.base, urllib.unquote(relpath))
 
67
        return os.path.join(self.base, urllib.unquote(relpath))
62
68
 
63
69
    def relpath(self, abspath):
64
70
        """Return the local path portion from a given absolute path.
65
71
        """
66
72
        from bzrlib.osutils import relpath
67
73
        if abspath is None:
68
 
            abspath = u'.'
 
74
            abspath = '.'
69
75
        return relpath(self.base, abspath)
70
76
 
71
77
    def has(self, relpath):
79
85
        try:
80
86
            path = self.abspath(relpath)
81
87
            return open(path, 'rb')
82
 
        except (IOError, OSError),e:
83
 
            self._translate_error(e, path)
 
88
        except IOError,e:
 
89
            if e.errno in (errno.ENOENT, errno.ENOTDIR):
 
90
                raise NoSuchFile('File or directory %r does not exist' % path, orig_error=e)
 
91
            raise LocalTransportError(orig_error=e)
84
92
 
85
 
    def put(self, relpath, f, mode=None):
 
93
    def put(self, relpath, f):
86
94
        """Copy the file-like or string object into the location.
87
95
 
88
96
        :param relpath: Location to put the contents, relative to base.
90
98
        """
91
99
        from bzrlib.atomicfile import AtomicFile
92
100
 
93
 
        path = relpath
94
101
        try:
95
102
            path = self.abspath(relpath)
96
 
            fp = AtomicFile(path, 'wb', new_mode=mode)
97
 
        except (IOError, OSError),e:
98
 
            self._translate_error(e, path)
 
103
            fp = AtomicFile(path, 'wb')
 
104
        except IOError, e:
 
105
            if e.errno == errno.ENOENT:
 
106
                raise NoSuchFile('File %r does not exist' % path, orig_error=e)
 
107
            raise LocalTransportError(orig_error=e)
99
108
        try:
100
109
            self._pump(f, fp)
101
110
            fp.commit()
104
113
 
105
114
    def iter_files_recursive(self):
106
115
        """Iter the relative paths of files in the transports sub-tree."""
107
 
        queue = list(self.list_dir(u'.'))
 
116
        queue = list(self.list_dir('.'))
108
117
        while queue:
109
118
            relpath = urllib.quote(queue.pop(0))
110
119
            st = self.stat(relpath)
114
123
            else:
115
124
                yield relpath
116
125
 
117
 
    def mkdir(self, relpath, mode=None):
 
126
    def mkdir(self, relpath):
118
127
        """Create a directory at the given path."""
119
 
        path = relpath
120
128
        try:
121
 
            path = self.abspath(relpath)
122
 
            os.mkdir(path)
123
 
            if mode is not None:
124
 
                os.chmod(path, mode)
125
 
        except (IOError, OSError),e:
126
 
            self._translate_error(e, path)
 
129
            os.mkdir(self.abspath(relpath))
 
130
        except OSError,e:
 
131
            if e.errno == errno.EEXIST:
 
132
                raise FileExists(orig_error=e)
 
133
            elif e.errno == errno.ENOENT:
 
134
                raise NoSuchFile(orig_error=e)
 
135
            raise LocalTransportError(orig_error=e)
127
136
 
128
137
    def append(self, relpath, f):
129
138
        """Append the text in the file-like object into the final
139
148
        path_to = self.abspath(rel_to)
140
149
        try:
141
150
            shutil.copy(path_from, path_to)
142
 
        except (IOError, OSError),e:
143
 
            # TODO: What about path_to?
144
 
            self._translate_error(e, path_from)
 
151
        except OSError,e:
 
152
            raise LocalTransportError(orig_error=e)
145
153
 
146
154
    def move(self, rel_from, rel_to):
147
155
        """Move the item at rel_from to the location at rel_to"""
149
157
        path_to = self.abspath(rel_to)
150
158
 
151
159
        try:
152
 
            rename(path_from, path_to)
153
 
        except (IOError, OSError),e:
154
 
            # TODO: What about path_to?
155
 
            self._translate_error(e, path_from)
 
160
            os.rename(path_from, path_to)
 
161
        except OSError,e:
 
162
            raise LocalTransportError(orig_error=e)
156
163
 
157
164
    def delete(self, relpath):
158
165
        """Delete the item at relpath"""
159
 
        path = relpath
160
166
        try:
161
 
            path = self.abspath(relpath)
162
 
            os.remove(path)
163
 
        except (IOError, OSError),e:
164
 
            # TODO: What about path_to?
165
 
            self._translate_error(e, path)
 
167
            os.remove(self.abspath(relpath))
 
168
        except OSError,e:
 
169
            raise LocalTransportError(orig_error=e)
166
170
 
167
 
    def copy_to(self, relpaths, other, mode=None, pb=None):
 
171
    def copy_to(self, relpaths, other, pb=None):
168
172
        """Copy a set of entries from self into another Transport.
169
173
 
170
174
        :param relpaths: A list/generator of entries to be copied.
179
183
            count = 0
180
184
            for path in relpaths:
181
185
                self._update_pb(pb, 'copy-to', count, total)
182
 
                try:
183
 
                    mypath = self.abspath(path)
184
 
                    otherpath = other.abspath(path)
185
 
                    shutil.copy(mypath, otherpath)
186
 
                    if mode is not None:
187
 
                        os.chmod(otherpath, mode)
188
 
                except (IOError, OSError),e:
189
 
                    self._translate_error(e, path)
 
186
                shutil.copy(self.abspath(path), other.abspath(path))
190
187
                count += 1
191
188
            return count
192
189
        else:
193
 
            return super(LocalTransport, self).copy_to(relpaths, other, mode=mode, pb=pb)
 
190
            return super(LocalTransport, self).copy_to(relpaths, other, pb=pb)
194
191
 
195
192
    def listable(self):
196
193
        """See Transport.listable."""
201
198
        WARNING: many transports do not support this, so trying avoid using
202
199
        it if at all possible.
203
200
        """
204
 
        path = relpath
205
201
        try:
206
 
            path = self.abspath(relpath)
207
 
            return os.listdir(path)
208
 
        except (IOError, OSError),e:
209
 
            self._translate_error(e, path)
 
202
            return os.listdir(self.abspath(relpath))
 
203
        except OSError,e:
 
204
            raise LocalTransportError(orig_error=e)
210
205
 
211
206
    def stat(self, relpath):
212
207
        """Return the stat information for a file.
213
208
        """
214
 
        path = relpath
215
209
        try:
216
 
            path = self.abspath(relpath)
217
 
            return os.stat(path)
218
 
        except (IOError, OSError),e:
219
 
            self._translate_error(e, path)
 
210
            return os.stat(self.abspath(relpath))
 
211
        except OSError,e:
 
212
            raise LocalTransportError(orig_error=e)
220
213
 
221
214
    def lock_read(self, relpath):
222
215
        """Lock the given file for shared (read) access.