/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: Gustav Hartvigsson
  • Date: 2021-01-11 20:19:38 UTC
  • mfrom: (7526.3.2 work)
  • Revision ID: gustav.hartvigsson@gmail.com-20210111201938-omr9wjz3qdgyxe8k
Merged lp:brz

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/remote.py
76
76
    NoSuchRef,
77
77
    )
78
78
from .mapping import (
 
79
    encode_git_path,
79
80
    mapping_registry,
80
81
    )
81
82
from .object_store import (
115
116
    )
116
117
import os
117
118
import select
118
 
import tempfile
119
119
 
120
120
import urllib.parse as urlparse
121
121
from urllib.parse import splituser
201
201
        return PermissionDenied(url, message)
202
202
    if message.endswith(' does not appear to be a git repository'):
203
203
        return NotBranchError(url, message)
 
204
    if message == 'pre-receive hook declined':
 
205
        return PermissionDenied(url, message)
204
206
    if re.match('(.+) is not a valid repository name',
205
207
                message.splitlines()[0]):
206
208
        return NotBranchError(url, message)
 
209
    if message == (
 
210
            'GitLab: You are not allowed to push code to protected branches '
 
211
            'on this project.'):
 
212
        return PermissionDenied(url, message)
207
213
    m = re.match(r'Permission to ([^ ]+) denied to ([^ ]+)\.', message)
208
214
    if m:
209
215
        return PermissionDenied(m.group(1), 'denied to %s' % m.group(2))
211
217
    return RemoteGitError(message)
212
218
 
213
219
 
 
220
def parse_git_hangup(url, e):
 
221
    """Parse the error lines from a git servers stderr on hangup.
 
222
 
 
223
    :param url: URL of the remote repository
 
224
    :param e: A HangupException
 
225
    """
 
226
    stderr_lines = getattr(e, 'stderr_lines', None)
 
227
    if not stderr_lines:
 
228
        return e
 
229
    if all(line.startswith(b'remote: ') for line in stderr_lines):
 
230
        stderr_lines = [
 
231
            line[len(b'remote: '):] for line in stderr_lines]
 
232
    interesting_lines = [
 
233
        line for line in stderr_lines
 
234
        if line and line.replace(b'=', b'')]
 
235
    if len(interesting_lines) == 1:
 
236
        interesting_line = interesting_lines[0]
 
237
        return parse_git_error(
 
238
            url, interesting_line.decode('utf-8', 'surrogateescape'))
 
239
    return RemoteGitError(
 
240
        b'\n'.join(stderr_lines).decode('utf-8', 'surrogateescape'))
 
241
 
 
242
 
214
243
class GitSmartTransport(Transport):
215
244
 
216
245
    def __init__(self, url, _client=None):
407
436
                write_error,
408
437
                format=(format.encode('ascii') if format else None),
409
438
                subdirs=subdirs,
410
 
                prefix=(prefix.encode('utf-8') if prefix else None))
 
439
                prefix=(encode_git_path(prefix) if prefix else None))
 
440
        except HangupException as e:
 
441
            raise parse_git_hangup(self.transport.external_url(), e)
411
442
        except GitProtocolError as e:
412
443
            raise parse_git_error(self.transport.external_url(), e)
413
444
        finally:
430
461
            self._refs = remote_refs_dict_to_container(
431
462
                result.refs, result.symrefs)
432
463
            return result
 
464
        except HangupException as e:
 
465
            raise parse_git_hangup(self.transport.external_url(), e)
433
466
        except GitProtocolError as e:
434
467
            raise parse_git_error(self.transport.external_url(), e)
435
468
        finally:
451
484
            return self._client.send_pack(
452
485
                self._client_path, get_changed_refs_wrapper,
453
486
                generate_pack_data, progress)
 
487
        except HangupException as e:
 
488
            raise parse_git_hangup(self.transport.external_url(), e)
454
489
        except GitProtocolError as e:
455
490
            raise parse_git_error(self.transport.external_url(), e)
456
491
        finally:
481
516
 
482
517
        def generate_pack_data(have, want, ofs_delta=False):
483
518
            return pack_objects_to_data([])
484
 
        self.send_pack(get_changed_refs, generate_pack_data)
 
519
        result = self.send_pack(get_changed_refs, generate_pack_data)
 
520
        if result is not None and not isinstance(result, dict):
 
521
            error = result.ref_status.get(refname)
 
522
            if error:
 
523
                raise RemoteGitError(error)
485
524
 
486
525
    @property
487
526
    def user_url(self):
551
590
            # No revision supplied by the user, default to the branch
552
591
            # revision
553
592
            revision_id = source.last_revision()
 
593
        else:
 
594
            if not source.repository.has_revision(revision_id):
 
595
                raise NoSuchRevision(source, revision_id)
554
596
 
555
597
        push_result = GitPushResult()
556
598
        push_result.workingtree_updated = None
560
602
        push_result.branch_push_result = None
561
603
        repo = self.find_repository()
562
604
        refname = self._get_selected_ref(name)
563
 
        ref_chain, old_sha = self.get_refs_container().follow(refname)
564
 
        if ref_chain:
565
 
            actual_refname = ref_chain[-1]
566
 
        else:
 
605
        try:
 
606
            ref_chain, old_sha = self.get_refs_container().follow(refname)
 
607
        except NotBranchError:
567
608
            actual_refname = refname
 
609
            old_sha = None
 
610
        else:
 
611
            if ref_chain:
 
612
                actual_refname = ref_chain[-1]
 
613
            else:
 
614
                actual_refname = refname
568
615
        if isinstance(source, GitBranch) and lossy:
569
616
            raise errors.LossyPushToSameVCS(source.controldir, self)
570
617
        source_store = get_object_store(source.repository)
584
631
                    raise errors.NoRoundtrippingSupport(
585
632
                        source, self.open_branch(name=name, nascent_ok=True))
586
633
            if not overwrite:
 
634
                old_sha = remote_refs.get(actual_refname)
587
635
                if remote_divergence(old_sha, new_sha, source_store):
588
636
                    raise DivergedBranches(
589
637
                        source, self.open_branch(name, nascent_ok=True))
603
651
                            new_sha = repo.lookup_bzr_revision_id(revid)[0]
604
652
                        except errors.NoSuchRevision:
605
653
                            continue
 
654
                        else:
 
655
                            if not source.repository.has_revision(revid):
 
656
                                continue
606
657
                    ret[tag_name_to_ref(tagname)] = new_sha
607
658
            return ret
608
659
        with source_store.lock_read():
624
675
                else:
625
676
                    return source_store.generate_pack_data(
626
677
                        have, want, progress=progress, ofs_delta=ofs_delta)
627
 
            new_refs = self.send_pack(get_changed_refs, generate_pack_data)
 
678
            dw_result = self.send_pack(get_changed_refs, generate_pack_data)
 
679
            if not isinstance(dw_result, dict):
 
680
                new_refs = dw_result.refs
 
681
                error = dw_result.ref_status.get(actual_refname)
 
682
                if error:
 
683
                    raise RemoteGitError(error)
 
684
                for ref, error in dw_result.ref_status.items():
 
685
                    if error:
 
686
                        trace.warning('unable to open ref %s: %s',
 
687
                                      ref, error)
 
688
            else:  # dulwich < 0.20.4
 
689
                new_refs = dw_result
628
690
        push_result.new_revid = repo.lookup_foreign_revision_id(
629
691
            new_refs[actual_refname])
630
692
        if old_sha is not None:
829
891
        """
830
892
        commit = self._repository.lookup_bzr_revision_id(
831
893
            self.get_revision_id())[0]
 
894
        import tempfile
832
895
        f = tempfile.SpooledTemporaryFile()
833
896
        # git-upload-archive(1) generaly only supports refs. So let's see if we
834
897
        # can find one.
885
948
 
886
949
    def fetch_objects(self, determine_wants, graph_walker, resolve_ext_ref,
887
950
                      progress=None):
 
951
        import tempfile
888
952
        fd, path = tempfile.mkstemp(suffix=".pack")
889
953
        try:
890
954
            self.fetch_pack(determine_wants, graph_walker,
943
1007
 
944
1008
        def generate_pack_data(have, want, ofs_delta=False):
945
1009
            return pack_objects_to_data([])
946
 
        self.repository.send_pack(get_changed_refs, generate_pack_data)
 
1010
        result = self.repository.send_pack(
 
1011
            get_changed_refs, generate_pack_data)
 
1012
        if result and not isinstance(result, dict):
 
1013
            error = result.ref_status.get(ref)
 
1014
            if error:
 
1015
                raise RemoteGitError(error)
947
1016
 
948
1017
 
949
1018
class RemoteGitBranch(GitBranch):
1027
1096
            return {self.ref: sha}
1028
1097
        def generate_pack_data(have, want, ofs_delta=False):
1029
1098
            return pack_objects_to_data([])
1030
 
        self.repository.send_pack(get_changed_refs, generate_pack_data)
 
1099
        result = self.repository.send_pack(
 
1100
            get_changed_refs, generate_pack_data)
 
1101
        if result is not None and not isinstance(result, dict):
 
1102
            error = result.ref_status.get(self.ref)
 
1103
            if error:
 
1104
                raise RemoteGitError(error)
1031
1105
        self._sha = sha
1032
1106
 
1033
1107