1
# Copyright (C) 2005-2010 Canonical Ltd
1
# Copyright (C) 2005 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
17
"""Implementation of Transport that uses memory for its storage.
19
The contents of the transport will be lost when the object is discarded,
20
so this is primarily useful for testing.
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
"""Implementation of Transport that uses memory for its storage."""
26
from stat import S_IFREG, S_IFDIR
27
20
from cStringIO import StringIO
34
from bzrlib.errors import (
41
22
from bzrlib.trace import mutter
42
from bzrlib.transport import (
43
AppendBasedFileStream,
23
from bzrlib.transport import Transport, \
24
TransportError, NoSuchFile, FileExists
50
27
class MemoryStat(object):
52
def __init__(self, size, is_dir, perms):
29
def __init__(self, size):
53
30
self.st_size = size
57
self.st_mode = S_IFREG | perms
61
self.st_mode = S_IFDIR | perms
64
class MemoryTransport(transport.Transport):
65
"""This is an in memory file system for transient data storage."""
67
def __init__(self, url=""):
33
class MemoryTransport(Transport):
34
"""This is the transport agent for local filesystem access."""
68
37
"""Set the 'base' path where files will be stored."""
73
super(MemoryTransport, self).__init__(url)
74
split = url.find(':') + 3
75
self._scheme = url[:split]
76
self._cwd = url[split:]
77
# dictionaries from absolute path to file mode
78
self._dirs = {'/':None}
38
super(MemoryTransport, self).__init__('in-memory:')
82
42
def clone(self, offset=None):
83
43
"""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)
89
result._dirs = self._dirs
90
result._files = self._files
91
result._locks = self._locks
94
46
def abspath(self, relpath):
95
47
"""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]
105
def append_file(self, relpath, f, mode=None):
106
"""See Transport.append_file()."""
107
_abspath = self._abspath(relpath)
108
self._check_parent(_abspath)
109
orig_content, orig_mode = self._files.get(_abspath, ("", None))
112
self._files[_abspath] = (orig_content + f.read(), mode)
113
return len(orig_content)
115
def _check_parent(self, _abspath):
116
dir = os.path.dirname(_abspath)
48
return self.base + relpath
50
def append(self, relpath, f):
51
"""See Transport.append()."""
52
self._check_parent(relpath)
53
self._files[relpath] = self._files.get(relpath, "") + f.read()
55
def _check_parent(self, relpath):
56
dir = os.path.dirname(relpath)
118
58
if not dir in self._dirs:
119
raise NoSuchFile(_abspath)
59
raise NoSuchFile(relpath)
121
61
def has(self, relpath):
122
62
"""See Transport.has()."""
123
_abspath = self._abspath(relpath)
124
return (_abspath in self._files) or (_abspath in self._dirs)
126
def delete(self, relpath):
127
"""See Transport.delete()."""
128
_abspath = self._abspath(relpath)
129
if not _abspath in self._files:
130
raise NoSuchFile(relpath)
131
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)
63
return relpath in self._files
139
65
def get(self, relpath):
140
66
"""See Transport.get()."""
141
_abspath = self._abspath(relpath)
142
if not _abspath in self._files:
143
if _abspath in self._dirs:
144
return LateReadError(relpath)
146
raise NoSuchFile(relpath)
147
return StringIO(self._files[_abspath][0])
149
def put_file(self, relpath, f, mode=None):
150
"""See Transport.put_file()."""
151
_abspath = self._abspath(relpath)
152
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)
163
def mkdir(self, relpath, mode=None):
67
if not relpath in self._files:
68
raise NoSuchFile(relpath)
69
return StringIO(self._files[relpath])
71
def put(self, relpath, f):
72
"""See Transport.put()."""
73
self._check_parent(relpath)
74
self._files[relpath] = f.read()
76
def mkdir(self, relpath):
164
77
"""See Transport.mkdir()."""
165
_abspath = self._abspath(relpath)
166
self._check_parent(_abspath)
167
if _abspath in self._dirs:
78
self._check_parent(relpath)
79
if relpath in self._dirs:
168
80
raise FileExists(relpath)
169
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
81
self._dirs.add(relpath)
178
83
def listable(self):
179
84
"""See Transport.listable."""
182
87
def iter_files_recursive(self):
183
for file in self._files:
184
if file.startswith(self._cwd):
185
yield urlutils.escape(file[len(self._cwd):])
187
def list_dir(self, relpath):
188
"""See Transport.list_dir()."""
189
_abspath = self._abspath(relpath)
190
if _abspath != '/' and _abspath not in self._dirs:
191
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)
205
def rename(self, rel_from, rel_to):
206
"""Rename a file or directory; fail if the destination exists"""
207
abs_from = self._abspath(rel_from)
208
abs_to = self._abspath(rel_to)
212
elif x.startswith(abs_from + '/'):
213
x = abs_to + x[len(abs_from):]
215
def do_renames(container):
216
for path in container:
217
new_path = replace(path)
219
if new_path in container:
220
raise FileExists(new_path)
221
container[new_path] = container[path]
223
do_renames(self._files)
224
do_renames(self._dirs)
226
def rmdir(self, relpath):
227
"""See Transport.rmdir."""
228
_abspath = self._abspath(relpath)
229
if _abspath in self._files:
230
self._translate_error(IOError(errno.ENOTDIR, relpath), relpath)
231
for path in self._files:
232
if path.startswith(_abspath + '/'):
233
self._translate_error(IOError(errno.ENOTEMPTY, relpath),
235
for path in self._dirs:
236
if path.startswith(_abspath + '/') and path != _abspath:
237
self._translate_error(IOError(errno.ENOTEMPTY, relpath), relpath)
238
if not _abspath in self._dirs:
239
raise NoSuchFile(relpath)
240
del self._dirs[_abspath]
88
return iter(self._files)
90
# def list_dir(self, relpath):
242
93
def stat(self, relpath):
243
94
"""See Transport.stat()."""
244
_abspath = self._abspath(relpath)
245
if _abspath in self._files:
246
return MemoryStat(len(self._files[_abspath][0]), False,
247
self._files[_abspath][1])
248
elif _abspath in self._dirs:
249
return MemoryStat(0, True, self._dirs[_abspath])
251
raise NoSuchFile(_abspath)
253
def lock_read(self, relpath):
254
"""See Transport.lock_read()."""
255
return _MemoryLock(self._abspath(relpath), self)
257
def lock_write(self, relpath):
258
"""See Transport.lock_write()."""
259
return _MemoryLock(self._abspath(relpath), self)
261
def _abspath(self, relpath):
262
"""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)
282
class _MemoryLock(object):
283
"""This makes a lock."""
285
def __init__(self, path, transport):
287
self.transport = transport
288
if self.path in self.transport._locks:
289
raise LockError('File %r already locked' % (self.path,))
290
self.transport._locks[self.path] = self
293
# Should this warn, or actually try to cleanup?
295
warnings.warn("MemoryLock %r not explicitly unlocked" % (self.path,))
299
del self.transport._locks[self.path]
300
self.transport = None
303
class MemoryServer(transport.Server):
304
"""Server for the MemoryTransport for testing with."""
306
def start_server(self):
307
self._dirs = {'/':None}
310
self._scheme = "memory+%s:///" % id(self)
311
def memory_factory(url):
312
from bzrlib.transport import memory
313
result = memory.MemoryTransport(url)
314
result._dirs = self._dirs
315
result._files = self._files
316
result._locks = self._locks
318
self._memory_factory = memory_factory
319
transport.register_transport(self._scheme, self._memory_factory)
321
def stop_server(self):
322
# unregister this server
323
transport.unregister_transport(self._scheme, self._memory_factory)
326
"""See bzrlib.transport.Server.get_url."""
329
def get_bogus_url(self):
330
raise NotImplementedError
333
def get_test_permutations():
334
"""Return the permutations to be used in testing."""
335
return [(MemoryTransport, MemoryServer),
95
return MemoryStat(len(self._files[relpath]))
97
# def lock_read(self, relpath):
100
# def lock_write(self, relpath):
added
removed
bzrlib/transport/memory.py
