/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/transport/memory.py

  • Committer: Jelmer Vernooij
  • Date: 2018-06-11 20:48:24 UTC
  • mfrom: (6974.2.1 python3-graph)
  • Revision ID: jelmer@jelmer.uk-20180611204824-zll0a3pzyciekd1f
merge lp:~jelmer/brz/python3-graph

Show diffs side-by-side

added added

removed removed

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