/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/git/interrepo.py

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

• reverse the comparison (7490.22.1 to 7296.10.5)
• stop comparing with revision 7296.10.5

Show diffs side-by-side

added

removed

breezy/git/interrepo.py

46

46

    NoSuchRevision,

47

47

    )

48

48

from ..repository import (

 

49

    FetchResult,

49

50

    InterRepository,

50

51

    )

51

52

from ..revision import (

80

81

    )

81

82

from .refs import (

82

83

    is_tag,

 

84

    ref_to_tag_name,

83

85

    )

84

86

from .repository import (

85

87

    GitRepository,

216

218

                stop_revids.append(revid)

217

219

        missing = set()

218

220

        graph = self.source.get_graph()

219

 

        pb = ui.ui_factory.nested_progress_bar()

220

 

        try:

 

221

        with ui.ui_factory.nested_progress_bar() as pb:

221

222

            while stop_revids:

222

223

                new_stop_revids = []

223

224

                for revid in stop_revids:

231

232

                for parent_revids in viewvalues(parent_map):

232

233

                    stop_revids.update(parent_revids)

233

234

                pb.update("determining revisions to fetch", len(missing))

234

 

        finally:

235

 

            pb.finished()

236

235

        return graph.iter_topo_order(missing)

237

236

 

238

237

    def _get_target_bzr_refs(self):

302

301

        with self.source_store.lock_read():

303

302

            todo = list(self.missing_revisions(revs))[:limit]

304

303

            revidmap = {}

305

 

            pb = ui.ui_factory.nested_progress_bar()

306

 

            try:

 

304

            with ui.ui_factory.nested_progress_bar() as pb:

307

305

                object_generator = MissingObjectsIterator(

308

306

                    self.source_store, self.source, pb)

309

307

                for (old_revid, git_sha) in object_generator.import_revisions(

321

319

                    revidmap[old_revid] = (git_sha, new_revid)

322

320

                self.target_store.add_objects(object_generator)

323

321

                return revidmap

324

 

            finally:

325

 

                pb.finished()

326

322

 

327

323

    def fetch(self, revision_id=None, pb=None, find_ghosts=False,

328

 

              fetch_spec=None, mapped_refs=None):

 

324

              fetch_spec=None, mapped_refs=None, lossy=False):

329

325

        if mapped_refs is not None:

330

326

            stop_revisions = mapped_refs

331

327

        elif revision_id is not None:

342

338

                              for revid in self.source.all_revision_ids()]

343

339

        self._warn_slow()

344

340

        try:

345

 

            self.fetch_objects(stop_revisions, lossy=False)

 

341

            revidmap = self.fetch_objects(stop_revisions, lossy=lossy)

346

342

        except NoPushSupport:

347

343

            raise NoRoundtrippingSupport(self.source, self.target)

 

344

        return FetchResult(revidmap)

348

345

 

349

346

    @staticmethod

350

347

    def is_compatible(source, target):

413

410

    def _target_has_shas(self, shas):

414

411

        raise NotImplementedError(self._target_has_shas)

415

412

 

416

 

    def get_determine_wants_heads(self, wants, include_tags=False):

 

413

    def get_determine_wants_heads(self, wants, include_tags=False, tag_selector=None):

417

414

        wants = set(wants)

418

415

 

419

416

        def determine_wants(refs):

426

423

                for k, sha in viewitems(refs):

427

424

                    if k.endswith(ANNOTATED_TAG_SUFFIX):

428

425

                        continue

429

 

                    if not is_tag(k):

 

426

                    try:

 

427

                        tag_name = ref_to_tag_name(k)

 

428

                    except ValueError:

 

429

                        continue

 

430

                    if tag_selector and not tag_selector(tag_name):

430

431

                        continue

431

432

                    if sha == ZERO_SHA:

432

433

                        continue

512

513

        """

513

514

        raise NotImplementedError(self.fetch_objects)

514

515

 

515

 

    def get_determine_wants_revids(self, revids, include_tags=False):

 

516

    def get_determine_wants_revids(self, revids, include_tags=False, tag_selector=None):

516

517

        wants = set()

517

518

        for revid in set(revids):

518

519

            if self.target.has_revision(revid):

519

520

                continue

520

521

            git_sha, mapping = self.source.lookup_bzr_revision_id(revid)

521

522

            wants.add(git_sha)

522

 

        return self.get_determine_wants_heads(wants, include_tags=include_tags)

 

523

        return self.get_determine_wants_heads(

 

524

            wants, include_tags=include_tags, tag_selector=tag_selector)

523

525

 

524

526

    def fetch(self, revision_id=None, find_ghosts=False,

525

 

              mapping=None, fetch_spec=None, include_tags=False):

 

527

              mapping=None, fetch_spec=None, include_tags=False, lossy=False):

526

528

        if mapping is None:

527

529

            mapping = self.source.get_mapping()

528

530

        if revision_id is not None:

543

545

        else:

544

546

            determine_wants = self.determine_wants_all

545

547

 

546

 

        (pack_hint, _, remote_refs) = self.fetch_objects(determine_wants,

547

 

                                                         mapping)

 

548

        (pack_hint, _, remote_refs) = self.fetch_objects(

 

549

            determine_wants, mapping, lossy=lossy)

548

550

        if pack_hint is not None and self.target._format.pack_compresses:

549

551

            self.target.pack(hint=pack_hint)

550

 

        return remote_refs

 

552

        result = FetchResult()

 

553

        result.refs = remote_refs

 

554

        return result

551

555

 

552

556

 

553

557

class InterRemoteGitNonGitRepository(InterGitNonGitRepository):

574

578

                lambda sha: store[sha].parents)

575

579

            wants_recorder = DetermineWantsRecorder(determine_wants)

576

580

 

577

 

            pb = ui.ui_factory.nested_progress_bar()

578

 

            try:

 

581

            with ui.ui_factory.nested_progress_bar() as pb:

579

582

                objects_iter = self.source.fetch_objects(

580

583

                    wants_recorder, graph_walker, store.get_raw)

581

584

                trace.mutter("Importing %d new revisions",

584

587

                    self.target, mapping, objects_iter, store,

585

588

                    wants_recorder.wants, pb, limit)

586

589

                return (pack_hint, last_rev, wants_recorder.remote_refs)

587

 

            finally:

588

 

                pb.finished()

589

590

 

590

591

    @staticmethod

591

592

    def is_compatible(source, target):

610

611

        self._warn_slow()

611

612

        remote_refs = self.source.controldir.get_refs_container().as_dict()

612

613

        wants = determine_wants(remote_refs)

613

 

        pb = ui.ui_factory.nested_progress_bar()

614

614

        target_git_object_retriever = get_object_store(self.target, mapping)

615

 

        try:

 

615

        with ui.ui_factory.nested_progress_bar() as pb:

616

616

            target_git_object_retriever.lock_write()

617

617

            try:

618

618

                (pack_hint, last_rev) = import_git_objects(

621

621

                return (pack_hint, last_rev, remote_refs)

622

622

            finally:

623

623

                target_git_object_retriever.unlock()

624

 

        finally:

625

 

            pb.finished()

626

624

 

627

625

    @staticmethod

628

626

    def is_compatible(source, target):

669

667

 

670

668

    def fetch(self, revision_id=None, find_ghosts=False,

671

669

              mapping=None, fetch_spec=None, branches=None, limit=None,

672

 

              include_tags=False):

 

670

              include_tags=False, lossy=False):

673

671

        if mapping is None:

674

672

            mapping = self.source.get_mapping()

675

673

        if revision_id is not None:

683

681

                    "Unsupported search result type %s" % recipe[0])

684

682

            args = heads

685

683

        if branches is not None:

686

 

            def determine_wants(refs):

687

 

                ret = []

688

 

                for name, value in viewitems(refs):

689

 

                    if value == ZERO_SHA:

690

 

                        continue

691

 

 

692

 

                    if name in branches or (include_tags and is_tag(name)):

693

 

                        ret.append(value)

694

 

                return ret

 

684

            determine_wants = self.get_determine_wants_branches(

 

685

                branches, include_tags=include_tags)

695

686

        elif fetch_spec is None and revision_id is None:

696

687

            determine_wants = self.determine_wants_all

697

688

        else:

698

689

            determine_wants = self.get_determine_wants_revids(

699

690

                args, include_tags=include_tags)

700

691

        wants_recorder = DetermineWantsRecorder(determine_wants)

701

 

        self.fetch_objects(wants_recorder, mapping, limit=limit)

702

 

        return wants_recorder.remote_refs

 

692

        self.fetch_objects(wants_recorder, mapping, limit=limit, lossy=lossy)

 

693

        result = FetchResult()

 

694

        result.refs = wants_recorder.remote_refs

 

695

        return result

703

696

 

704

 

    def get_determine_wants_revids(self, revids, include_tags=False):

 

697

    def get_determine_wants_revids(self, revids, include_tags=False, tag_selector=None):

705

698

        wants = set()

706

699

        for revid in set(revids):

707

700

            if revid == NULL_REVISION:

708

701

                continue

709

702

            git_sha, mapping = self.source.lookup_bzr_revision_id(revid)

710

703

            wants.add(git_sha)

711

 

        return self.get_determine_wants_heads(wants, include_tags=include_tags)

 

704

        return self.get_determine_wants_heads(wants, include_tags=include_tags, tag_selector=tag_selector)

 

705

 

 

706

    def get_determine_wants_branches(self, branches, include_tags=False):

 

707

        def determine_wants(refs):

 

708

            ret = []

 

709

            for name, value in viewitems(refs):

 

710

                if value == ZERO_SHA:

 

711

                    continue

 

712

 

 

713

                if name.endswith(ANNOTATED_TAG_SUFFIX):

 

714

                    continue

 

715

 

 

716

                if name in branches or (include_tags and is_tag(name)):

 

717

                    ret.append(value)

 

718

            return ret

 

719

        return determine_wants

712

720

 

713

721

    def determine_wants_all(self, refs):

714

722

        potential = set([

726

734

        if limit is not None:

727

735

            raise FetchLimitUnsupported(self)

728

736

        from .remote import DefaultProgressReporter

729

 

        pb = ui.ui_factory.nested_progress_bar()

730

 

        progress = DefaultProgressReporter(pb).progress

731

 

        try:

 

737

        with ui.ui_factory.nested_progress_bar() as pb:

 

738

            progress = DefaultProgressReporter(pb).progress

732

739

            refs = self.source._git.fetch(

733

740

                self.target._git, determine_wants,

734

741

                progress=progress)

735

 

        finally:

736

 

            pb.finished()

737

742

        return (None, None, refs)

738

743

 

739

744

    @staticmethod

• Older »

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