1
# Copyright (C) 2005, 2006 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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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.
16
"""Implementation of Transport that uses memory for its storage."""
26
from stat import S_IFREG, S_IFDIR
27
20
from cStringIO import StringIO
30
from bzrlib.errors import TransportError, NoSuchFile, FileExists, LockError
31
22
from bzrlib.trace import mutter
32
from bzrlib.transport import (Transport, register_transport, Server)
33
import bzrlib.urlutils as urlutils
23
from bzrlib.transport import Transport, \
24
TransportError, NoSuchFile, FileExists
37
27
class MemoryStat(object):
39
def __init__(self, size, is_dir, perms):
29
def __init__(self, size):
40
30
self.st_size = size
44
self.st_mode = S_IFREG | perms
48
self.st_mode = S_IFDIR | perms
51
33
class MemoryTransport(Transport):
52
"""This is an in memory file system for transient data storage."""
34
"""This is the transport agent for local filesystem access."""
54
def __init__(self, url=""):
55
37
"""Set the 'base' path where files will be stored."""
60
super(MemoryTransport, self).__init__(url)
61
split = url.find(':') + 3
62
self._scheme = url[:split]
63
self._cwd = url[split:]
64
# dictionaries from absolute path to file mode
65
self._dirs = {'/':None}
38
super(MemoryTransport, self).__init__('in-memory:')
69
42
def clone(self, offset=None):
70
43
"""See Transport.clone()."""
71
path = self._combine_paths(self._cwd, offset)
72
if len(path) == 0 or path[-1] != '/':
74
url = self._scheme + path
75
result = MemoryTransport(url)
76
result._dirs = self._dirs
77
result._files = self._files
78
result._locks = self._locks
81
46
def abspath(self, relpath):
82
47
"""See Transport.abspath()."""
83
# while a little slow, this is sufficiently fast to not matter in our
84
# current environment - XXX RBC 20060404 move the clone '..' handling
85
# into here and call abspath from clone
86
temp_t = self.clone(relpath)
87
if temp_t.base.count('/') == 3:
90
return temp_t.base[:-1]
92
def append_file(self, relpath, f, mode=None):
93
"""See Transport.append_file()."""
94
_abspath = self._abspath(relpath)
95
self._check_parent(_abspath)
96
orig_content, orig_mode = self._files.get(_abspath, ("", None))
99
self._files[_abspath] = (orig_content + f.read(), mode)
100
return len(orig_content)
102
def _check_parent(self, _abspath):
103
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)
105
58
if not dir in self._dirs:
106
raise NoSuchFile(_abspath)
59
raise NoSuchFile(relpath)
108
61
def has(self, relpath):
109
62
"""See Transport.has()."""
110
_abspath = self._abspath(relpath)
111
return (_abspath in self._files) or (_abspath in self._dirs)
113
def delete(self, relpath):
114
"""See Transport.delete()."""
115
_abspath = self._abspath(relpath)
116
if not _abspath in self._files:
117
raise NoSuchFile(relpath)
118
del self._files[_abspath]
63
return relpath in self._files
120
65
def get(self, relpath):
121
66
"""See Transport.get()."""
122
_abspath = self._abspath(relpath)
123
if not _abspath in self._files:
67
if not relpath in self._files:
124
68
raise NoSuchFile(relpath)
125
return StringIO(self._files[_abspath][0])
127
def put_file(self, relpath, f, mode=None):
128
"""See Transport.put_file()."""
129
_abspath = self._abspath(relpath)
130
self._check_parent(_abspath)
131
self._files[_abspath] = (f.read(), mode)
133
def mkdir(self, relpath, mode=None):
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):
134
77
"""See Transport.mkdir()."""
135
_abspath = self._abspath(relpath)
136
self._check_parent(_abspath)
137
if _abspath in self._dirs:
78
self._check_parent(relpath)
79
if relpath in self._dirs:
138
80
raise FileExists(relpath)
139
self._dirs[_abspath]=mode
81
self._dirs.add(relpath)
141
83
def listable(self):
142
84
"""See Transport.listable."""
145
87
def iter_files_recursive(self):
146
for file in self._files:
147
if file.startswith(self._cwd):
148
yield urlutils.escape(file[len(self._cwd):])
150
def list_dir(self, relpath):
151
"""See Transport.list_dir()."""
152
_abspath = self._abspath(relpath)
153
if _abspath != '/' and _abspath not in self._dirs:
154
raise NoSuchFile(relpath)
156
for path in self._files:
157
if (path.startswith(_abspath) and
158
path[len(_abspath) + 1:].find('/') == -1 and
159
len(path) > len(_abspath)):
160
result.append(path[len(_abspath) + 1:])
161
for path in self._dirs:
162
if (path.startswith(_abspath) and
163
path[len(_abspath) + 1:].find('/') == -1 and
164
len(path) > len(_abspath) and
165
path[len(_abspath)] == '/'):
166
result.append(path[len(_abspath) + 1:])
167
return map(urlutils.escape, result)
169
def rename(self, rel_from, rel_to):
170
"""Rename a file or directory; fail if the destination exists"""
171
abs_from = self._abspath(rel_from)
172
abs_to = self._abspath(rel_to)
176
elif x.startswith(abs_from + '/'):
177
x = abs_to + x[len(abs_from):]
179
def do_renames(container):
180
for path in container:
181
new_path = replace(path)
183
if new_path in container:
184
raise FileExists(new_path)
185
container[new_path] = container[path]
187
do_renames(self._files)
188
do_renames(self._dirs)
190
def rmdir(self, relpath):
191
"""See Transport.rmdir."""
192
_abspath = self._abspath(relpath)
193
if _abspath in self._files:
194
self._translate_error(IOError(errno.ENOTDIR, relpath), relpath)
195
for path in self._files:
196
if path.startswith(_abspath):
197
self._translate_error(IOError(errno.ENOTEMPTY, relpath),
199
for path in self._dirs:
200
if path.startswith(_abspath) and path != _abspath:
201
self._translate_error(IOError(errno.ENOTEMPTY, relpath), relpath)
202
if not _abspath in self._dirs:
203
raise NoSuchFile(relpath)
204
del self._dirs[_abspath]
88
return iter(self._files)
90
# def list_dir(self, relpath):
206
93
def stat(self, relpath):
207
94
"""See Transport.stat()."""
208
_abspath = self._abspath(relpath)
209
if _abspath in self._files:
210
return MemoryStat(len(self._files[_abspath][0]), False,
211
self._files[_abspath][1])
212
elif _abspath in self._dirs:
213
return MemoryStat(0, True, self._dirs[_abspath])
215
raise NoSuchFile(_abspath)
217
def lock_read(self, relpath):
218
"""See Transport.lock_read()."""
219
return _MemoryLock(self._abspath(relpath), self)
221
def lock_write(self, relpath):
222
"""See Transport.lock_write()."""
223
return _MemoryLock(self._abspath(relpath), self)
225
def _abspath(self, relpath):
226
"""Generate an internal absolute path."""
227
relpath = urlutils.unescape(relpath)
228
if relpath.find('..') != -1:
229
raise AssertionError('relpath contains ..')
232
if relpath[0] == '/':
235
if (self._cwd == '/'):
237
return self._cwd[:-1]
238
if relpath.endswith('/'):
239
relpath = relpath[:-1]
240
if relpath.startswith('./'):
241
relpath = relpath[2:]
242
return self._cwd + relpath
245
class _MemoryLock(object):
246
"""This makes a lock."""
248
def __init__(self, path, transport):
249
assert isinstance(transport, MemoryTransport)
251
self.transport = transport
252
if self.path in self.transport._locks:
253
raise LockError('File %r already locked' % (self.path,))
254
self.transport._locks[self.path] = self
257
# Should this warn, or actually try to cleanup?
259
warnings.warn("MemoryLock %r not explicitly unlocked" % (self.path,))
263
del self.transport._locks[self.path]
264
self.transport = None
267
class MemoryServer(Server):
268
"""Server for the MemoryTransport for testing with."""
271
"""See bzrlib.transport.Server.setUp."""
272
self._dirs = {'/':None}
275
self._scheme = "memory+%s:///" % id(self)
276
def memory_factory(url):
277
result = MemoryTransport(url)
278
result._dirs = self._dirs
279
result._files = self._files
280
result._locks = self._locks
282
register_transport(self._scheme, memory_factory)
285
"""See bzrlib.transport.Server.tearDown."""
286
# unregister this server
289
"""See bzrlib.transport.Server.get_url."""
293
def get_test_permutations():
294
"""Return the permutations to be used in testing."""
295
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
