/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/groupcompress_repo.py

• browse files at revision 4525.1.1
• compare with another revision
• download diff
• download tarball
• view history from revision 4525.1.1

• reverse the comparison (4525.1.1 to 5280)
• stop comparing with revision 5280

Show diffs side-by-side

added

removed

bzrlib/repofmt/groupcompress_repo.py

1

 

# Copyright (C) 2008, 2009, 2010 Canonical Ltd

 

1

# Copyright (C) 2008, 2009 Canonical Ltd

2

2

#

3

3

# This program is free software; you can redistribute it and/or modify

4

4

# it under the terms of the GNU General Public License as published by

29

29

    knit,

30

30

    osutils,

31

31

    pack,

 

32

    remote,

32

33

    revision as _mod_revision,

33

34

    trace,

34

35

    ui,

52

53

    ResumedPack,

53

54

    Packer,

54

55

    )

55

 

from bzrlib.static_tuple import StaticTuple

56

56

 

57

57

 

58

58

class GCPack(NewPack):

154

154

        self._writer.begin()

155

155

        # what state is the pack in? (open, finished, aborted)

156

156

        self._state = 'open'

157

 

        # no name until we finish writing the content

158

 

        self.name = None

159

157

 

160

158

    def _check_references(self):

161

159

        """Make sure our external references are present.

262

260

        remaining_keys = set(keys)

263

261

        counter = [0]

264

262

        if self._gather_text_refs:

 

263

            bytes_to_info = inventory.CHKInventory._bytes_to_utf8name_key

265

264

            self._text_refs = set()

266

265

        def _get_referenced_stream(root_keys, parse_leaf_nodes=False):

267

266

            cur_keys = root_keys

288

287

                    # Store is None, because we know we have a LeafNode, and we

289

288

                    # just want its entries

290

289

                    for file_id, bytes in node.iteritems(None):

291

 

                        self._text_refs.add(chk_map._bytes_to_text_key(bytes))

 

290

                        name_utf8, file_id, revision_id = bytes_to_info(bytes)

 

291

                        self._text_refs.add((file_id, revision_id))

292

292

                def next_stream():

293

293

                    stream = source_vf.get_record_stream(cur_keys,

294

294

                                                         'as-requested', True)

350

350

        """Build a VersionedFiles instance on top of this group of packs."""

351

351

        index_name = index_name + '_index'

352

352

        index_to_pack = {}

353

 

        access = knit._DirectPackAccess(index_to_pack,

354

 

                                        reload_func=self._reload_func)

 

353

        access = knit._DirectPackAccess(index_to_pack)

355

354

        if for_write:

356

355

            # Use new_pack

357

356

            if self.new_pack is None:

411

410

 

412

411

    def _copy_inventory_texts(self):

413

412

        source_vf, target_vf = self._build_vfs('inventory', True, True)

414

 

        # It is not sufficient to just use self.revision_keys, as stacked

415

 

        # repositories can have more inventories than they have revisions.

416

 

        # One alternative would be to do something with

417

 

        # get_parent_map(self.revision_keys), but that shouldn't be any faster

418

 

        # than this.

419

 

        inventory_keys = source_vf.keys()

420

 

        missing_inventories = set(self.revision_keys).difference(inventory_keys)

421

 

        if missing_inventories:

422

 

            missing_inventories = sorted(missing_inventories)

423

 

            raise ValueError('We are missing inventories for revisions: %s'

424

 

                % (missing_inventories,))

425

 

        self._copy_stream(source_vf, target_vf, inventory_keys,

 

413

        self._copy_stream(source_vf, target_vf, self.revision_keys,

426

414

                          'inventories', self._get_filtered_inv_stream, 2)

427

415

 

428

416

    def _copy_chk_texts(self):

478

466

        if not self._use_pack(self.new_pack):

479

467

            self.new_pack.abort()

480

468

            return None

481

 

        self.new_pack.finish_content()

482

 

        if len(self.packs) == 1:

483

 

            old_pack = self.packs[0]

484

 

            if old_pack.name == self.new_pack._hash.hexdigest():

485

 

                # The single old pack was already optimally packed.

486

 

                trace.mutter('single pack %s was already optimally packed',

487

 

                    old_pack.name)

488

 

                self.new_pack.abort()

489

 

                return None

490

469

        self.pb.update('finishing repack', 6, 7)

491

470

        self.new_pack.finish()

492

471

        self._pack_collection.allocate(self.new_pack)

583

562

    pack_factory = GCPack

584

563

    resumed_pack_factory = ResumedGCPack

585

564

 

586

 

    def _check_new_inventories(self):

587

 

        """Detect missing inventories or chk root entries for the new revisions

588

 

        in this write group.

589

 

 

590

 

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

591

 

            empty no problems were found.

592

 

        """

593

 

        # Ensure that all revisions added in this write group have:

594

 

        #   - corresponding inventories,

595

 

        #   - chk root entries for those inventories,

596

 

        #   - and any present parent inventories have their chk root

597

 

        #     entries too.

598

 

        # And all this should be independent of any fallback repository.

599

 

        problems = []

600

 

        key_deps = self.repo.revisions._index._key_dependencies

601

 

        new_revisions_keys = key_deps.get_new_keys()

602

 

        no_fallback_inv_index = self.repo.inventories._index

603

 

        no_fallback_chk_bytes_index = self.repo.chk_bytes._index

604

 

        no_fallback_texts_index = self.repo.texts._index

605

 

        inv_parent_map = no_fallback_inv_index.get_parent_map(

606

 

            new_revisions_keys)

607

 

        # Are any inventories for corresponding to the new revisions missing?

608

 

        corresponding_invs = set(inv_parent_map)

609

 

        missing_corresponding = set(new_revisions_keys)

610

 

        missing_corresponding.difference_update(corresponding_invs)

611

 

        if missing_corresponding:

612

 

            problems.append("inventories missing for revisions %s" %

613

 

                (sorted(missing_corresponding),))

614

 

            return problems

615

 

        # Are any chk root entries missing for any inventories?  This includes

616

 

        # any present parent inventories, which may be used when calculating

617

 

        # deltas for streaming.

618

 

        all_inv_keys = set(corresponding_invs)

619

 

        for parent_inv_keys in inv_parent_map.itervalues():

620

 

            all_inv_keys.update(parent_inv_keys)

621

 

        # Filter out ghost parents.

622

 

        all_inv_keys.intersection_update(

623

 

            no_fallback_inv_index.get_parent_map(all_inv_keys))

624

 

        parent_invs_only_keys = all_inv_keys.symmetric_difference(

625

 

            corresponding_invs)

626

 

        all_missing = set()

627

 

        inv_ids = [key[-1] for key in all_inv_keys]

628

 

        parent_invs_only_ids = [key[-1] for key in parent_invs_only_keys]

629

 

        root_key_info = _build_interesting_key_sets(

630

 

            self.repo, inv_ids, parent_invs_only_ids)

631

 

        expected_chk_roots = root_key_info.all_keys()

632

 

        present_chk_roots = no_fallback_chk_bytes_index.get_parent_map(

633

 

            expected_chk_roots)

634

 

        missing_chk_roots = expected_chk_roots.difference(present_chk_roots)

635

 

        if missing_chk_roots:

636

 

            problems.append("missing referenced chk root keys: %s"

637

 

                % (sorted(missing_chk_roots),))

638

 

            # Don't bother checking any further.

639

 

            return problems

640

 

        # Find all interesting chk_bytes records, and make sure they are

641

 

        # present, as well as the text keys they reference.

642

 

        chk_bytes_no_fallbacks = self.repo.chk_bytes.without_fallbacks()

643

 

        chk_bytes_no_fallbacks._search_key_func = \

644

 

            self.repo.chk_bytes._search_key_func

645

 

        chk_diff = chk_map.iter_interesting_nodes(

646

 

            chk_bytes_no_fallbacks, root_key_info.interesting_root_keys,

647

 

            root_key_info.uninteresting_root_keys)

648

 

        text_keys = set()

649

 

        try:

650

 

            for record in _filter_text_keys(chk_diff, text_keys,

651

 

                                            chk_map._bytes_to_text_key):

652

 

                pass

653

 

        except errors.NoSuchRevision, e:

654

 

            # XXX: It would be nice if we could give a more precise error here.

655

 

            problems.append("missing chk node(s) for id_to_entry maps")

656

 

        chk_diff = chk_map.iter_interesting_nodes(

657

 

            chk_bytes_no_fallbacks, root_key_info.interesting_pid_root_keys,

658

 

            root_key_info.uninteresting_pid_root_keys)

659

 

        try:

660

 

            for interesting_rec, interesting_map in chk_diff:

661

 

                pass

662

 

        except errors.NoSuchRevision, e:

663

 

            problems.append(

664

 

                "missing chk node(s) for parent_id_basename_to_file_id maps")

665

 

        present_text_keys = no_fallback_texts_index.get_parent_map(text_keys)

666

 

        missing_text_keys = text_keys.difference(present_text_keys)

667

 

        if missing_text_keys:

668

 

            problems.append("missing text keys: %r"

669

 

                % (sorted(missing_text_keys),))

670

 

        return problems

671

 

 

672

565

    def _execute_pack_operations(self, pack_operations,

673

566

                                 _packer_class=GCCHKPacker,

674

567

                                 reload_func=None):

687

580

            packer = GCCHKPacker(self, packs, '.autopack',

688

581

                                 reload_func=reload_func)

689

582

            try:

690

 

                result = packer.pack()

 

583

                packer.pack()

691

584

            except errors.RetryWithNewPacks:

692

585

                # An exception is propagating out of this context, make sure

693

586

                # this packer has cleaned up. Packer() doesn't set its new_pack

696

589

                if packer.new_pack is not None:

697

590

                    packer.new_pack.abort()

698

591

                raise

699

 

            if result is None:

700

 

                return

701

592

            for pack in packs:

702

593

                self._remove_pack_from_memory(pack)

703

594

        # record the newly available packs and stop advertising the old

704

595

        # packs

705

 

        to_be_obsoleted = []

706

 

        for _, packs in pack_operations:

707

 

            to_be_obsoleted.extend(packs)

708

 

        result = self._save_pack_names(clear_obsolete_packs=True,

709

 

                                       obsolete_packs=to_be_obsoleted)

710

 

        return result

 

596

        self._save_pack_names(clear_obsolete_packs=True)

 

597

        # Move the old packs out of the way now they are no longer referenced.

 

598

        for revision_count, packs in pack_operations:

 

599

            self._obsolete_packs(packs)

711

600

 

712

601

 

713

602

class CHKInventoryRepository(KnitPackRepository):

738

627

            _GCGraphIndex(self._pack_collection.revision_index.combined_index,

739

628

                add_callback=self._pack_collection.revision_index.add_callback,

740

629

                parents=True, is_locked=self.is_locked,

741

 

                track_external_parent_refs=True, track_new_keys=True),

 

630

                track_external_parent_refs=True),

742

631

            access=self._pack_collection.revision_index.data_access,

743

632

            delta=False)

744

633

        self.signatures = GroupCompressVersionedFiles(

761

650

                parents=False, is_locked=self.is_locked,

762

651

                inconsistency_fatal=False),

763

652

            access=self._pack_collection.chk_index.data_access)

764

 

        search_key_name = self._format._serializer.search_key_name

765

 

        search_key_func = chk_map.search_key_registry.get(search_key_name)

766

 

        self.chk_bytes._search_key_func = search_key_func

767

653

        # True when the repository object is 'write locked' (as opposed to the

768

654

        # physical lock only taken out around changes to the pack-names list.)

769

655

        # Another way to represent this would be a decorator around the control

814

700

                                 ' no new_path %r' % (file_id,))

815

701

            if new_path == '':

816

702

                new_inv.root_id = file_id

817

 

                parent_id_basename_key = StaticTuple('', '').intern()

 

703

                parent_id_basename_key = ('', '')

818

704

            else:

819

705

                utf8_entry_name = entry.name.encode('utf-8')

820

 

                parent_id_basename_key = StaticTuple(entry.parent_id,

821

 

                                                     utf8_entry_name).intern()

 

706

                parent_id_basename_key = (entry.parent_id, utf8_entry_name)

822

707

            new_value = entry_to_bytes(entry)

823

708

            # Populate Caches?

824

709

            # new_inv._path_to_fileid_cache[new_path] = file_id

825

 

            key = StaticTuple(file_id).intern()

826

 

            id_to_entry_dict[key] = new_value

 

710

            id_to_entry_dict[(file_id,)] = new_value

827

711

            parent_id_basename_dict[parent_id_basename_key] = file_id

828

712

 

829

713

        new_inv._populate_from_dicts(self.chk_bytes, id_to_entry_dict,

862

746

        if basis_inv is None:

863

747

            if basis_revision_id == _mod_revision.NULL_REVISION:

864

748

                new_inv = self._create_inv_from_null(delta, new_revision_id)

865

 

                if new_inv.root_id is None:

866

 

                    raise errors.RootMissing()

867

749

                inv_lines = new_inv.to_lines()

868

750

                return self._inventory_add_lines(new_revision_id, parents,

869

751

                    inv_lines, check_content=False), new_inv

881

763

            if basis_tree is not None:

882

764

                basis_tree.unlock()

883

765

 

884

 

    def _deserialise_inventory(self, revision_id, bytes):

885

 

        return inventory.CHKInventory.deserialise(self.chk_bytes, bytes,

886

 

            (revision_id,))

887

 

 

888

 

    def _iter_inventories(self, revision_ids, ordering):

 

766

    def _iter_inventories(self, revision_ids):

889

767

        """Iterate over many inventory objects."""

890

 

        if ordering is None:

891

 

            ordering = 'unordered'

892

768

        keys = [(revision_id,) for revision_id in revision_ids]

893

 

        stream = self.inventories.get_record_stream(keys, ordering, True)

 

769

        stream = self.inventories.get_record_stream(keys, 'unordered', True)

894

770

        texts = {}

895

771

        for record in stream:

896

772

            if record.storage_kind != 'absent':

900

776

        for key in keys:

901

777

            yield inventory.CHKInventory.deserialise(self.chk_bytes, texts[key], key)

902

778

 

903

 

    def _iter_inventory_xmls(self, revision_ids, ordering):

904

 

        # Without a native 'xml' inventory, this method doesn't make sense.

905

 

        # However older working trees, and older bundles want it - so we supply

906

 

        # it allowing _get_inventory_xml to work. Bundles currently use the

907

 

        # serializer directly; this also isn't ideal, but there isn't an xml

908

 

        # iteration interface offered at all for repositories. We could make

909

 

        # _iter_inventory_xmls be part of the contract, even if kept private.

910

 

        inv_to_str = self._serializer.write_inventory_to_string

911

 

        for inv in self.iter_inventories(revision_ids, ordering=ordering):

912

 

            yield inv_to_str(inv), inv.revision_id

 

779

    def _iter_inventory_xmls(self, revision_ids):

 

780

        # Without a native 'xml' inventory, this method doesn't make sense, so

 

781

        # make it raise to trap naughty direct users.

 

782

        raise NotImplementedError(self._iter_inventory_xmls)

913

783

 

914

784

    def _find_present_inventory_keys(self, revision_keys):

915

785

        parent_map = self.inventories.get_parent_map(revision_keys)

941

811

                                        parent_keys)

942

812

            present_parent_inv_ids = set(

943

813

                [k[-1] for k in present_parent_inv_keys])

 

814

            uninteresting_root_keys = set()

 

815

            interesting_root_keys = set()

944

816

            inventories_to_read = set(revision_ids)

945

817

            inventories_to_read.update(present_parent_inv_ids)

946

 

            root_key_info = _build_interesting_key_sets(

947

 

                self, inventories_to_read, present_parent_inv_ids)

948

 

            interesting_root_keys = root_key_info.interesting_root_keys

949

 

            uninteresting_root_keys = root_key_info.uninteresting_root_keys

 

818

            for inv in self.iter_inventories(inventories_to_read):

 

819

                entry_chk_root_key = inv.id_to_entry.key()

 

820

                if inv.revision_id in present_parent_inv_ids:

 

821

                    uninteresting_root_keys.add(entry_chk_root_key)

 

822

                else:

 

823

                    interesting_root_keys.add(entry_chk_root_key)

 

824

 

950

825

            chk_bytes = self.chk_bytes

951

826

            for record, items in chk_map.iter_interesting_nodes(chk_bytes,

952

827

                        interesting_root_keys, uninteresting_root_keys,

953

828

                        pb=pb):

954

829

                for name, bytes in items:

955

830

                    (name_utf8, file_id, revision_id) = bytes_to_info(bytes)

956

 

                    # TODO: consider interning file_id, revision_id here, or

957

 

                    #       pushing that intern() into bytes_to_info()

958

 

                    # TODO: rich_root should always be True here, for all

959

 

                    #       repositories that support chk_bytes

960

831

                    if not rich_root and name_utf8 == '':

961

832

                        continue

962

833

                    try:

1005

876

 

1006

877

    def _get_source(self, to_format):

1007

878

        """Return a source for streaming from this repository."""

1008

 

        if self._format._serializer == to_format._serializer:

 

879

        if isinstance(to_format, remote.RemoteRepositoryFormat):

 

880

            # Can't just check attributes on to_format with the current code,

 

881

            # work around this:

 

882

            to_format._ensure_real()

 

883

            to_format = to_format._custom_format

 

884

        if to_format.__class__ is self._format.__class__:

1009

885

            # We must be exactly the same format, otherwise stuff like the chk

1010

 

            # page layout might be different.

1011

 

            # Actually, this test is just slightly looser than exact so that

1012

 

            # CHK2 <-> 2a transfers will work.

 

886

            # page layout might be different

1013

887

            return GroupCHKStreamSource(self, to_format)

1014

888

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

1015

889

 

1087

961

                uninteresting_root_keys.add(inv.id_to_entry.key())

1088

962

                uninteresting_pid_root_keys.add(

1089

963

                    inv.parent_id_basename_to_file_id.key())

 

964

        bytes_to_info = inventory.CHKInventory._bytes_to_utf8name_key

1090

965

        chk_bytes = self.from_repository.chk_bytes

1091

966

        def _filter_id_to_entry():

1092

 

            interesting_nodes = chk_map.iter_interesting_nodes(chk_bytes,

1093

 

                        self._chk_id_roots, uninteresting_root_keys)

1094

 

            for record in _filter_text_keys(interesting_nodes, self._text_keys,

1095

 

                    chk_map._bytes_to_text_key):

 

967

            for record, items in chk_map.iter_interesting_nodes(chk_bytes,

 

968

                        self._chk_id_roots, uninteresting_root_keys):

 

969

                for name, bytes in items:

 

970

                    # Note: we don't care about name_utf8, because we are always

 

971

                    # rich-root = True

 

972

                    _, file_id, revision_id = bytes_to_info(bytes)

 

973

                    self._text_keys.add((file_id, revision_id))

1096

974

                if record is not None:

1097

975

                    yield record

1098

976

            # Consumed

1108

986

        yield 'chk_bytes', _get_parent_id_basename_to_file_id_pages()

1109

987

 

1110

988

    def get_stream(self, search):

1111

 

        def wrap_and_count(pb, rc, stream):

1112

 

            """Yield records from stream while showing progress."""

1113

 

            count = 0

1114

 

            for record in stream:

1115

 

                if count == rc.STEP:

1116

 

                    rc.increment(count)

1117

 

                    pb.update('Estimate', rc.current, rc.max)

1118

 

                    count = 0

1119

 

                count += 1

1120

 

                yield record

1121

 

 

1122

989

        revision_ids = search.get_keys()

1123

 

        pb = ui.ui_factory.nested_progress_bar()

1124

 

        rc = self._record_counter

1125

 

        self._record_counter.setup(len(revision_ids))

1126

990

        for stream_info in self._fetch_revision_texts(revision_ids):

1127

 

            yield (stream_info[0],

1128

 

                wrap_and_count(pb, rc, stream_info[1]))

 

991

            yield stream_info

1129

992

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

1130

 

        self.from_repository.revisions.clear_cache()

1131

 

        self.from_repository.signatures.clear_cache()

1132

 

        s = self._get_inventory_stream(self._revision_keys)

1133

 

        yield (s[0], wrap_and_count(pb, rc, s[1]))

1134

 

        self.from_repository.inventories.clear_cache()

 

993

        yield self._get_inventory_stream(self._revision_keys)

1135

994

        # TODO: The keys to exclude might be part of the search recipe

1136

995

        # For now, exclude all parents that are at the edge of ancestry, for

1137

996

        # which we have inventories

1139

998

        parent_keys = from_repo._find_parent_keys_of_revisions(

1140

999

                        self._revision_keys)

1141

1000

        for stream_info in self._get_filtered_chk_streams(parent_keys):

1142

 

            yield (stream_info[0], wrap_and_count(pb, rc, stream_info[1]))

1143

 

        self.from_repository.chk_bytes.clear_cache()

1144

 

        s = self._get_text_stream()

1145

 

        yield (s[0], wrap_and_count(pb, rc, s[1]))

1146

 

        self.from_repository.texts.clear_cache()

1147

 

        pb.update('Done', rc.max, rc.max)

1148

 

        pb.finished()

 

1001

            yield stream_info

 

1002

        yield self._get_text_stream()

1149

1003

 

1150

1004

    def get_stream_for_missing_keys(self, missing_keys):

1151

1005

        # missing keys can only occur when we are byte copying and not

1160

1014

            missing_inventory_keys.add(key[1:])

1161

1015

        if self._chk_id_roots or self._chk_p_id_roots:

1162

1016

            raise AssertionError('Cannot call get_stream_for_missing_keys'

1163

 

                ' until all of get_stream() has been consumed.')

 

1017

                ' untill all of get_stream() has been consumed.')

1164

1018

        # Yield the inventory stream, so we can find the chk stream

1165

1019

        # Some of the missing_keys will be missing because they are ghosts.

1166

1020

        # As such, we can ignore them. The Sink is required to verify there are

1173

1027

            yield stream_info

1174

1028

 

1175

1029

 

1176

 

class _InterestingKeyInfo(object):

1177

 

    def __init__(self):

1178

 

        self.interesting_root_keys = set()

1179

 

        self.interesting_pid_root_keys = set()

1180

 

        self.uninteresting_root_keys = set()

1181

 

        self.uninteresting_pid_root_keys = set()

1182

 

 

1183

 

    def all_interesting(self):

1184

 

        return self.interesting_root_keys.union(self.interesting_pid_root_keys)

1185

 

 

1186

 

    def all_uninteresting(self):

1187

 

        return self.uninteresting_root_keys.union(

1188

 

            self.uninteresting_pid_root_keys)

1189

 

 

1190

 

    def all_keys(self):

1191

 

        return self.all_interesting().union(self.all_uninteresting())

1192

 

 

1193

 

 

1194

 

def _build_interesting_key_sets(repo, inventory_ids, parent_only_inv_ids):

1195

 

    result = _InterestingKeyInfo()

1196

 

    for inv in repo.iter_inventories(inventory_ids, 'unordered'):

1197

 

        root_key = inv.id_to_entry.key()

1198

 

        pid_root_key = inv.parent_id_basename_to_file_id.key()

1199

 

        if inv.revision_id in parent_only_inv_ids:

1200

 

            result.uninteresting_root_keys.add(root_key)

1201

 

            result.uninteresting_pid_root_keys.add(pid_root_key)

1202

 

        else:

1203

 

            result.interesting_root_keys.add(root_key)

1204

 

            result.interesting_pid_root_keys.add(pid_root_key)

1205

 

    return result

1206

 

 

1207

 

 

1208

 

def _filter_text_keys(interesting_nodes_iterable, text_keys, bytes_to_text_key):

1209

 

    """Iterate the result of iter_interesting_nodes, yielding the records

1210

 

    and adding to text_keys.

1211

 

    """

1212

 

    text_keys_update = text_keys.update

1213

 

    for record, items in interesting_nodes_iterable:

1214

 

        text_keys_update([bytes_to_text_key(b) for n,b in items])

1215

 

        yield record

1216

 

 

1217

 

 

1218

 

 

1219

 

 

1220

1030

class RepositoryFormatCHK1(RepositoryFormatPack):

1221

1031

    """A hashed CHK+group compress pack repository."""

1222

1032

 

1261

1071

        return ("Development repository format - rich roots, group compression"

1262

1072

            " and chk inventories")

1263

1073

 

 

1074

    def check_conversion_target(self, target_format):

 

1075

        if not target_format.rich_root_data:

 

1076

            raise errors.BadConversionTarget(

 

1077

                'Does not support rich root data.', target_format)

 

1078

        if (self.supports_tree_reference and 

 

1079

            not getattr(target_format, 'supports_tree_reference', False)):

 

1080

            raise errors.BadConversionTarget(

 

1081

                'Does not support nested trees', target_format)

 

1082

 

 

1083

 

1264

1084

 

1265

1085

class RepositoryFormatCHK2(RepositoryFormatCHK1):

1266

1086

    """A CHK repository that uses the bencode revision serializer."""

1283

1103

 

1284

1104

class RepositoryFormat2a(RepositoryFormatCHK2):

1285

1105

    """A CHK repository that uses the bencode revision serializer.

1286

 

 

 

1106

    

1287

1107

    This is the same as RepositoryFormatCHK2 but with a public name.

1288

1108

    """

1289

1109

 

1299

1119

 

1300

1120

    def get_format_string(self):

1301

1121

        return ('Bazaar repository format 2a (needs bzr 1.16 or later)\n')

1302

 

 

1303

 

    def get_format_description(self):

1304

 

        """See RepositoryFormat.get_format_description()."""

1305

 

        return ("Repository format 2a - rich roots, group compression"

1306

 

            " and chk inventories")

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0