← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bundle/serializer/v10.py

  • Committer: Aaron Bentley
  • Date: 2007-06-14 13:40:34 UTC
  • mto: (2520.5.2 bzr.mpbundle)
  • mto: This revision was merged to the branch mainline in revision 2631.
  • Revision ID: abentley@panoramicfeedback.com-20070614134034-62f8djek7v6io72w
Finish turning ContainerWriter into a new layer

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bundle/serializer/v10.py
8
8
from bzrlib.bundle import bundle_data, serializer
9
9
 
10
10
 
11
 
class ContainerWriter(pack.ContainerWriter):
12
 
 
13
 
    def add_multiparent_record(self, names, mp_bytes):
14
 
        self.add_bytes_record(names, mp_bytes)
15
 
    def add_record(self, add_method, name, parents, text):
 
11
class ContainerWriter(object):
 
12
 
 
13
    def __init__(self, write_func):
 
14
        self._container = pack.ContainerWriter(write_func)
 
15
 
 
16
    def begin(self):
 
17
        self._container.begin()
 
18
 
 
19
    def end(self):
 
20
        self._container.end()
 
21
 
 
22
    def add_multiparent_record(self, mp_bytes, parents, repo_kind,
 
23
                               revision_id, file_id):
 
24
        self._add_record(mp_bytes, parents, repo_kind, revision_id, file_id)
 
25
 
 
26
    def add_fulltext_record(self, bytes, parents, repo_kind, revision_id,
 
27
                            file_id):
 
28
        self._add_record(bytes, parents, repo_kind, revision_id, file_id)
 
29
 
 
30
    @staticmethod
 
31
    def encode_parents(parents):
 
32
        return ' '.join(parents) + '\n'
 
33
 
 
34
    @staticmethod
 
35
    def encode_name(name_kind, revision_id, file_id=None):
 
36
        assert name_kind in ('revision', 'file', 'inventory')
 
37
        if name_kind in ('revision', 'inventory'):
 
38
            assert file_id is None
 
39
        else:
 
40
            assert file_id is not None
 
41
        if file_id is not None:
 
42
            file_tail = '/' + file_id
 
43
        else:
 
44
            file_tail = ''
 
45
        return name_kind + ':' + revision_id + file_tail
 
46
 
 
47
    def _add_record(self, bytes, parents, repo_kind, revision_id, file_id):
 
48
        name = self.encode_name(repo_kind, revision_id, file_id)
16
49
        parents = self.encode_parents(parents)
17
 
        text = parents + text
18
 
        add_method(text, [name])
 
50
        bytes = parents + bytes
 
51
        self._container.add_bytes_record(bytes, [name])
19
52
 
20
53
 
21
54
class BundleSerializerV10(serializer.BundleSerializer):
38
71
        self.add_mp_records(container, 'inventory', None, inv_vf, revision_ids)
39
72
        for revision_id in revision_ids:
40
73
            parents = repository.revision_parents(revision_id)
41
 
            container_name = self.encode_name('revision', revision_id)
42
74
            revision_text = repository.get_revision_xml(revision_id)
43
 
            self.add_record(container.add_bytes_record, container_name,
44
 
                            parents, revision_text)
 
75
            container.add_fulltext_record(revision_text, parents,
 
76
                                          'revision', revision_id, None)
45
77
        container.end()
46
78
        fileobj.write(s.getvalue().encode('bz2').encode('base-64'))
47
79
 
48
 
 
49
 
    def add_mp_records(self, container, name_kind, file_id, vf,
50
 
                       file_revision_ids):
51
 
        for file_revision_id in file_revision_ids:
52
 
            parents = vf.get_parents(file_revision_id)
53
 
            text = ''.join(vf.make_mpdiff(file_revision_id).to_patch())
54
 
            container_name = self.encode_name(name_kind, file_revision_id,
55
 
                                              file_id)
56
 
            self.add_record(container.add_multiparent_record,
57
 
                            container_name, parents, text)
58
 
 
59
 
    def encode_parents(self, parents):
60
 
        return ' '.join(parents) + '\n'
 
80
    def add_mp_records(self, container, repo_kind, file_id, vf,
 
81
                       revision_ids):
 
82
        for revision_id in revision_ids:
 
83
            parents = vf.get_parents(revision_id)
 
84
            text = ''.join(vf.make_mpdiff(revision_id).to_patch())
 
85
            container.add_multiparent_record(text, parents, repo_kind,
 
86
                                             revision_id, file_id)
61
87
 
62
88
    def decode_parents(self, parents_line):
63
89
        parents = parents_line.rstrip('\n').split(' ')
70
96
        return container
71
97
 
72
98
    @staticmethod
73
 
    def encode_name(name_kind, revision_id, file_id=None):
74
 
        assert name_kind in ('revision', 'file', 'inventory')
75
 
        if name_kind in ('revision', 'inventory'):
76
 
            assert file_id is None
77
 
        else:
78
 
            assert file_id is not None
79
 
        if file_id is not None:
80
 
            file_tail = '/' + file_id
81
 
        else:
82
 
            file_tail = ''
83
 
        return name_kind + ':' + revision_id + file_tail
84
 
 
85
 
    @staticmethod
86
99
    def decode_name(name):
87
100
        kind, revisionfile_id = name.split(':', 1)
88
101
        revisionfile_id = revisionfile_id.split('/')
108
121
    def install_revisions(self, repository):
109
122
        repository.lock_write()
110
123
        try:
111
 
            ri = RevisionInstaller(self._fileobj, self._serializer, repository)
 
124
            ri = RevisionInstaller(self._get_container_reader(),
 
125
                                   self._serializer, repository)
112
126
            return ri.install()
113
127
        finally:
114
128
            repository.unlock()
115
129
 
 
130
    def _get_container_reader(self):
 
131
        self._fileobj.seek(0)
 
132
        line = self._fileobj.readline()
 
133
        if line != '\n':
 
134
            self._fileobj.readline()
 
135
        s = StringIO(self._fileobj.read().decode('base-64').decode('bz2'))
 
136
        return pack.ContainerReader(s.read)
 
137
 
116
138
    def _get_real_revisions(self):
117
139
        from bzrlib import xml7
118
 
        self._fileobj.seek(0)
119
140
        if self.__real_revisions is None:
120
141
            self.__real_revisions = []
121
 
            line = self._fileobj.readline()
122
 
            if line != '\n':
123
 
                line = self._fileobj.readline()
124
 
            container = pack.ContainerReader(self._fileobj.read)
 
142
            container = self._get_container_reader()
125
143
            for (name,), bytes in container.iter_records():
126
144
                kind, revision_id, file_id = self._serializer.decode_name(name)
127
145
                if kind == 'revision':
148
166
 
149
167
class RevisionInstaller(object):
150
168
 
151
 
    def __init__(self, fileobj, serializer, repository):
152
 
        fileobj.seek(0)
153
 
        line = fileobj.readline()
154
 
        if line != '\n':
155
 
            fileobj.readline()
156
 
        s = StringIO(fileobj.read().decode('base-64').decode('bz2'))
157
 
        self._container = pack.ContainerReader(s.read)
 
169
    def __init__(self, container, serializer, repository):
 
170
        self._container = container
158
171
        self._serializer = serializer
159
172
        self._repository = repository
160
173