1
# Copyright (C) 2005-2010 Canonical Ltd
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
# 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
17
17
"""Implementation of Transport that uses memory for its storage.
20
20
so this is primarily useful for testing.
26
from stat import S_IFREG, S_IFDIR
27
28
from cStringIO import StringIO
34
from bzrlib.errors import (
41
30
from bzrlib.trace import mutter
42
from bzrlib.transport import (
43
AppendBasedFileStream,
31
from bzrlib.errors import TransportError, NoSuchFile, FileExists, LockError
32
from bzrlib.transport import Transport, register_transport, Server
50
34
class MemoryStat(object):
61
45
self.st_mode = S_IFDIR | perms
64
class MemoryTransport(transport.Transport):
48
class MemoryTransport(Transport):
65
49
"""This is an in memory file system for transient data storage."""
67
51
def __init__(self, url=""):
68
52
"""Set the 'base' path where files will be stored."""
73
57
super(MemoryTransport, self).__init__(url)
74
split = url.find(':') + 3
75
self._scheme = url[:split]
76
self._cwd = url[split:]
58
self._cwd = url[url.find(':') + 1:]
77
59
# dictionaries from absolute path to file mode
78
self._dirs = {'/':None}
82
64
def clone(self, offset=None):
83
65
"""See Transport.clone()."""
84
path = self._combine_paths(self._cwd, offset)
85
if len(path) == 0 or path[-1] != '/':
87
url = self._scheme + path
88
result = self.__class__(url)
68
segments = offset.split('/')
69
cwdsegments = self._cwd.split('/')[:-1]
71
segment = segments.pop(0)
75
if len(cwdsegments) > 1:
78
cwdsegments.append(segment)
79
url = self.base[:self.base.find(':') + 1] + '/'.join(cwdsegments) + '/'
80
result = MemoryTransport(url)
89
81
result._dirs = self._dirs
90
82
result._files = self._files
91
83
result._locks = self._locks
94
86
def abspath(self, relpath):
95
87
"""See Transport.abspath()."""
96
# while a little slow, this is sufficiently fast to not matter in our
97
# current environment - XXX RBC 20060404 move the clone '..' handling
98
# into here and call abspath from clone
99
temp_t = self.clone(relpath)
100
if temp_t.base.count('/') == 3:
103
return temp_t.base[:-1]
88
return self.base[:-1] + self._abspath(relpath)[len(self._cwd) - 1:]
105
def append_file(self, relpath, f, mode=None):
106
"""See Transport.append_file()."""
90
def append(self, relpath, f):
91
"""See Transport.append()."""
107
92
_abspath = self._abspath(relpath)
108
93
self._check_parent(_abspath)
109
94
orig_content, orig_mode = self._files.get(_abspath, ("", None))
112
self._files[_abspath] = (orig_content + f.read(), mode)
95
self._files[_abspath] = (orig_content + f.read(), orig_mode)
113
96
return len(orig_content)
115
98
def _check_parent(self, _abspath):
121
104
def has(self, relpath):
122
105
"""See Transport.has()."""
123
106
_abspath = self._abspath(relpath)
124
return (_abspath in self._files) or (_abspath in self._dirs)
107
return _abspath in self._files or _abspath in self._dirs
126
109
def delete(self, relpath):
127
110
"""See Transport.delete()."""
130
113
raise NoSuchFile(relpath)
131
114
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
116
def get(self, relpath):
140
117
"""See Transport.get()."""
141
118
_abspath = self._abspath(relpath)
142
119
if not _abspath in self._files:
143
if _abspath in self._dirs:
144
return LateReadError(relpath)
146
raise NoSuchFile(relpath)
120
raise NoSuchFile(relpath)
147
121
return StringIO(self._files[_abspath][0])
149
def put_file(self, relpath, f, mode=None):
150
"""See Transport.put_file()."""
123
def put(self, relpath, f, mode=None):
124
"""See Transport.put()."""
151
125
_abspath = self._abspath(relpath)
152
126
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)
127
self._files[_abspath] = (f.read(), mode)
163
129
def mkdir(self, relpath, mode=None):
164
130
"""See Transport.mkdir()."""
168
134
raise FileExists(relpath)
169
135
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
137
def listable(self):
179
138
"""See Transport.listable."""
182
141
def iter_files_recursive(self):
183
142
for file in self._files:
184
143
if file.startswith(self._cwd):
185
yield urlutils.escape(file[len(self._cwd):])
144
yield file[len(self._cwd):]
187
146
def list_dir(self, relpath):
188
147
"""See Transport.list_dir()."""
189
148
_abspath = self._abspath(relpath)
190
149
if _abspath != '/' and _abspath not in self._dirs:
191
150
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)
152
for path in self._files:
153
if (path.startswith(_abspath) and
154
path[len(_abspath) + 1:].find('/') == -1 and
155
len(path) > len(_abspath)):
156
result.append(path[len(_abspath) + 1:])
157
for path in self._dirs:
158
if (path.startswith(_abspath) and
159
path[len(_abspath) + 1:].find('/') == -1 and
160
len(path) > len(_abspath) and
161
path[len(_abspath)] == '/'):
162
result.append(path[len(_abspath) + 1:])
205
165
def rename(self, rel_from, rel_to):
206
166
"""Rename a file or directory; fail if the destination exists"""
222
182
del container[path]
223
183
do_renames(self._files)
224
184
do_renames(self._dirs)
226
186
def rmdir(self, relpath):
227
187
"""See Transport.rmdir."""
228
188
_abspath = self._abspath(relpath)
229
189
if _abspath in self._files:
230
190
self._translate_error(IOError(errno.ENOTDIR, relpath), relpath)
231
191
for path in self._files:
232
if path.startswith(_abspath + '/'):
192
if path.startswith(_abspath):
233
193
self._translate_error(IOError(errno.ENOTEMPTY, relpath),
235
195
for path in self._dirs:
236
if path.startswith(_abspath + '/') and path != _abspath:
196
if path.startswith(_abspath) and path != _abspath:
237
197
self._translate_error(IOError(errno.ENOTEMPTY, relpath), relpath)
238
198
if not _abspath in self._dirs:
239
199
raise NoSuchFile(relpath)
243
203
"""See Transport.stat()."""
244
204
_abspath = self._abspath(relpath)
245
205
if _abspath in self._files:
246
return MemoryStat(len(self._files[_abspath][0]), False,
206
return MemoryStat(len(self._files[_abspath][0]), False,
247
207
self._files[_abspath][1])
209
return MemoryStat(0, True, None)
248
210
elif _abspath in self._dirs:
249
211
return MemoryStat(0, True, self._dirs[_abspath])
261
223
def _abspath(self, relpath):
262
224
"""Generate an internal absolute path."""
263
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)
225
if relpath.find('..') != -1:
226
raise AssertionError('relpath contains ..')
228
return self._cwd[:-1]
229
if relpath.endswith('/'):
230
relpath = relpath[:-1]
231
if relpath.startswith('./'):
232
relpath = relpath[2:]
233
return self._cwd + relpath
282
236
class _MemoryLock(object):
283
237
"""This makes a lock."""
285
239
def __init__(self, path, transport):
240
assert isinstance(transport, MemoryTransport)
287
242
self.transport = transport
288
243
if self.path in self.transport._locks:
292
247
def __del__(self):
293
248
# Should this warn, or actually try to cleanup?
294
249
if self.transport:
295
warnings.warn("MemoryLock %r not explicitly unlocked" % (self.path,))
250
warn("MemoryLock %r not explicitly unlocked" % (self.path,))
298
253
def unlock(self):
300
255
self.transport = None
303
class MemoryServer(transport.Server):
258
class MemoryServer(Server):
304
259
"""Server for the MemoryTransport for testing with."""
306
def start_server(self):
307
self._dirs = {'/':None}
262
"""See bzrlib.transport.Server.setUp."""
310
self._scheme = "memory+%s:///" % id(self)
266
self._scheme = "memory+%s:" % id(self)
311
267
def memory_factory(url):
312
from bzrlib.transport import memory
313
result = memory.MemoryTransport(url)
268
result = MemoryTransport(url)
314
269
result._dirs = self._dirs
315
270
result._files = self._files
316
271
result._locks = self._locks
318
self._memory_factory = memory_factory
319
transport.register_transport(self._scheme, self._memory_factory)
273
register_transport(self._scheme, memory_factory)
321
def stop_server(self):
276
"""See bzrlib.transport.Server.tearDown."""
322
277
# unregister this server
323
transport.unregister_transport(self._scheme, self._memory_factory)
325
279
def get_url(self):
326
280
"""See bzrlib.transport.Server.get_url."""
327
281
return self._scheme
329
def get_bogus_url(self):
330
raise NotImplementedError
333
284
def get_test_permutations():
334
285
"""Return the permutations to be used in testing."""
added
removed
bzrlib/transport/memory.py
