/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 bzrlib/bundle/serializer/__init__.py

  • Committer: Marius Kruger
  • Date: 2007-08-12 08:15:15 UTC
  • mfrom: (2695 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2979.
  • Revision ID: amanic@gmail.com-20070812081515-vgekipfhohcuj6rn
merge with bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bundle/serializer/__init__.py
38
38
 
39
39
_serializers = {}
40
40
 
 
41
v4_string = '4'
 
42
 
 
43
def _get_bundle_header(version):
 
44
    return '%s%s\n' % (BUNDLE_HEADER, version)
41
45
 
42
46
def _get_filename(f):
43
47
    return getattr(f, 'name', '<unknown>')
79
83
    return serializer.read(f)
80
84
 
81
85
 
 
86
def get_serializer(version):
 
87
    try:
 
88
        return _serializers[version](version)
 
89
    except KeyError:
 
90
        raise errors.BundleNotSupported(version, 'unknown bundle format')
 
91
 
 
92
 
82
93
def write(source, revision_ids, f, version=None, forced_bases={}):
83
94
    """Serialize a list of bundles to a filelike object.
84
95
 
88
99
    :param version: [optional] target serialization version
89
100
    """
90
101
 
91
 
    if version not in _serializers:
92
 
        raise errors.BundleNotSupported(version, 'unknown bundle format')
93
 
 
94
 
    serializer = _serializers[version](version)
95
102
    source.lock_read()
96
103
    try:
97
 
        return serializer.write(source, revision_ids, forced_bases, f)
 
104
        return get_serializer(version).write(source, revision_ids,
 
105
                                             forced_bases, f)
98
106
    finally:
99
107
        source.unlock()
100
108
 
101
109
 
102
110
def write_bundle(repository, revision_id, base_revision_id, out, format=None):
103
 
    """"""
104
 
    repository.lock_read()
105
 
    try:
106
 
        return _write_bundle(repository, revision_id, base_revision_id, out,
107
 
                             format)
108
 
    finally:
109
 
        repository.unlock()
110
 
 
111
 
 
112
 
def _write_bundle(repository, revision_id, base_revision_id, out, format):
113
111
    """Write a bundle of revisions.
114
112
 
115
113
    :param repository: Repository containing revisions to serialize.
118
116
         applying the bundle.
119
117
    :param out: Output file.
120
118
    """
121
 
    if base_revision_id is NULL_REVISION:
122
 
        base_revision_id = None
123
 
    base_ancestry = set(repository.get_ancestry(base_revision_id))
124
 
    revision_ids = [r for r in repository.get_ancestry(revision_id) if r
125
 
                    not in base_ancestry]
126
 
    revision_ids = list(reversed(revision_ids))
127
 
    write(repository, revision_ids, out, format,
128
 
          forced_bases = {revision_id:base_revision_id})
129
 
    return revision_ids
 
119
    repository.lock_read()
 
120
    try:
 
121
        return get_serializer(format).write_bundle(repository, revision_id,
 
122
                                                   base_revision_id, out)
 
123
    finally:
 
124
        repository.unlock()
130
125
 
131
126
 
132
127
class BundleSerializer(object):
145
140
        """
146
141
        raise NotImplementedError
147
142
 
 
143
    def write_bundle(self, repository, target, base, fileobj):
 
144
        """Write the bundle to the supplied file.
 
145
 
 
146
        :param repository: The repository to retrieve revision data from
 
147
        :param target: The revision to provide data for
 
148
        :param base: The most recent of ancestor of the revision that does not
 
149
            need to be included in the bundle
 
150
        :param fileobj: The file to output to
 
151
        """
 
152
        raise NotImplementedError
 
153
 
148
154
    def write(self, source, revision_ids, forced_bases, f):
149
155
        """Write the bundle to the supplied file.
150
156
 
 
157
        DEPRECATED: see write_bundle
151
158
        :param source: A source for revision information
152
159
        :param revision_ids: The list of revision ids to serialize
153
160
        :param forced_bases: A dict of revision -> base that overrides default
155
162
        """
156
163
        raise NotImplementedError
157
164
 
 
165
    def _write_bundle(self, repository, revision_id, base_revision_id, out):
 
166
        """Helper function for translating write_bundle to write"""
 
167
        forced_bases = {revision_id:base_revision_id}
 
168
        if base_revision_id is NULL_REVISION:
 
169
            base_revision_id = None
 
170
        revision_ids = set(repository.get_ancestry(revision_id,
 
171
                           topo_sorted=False))
 
172
        revision_ids.difference_update(repository.get_ancestry(
 
173
            base_revision_id, topo_sorted=False))
 
174
        revision_ids = list(repository.get_graph().iter_topo_order(
 
175
            revision_ids))
 
176
        revision_ids.reverse()
 
177
        self.write(repository, revision_ids, forced_bases, out)
 
178
        return revision_ids
 
179
 
158
180
 
159
181
def register(version, klass, overwrite=False):
160
182
    """Register a BundleSerializer version.
196
218
 
197
219
register_lazy('0.8', 'bzrlib.bundle.serializer.v08', 'BundleSerializerV08')
198
220
register_lazy('0.9', 'bzrlib.bundle.serializer.v09', 'BundleSerializerV09')
199
 
register_lazy(None, 'bzrlib.bundle.serializer.v09', 'BundleSerializerV09')
 
221
register_lazy(v4_string, 'bzrlib.bundle.serializer.v4',
 
222
              'BundleSerializerV4')
 
223
register_lazy(None, 'bzrlib.bundle.serializer.v4', 'BundleSerializerV4')
200
224