← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/memory.py

Move working tree initialisation out from  Branch.initialize, deprecated Branch.initialize to Branch.create.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/memory.py
22
22
from cStringIO import StringIO
23
23
 
24
24
from bzrlib.trace import mutter
25
 
from bzrlib.errors import TransportError, NoSuchFile, FileExists
 
25
from bzrlib.errors import TransportError, NoSuchFile, FileExists, LockError
26
26
from bzrlib.transport import Transport, register_transport, Server
27
27
 
28
28
class MemoryStat(object):
50
50
        self._cwd = url[url.find(':') + 1:]
51
51
        self._dirs = {}
52
52
        self._files = {}
 
53
        self._locks = {}
53
54
 
54
55
    def clone(self, offset=None):
55
56
        """See Transport.clone()."""
70
71
        result = MemoryTransport(url)
71
72
        result._dirs = self._dirs
72
73
        result._files = self._files
 
74
        result._locks = self._locks
73
75
        return result
74
76
 
75
77
    def abspath(self, relpath):
76
78
        """See Transport.abspath()."""
77
 
        return self.base[:-1] + self._abspath(relpath)
 
79
        return self.base[:-1] + self._abspath(relpath)[len(self._cwd) - 1:]
78
80
 
79
81
    def append(self, relpath, f):
80
82
        """See Transport.append()."""
176
178
        elif _abspath in self._dirs:
177
179
            return MemoryStat(0, True, self._dirs[_abspath])
178
180
        else:
179
 
            raise NoSuchFile(relpath)
180
 
 
181
 
#    def lock_read(self, relpath):
182
 
#   TODO if needed
183
 
#
184
 
#    def lock_write(self, relpath):
185
 
#   TODO if needed
 
181
            raise NoSuchFile(_abspath)
 
182
 
 
183
    def lock_read(self, relpath):
 
184
        """See Transport.lock_read()."""
 
185
        return _MemoryLock(self._abspath(relpath), self)
 
186
 
 
187
    def lock_write(self, relpath):
 
188
        """See Transport.lock_write()."""
 
189
        return _MemoryLock(self._abspath(relpath), self)
186
190
 
187
191
    def _abspath(self, relpath):
188
192
        """Generate an internal absolute path."""
197
201
        return self._cwd + relpath
198
202
 
199
203
 
 
204
class _MemoryLock(object):
 
205
    """This makes a lock."""
 
206
 
 
207
    def __init__(self, path, transport):
 
208
        assert isinstance(transport, MemoryTransport)
 
209
        self.path = path
 
210
        self.transport = transport
 
211
        if self.path in self.transport._locks:
 
212
            raise LockError('File %r already locked' % (self.path,))
 
213
        self.transport._locks[self.path] = self
 
214
 
 
215
    def __del__(self):
 
216
        # Should this warn, or actually try to cleanup?
 
217
        if self.transport:
 
218
            warn("MemoryLock %r not explicitly unlocked" % (self.path,))
 
219
            self.unlock()
 
220
 
 
221
    def unlock(self):
 
222
        del self.transport._locks[self.path]
 
223
        self.transport = None
 
224
 
 
225
 
200
226
class MemoryServer(Server):
201
227
    """Server for the MemoryTransport for testing with."""
202
228
 
203
229
    def setUp(self):
204
230
        """See bzrlib.transport.Server.setUp."""
 
231
        self._dirs = {}
 
232
        self._files = {}
 
233
        self._locks = {}
205
234
        self._scheme = "memory+%s:" % id(self)
206
 
        register_transport(self._scheme, MemoryTransport)
 
235
        def memory_factory(url):
 
236
            result = MemoryTransport(url)
 
237
            result._dirs = self._dirs
 
238
            result._files = self._files
 
239
            result._locks = self._locks
 
240
            return result
 
241
        register_transport(self._scheme, memory_factory)
207
242
 
208
243
    def tearDown(self):
209
244
        """See bzrlib.transport.Server.tearDown."""