← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/memory.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-03-09 08:50:48 UTC
  • mfrom: (1553.5.83 bzr.mbp.locks)
  • Revision ID: pqm@pqm.ubuntu.com-20060309085048-37f21fd146dabe93
[merge] LockDir integration into new formats

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/memory.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
 
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.
7
 
#
 
7
 
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.
12
 
#
 
12
 
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
16
16
 
17
17
"""Implementation of Transport that uses memory for its storage.
18
18
 
20
20
so this is primarily useful for testing.
21
21
"""
22
22
 
23
 
from __future__ import absolute_import
24
 
 
 
23
from copy import copy
25
24
import os
26
25
import errno
27
 
from stat import S_IFREG, S_IFDIR
 
26
import re
 
27
from stat import *
28
28
from cStringIO import StringIO
29
29
 
30
 
from bzrlib import (
31
 
    transport,
32
 
    urlutils,
33
 
    )
34
 
from bzrlib.errors import (
35
 
    FileExists,
36
 
    LockError,
37
 
    InProcessTransport,
38
 
    NoSuchFile,
39
 
    )
40
 
from bzrlib.transport import (
41
 
    AppendBasedFileStream,
42
 
    _file_streams,
43
 
    LateReadError,
44
 
    )
45
 
 
46
 
 
 
30
from bzrlib.trace import mutter
 
31
from bzrlib.errors import TransportError, NoSuchFile, FileExists, LockError
 
32
from bzrlib.transport import Transport, register_transport, Server
47
33
 
48
34
class MemoryStat(object):
49
35
 
59
45
            self.st_mode = S_IFDIR | perms
60
46
 
61
47
 
62
 
class MemoryTransport(transport.Transport):
 
48
class MemoryTransport(Transport):
63
49
    """This is an in memory file system for transient data storage."""
64
50
 
65
51
    def __init__(self, url=""):
66
52
        """Set the 'base' path where files will be stored."""
67
53
        if url == "":
68
 
            url = "memory:///"
 
54
            url = "memory:/"
69
55
        if url[-1] != '/':
70
56
            url = url + '/'
71
57
        super(MemoryTransport, self).__init__(url)
72
 
        split = url.find(':') + 3
73
 
        self._scheme = url[:split]
74
 
        self._cwd = url[split:]
 
58
        self._cwd = url[url.find(':') + 1:]
75
59
        # dictionaries from absolute path to file mode
76
 
        self._dirs = {'/':None}
 
60
        self._dirs = {}
77
61
        self._files = {}
78
62
        self._locks = {}
79
63
 
80
64
    def clone(self, offset=None):
81
65
        """See Transport.clone()."""
82
 
        path = urlutils.URL._combine_paths(self._cwd, offset)
83
 
        if len(path) == 0 or path[-1] != '/':
84
 
            path += '/'
85
 
        url = self._scheme + path
86
 
        result = self.__class__(url)
 
66
        if offset is None:
 
67
            return copy(self)
 
68
        segments = offset.split('/')
 
69
        cwdsegments = self._cwd.split('/')[:-1]
 
70
        while len(segments):
 
71
            segment = segments.pop(0)
 
72
            if segment == '.':
 
73
                continue
 
74
            if segment == '..':
 
75
                if len(cwdsegments) > 1:
 
76
                    cwdsegments.pop()
 
77
                continue
 
78
            cwdsegments.append(segment)
 
79
        url = self.base[:self.base.find(':') + 1] + '/'.join(cwdsegments) + '/'
 
80
        result = MemoryTransport(url)
87
81
        result._dirs = self._dirs
88
82
        result._files = self._files
89
83
        result._locks = self._locks
91
85
 
92
86
    def abspath(self, relpath):
93
87
        """See Transport.abspath()."""
94
 
        # while a little slow, this is sufficiently fast to not matter in our
95
 
        # current environment - XXX RBC 20060404 move the clone '..' handling
96
 
        # into here and call abspath from clone
97
 
        temp_t = self.clone(relpath)
98
 
        if temp_t.base.count('/') == 3:
99
 
            return temp_t.base
100
 
        else:
101
 
            return temp_t.base[:-1]
 
88
        return self.base[:-1] + self._abspath(relpath)[len(self._cwd) - 1:]
102
89
 
103
 
    def append_file(self, relpath, f, mode=None):
104
 
        """See Transport.append_file()."""
 
90
    def append(self, relpath, f):
 
91
        """See Transport.append()."""
105
92
        _abspath = self._abspath(relpath)
106
93
        self._check_parent(_abspath)
107
94
        orig_content, orig_mode = self._files.get(_abspath, ("", None))
108
 
        if mode is None:
109
 
            mode = orig_mode
110
 
        self._files[_abspath] = (orig_content + f.read(), mode)
 
95
        self._files[_abspath] = (orig_content + f.read(), orig_mode)
111
96
        return len(orig_content)
112
97
 
113
98
    def _check_parent(self, _abspath):
119
104
    def has(self, relpath):
120
105
        """See Transport.has()."""
121
106
        _abspath = self._abspath(relpath)
122
 
        return (_abspath in self._files) or (_abspath in self._dirs)
 
107
        return _abspath in self._files or _abspath in self._dirs
123
108
 
124
109
    def delete(self, relpath):
125
110
        """See Transport.delete()."""
128
113
            raise NoSuchFile(relpath)
129
114
        del self._files[_abspath]
130
115
 
131
 
    def external_url(self):
132
 
        """See bzrlib.transport.Transport.external_url."""
133
 
        # MemoryTransport's are only accessible in-process
134
 
        # so we raise here
135
 
        raise InProcessTransport(self)
136
 
 
137
116
    def get(self, relpath):
138
117
        """See Transport.get()."""
139
118
        _abspath = self._abspath(relpath)
140
119
        if not _abspath in self._files:
141
 
            if _abspath in self._dirs:
142
 
                return LateReadError(relpath)
143
 
            else:
144
 
                raise NoSuchFile(relpath)
 
120
            raise NoSuchFile(relpath)
145
121
        return StringIO(self._files[_abspath][0])
146
122
 
147
 
    def put_file(self, relpath, f, mode=None):
148
 
        """See Transport.put_file()."""
 
123
    def put(self, relpath, f, mode=None):
 
124
        """See Transport.put()."""
149
125
        _abspath = self._abspath(relpath)
150
126
        self._check_parent(_abspath)
151
 
        bytes = f.read()
152
 
        if type(bytes) is not str:
153
 
            # Although not strictly correct, we raise UnicodeEncodeError to be
154
 
            # compatible with other transports.
155
 
            raise UnicodeEncodeError(
156
 
                'undefined', bytes, 0, 1,
157
 
                'put_file must be given a file of bytes, not unicode.')
158
 
        self._files[_abspath] = (bytes, mode)
159
 
        return len(bytes)
 
127
        self._files[_abspath] = (f.read(), mode)
160
128
 
161
129
    def mkdir(self, relpath, mode=None):
162
130
        """See Transport.mkdir()."""
166
134
            raise FileExists(relpath)
167
135
        self._dirs[_abspath]=mode
168
136
 
169
 
    def open_write_stream(self, relpath, mode=None):
170
 
        """See Transport.open_write_stream."""
171
 
        self.put_bytes(relpath, "", mode)
172
 
        result = AppendBasedFileStream(self, relpath)
173
 
        _file_streams[self.abspath(relpath)] = result
174
 
        return result
175
 
 
176
137
    def listable(self):
177
138
        """See Transport.listable."""
178
139
        return True
180
141
    def iter_files_recursive(self):
181
142
        for file in self._files:
182
143
            if file.startswith(self._cwd):
183
 
                yield urlutils.escape(file[len(self._cwd):])
184
 
 
 
144
                yield file[len(self._cwd):]
 
145
    
185
146
    def list_dir(self, relpath):
186
147
        """See Transport.list_dir()."""
187
148
        _abspath = self._abspath(relpath)
188
149
        if _abspath != '/' and _abspath not in self._dirs:
189
150
            raise NoSuchFile(relpath)
190
151
        result = []
191
 
 
192
 
        if not _abspath.endswith('/'):
193
 
            _abspath += '/'
194
 
 
195
 
        for path_group in self._files, self._dirs:
196
 
            for path in path_group:
197
 
                if path.startswith(_abspath):
198
 
                    trailing = path[len(_abspath):]
199
 
                    if trailing and '/' not in trailing:
200
 
                        result.append(trailing)
201
 
        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:])
 
163
        return result
202
164
 
203
165
    def rename(self, rel_from, rel_to):
204
166
        """Rename a file or directory; fail if the destination exists"""
220
182
                    del container[path]
221
183
        do_renames(self._files)
222
184
        do_renames(self._dirs)
223
 
 
 
185
    
224
186
    def rmdir(self, relpath):
225
187
        """See Transport.rmdir."""
226
188
        _abspath = self._abspath(relpath)
227
189
        if _abspath in self._files:
228
190
            self._translate_error(IOError(errno.ENOTDIR, relpath), relpath)
229
191
        for path in self._files:
230
 
            if path.startswith(_abspath + '/'):
 
192
            if path.startswith(_abspath):
231
193
                self._translate_error(IOError(errno.ENOTEMPTY, relpath),
232
194
                                      relpath)
233
195
        for path in self._dirs:
234
 
            if path.startswith(_abspath + '/') and path != _abspath:
 
196
            if path.startswith(_abspath) and path != _abspath:
235
197
                self._translate_error(IOError(errno.ENOTEMPTY, relpath), relpath)
236
198
        if not _abspath in self._dirs:
237
199
            raise NoSuchFile(relpath)
241
203
        """See Transport.stat()."""
242
204
        _abspath = self._abspath(relpath)
243
205
        if _abspath in self._files:
244
 
            return MemoryStat(len(self._files[_abspath][0]), False,
 
206
            return MemoryStat(len(self._files[_abspath][0]), False, 
245
207
                              self._files[_abspath][1])
 
208
        elif _abspath == '':
 
209
            return MemoryStat(0, True, None)
246
210
        elif _abspath in self._dirs:
247
211
            return MemoryStat(0, True, self._dirs[_abspath])
248
212
        else:
258
222
 
259
223
    def _abspath(self, relpath):
260
224
        """Generate an internal absolute path."""
261
 
        relpath = urlutils.unescape(relpath)
262
 
        if relpath[:1] == '/':
263
 
            return relpath
264
 
        cwd_parts = self._cwd.split('/')
265
 
        rel_parts = relpath.split('/')
266
 
        r = []
267
 
        for i in cwd_parts + rel_parts:
268
 
            if i == '..':
269
 
                if not r:
270
 
                    raise ValueError("illegal relpath %r under %r"
271
 
                        % (relpath, self._cwd))
272
 
                r = r[:-1]
273
 
            elif i == '.' or i == '':
274
 
                pass
275
 
            else:
276
 
                r.append(i)
277
 
        return '/' + '/'.join(r)
 
225
        if relpath.find('..') != -1:
 
226
            raise AssertionError('relpath contains ..')
 
227
        if relpath == '.':
 
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
278
234
 
279
235
 
280
236
class _MemoryLock(object):
281
237
    """This makes a lock."""
282
238
 
283
239
    def __init__(self, path, transport):
 
240
        assert isinstance(transport, MemoryTransport)
284
241
        self.path = path
285
242
        self.transport = transport
286
243
        if self.path in self.transport._locks:
287
244
            raise LockError('File %r already locked' % (self.path,))
288
245
        self.transport._locks[self.path] = self
289
246
 
 
247
    def __del__(self):
 
248
        # Should this warn, or actually try to cleanup?
 
249
        if self.transport:
 
250
            warn("MemoryLock %r not explicitly unlocked" % (self.path,))
 
251
            self.unlock()
 
252
 
290
253
    def unlock(self):
291
254
        del self.transport._locks[self.path]
292
255
        self.transport = None
293
256
 
294
257
 
295
 
class MemoryServer(transport.Server):
 
258
class MemoryServer(Server):
296
259
    """Server for the MemoryTransport for testing with."""
297
260
 
298
 
    def start_server(self):
299
 
        self._dirs = {'/':None}
 
261
    def setUp(self):
 
262
        """See bzrlib.transport.Server.setUp."""
 
263
        self._dirs = {}
300
264
        self._files = {}
301
265
        self._locks = {}
302
 
        self._scheme = "memory+%s:///" % id(self)
 
266
        self._scheme = "memory+%s:" % id(self)
303
267
        def memory_factory(url):
304
 
            from bzrlib.transport import memory
305
 
            result = memory.MemoryTransport(url)
 
268
            result = MemoryTransport(url)
306
269
            result._dirs = self._dirs
307
270
            result._files = self._files
308
271
            result._locks = self._locks
309
272
            return result
310
 
        self._memory_factory = memory_factory
311
 
        transport.register_transport(self._scheme, self._memory_factory)
 
273
        register_transport(self._scheme, memory_factory)
312
274
 
313
 
    def stop_server(self):
 
275
    def tearDown(self):
 
276
        """See bzrlib.transport.Server.tearDown."""
314
277
        # unregister this server
315
 
        transport.unregister_transport(self._scheme, self._memory_factory)
316
278
 
317
279
    def get_url(self):
318
280
        """See bzrlib.transport.Server.get_url."""
319
281
        return self._scheme
320
282
 
321
 
    def get_bogus_url(self):
322
 
        raise NotImplementedError
323
 
 
324
283
 
325
284
def get_test_permutations():
326
285
    """Return the permutations to be used in testing."""