/brz/remove-bazaar

# Copyright (C) 2007-2010 Canonical Ltd

    cleanup,

from bzrlib.decorators import needs_write_lock, only_raises

    RepositoryWriteLockResult,

    StreamSource,

    note,

        unlimited_cache = False

        if index_type == 'chk':

            unlimited_cache = True

                self.index_sizes[self.index_offset(index_type)],

                unlimited_cache=unlimited_cache))

        new_name = '../packs/' + self.file_name()

        self.upload_transport.rename(self.file_name(), new_name)

        # no name until we finish writing the content

        self.name = None

    def finish_content(self):

        if self.name is not None:

            return

        self._writer.end()

        if self._buffer[1]:

            self._write_data('', flush=True)

        self.name = self._hash.hexdigest()

 

        self.finish_content()

        self.combined_index.insert_index(0, index, pack.name)

        del self.combined_index._index_names[:]

    def remove_index(self, index):

        pos = self.combined_index._indices.index(index)

        del self.combined_index._indices[pos]

        del self.combined_index._index_names[pos]

            (key, eol_flag, references) for the node retrieved by the

        bad_texts.sort(key=lambda key:rev_order.get(key[0][1], 0))

        all_indices = [self.revision_index, self.inventory_index,

                self.text_index, self.signature_index]

            all_indices.append(self.chk_index)

        # Tell all the CombinedGraphIndex objects about each other, so they can

        # share hints about which pack names to search first.

        all_combined = [agg_idx.combined_index for agg_idx in all_indices]

        for combined_idx in all_combined:

            combined_idx.set_sibling_indices(

                set(all_combined).difference([combined_idx]))

    def __repr__(self):

        return '%s(%r)' % (self.__class__.__name__, self.repo)

 

        :return: Something evaluating true if packing took place.

            except errors.RetryAutopack:

            return None

        result = self._execute_pack_operations(pack_operations,

        return result

        :return: The new pack names.

        to_be_obsoleted = []

        for _, packs in pack_operations:

            to_be_obsoleted.extend(packs)

        result = self._save_pack_names(clear_obsolete_packs=True,

                                       obsolete_packs=to_be_obsoleted)

        return result

        return not (self.repo._format.pack_compresses or (len(self._names) > 1))

    def pack(self, hint=None, clean_obsolete_packs=False):

            'containing %d revisions with hint %r.', self, total_packs,

            total_revisions, hint)

            if hint is None or pack.name in hint:

                # Either no hint was provided (so we are packing everything),

                # or this pack was included in the hint.

                pack_operations[-1][0] += pack.get_revision_count()

                pack_operations[-1][1].append(pack)

        if clean_obsolete_packs:

            self._clear_obsolete_packs()

 

                chk_index = self._make_index(name, '.cix', unlimited_cache=True)

                chk_index = self._make_index(name, '.cix', resume=True,

                                             unlimited_cache=True)

    def _make_index(self, name, suffix, resume=False, unlimited_cache=False):

        return self._index_class(transport, index_name, index_size,

                                 unlimited_cache=unlimited_cache)

            try:

                pack.pack_transport.rename(pack.file_name(),

                    '../obsolete_packs/' + pack.file_name())

            except (errors.PathError, errors.TransportError), e:

                # TODO: Should these be warnings or mutters?

                mutter("couldn't rename obsolete pack, skipping it:\n%s"

                       % (e,))

                try:

                    self._index_transport.rename(pack.name + suffix,

                        '../obsolete_packs/' + pack.name + suffix)

                except (errors.PathError, errors.TransportError), e:

                    mutter("couldn't rename obsolete index, skipping it:\n%s"

                           % (e,))

    def _remove_pack_indices(self, pack, ignore_missing=False):

        """Remove the indices for pack from the aggregated indices.

        

        :param ignore_missing: Suppress KeyErrors from calling remove_index.

        """

        for index_type in Pack.index_definitions.keys():

            attr_name = index_type + '_index'

            aggregate_index = getattr(self, attr_name)

            if aggregate_index is not None:

                pack_index = getattr(pack, attr_name)

                try:

                    aggregate_index.remove_index(pack_index)

                except KeyError:

                    if ignore_missing:

                        continue

                    raise

        orig_disk_nodes = set(disk_nodes)

        return disk_nodes, deleted_nodes, new_nodes, orig_disk_nodes

    def _save_pack_names(self, clear_obsolete_packs=False, obsolete_packs=None):

        :param obsolete_packs: Packs that are obsolete once the new pack-names

            file has been written.

        :return: A list of the names saved that were not previously on disk.

        already_obsolete = []

            (disk_nodes, deleted_nodes, new_nodes,

             orig_disk_nodes) = self._diff_pack_names()

                to_preserve = None

                if obsolete_packs:

                    to_preserve = set([o.name for o in obsolete_packs])

                already_obsolete = self._clear_obsolete_packs(to_preserve)

        if obsolete_packs:

            # TODO: We could add one more condition here. "if o.name not in

            #       orig_disk_nodes and o != the new_pack we haven't written to

            #       disk yet. However, the new pack object is not easily

            #       accessible here (it would have to be passed through the

            #       autopacking code, etc.)

            obsolete_packs = [o for o in obsolete_packs

                              if o.name not in already_obsolete]

            self._obsolete_packs(obsolete_packs)

        return [new_node[0][0] for new_node in new_nodes]

        (disk_nodes, deleted_nodes, new_nodes,

         orig_disk_nodes) = self._diff_pack_names()

        # _packs_at_load is meant to be the explicit list of names in

        # 'pack-names' at then start. As such, it should not contain any

        # pending names that haven't been written out yet.

        self._packs_at_load = orig_disk_nodes

    def _clear_obsolete_packs(self, preserve=None):

 

        :return: A list of pack identifiers (the filename without '.pack') that

            were found in obsolete_packs.

        found = []

        if preserve is None:

            preserve = set()

            name, ext = osutils.splitext(filename)

            if ext == '.pack':

                found.append(name)

            if name in preserve:

                continue

                warning("couldn't delete obsolete pack, skipping it:\n%s"

                        % (e,))

        return found

            operation = cleanup.OperationWithCleanups(self._new_pack.abort)

            operation.add_cleanup(setattr, self, '_new_pack', None)

            # If we aborted while in the middle of finishing the write

            # group, _remove_pack_indices could fail because the indexes are

            # already gone.  But they're not there we shouldn't fail in this

            # case, so we pass ignore_missing=True.

            operation.add_cleanup(self._remove_pack_indices, self._new_pack,

                ignore_missing=True)

            operation.run_simple()

            operation = cleanup.OperationWithCleanups(resumed_pack.abort)

            # See comment in previous finally block.

            operation.add_cleanup(self._remove_pack_indices, resumed_pack,

                ignore_missing=True)

            operation.run_simple()

    def _check_new_inventories(self):

        """Detect missing inventories in this write group.

 

        :returns: list of strs, summarising any problems found.  If the list is

            empty no problems were found.

        """

        # The base implementation does no checks.  GCRepositoryPackCollection

        # overrides this.

        return []

        

        problems = self._check_new_inventories()

        if problems:

            problems_summary = '\n'.join(problems)

            raise errors.BzrCheckError(

                "Cannot add revision(s) to repository: " + problems_summary)

        any_new_content = False

            any_new_content = True

            any_new_content = True

        if any_new_content:

            result = self.autopack()

            if not result:

                return self._save_pack_names()

            return result

        return []

    def _warn_if_deprecated(self, branch=None):

            super(KnitPackRepository, self)._warn_if_deprecated(branch)

        self.revisions._index._key_dependencies.clear()

    def _get_source(self, to_format):

        if to_format.network_name() == self._format.network_name():

            return KnitPackStreamSource(self, to_format)

        return super(KnitPackRepository, self)._get_source(to_format)

        hint = self._pack_collection._commit_write_group()

        self.revisions._index._key_dependencies.clear()

        return hint

        self.revisions._index._key_dependencies.clear()

        try:

            self._pack_collection._resume_write_group(tokens)

        except errors.UnresumableWriteGroup:

            self._abort_write_group()

            raise

            if 'relock' in debug.debug_flags and self._prev_lock == 'w':

                note('%r was write locked again', self)

            self._prev_lock = 'w'

        return RepositoryWriteLockResult(self.unlock, None)

            if 'relock' in debug.debug_flags and self._prev_lock == 'r':

                note('%r was read locked again', self)

            self._prev_lock = 'r'

        return self

    def pack(self, hint=None, clean_obsolete_packs=False):

        self._pack_collection.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)

    @only_raises(errors.LockNotHeld, errors.LockBroken)

class KnitPackStreamSource(StreamSource):

    """A StreamSource used to transfer data between same-format KnitPack repos.

 

    This source assumes:

        1) Same serialization format for all objects

        2) Same root information

        3) XML format inventories

        4) Atomic inserts (so we can stream inventory texts before text

           content)

        5) No chk_bytes

    """

 

    def __init__(self, from_repository, to_format):

        super(KnitPackStreamSource, self).__init__(from_repository, to_format)

        self._text_keys = None

        self._text_fetch_order = 'unordered'

 

    def _get_filtered_inv_stream(self, revision_ids):

        from_repo = self.from_repository

        parent_ids = from_repo._find_parent_ids_of_revisions(revision_ids)

        parent_keys = [(p,) for p in parent_ids]

        find_text_keys = from_repo._find_text_key_references_from_xml_inventory_lines

        parent_text_keys = set(find_text_keys(

            from_repo._inventory_xml_lines_for_keys(parent_keys)))

        content_text_keys = set()

        knit = KnitVersionedFiles(None, None)

        factory = KnitPlainFactory()

        def find_text_keys_from_content(record):

            if record.storage_kind not in ('knit-delta-gz', 'knit-ft-gz'):

                raise ValueError("Unknown content storage kind for"

                    " inventory text: %s" % (record.storage_kind,))

            # It's a knit record, it has a _raw_record field (even if it was

            # reconstituted from a network stream).

            raw_data = record._raw_record

            # read the entire thing

            revision_id = record.key[-1]

            content, _ = knit._parse_record(revision_id, raw_data)

            if record.storage_kind == 'knit-delta-gz':

                line_iterator = factory.get_linedelta_content(content)

            elif record.storage_kind == 'knit-ft-gz':

                line_iterator = factory.get_fulltext_content(content)

            content_text_keys.update(find_text_keys(

                [(line, revision_id) for line in line_iterator]))

        revision_keys = [(r,) for r in revision_ids]

        def _filtered_inv_stream():

            source_vf = from_repo.inventories

            stream = source_vf.get_record_stream(revision_keys,

                                                 'unordered', False)

            for record in stream:

                if record.storage_kind == 'absent':

                    raise errors.NoSuchRevision(from_repo, record.key)

                find_text_keys_from_content(record)

                yield record

            self._text_keys = content_text_keys - parent_text_keys

        return ('inventories', _filtered_inv_stream())

 

    def _get_text_stream(self):

        # Note: We know we don't have to handle adding root keys, because both

        # the source and target are the identical network name.

        text_stream = self.from_repository.texts.get_record_stream(

                        self._text_keys, self._text_fetch_order, False)

        return ('texts', text_stream)

 

    def get_stream(self, search):

        revision_ids = search.get_keys()

        for stream_info in self._fetch_revision_texts(revision_ids):

            yield stream_info

        self._revision_keys = [(rev_id,) for rev_id in revision_ids]

        yield self._get_filtered_inv_stream(revision_ids)

        yield self._get_text_stream()

 

 

 

        repository = self.open(a_bzrdir=a_bzrdir, _found=True)

        self._run_post_repo_init_hooks(repository, a_bzrdir, shared)

        return repository

    experimental = True