/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/git/remote.py

  • Committer: Jelmer Vernooij
  • Date: 2020-02-13 23:57:28 UTC
  • mfrom: (7490 work)
  • mto: This revision was merged to the branch mainline in revision 7492.
  • Revision ID: jelmer@jelmer.uk-20200213235728-m6ds0mm3mbs4y182
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/remote.py
16
16
 
17
17
"""Remote dirs, repositories and branches."""
18
18
 
 
19
from __future__ import absolute_import
 
20
 
19
21
import gzip
20
22
from io import BytesIO
21
23
import re
76
78
    NoSuchRef,
77
79
    )
78
80
from .mapping import (
79
 
    encode_git_path,
80
81
    mapping_registry,
81
82
    )
82
83
from .object_store import (
116
117
    )
117
118
import os
118
119
import select
 
120
import tempfile
119
121
 
120
122
import urllib.parse as urlparse
121
123
from urllib.parse import splituser
204
206
    if re.match('(.+) is not a valid repository name',
205
207
                message.splitlines()[0]):
206
208
        return NotBranchError(url, message)
207
 
    if message == (
208
 
            'GitLab: You are not allowed to push code to protected branches '
209
 
            'on this project.'):
210
 
        return PermissionDenied(url, message)
211
209
    m = re.match(r'Permission to ([^ ]+) denied to ([^ ]+)\.', message)
212
210
    if m:
213
211
        return PermissionDenied(m.group(1), 'denied to %s' % m.group(2))
215
213
    return RemoteGitError(message)
216
214
 
217
215
 
218
 
def parse_git_hangup(url, e):
219
 
    """Parse the error lines from a git servers stderr on hangup.
220
 
 
221
 
    :param url: URL of the remote repository
222
 
    :param e: A HangupException
223
 
    """
224
 
    stderr_lines = getattr(e, 'stderr_lines', None)
225
 
    if not stderr_lines:
226
 
        return e
227
 
    if all(line.startswith(b'remote: ') for line in stderr_lines):
228
 
        stderr_lines = [
229
 
            line[len(b'remote: '):] for line in stderr_lines]
230
 
    interesting_lines = [
231
 
        line for line in stderr_lines
232
 
        if line and line.replace(b'=', b'')]
233
 
    if len(interesting_lines) == 1:
234
 
        interesting_line = interesting_lines[0]
235
 
        return parse_git_error(
236
 
            url, interesting_line.decode('utf-8', 'surrogateescape'))
237
 
    return RemoteGitError(
238
 
        b'\n'.join(stderr_lines).decode('utf-8', 'surrogateescape'))
239
 
 
240
 
 
241
216
class GitSmartTransport(Transport):
242
217
 
243
218
    def __init__(self, url, _client=None):
434
409
                write_error,
435
410
                format=(format.encode('ascii') if format else None),
436
411
                subdirs=subdirs,
437
 
                prefix=(encode_git_path(prefix) if prefix else None))
438
 
        except HangupException as e:
439
 
            raise parse_git_hangup(self.transport.external_url(), e)
 
412
                prefix=(prefix.encode('utf-8') if prefix else None))
440
413
        except GitProtocolError as e:
441
414
            raise parse_git_error(self.transport.external_url(), e)
442
415
        finally:
459
432
            self._refs = remote_refs_dict_to_container(
460
433
                result.refs, result.symrefs)
461
434
            return result
462
 
        except HangupException as e:
463
 
            raise parse_git_hangup(self.transport.external_url(), e)
464
435
        except GitProtocolError as e:
465
436
            raise parse_git_error(self.transport.external_url(), e)
466
437
        finally:
482
453
            return self._client.send_pack(
483
454
                self._client_path, get_changed_refs_wrapper,
484
455
                generate_pack_data, progress)
485
 
        except HangupException as e:
486
 
            raise parse_git_hangup(self.transport.external_url(), e)
487
456
        except GitProtocolError as e:
488
457
            raise parse_git_error(self.transport.external_url(), e)
489
458
        finally:
514
483
 
515
484
        def generate_pack_data(have, want, ofs_delta=False):
516
485
            return pack_objects_to_data([])
517
 
        result = self.send_pack(get_changed_refs, generate_pack_data)
518
 
        if result is not None and not isinstance(result, dict):
519
 
            error = result.ref_status.get(refname)
520
 
            if error:
521
 
                raise RemoteGitError(error)
 
486
        self.send_pack(get_changed_refs, generate_pack_data)
522
487
 
523
488
    @property
524
489
    def user_url(self):
582
547
 
583
548
    def push_branch(self, source, revision_id=None, overwrite=False,
584
549
                    remember=False, create_prefix=False, lossy=False,
585
 
                    name=None, tag_selector=None):
 
550
                    name=None):
586
551
        """Push the source branch into this ControlDir."""
587
552
        if revision_id is None:
588
553
            # No revision supplied by the user, default to the branch
589
554
            # revision
590
555
            revision_id = source.last_revision()
591
 
        else:
592
 
            if not source.repository.has_revision(revision_id):
593
 
                raise NoSuchRevision(source, revision_id)
594
556
 
595
557
        push_result = GitPushResult()
596
558
        push_result.workingtree_updated = None
630
592
            ret[actual_refname] = new_sha
631
593
            if fetch_tags:
632
594
                for tagname, revid in source.tags.get_tag_dict().items():
633
 
                    if tag_selector and not tag_selector(tagname):
634
 
                        continue
635
595
                    if lossy:
636
596
                        try:
637
597
                            new_sha = source_store._lookup_revision_sha1(revid)
643
603
                            new_sha = repo.lookup_bzr_revision_id(revid)[0]
644
604
                        except errors.NoSuchRevision:
645
605
                            continue
646
 
                        else:
647
 
                            if not source.repository.has_revision(revid):
648
 
                                continue
649
606
                    ret[tag_name_to_ref(tagname)] = new_sha
650
607
            return ret
651
608
        with source_store.lock_read():
652
 
            def generate_pack_data(have, want, progress=None,
653
 
                                   ofs_delta=True):
654
 
                git_repo = getattr(source.repository, '_git', None)
655
 
                if git_repo:
656
 
                    shallow = git_repo.get_shallow()
657
 
                else:
658
 
                    shallow = None
659
 
                if lossy:
660
 
                    return source_store.generate_lossy_pack_data(
661
 
                        have, want, shallow=shallow,
662
 
                        progress=progress, ofs_delta=ofs_delta)
663
 
                elif shallow:
664
 
                    return source_store.generate_pack_data(
665
 
                        have, want, shallow=shallow,
666
 
                        progress=progress, ofs_delta=ofs_delta)
667
 
                else:
668
 
                    return source_store.generate_pack_data(
669
 
                        have, want, progress=progress, ofs_delta=ofs_delta)
670
 
            dw_result = self.send_pack(get_changed_refs, generate_pack_data)
671
 
            if not isinstance(dw_result, dict):
672
 
                new_refs = dw_result.refs
673
 
                error = dw_result.ref_status.get(actual_refname)
674
 
                if error:
675
 
                    raise RemoteGitError(error)
676
 
                for ref, error in dw_result.ref_status.items():
677
 
                    if error:
678
 
                        trace.warning('unable to open ref %s: %s',
679
 
                                      ref, error)
680
 
            else:  # dulwich < 0.20.4
681
 
                new_refs = dw_result
 
609
            if lossy:
 
610
                generate_pack_data = source_store.generate_lossy_pack_data
 
611
            else:
 
612
                generate_pack_data = source_store.generate_pack_data
 
613
            new_refs = self.send_pack(get_changed_refs, generate_pack_data)
682
614
        push_result.new_revid = repo.lookup_foreign_revision_id(
683
615
            new_refs[actual_refname])
684
616
        if old_sha is not None:
780
712
            raise NotGitRepository()
781
713
        elif response.status != 200:
782
714
            raise GitProtocolError("unexpected http resp %d for %s" %
783
 
                                   (response.status, url))
 
715
                                   (response.code, url))
784
716
 
785
717
        # TODO: Optimization available by adding `preload_content=False` to the
786
718
        # request and just passing the `read` method on instead of going via
883
815
        """
884
816
        commit = self._repository.lookup_bzr_revision_id(
885
817
            self.get_revision_id())[0]
886
 
        import tempfile
887
818
        f = tempfile.SpooledTemporaryFile()
888
819
        # git-upload-archive(1) generaly only supports refs. So let's see if we
889
820
        # can find one.
940
871
 
941
872
    def fetch_objects(self, determine_wants, graph_walker, resolve_ext_ref,
942
873
                      progress=None):
943
 
        import tempfile
944
874
        fd, path = tempfile.mkstemp(suffix=".pack")
945
875
        try:
946
876
            self.fetch_pack(determine_wants, graph_walker,
999
929
 
1000
930
        def generate_pack_data(have, want, ofs_delta=False):
1001
931
            return pack_objects_to_data([])
1002
 
        result = self.repository.send_pack(
1003
 
            get_changed_refs, generate_pack_data)
1004
 
        if result and not isinstance(result, dict):
1005
 
            error = result.ref_status.get(ref)
1006
 
            if error:
1007
 
                raise RemoteGitError(error)
 
932
        self.repository.send_pack(get_changed_refs, generate_pack_data)
1008
933
 
1009
934
 
1010
935
class RemoteGitBranch(GitBranch):
1088
1013
            return {self.ref: sha}
1089
1014
        def generate_pack_data(have, want, ofs_delta=False):
1090
1015
            return pack_objects_to_data([])
1091
 
        result = self.repository.send_pack(
1092
 
            get_changed_refs, generate_pack_data)
1093
 
        if result is not None and not isinstance(result, dict):
1094
 
            error = result.ref_status.get(self.ref)
1095
 
            if error:
1096
 
                raise RemoteGitError(error)
 
1016
        self.repository.send_pack(get_changed_refs, generate_pack_data)
1097
1017
        self._sha = sha
1098
1018
 
1099
1019