← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

Merge from mbp.

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
23
22
import shutil
24
23
from stat import ST_MODE, S_ISDIR, ST_SIZE
25
24
import tempfile
26
25
import urllib
27
26
 
28
27
from bzrlib.trace import mutter
29
 
from bzrlib.transport import Transport, register_transport, \
30
 
    TransportError, NoSuchFile, FileExists
 
28
from bzrlib.transport import Transport
31
29
from bzrlib.osutils import abspath
32
30
 
33
 
class LocalTransportError(TransportError):
34
 
    pass
35
 
 
36
31
 
37
32
class LocalTransport(Transport):
38
33
    """This is the transport agent for local filesystem access."""
85
80
        try:
86
81
            path = self.abspath(relpath)
87
82
            return open(path, 'rb')
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)
 
83
        except (IOError, OSError),e:
 
84
            self._translate_error(e, path)
92
85
 
93
86
    def put(self, relpath, f):
94
87
        """Copy the file-like or string object into the location.
98
91
        """
99
92
        from bzrlib.atomicfile import AtomicFile
100
93
 
 
94
        path = relpath
101
95
        try:
102
96
            path = self.abspath(relpath)
103
97
            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)
 
98
        except (IOError, OSError),e:
 
99
            self._translate_error(e, path)
108
100
        try:
109
101
            self._pump(f, fp)
110
102
            fp.commit()
125
117
 
126
118
    def mkdir(self, relpath):
127
119
        """Create a directory at the given path."""
 
120
        path = relpath
128
121
        try:
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)
 
122
            path = self.abspath(relpath)
 
123
            os.mkdir(path)
 
124
        except (IOError, OSError),e:
 
125
            self._translate_error(e, path)
136
126
 
137
127
    def append(self, relpath, f):
138
128
        """Append the text in the file-like object into the final
148
138
        path_to = self.abspath(rel_to)
149
139
        try:
150
140
            shutil.copy(path_from, path_to)
151
 
        except OSError,e:
152
 
            raise LocalTransportError(orig_error=e)
 
141
        except (IOError, OSError),e:
 
142
            # TODO: What about path_to?
 
143
            self._translate_error(e, path_from)
153
144
 
154
145
    def move(self, rel_from, rel_to):
155
146
        """Move the item at rel_from to the location at rel_to"""
158
149
 
159
150
        try:
160
151
            os.rename(path_from, path_to)
161
 
        except OSError,e:
162
 
            raise LocalTransportError(orig_error=e)
 
152
        except (IOError, OSError),e:
 
153
            # TODO: What about path_to?
 
154
            self._translate_error(e, path_from)
163
155
 
164
156
    def delete(self, relpath):
165
157
        """Delete the item at relpath"""
 
158
        path = relpath
166
159
        try:
167
 
            os.remove(self.abspath(relpath))
168
 
        except OSError,e:
169
 
            raise LocalTransportError(orig_error=e)
 
160
            path = self.abspath(relpath)
 
161
            os.remove(path)
 
162
        except (IOError, OSError),e:
 
163
            # TODO: What about path_to?
 
164
            self._translate_error(e, path)
170
165
 
171
166
    def copy_to(self, relpaths, other, pb=None):
172
167
        """Copy a set of entries from self into another Transport.
185
180
                self._update_pb(pb, 'copy-to', count, total)
186
181
                try:
187
182
                    shutil.copy(self.abspath(path), other.abspath(path))
188
 
                except IOError, e:
189
 
                    if e.errno in (errno.ENOENT, errno.ENOTDIR):
190
 
                        raise NoSuchFile('File or directory %r does not exist' % path, orig_error=e)
191
 
                    raise LocalTransportError(orig_error=e)
 
183
                except (IOError, OSError),e:
 
184
                    self._translate_error(e, path)
192
185
                count += 1
193
186
            return count
194
187
        else:
203
196
        WARNING: many transports do not support this, so trying avoid using
204
197
        it if at all possible.
205
198
        """
 
199
        path = relpath
206
200
        try:
207
 
            return os.listdir(self.abspath(relpath))
208
 
        except OSError,e:
209
 
            raise LocalTransportError(orig_error=e)
 
201
            path = self.abspath(relpath)
 
202
            return os.listdir(path)
 
203
        except (IOError, OSError),e:
 
204
            self._translate_error(e, path)
210
205
 
211
206
    def stat(self, relpath):
212
207
        """Return the stat information for a file.
213
208
        """
 
209
        path = relpath
214
210
        try:
215
 
            return os.stat(self.abspath(relpath))
216
 
        except OSError,e:
217
 
            raise LocalTransportError(orig_error=e)
 
211
            path = self.abspath(relpath)
 
212
            return os.stat(path)
 
213
        except (IOError, OSError),e:
 
214
            self._translate_error(e, path)
218
215
 
219
216
    def lock_read(self, relpath):
220
217
        """Lock the given file for shared (read) access.