1
1
# Copyright (C) 2005, 2006 Canonical Ltd
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.
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.
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
20
20
so this is primarily useful for testing.
26
from stat import S_IFREG, S_IFDIR
27
28
from cStringIO import StringIO
30
from bzrlib.errors import (
30
from bzrlib.errors import TransportError, NoSuchFile, FileExists, LockError
37
31
from bzrlib.trace import mutter
38
from bzrlib.transport import (
39
AppendBasedFileStream,
32
from bzrlib.transport import (Transport, register_transport, Server)
46
33
import bzrlib.urlutils as urlutils
73
60
super(MemoryTransport, self).__init__(url)
74
split = url.find(':') + 3
75
self._scheme = url[:split]
76
self._cwd = url[split:]
61
self._cwd = url[url.find(':') + 3:]
77
62
# dictionaries from absolute path to file mode
78
63
self._dirs = {'/':None}
82
67
def clone(self, offset=None):
83
68
"""See Transport.clone()."""
84
path = self._combine_paths(self._cwd, offset)
85
if len(path) == 0 or path[-1] != '/':
87
url = self._scheme + path
69
if offset is None or offset == '':
71
segments = offset.split('/')
72
cwdsegments = self._cwd.split('/')[:-1]
74
segment = segments.pop(0)
78
if len(cwdsegments) > 1:
81
cwdsegments.append(segment)
82
url = self.base[:self.base.find(':') + 3] + '/'.join(cwdsegments) + '/'
88
83
result = MemoryTransport(url)
89
84
result._dirs = self._dirs
90
85
result._files = self._files
103
98
return temp_t.base[:-1]
105
def append_file(self, relpath, f, mode=None):
106
"""See Transport.append_file()."""
100
def append(self, relpath, f, mode=None):
101
"""See Transport.append()."""
107
102
_abspath = self._abspath(relpath)
108
103
self._check_parent(_abspath)
109
104
orig_content, orig_mode = self._files.get(_abspath, ("", None))
121
116
def has(self, relpath):
122
117
"""See Transport.has()."""
123
118
_abspath = self._abspath(relpath)
124
return (_abspath in self._files) or (_abspath in self._dirs)
119
return _abspath in self._files or _abspath in self._dirs
126
121
def delete(self, relpath):
127
122
"""See Transport.delete()."""
130
125
raise NoSuchFile(relpath)
131
126
del self._files[_abspath]
133
def external_url(self):
134
"""See bzrlib.transport.Transport.external_url."""
135
# MemoryTransport's are only accessible in-process
137
raise InProcessTransport(self)
139
128
def get(self, relpath):
140
129
"""See Transport.get()."""
141
130
_abspath = self._abspath(relpath)
142
131
if not _abspath in self._files:
143
if _abspath in self._dirs:
144
return LateReadError(relpath)
146
raise NoSuchFile(relpath)
132
raise NoSuchFile(relpath)
147
133
return StringIO(self._files[_abspath][0])
149
def put_file(self, relpath, f, mode=None):
150
"""See Transport.put_file()."""
135
def put(self, relpath, f, mode=None):
136
"""See Transport.put()."""
151
137
_abspath = self._abspath(relpath)
152
138
self._check_parent(_abspath)
154
if type(bytes) is not str:
155
# Although not strictly correct, we raise UnicodeEncodeError to be
156
# compatible with other transports.
157
raise UnicodeEncodeError(
158
'undefined', bytes, 0, 1,
159
'put_file must be given a file of bytes, not unicode.')
160
self._files[_abspath] = (bytes, mode)
139
self._files[_abspath] = (f.read(), mode)
163
141
def mkdir(self, relpath, mode=None):
164
142
"""See Transport.mkdir()."""
168
146
raise FileExists(relpath)
169
147
self._dirs[_abspath]=mode
171
def open_write_stream(self, relpath, mode=None):
172
"""See Transport.open_write_stream."""
173
self.put_bytes(relpath, "", mode)
174
result = AppendBasedFileStream(self, relpath)
175
_file_streams[self.abspath(relpath)] = result
178
149
def listable(self):
179
150
"""See Transport.listable."""
182
153
def iter_files_recursive(self):
183
154
for file in self._files:
184
155
if file.startswith(self._cwd):
185
yield urlutils.escape(file[len(self._cwd):])
156
yield file[len(self._cwd):]
187
158
def list_dir(self, relpath):
188
159
"""See Transport.list_dir()."""
190
161
if _abspath != '/' and _abspath not in self._dirs:
191
162
raise NoSuchFile(relpath)
194
if not _abspath.endswith('/'):
197
for path_group in self._files, self._dirs:
198
for path in path_group:
199
if path.startswith(_abspath):
200
trailing = path[len(_abspath):]
201
if trailing and '/' not in trailing:
202
result.append(trailing)
203
return map(urlutils.escape, result)
164
for path in self._files:
165
if (path.startswith(_abspath) and
166
path[len(_abspath) + 1:].find('/') == -1 and
167
len(path) > len(_abspath)):
168
result.append(path[len(_abspath) + 1:])
169
for path in self._dirs:
170
if (path.startswith(_abspath) and
171
path[len(_abspath) + 1:].find('/') == -1 and
172
len(path) > len(_abspath) and
173
path[len(_abspath)] == '/'):
174
result.append(path[len(_abspath) + 1:])
205
177
def rename(self, rel_from, rel_to):
206
178
"""Rename a file or directory; fail if the destination exists"""
229
201
if _abspath in self._files:
230
202
self._translate_error(IOError(errno.ENOTDIR, relpath), relpath)
231
203
for path in self._files:
232
if path.startswith(_abspath + '/'):
204
if path.startswith(_abspath):
233
205
self._translate_error(IOError(errno.ENOTEMPTY, relpath),
235
207
for path in self._dirs:
236
if path.startswith(_abspath + '/') and path != _abspath:
208
if path.startswith(_abspath) and path != _abspath:
237
209
self._translate_error(IOError(errno.ENOTEMPTY, relpath), relpath)
238
210
if not _abspath in self._dirs:
239
211
raise NoSuchFile(relpath)
261
233
def _abspath(self, relpath):
262
234
"""Generate an internal absolute path."""
263
235
relpath = urlutils.unescape(relpath)
264
if relpath[:1] == '/':
266
cwd_parts = self._cwd.split('/')
267
rel_parts = relpath.split('/')
269
for i in cwd_parts + rel_parts:
272
raise ValueError("illegal relpath %r under %r"
273
% (relpath, self._cwd))
275
elif i == '.' or i == '':
279
return '/' + '/'.join(r)
236
if relpath.find('..') != -1:
237
raise AssertionError('relpath contains ..')
239
if (self._cwd == '/'):
241
return self._cwd[:-1]
242
if relpath.endswith('/'):
243
relpath = relpath[:-1]
244
if relpath.startswith('./'):
245
relpath = relpath[2:]
246
return self._cwd + relpath
282
249
class _MemoryLock(object):
283
250
"""This makes a lock."""
285
252
def __init__(self, path, transport):
253
assert isinstance(transport, MemoryTransport)
287
255
self.transport = transport
288
256
if self.path in self.transport._locks:
292
260
def __del__(self):
293
261
# Should this warn, or actually try to cleanup?
294
262
if self.transport:
295
warnings.warn("MemoryLock %r not explicitly unlocked" % (self.path,))
263
warn("MemoryLock %r not explicitly unlocked" % (self.path,))
298
266
def unlock(self):
added
removed
bzrlib/transport/memory.py
