~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/memory.py

Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""Implementation of Transport that uses memory for its storage.
 
18
 
 
19
The contents of the transport will be lost when the object is discarded,
 
20
so this is primarily useful for testing.
 
21
"""
 
22
 
 
23
import os
 
24
import errno
 
25
import re
 
26
from stat import S_IFREG, S_IFDIR
 
27
from cStringIO import StringIO
 
28
import warnings
 
29
 
 
30
from bzrlib.errors import TransportError, NoSuchFile, FileExists, LockError
 
31
from bzrlib.trace import mutter
 
32
from bzrlib.transport import (Transport, register_transport, Server)
 
33
import bzrlib.urlutils as urlutils
 
34
 
 
35
 
 
36
 
 
37
class MemoryStat(object):
 
38
 
 
39
    def __init__(self, size, is_dir, perms):
 
40
        self.st_size = size
 
41
        if not is_dir:
 
42
            if perms is None:
 
43
                perms = 0644
 
44
            self.st_mode = S_IFREG | perms
 
45
        else:
 
46
            if perms is None:
 
47
                perms = 0755
 
48
            self.st_mode = S_IFDIR | perms
 
49
 
 
50
 
 
51
class MemoryTransport(Transport):
 
52
    """This is an in memory file system for transient data storage."""
 
53
 
 
54
    def __init__(self, url=""):
 
55
        """Set the 'base' path where files will be stored."""
 
56
        if url == "":
 
57
            url = "memory:///"
 
58
        if url[-1] != '/':
 
59
            url = url + '/'
 
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}
 
66
        self._files = {}
 
67
        self._locks = {}
 
68
 
 
69
    def clone(self, offset=None):
 
70
        """See Transport.clone()."""
 
71
        path = self._combine_paths(self._cwd, offset)
 
72
        if len(path) == 0 or path[-1] != '/':
 
73
            path += '/'
 
74
        url = self._scheme + path
 
75
        result = MemoryTransport(url)
 
76
        result._dirs = self._dirs
 
77
        result._files = self._files
 
78
        result._locks = self._locks
 
79
        return result
 
80
 
 
81
    def abspath(self, relpath):
 
82
        """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:
 
88
            return temp_t.base
 
89
        else:
 
90
            return temp_t.base[:-1]
 
91
 
 
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))
 
97
        if mode is None:
 
98
            mode = orig_mode
 
99
        self._files[_abspath] = (orig_content + f.read(), mode)
 
100
        return len(orig_content)
 
101
 
 
102
    def _check_parent(self, _abspath):
 
103
        dir = os.path.dirname(_abspath)
 
104
        if dir != '/':
 
105
            if not dir in self._dirs:
 
106
                raise NoSuchFile(_abspath)
 
107
 
 
108
    def has(self, relpath):
 
109
        """See Transport.has()."""
 
110
        _abspath = self._abspath(relpath)
 
111
        return (_abspath in self._files) or (_abspath in self._dirs)
 
112
 
 
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]
 
119
 
 
120
    def get(self, relpath):
 
121
        """See Transport.get()."""
 
122
        _abspath = self._abspath(relpath)
 
123
        if not _abspath in self._files:
 
124
            raise NoSuchFile(relpath)
 
125
        return StringIO(self._files[_abspath][0])
 
126
 
 
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
        bytes = f.read()
 
132
        if type(bytes) is not str:
 
133
            # Although not strictly correct, we raise UnicodeEncodeError to be
 
134
            # compatible with other transports.
 
135
            raise UnicodeEncodeError(
 
136
                'undefined', bytes, 0, 1,
 
137
                'put_file must be given a file of bytes, not unicode.')
 
138
        self._files[_abspath] = (bytes, mode)
 
139
 
 
140
    def mkdir(self, relpath, mode=None):
 
141
        """See Transport.mkdir()."""
 
142
        _abspath = self._abspath(relpath)
 
143
        self._check_parent(_abspath)
 
144
        if _abspath in self._dirs:
 
145
            raise FileExists(relpath)
 
146
        self._dirs[_abspath]=mode
 
147
 
 
148
    def listable(self):
 
149
        """See Transport.listable."""
 
150
        return True
 
151
 
 
152
    def iter_files_recursive(self):
 
153
        for file in self._files:
 
154
            if file.startswith(self._cwd):
 
155
                yield urlutils.escape(file[len(self._cwd):])
 
156
    
 
157
    def list_dir(self, relpath):
 
158
        """See Transport.list_dir()."""
 
159
        _abspath = self._abspath(relpath)
 
160
        if _abspath != '/' and _abspath not in self._dirs:
 
161
            raise NoSuchFile(relpath)
 
162
        result = []
 
163
 
 
164
        if not _abspath.endswith('/'):
 
165
            _abspath += '/'
 
166
 
 
167
        for path_group in self._files, self._dirs:
 
168
            for path in path_group:
 
169
                if path.startswith(_abspath):
 
170
                    trailing = path[len(_abspath):]
 
171
                    if trailing and '/' not in trailing:
 
172
                        result.append(trailing)
 
173
        return map(urlutils.escape, result)
 
174
 
 
175
    def rename(self, rel_from, rel_to):
 
176
        """Rename a file or directory; fail if the destination exists"""
 
177
        abs_from = self._abspath(rel_from)
 
178
        abs_to = self._abspath(rel_to)
 
179
        def replace(x):
 
180
            if x == abs_from:
 
181
                x = abs_to
 
182
            elif x.startswith(abs_from + '/'):
 
183
                x = abs_to + x[len(abs_from):]
 
184
            return x
 
185
        def do_renames(container):
 
186
            for path in container:
 
187
                new_path = replace(path)
 
188
                if new_path != path:
 
189
                    if new_path in container:
 
190
                        raise FileExists(new_path)
 
191
                    container[new_path] = container[path]
 
192
                    del container[path]
 
193
        do_renames(self._files)
 
194
        do_renames(self._dirs)
 
195
    
 
196
    def rmdir(self, relpath):
 
197
        """See Transport.rmdir."""
 
198
        _abspath = self._abspath(relpath)
 
199
        if _abspath in self._files:
 
200
            self._translate_error(IOError(errno.ENOTDIR, relpath), relpath)
 
201
        for path in self._files:
 
202
            if path.startswith(_abspath + '/'):
 
203
                self._translate_error(IOError(errno.ENOTEMPTY, relpath),
 
204
                                      relpath)
 
205
        for path in self._dirs:
 
206
            if path.startswith(_abspath + '/') and path != _abspath:
 
207
                self._translate_error(IOError(errno.ENOTEMPTY, relpath), relpath)
 
208
        if not _abspath in self._dirs:
 
209
            raise NoSuchFile(relpath)
 
210
        del self._dirs[_abspath]
 
211
 
 
212
    def stat(self, relpath):
 
213
        """See Transport.stat()."""
 
214
        _abspath = self._abspath(relpath)
 
215
        if _abspath in self._files:
 
216
            return MemoryStat(len(self._files[_abspath][0]), False, 
 
217
                              self._files[_abspath][1])
 
218
        elif _abspath in self._dirs:
 
219
            return MemoryStat(0, True, self._dirs[_abspath])
 
220
        else:
 
221
            raise NoSuchFile(_abspath)
 
222
 
 
223
    def lock_read(self, relpath):
 
224
        """See Transport.lock_read()."""
 
225
        return _MemoryLock(self._abspath(relpath), self)
 
226
 
 
227
    def lock_write(self, relpath):
 
228
        """See Transport.lock_write()."""
 
229
        return _MemoryLock(self._abspath(relpath), self)
 
230
 
 
231
    def _abspath(self, relpath):
 
232
        """Generate an internal absolute path."""
 
233
        relpath = urlutils.unescape(relpath)
 
234
        if relpath.find('..') != -1:
 
235
            raise AssertionError('relpath contains ..')
 
236
        if relpath == '':
 
237
            return '/'
 
238
        if relpath[0] == '/':
 
239
            return relpath
 
240
        if relpath == '.':
 
241
            if (self._cwd == '/'):
 
242
                return self._cwd
 
243
            return self._cwd[:-1]
 
244
        if relpath.endswith('/'):
 
245
            relpath = relpath[:-1]
 
246
        if relpath.startswith('./'):
 
247
            relpath = relpath[2:]
 
248
        return self._cwd + relpath
 
249
 
 
250
 
 
251
class _MemoryLock(object):
 
252
    """This makes a lock."""
 
253
 
 
254
    def __init__(self, path, transport):
 
255
        assert isinstance(transport, MemoryTransport)
 
256
        self.path = path
 
257
        self.transport = transport
 
258
        if self.path in self.transport._locks:
 
259
            raise LockError('File %r already locked' % (self.path,))
 
260
        self.transport._locks[self.path] = self
 
261
 
 
262
    def __del__(self):
 
263
        # Should this warn, or actually try to cleanup?
 
264
        if self.transport:
 
265
            warnings.warn("MemoryLock %r not explicitly unlocked" % (self.path,))
 
266
            self.unlock()
 
267
 
 
268
    def unlock(self):
 
269
        del self.transport._locks[self.path]
 
270
        self.transport = None
 
271
 
 
272
 
 
273
class MemoryServer(Server):
 
274
    """Server for the MemoryTransport for testing with."""
 
275
 
 
276
    def setUp(self):
 
277
        """See bzrlib.transport.Server.setUp."""
 
278
        self._dirs = {'/':None}
 
279
        self._files = {}
 
280
        self._locks = {}
 
281
        self._scheme = "memory+%s:///" % id(self)
 
282
        def memory_factory(url):
 
283
            result = MemoryTransport(url)
 
284
            result._dirs = self._dirs
 
285
            result._files = self._files
 
286
            result._locks = self._locks
 
287
            return result
 
288
        register_transport(self._scheme, memory_factory)
 
289
 
 
290
    def tearDown(self):
 
291
        """See bzrlib.transport.Server.tearDown."""
 
292
        # unregister this server
 
293
 
 
294
    def get_url(self):
 
295
        """See bzrlib.transport.Server.get_url."""
 
296
        return self._scheme
 
297
 
 
298
 
 
299
def get_test_permutations():
 
300
    """Return the permutations to be used in testing."""
 
301
    return [(MemoryTransport, MemoryServer),
 
302
            ]