/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/git/remote.py

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

Show diffs side-by-side

added

removed

breezy/git/remote.py

133

133

    def _lookup_revno(self, revid):

134

134

        try:

135

135

            return _quick_lookup_revno(self.source_branch, self.target_branch,

136

 

                revid)

 

136

                                       revid)

137

137

        except GitSmartRemoteNotSupported:

138

138

            return None

139

139

 

189

189

    :param message: Message sent by the remote git server

190

190

    """

191

191

    message = str(message).strip()

192

 

    if (message.startswith("Could not find Repository ") or

193

 

        message == 'Repository not found.' or

194

 

        (message.startswith('Repository ') and message.endswith(' not found.'))):

 

192

    if (message.startswith("Could not find Repository ")

 

193

        or message == 'Repository not found.'

 

194

            or (message.startswith('Repository ') and message.endswith(' not found.'))):

195

195

        return NotBranchError(url, message)

196

196

    if message == "HEAD failed to update":

197

197

        base_url, _ = urlutils.split_segment_parameters(url)

263

263

            # return dulwich.client.LocalGitClient()

264

264

            return dulwich.client.SubprocessGitClient()

265

265

        return dulwich.client.TCPGitClient(self._host, self._port,

266

 

            report_activity=self._report_activity)

 

266

                                           report_activity=self._report_activity)

267

267

 

268

268

 

269

269

class SSHSocketWrapper(object):

289

289

 

290

290

    def run_command(self, host, command, username=None, port=None):

291

291

        connection = self.bzr_ssh_vendor.connect_ssh(username=username,

292

 

            password=None, port=port, host=host, command=command)

 

292

                                                     password=None, port=port, host=host, command=command)

293

293

        (kind, io_object) = connection.get_sock_or_pipes()

294

294

        if kind == 'socket':

295

295

            return SSHSocketWrapper(io_object)

317

317

            return ret

318

318

        location_config = config.LocationConfig(self.base)

319

319

        client = dulwich.client.SSHGitClient(self._host, self._port, self._username,

320

 

            report_activity=self._report_activity)

 

320

                                             report_activity=self._report_activity)

321

321

        # Set up alternate pack program paths

322

322

        upload_pack = location_config.get_user_option('git_upload_pack')

323

323

        if upload_pack:

397

397

            pb = None

398

398

        try:

399

399

            self._client.archive(self._client_path, committish,

400

 

                write_data, progress, write_error, format=format,

401

 

                subdirs=subdirs, prefix=prefix)

 

400

                                 write_data, progress, write_error, format=format,

 

401

                                 subdirs=subdirs, prefix=prefix)

402

402

        except GitProtocolError as e:

403

403

            raise parse_git_error(self.transport.external_url(), e)

404

404

        finally:

413

413

            pb = None

414

414

        try:

415

415

            result = self._client.fetch_pack(self._client_path, determine_wants,

416

 

                graph_walker, pack_data, progress)

 

416

                                             graph_walker, pack_data, progress)

417

417

            if result.refs is None:

418

418

                result.refs = {}

419

 

            self._refs = remote_refs_dict_to_container(result.refs, result.symrefs)

 

419

            self._refs = remote_refs_dict_to_container(

 

420

                result.refs, result.symrefs)

420

421

            return result

421

422

        except GitProtocolError as e:

422

423

            raise parse_git_error(self.transport.external_url(), e)

430

431

            progress = DefaultProgressReporter(pb).progress

431

432

        else:

432

433

            pb = None

 

434

 

433

435

        def get_changed_refs_wrapper(refs):

434

436

            # TODO(jelmer): This drops symref information

435

437

            self._refs = remote_refs_dict_to_container(refs)

436

438

            return get_changed_refs(refs)

437

439

        try:

438

440

            return self._client.send_pack(self._client_path,

439

 

                    get_changed_refs_wrapper, generate_pack_data, progress)

 

441

                                          get_changed_refs_wrapper, generate_pack_data, progress)

440

442

        except GitProtocolError as e:

441

443

            raise parse_git_error(self.transport.external_url(), e)

442

444

        finally:

449

451

        if refname != b'HEAD' and refname in self.get_refs_container():

450

452

            raise AlreadyBranchError(self.user_url)

451

453

        if refname in self.get_refs_container():

452

 

            ref_chain, unused_sha = self.get_refs_container().follow(self._get_selected_ref(None))

 

454

            ref_chain, unused_sha = self.get_refs_container().follow(

 

455

                self._get_selected_ref(None))

453

456

            if ref_chain[0] == b'HEAD':

454

457

                refname = ref_chain[1]

455

458

        repo = self.open_repository()

457

460

 

458

461

    def destroy_branch(self, name=None):

459

462

        refname = self._get_selected_ref(name)

 

463

 

460

464

        def get_changed_refs(old_refs):

461

465

            ret = dict(old_refs)

462

466

            if not refname in ret:

463

467

                raise NotBranchError(self.user_url)

464

468

            ret[refname] = dulwich.client.ZERO_SHA

465

469

            return ret

 

470

 

466

471

        def generate_pack_data(have, want, ofs_delta=False):

467

472

            return pack_objects_to_data([])

468

473

        self.send_pack(get_changed_refs, generate_pack_data)

487

492

        return RemoteGitRepository(self)

488

493

 

489

494

    def open_branch(self, name=None, unsupported=False,

490

 

            ignore_fallbacks=False, ref=None, possible_transports=None,

491

 

            nascent_ok=False):

 

495

                    ignore_fallbacks=False, ref=None, possible_transports=None,

 

496

                    nascent_ok=False):

492

497

        repo = self.open_repository()

493

498

        ref = self._get_selected_ref(name, ref)

494

499

        if not nascent_ok and ref not in self.get_refs_container():

495

500

            raise NotBranchError(self.root_transport.base,

496

 

                    controldir=self)

 

501

                                 controldir=self)

497

502

        ref_chain, unused_sha = self.get_refs_container().follow(ref)

498

503

        return RemoteGitBranch(self, repo, ref_chain[-1])

499

504

 

510

515

        if self._refs is not None:

511

516

            return self._refs

512

517

        result = self.fetch_pack(lambda x: None, None,

513

 

            lambda x: None, lambda x: trace.mutter("git: %s" % x))

 

518

                                 lambda x: None, lambda x: trace.mutter("git: %s" % x))

514

519

        self._refs = remote_refs_dict_to_container(

515

 

                result.refs, result.symrefs)

 

520

            result.refs, result.symrefs)

516

521

        return self._refs

517

522

 

518

523

    def push_branch(self, source, revision_id=None, overwrite=False,

548

553

                if not overwrite:

549

554

                    if remote_divergence(ret.get(refname), new_sha, source_store):

550

555

                        raise DivergedBranches(

551

 

                                source, self.open_branch(name, nascent_ok=True))

 

556

                            source, self.open_branch(name, nascent_ok=True))

552

557

                ret[refname] = new_sha

553

558

                return ret

554

559

            if lossy:

557

562

                generate_pack_data = source_store.generate_pack_data

558

563

            new_refs = self.send_pack(get_changed_refs, generate_pack_data)

559

564

        push_result.new_revid = repo.lookup_foreign_revision_id(

560

 

                new_refs[refname])

 

565

            new_refs[refname])

561

566

        try:

562

567

            old_remote = self._refs[refname]

563

568

        except KeyError:

603

608

                def report_progress(cur, total):

604

609

                    pb.update("generating index", cur, total)

605

610

                self.data.create_index(path,

606

 

                    progress=report_progress)

 

611

                                       progress=report_progress)

607

612

            finally:

608

613

                pb.finished()

609

614

        return load_pack_index(path)

621

626

 

622

627

    def __init__(self, transport, *args, **kwargs):

623

628

        self.transport = transport

624

 

        super(BzrGitHttpClient, self).__init__(transport.external_url(), *args, **kwargs)

 

629

        super(BzrGitHttpClient, self).__init__(

 

630

            transport.external_url(), *args, **kwargs)

625

631

 

626

632

    def _http_request(self, url, headers=None, data=None,

627

633

                      allow_compression=False):

721

727

        else:

722

728

            raise NotBranchError(transport.base)

723

729

        if not _found:

724

 

            pass # TODO(jelmer): Actually probe for something

 

730

            pass  # TODO(jelmer): Actually probe for something

725

731

        return RemoteGitDir(transport, self, client, client_path)

726

732

 

727

733

    def get_format_description(self):

735

741

            external_url = transport.external_url()

736

742

        except InProcessTransport:

737

743

            raise NotBranchError(path=transport.base)

738

 

        return (external_url.startswith("http:") or

739

 

                external_url.startswith("https:") or

740

 

                external_url.startswith("git+") or

741

 

                external_url.startswith("git:"))

 

744

        return (external_url.startswith("http:")

 

745

                or external_url.startswith("https:")

 

746

                or external_url.startswith("git+")

 

747

                or external_url.startswith("git:"))

742

748

 

743

749

 

744

750

class GitRemoteRevisionTree(RevisionTree):

758

764

        # git-upload-archive(1) generaly only supports refs. So let's see if we

759

765

        # can find one.

760

766

        reverse_refs = {

761

 

                v: k for (k, v) in

762

 

                self._repository.controldir.get_refs_container().as_dict().items()}

 

767

            v: k for (k, v) in

 

768

            self._repository.controldir.get_refs_container().as_dict().items()}

763

769

        try:

764

770

            committish = reverse_refs[commit]

765

771

        except KeyError:

767

773

            # Let's hope for the best.

768

774

            committish = commit

769

775

        self._repository.archive(

770

 

                format, committish, f.write,

771

 

                subdirs=([subdir] if subdir else None),

772

 

                prefix=(root+'/') if root else '')

 

776

            format, committish, f.write,

 

777

            subdirs=([subdir] if subdir else None),

 

778

            prefix=(root + '/') if root else '')

773

779

        f.seek(0)

774

780

        return osutils.file_iterator(f)

775

781

 

799

805

        fd, path = tempfile.mkstemp(suffix=".pack")

800

806

        try:

801

807

            self.fetch_pack(determine_wants, graph_walker,

802

 

                lambda x: os.write(fd, x), progress)

 

808

                            lambda x: os.write(fd, x), progress)

803

809

        finally:

804

810

            os.close(fd)

805

811

        if os.path.getsize(path) == 0:

843

849

 

844

850

    def _set_ref(self, name, sha):

845

851

        ref = tag_name_to_ref(name)

 

852

 

846

853

        def get_changed_refs(old_refs):

847

854

            ret = dict(old_refs)

848

855

            if sha == dulwich.client.ZERO_SHA and ref not in ret:

849

856

                raise NoSuchTag(name)

850

857

            ret[ref] = sha

851

858

            return ret

 

859

 

852

860

        def generate_pack_data(have, want, ofs_delta=False):

853

861

            return pack_objects_to_data([])

854

862

        self.repository.send_pack(get_changed_refs, generate_pack_data)

859

867

    def __init__(self, controldir, repository, name):

860

868

        self._sha = None

861

869

        super(RemoteGitBranch, self).__init__(controldir, repository, name,

862

 

                RemoteGitBranchFormat())

 

870

                                              RemoteGitBranchFormat())

863

871

 

864

872

    def last_revision_info(self):

865

873

        raise GitSmartRemoteNotSupported(self.last_revision_info, self)

• Older »

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