/brz/remove-bazaar

# Copyright (C) 2007-2010 Canonical Ltd

from __future__ import absolute_import

 

from ... import (

    bencode,

    repository as _mod_repository,

from ...bzr import (

    pack,

    serializer,

    versionedfile as _mod_versionedfile,

    )

from ...bundle import bundle_data, serializer as bundle_serializer

from ...i18n import ngettext

from ...sixish import (

    BytesIO,

    viewitems,

    )

 

 

class _MPDiffInventoryGenerator(_mod_versionedfile._MPDiffGenerator):

    """Generate Inventory diffs serialized inventories."""

 

    def __init__(self, repo, inventory_keys):

        super(_MPDiffInventoryGenerator, self).__init__(repo.inventories,

                                                        inventory_keys)

        self.repo = repo

        self.sha1s = {}

 

    def iter_diffs(self):

        """Compute the diffs one at a time."""

        # This is instead of compute_diffs() since we guarantee our ordering of

        # inventories, we don't have to do any buffering

        self._find_needed_keys()

        # We actually use a slightly different ordering. We grab all of the

        # parents first, and then grab the ordered requests.

        needed_ids = [k[-1] for k in self.present_parents]

        needed_ids.extend([k[-1] for k in self.ordered_keys])

        inv_to_bytes = self.repo._serializer.write_inventory_to_string

        for inv in self.repo.iter_inventories(needed_ids):

            revision_id = inv.revision_id

            key = (revision_id,)

            if key in self.present_parents:

                # Not a key we will transmit, which is a shame, since because

                # of that bundles don't work with stacked branches

                parent_ids = None

            else:

                parent_ids = [k[-1] for k in self.parent_map[key]]

            as_bytes = inv_to_bytes(inv)

            self._process_one_record(key, (as_bytes,))

            if parent_ids is None:

                continue

            diff = self.diffs.pop(key)

            sha1 = osutils.sha_string(as_bytes)

            yield revision_id, parent_ids, sha1, diff

        self._fileobj.write(bundle_serializer._get_bundle_header('4'))

        self._fileobj.write(b'#\n')

        metadata = {b'parents': parents,

                    b'storage_kind': b'mpdiff',

                    b'sha1': sha1}

        metadata = {b'parents': parents,

                    b'storage_kind': b'mpdiff'}

        self._add_record(bytes, {b'parents': parents,

                                 b'storage_kind': b'fulltext'}, repo_kind, revision_id, None)

    def add_info_record(self, kwargs):

        kwargs[b'storage_kind'] = b'header'

                                'info'):

        names = [n.replace(b'/', b'//') for n in

                 (content_kind.encode('ascii'), revision_id, file_id) if n is not None]

        return b'/'.join(names)

        if metadata[b'storage_kind'] != b'header':

            source_file = BytesIO(bz2.decompress(fileobj.read()))

        segments = re.split(b'(//?)', name)

        names = [b'']

            if segment == b'//':

                names[-1] += b'/'

            elif segment == b'/':

                names.append(b'')

        return content_kind.decode('ascii'), revision_id, file_id

            if metadata[b'storage_kind'] == b'header':

                _unused, bytes = next(iterator)

        write_op = BundleWriteOperation(base, target, repository, fileobj)

        return serializer.format_registry.get(info[b'serializer'].decode('ascii'))

        self.revision_keys = {(revid,) for revid in self.revision_ids}

        trace.note(ngettext('Bundling %d revision.', 'Bundling %d revisions.',

                            len(self.revision_ids)), len(self.revision_ids))

        with self.repository.lock_read():

        self.bundle.add_info_record({b'serializer': serializer_format,

                                     b'supports_rich_root': supports_rich_root})

            self.revision_ids)

        for file_id, revision_ids in viewitems(altered_fileids):

            inv_vf, self.revision_keys)]

        generator = _MPDiffInventoryGenerator(self.repository,

                                              inventory_key_order)

        for revision_id, parent_ids, sha1, diff in generator.iter_diffs():

            text = b''.join(diff.to_patch())

        revision_to_bytes = self.repository._serializer.write_revision_to_string

            revision_text = revision_to_bytes(revision)

                                            'revision', revision_id)

                        revision_id), parents, 'signature', revision_id)

            text = b''.join(mpdiff.to_patch())

 

        with repository.lock_write():

                    bundle_reader.iter_records():

        with _mod_repository.WriteGroup(self._repository):

            return self._install_in_write_group()

                self._container.iter_records():

                    (repo_kind, file_id) != ('file', current_file)):

                                              pending_file_records)

                pending_inventory_records.append(

                    ((revision_id,), metadata, bytes))

                pending_file_records.append(

                    ((file_id, revision_id), metadata, bytes))

        self._install_mp_records_keys(

            self._repository.texts, pending_file_records)

        if (info[b'supports_rich_root'] == 0 and

                self._repository.supports_rich_root()):

            parents = [prefix + (parent,) for parent in meta[b'parents']]

            vf_records.append((key, parents, meta[b'sha1'], d_func(text)))

                parent_keys)

                    present_parent_ids):

                        if parent_id not in ghosts]

        if (self._info[b'serializer'] == self._repository._serializer.format_num

                and self._repository._serializer.support_altered_by_hack):

                                                 records)

        inventory_text_cache = lru_cache.LRUSizeCache(10 * 1024 * 1024)

        with ui.ui_factory.nested_progress_bar() as pb:

                parent_ids = metadata[b'parents']

                                                                  ).to_lines(p_texts)

                inv_text = b''.join(target_lines)

                if sha1 != metadata[b'sha1']:

                                                                delta, revision_id, parent_ids)

                           parent in parent_ids]