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)
157
if not _abspath.endswith('/'):
160
for path_group in self._files, self._dirs:
161
for path in path_group:
162
if path.startswith(_abspath):
163
trailing = path[len(_abspath):]
164
if trailing and '/' not in trailing:
165
result.append(trailing)
166
return map(urlutils.escape, result)
168
def rename(self, rel_from, rel_to):
169
"""Rename a file or directory; fail if the destination exists"""
170
abs_from = self._abspath(rel_from)
171
abs_to = self._abspath(rel_to)
175
elif x.startswith(abs_from + '/'):
176
x = abs_to + x[len(abs_from):]
178
def do_renames(container):
179
for path in container:
180
new_path = replace(path)
182
if new_path in container:
183
raise FileExists(new_path)
184
container[new_path] = container[path]
186
do_renames(self._files)
187
do_renames(self._dirs)
189
def rmdir(self, relpath):
190
"""See Transport.rmdir."""
191
_abspath = self._abspath(relpath)
192
if _abspath in self._files:
193
self._translate_error(IOError(errno.ENOTDIR, relpath), relpath)
194
for path in self._files:
195
if path.startswith(_abspath):
196
self._translate_error(IOError(errno.ENOTEMPTY, relpath),
198
for path in self._dirs:
199
if path.startswith(_abspath) and path != _abspath:
200
self._translate_error(IOError(errno.ENOTEMPTY, relpath), relpath)
201
if not _abspath in self._dirs:
202
raise NoSuchFile(relpath)
203
del self._dirs[_abspath]
88
return iter(self._files)
90
# def list_dir(self, relpath):
205
93
def stat(self, relpath):
206
94
"""See Transport.stat()."""
207
_abspath = self._abspath(relpath)
208
if _abspath in self._files:
209
return MemoryStat(len(self._files[_abspath][0]), False,
210
self._files[_abspath][1])
211
elif _abspath in self._dirs:
212
return MemoryStat(0, True, self._dirs[_abspath])
214
raise NoSuchFile(_abspath)
216
def lock_read(self, relpath):
217
"""See Transport.lock_read()."""
218
return _MemoryLock(self._abspath(relpath), self)
220
def lock_write(self, relpath):
221
"""See Transport.lock_write()."""
222
return _MemoryLock(self._abspath(relpath), self)
224
def _abspath(self, relpath):
225
"""Generate an internal absolute path."""
226
relpath = urlutils.unescape(relpath)
227
if relpath.find('..') != -1:
228
raise AssertionError('relpath contains ..')
231
if relpath[0] == '/':
234
if (self._cwd == '/'):
236
return self._cwd[:-1]
237
if relpath.endswith('/'):
238
relpath = relpath[:-1]
239
if relpath.startswith('./'):
240
relpath = relpath[2:]
241
return self._cwd + relpath
244
class _MemoryLock(object):
245
"""This makes a lock."""
247
def __init__(self, path, transport):
248
assert isinstance(transport, MemoryTransport)
250
self.transport = transport
251
if self.path in self.transport._locks:
252
raise LockError('File %r already locked' % (self.path,))
253
self.transport._locks[self.path] = self
256
# Should this warn, or actually try to cleanup?
258
warnings.warn("MemoryLock %r not explicitly unlocked" % (self.path,))
262
del self.transport._locks[self.path]
263
self.transport = None
266
class MemoryServer(Server):
267
"""Server for the MemoryTransport for testing with."""
270
"""See bzrlib.transport.Server.setUp."""
271
self._dirs = {'/':None}
274
self._scheme = "memory+%s:///" % id(self)
275
def memory_factory(url):
276
result = MemoryTransport(url)
277
result._dirs = self._dirs
278
result._files = self._files
279
result._locks = self._locks
281
register_transport(self._scheme, memory_factory)
284
"""See bzrlib.transport.Server.tearDown."""
285
# unregister this server
288
"""See bzrlib.transport.Server.get_url."""
292
def get_test_permutations():
293
"""Return the permutations to be used in testing."""
294
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
