/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-09-02 16:35:18 UTC
  • mto: (7490.40.109 work)
  • mto: This revision was merged to the branch mainline in revision 7526.
  • Revision ID: jelmer@jelmer.uk-20200902163518-sy9f4unbboljphgu
Handle duplicate directories entries for git.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/remote.py
1
 
# Copyright (C) 2007-2010 Jelmer Vernooij <jelmer@samba.org>
 
1
# Copyright (C) 2007-2018 Jelmer Vernooij <jelmer@jelmer.uk>
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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
from bzrlib import (
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Remote dirs, repositories and branches."""
 
18
 
 
19
from __future__ import absolute_import
 
20
 
 
21
import gzip
 
22
from io import BytesIO
 
23
import re
 
24
 
 
25
from .. import (
18
26
    config,
19
27
    debug,
20
 
    tag,
 
28
    errors,
 
29
    osutils,
21
30
    trace,
22
31
    ui,
23
32
    urlutils,
24
33
    )
25
 
from bzrlib.errors import (
 
34
from ..push import (
 
35
    PushResult,
 
36
    )
 
37
from ..errors import (
 
38
    AlreadyBranchError,
26
39
    BzrError,
 
40
    DivergedBranches,
 
41
    InProcessTransport,
27
42
    InvalidRevisionId,
28
43
    NoSuchFile,
29
44
    NoSuchRevision,
 
45
    NoSuchTag,
 
46
    NotBranchError,
30
47
    NotLocalUrl,
31
 
    )
32
 
from bzrlib.transport import (
 
48
    PermissionDenied,
 
49
    UninitializableFormat,
 
50
    )
 
51
from ..revision import NULL_REVISION
 
52
from ..revisiontree import RevisionTree
 
53
from ..sixish import (
 
54
    text_type,
 
55
    viewitems,
 
56
    )
 
57
from ..transport import (
33
58
    Transport,
 
59
    register_urlparse_netloc_protocol,
34
60
    )
35
61
 
36
 
from bzrlib.plugins.git import (
 
62
from . import (
37
63
    lazy_check_versions,
 
64
    is_github_url,
 
65
    user_agent_for_github,
38
66
    )
39
67
lazy_check_versions()
40
68
 
41
 
from bzrlib.plugins.git.branch import (
 
69
from .branch import (
42
70
    GitBranch,
43
 
    )
44
 
from bzrlib.plugins.git.errors import (
 
71
    GitBranchFormat,
 
72
    GitBranchPushResult,
 
73
    GitTags,
 
74
    _quick_lookup_revno,
 
75
    )
 
76
from .dir import (
 
77
    GitControlDirFormat,
 
78
    GitDir,
 
79
    )
 
80
from .errors import (
45
81
    GitSmartRemoteNotSupported,
46
82
    NoSuchRef,
47
83
    )
48
 
from bzrlib.plugins.git.dir import (
49
 
    GitDir,
50
 
    )
51
 
from bzrlib.plugins.git.mapping import (
 
84
from .mapping import (
 
85
    encode_git_path,
52
86
    mapping_registry,
53
87
    )
54
 
from bzrlib.plugins.git.repository import (
 
88
from .object_store import (
 
89
    get_object_store,
 
90
    )
 
91
from .push import (
 
92
    remote_divergence,
 
93
    )
 
94
from .repository import (
55
95
    GitRepository,
 
96
    GitRepositoryFormat,
56
97
    )
57
 
from bzrlib.plugins.git.refs import (
58
 
    extract_tags,
 
98
from .refs import (
59
99
    branch_name_to_ref,
 
100
    is_peeled,
 
101
    ref_to_tag_name,
 
102
    tag_name_to_ref,
60
103
    )
61
104
 
62
 
import dulwich as git
 
105
import dulwich
 
106
import dulwich.client
63
107
from dulwich.errors import (
64
108
    GitProtocolError,
 
109
    HangupException,
65
110
    )
66
111
from dulwich.pack import (
67
112
    Pack,
68
 
    ThinPackData,
 
113
    pack_objects_to_data,
 
114
    )
 
115
from dulwich.protocol import ZERO_SHA
 
116
from dulwich.refs import (
 
117
    DictRefsContainer,
 
118
    SYMREF,
 
119
    )
 
120
from dulwich.repo import (
 
121
    NotGitRepository,
69
122
    )
70
123
import os
71
 
import tempfile
72
 
import urllib
73
 
import urlparse
74
 
urlparse.uses_netloc.extend(['git', 'git+ssh'])
 
124
import select
 
125
 
 
126
try:
 
127
    import urllib.parse as urlparse
 
128
    from urllib.parse import splituser
 
129
except ImportError:
 
130
    import urlparse
 
131
    from urllib import splituser
 
132
 
 
133
# urlparse only supports a limited number of schemes by default
 
134
register_urlparse_netloc_protocol('git')
 
135
register_urlparse_netloc_protocol('git+ssh')
75
136
 
76
137
from dulwich.pack import load_pack_index
77
138
 
78
139
 
 
140
class GitPushResult(PushResult):
 
141
 
 
142
    def _lookup_revno(self, revid):
 
143
        try:
 
144
            return _quick_lookup_revno(self.source_branch, self.target_branch,
 
145
                                       revid)
 
146
        except GitSmartRemoteNotSupported:
 
147
            return None
 
148
 
 
149
    @property
 
150
    def old_revno(self):
 
151
        return self._lookup_revno(self.old_revid)
 
152
 
 
153
    @property
 
154
    def new_revno(self):
 
155
        return self._lookup_revno(self.new_revid)
 
156
 
 
157
 
79
158
# Don't run any tests on GitSmartTransport as it is not intended to be
80
159
# a full implementation of Transport
81
160
def get_test_permutations():
88
167
    :param url: Git URL
89
168
    :return: Tuple with host, port, username, path.
90
169
    """
91
 
    (scheme, netloc, loc, _, _) = urlparse.urlsplit(url)
92
 
    path = urllib.unquote(loc)
 
170
    parsed_url = urlparse.urlparse(url)
 
171
    path = urlparse.unquote(parsed_url.path)
93
172
    if path.startswith("/~"):
94
173
        path = path[1:]
95
 
    (username, hostport) = urllib.splituser(netloc)
96
 
    (host, port) = urllib.splitnport(hostport, None)
97
 
    return (host, port, username, path)
 
174
    return ((parsed_url.hostname or '', parsed_url.port, parsed_url.username, path))
 
175
 
 
176
 
 
177
class RemoteGitError(BzrError):
 
178
 
 
179
    _fmt = "Remote server error: %(msg)s"
 
180
 
 
181
 
 
182
class HeadUpdateFailed(BzrError):
 
183
 
 
184
    _fmt = ("Unable to update remote HEAD branch. To update the master "
 
185
            "branch, specify the URL %(base_url)s,branch=master.")
 
186
 
 
187
    def __init__(self, base_url):
 
188
        super(HeadUpdateFailed, self).__init__()
 
189
        self.base_url = base_url
 
190
 
 
191
 
 
192
def parse_git_error(url, message):
 
193
    """Parse a remote git server error and return a bzr exception.
 
194
 
 
195
    :param url: URL of the remote repository
 
196
    :param message: Message sent by the remote git server
 
197
    """
 
198
    message = str(message).strip()
 
199
    if (message.startswith("Could not find Repository ")
 
200
        or message == 'Repository not found.'
 
201
            or (message.startswith('Repository ') and
 
202
                message.endswith(' not found.'))):
 
203
        return NotBranchError(url, message)
 
204
    if message == "HEAD failed to update":
 
205
        base_url = urlutils.strip_segment_parameters(url)
 
206
        return HeadUpdateFailed(base_url)
 
207
    if message.startswith('access denied or repository not exported:'):
 
208
        extra, path = message.split(':', 1)
 
209
        return PermissionDenied(path.strip(), extra)
 
210
    if message.endswith('You are not allowed to push code to this project.'):
 
211
        return PermissionDenied(url, message)
 
212
    if message.endswith(' does not appear to be a git repository'):
 
213
        return NotBranchError(url, message)
 
214
    if message == 'pre-receive hook declined':
 
215
        return PermissionDenied(url, message)
 
216
    if re.match('(.+) is not a valid repository name',
 
217
                message.splitlines()[0]):
 
218
        return NotBranchError(url, message)
 
219
    if message == (
 
220
            'GitLab: You are not allowed to push code to protected branches '
 
221
            'on this project.'):
 
222
        return PermissionDenied(url, message)
 
223
    m = re.match(r'Permission to ([^ ]+) denied to ([^ ]+)\.', message)
 
224
    if m:
 
225
        return PermissionDenied(m.group(1), 'denied to %s' % m.group(2))
 
226
    # Don't know, just return it to the user as-is
 
227
    return RemoteGitError(message)
 
228
 
 
229
 
 
230
def parse_git_hangup(url, e):
 
231
    """Parse the error lines from a git servers stderr on hangup.
 
232
 
 
233
    :param url: URL of the remote repository
 
234
    :param e: A HangupException
 
235
    """
 
236
    stderr_lines = getattr(e, 'stderr_lines', None)
 
237
    if not stderr_lines:
 
238
        return e
 
239
    if all(line.startswith(b'remote: ') for line in stderr_lines):
 
240
        stderr_lines = [
 
241
            line[len(b'remote: '):] for line in stderr_lines]
 
242
    interesting_lines = [
 
243
        line for line in stderr_lines
 
244
        if line and line.replace(b'=', b'')]
 
245
    if len(interesting_lines) == 1:
 
246
        interesting_line = interesting_lines[0]
 
247
        return parse_git_error(
 
248
            url, interesting_line.decode('utf-8', 'surrogateescape'))
 
249
    return RemoteGitError(
 
250
        b'\n'.join(stderr_lines).decode('utf-8', 'surrogateescape'))
98
251
 
99
252
 
100
253
class GitSmartTransport(Transport):
107
260
            trace.mutter('host: %r, user: %r, port: %r, path: %r',
108
261
                         self._host, self._username, self._port, self._path)
109
262
        self._client = _client
 
263
        self._stripped_path = self._path.rsplit(",", 1)[0]
110
264
 
111
265
    def external_url(self):
112
266
        return self.base
114
268
    def has(self, relpath):
115
269
        return False
116
270
 
117
 
    def _get_client(self, thin_packs):
 
271
    def _get_client(self):
118
272
        raise NotImplementedError(self._get_client)
119
273
 
120
274
    def _get_path(self):
121
 
        return self._path
122
 
 
123
 
    def fetch_pack(self, determine_wants, graph_walker, pack_data, progress=None):
124
 
        if progress is None:
125
 
            def progress(text):
126
 
                trace.info("git: %s" % text)
127
 
        client = self._get_client(thin_packs=False)
128
 
        try:
129
 
            return client.fetch_pack(self._get_path(), determine_wants,
130
 
                graph_walker, pack_data, progress)
131
 
        except GitProtocolError, e:
132
 
            raise BzrError(e)
133
 
 
134
 
    def send_pack(self, get_changed_refs, generate_pack_contents):
135
 
        client = self._get_client(thin_packs=False)
136
 
        try:
137
 
            return client.send_pack(self._get_path(), get_changed_refs,
138
 
                generate_pack_contents)
139
 
        except GitProtocolError, e:
140
 
            raise BzrError(e)
 
275
        return self._stripped_path
141
276
 
142
277
    def get(self, path):
143
278
        raise NoSuchFile(path)
159
294
 
160
295
    _scheme = 'git'
161
296
 
162
 
    def _get_client(self, thin_packs):
 
297
    def _get_client(self):
163
298
        if self._client is not None:
164
299
            ret = self._client
165
300
            self._client = None
166
301
            return ret
167
 
        return git.client.TCPGitClient(self._host, self._port,
168
 
            thin_packs=thin_packs, report_activity=self._report_activity)
 
302
        if self._host == '':
 
303
            # return dulwich.client.LocalGitClient()
 
304
            return dulwich.client.SubprocessGitClient()
 
305
        return dulwich.client.TCPGitClient(
 
306
            self._host, self._port, report_activity=self._report_activity)
 
307
 
 
308
 
 
309
class SSHSocketWrapper(object):
 
310
 
 
311
    def __init__(self, sock):
 
312
        self.sock = sock
 
313
 
 
314
    def read(self, len=None):
 
315
        return self.sock.recv(len)
 
316
 
 
317
    def write(self, data):
 
318
        return self.sock.write(data)
 
319
 
 
320
    def can_read(self):
 
321
        return len(select.select([self.sock.fileno()], [], [], 0)[0]) > 0
 
322
 
 
323
 
 
324
class DulwichSSHVendor(dulwich.client.SSHVendor):
 
325
 
 
326
    def __init__(self):
 
327
        from ..transport import ssh
 
328
        self.bzr_ssh_vendor = ssh._get_ssh_vendor()
 
329
 
 
330
    def run_command(self, host, command, username=None, port=None):
 
331
        connection = self.bzr_ssh_vendor.connect_ssh(
 
332
            username=username, password=None, port=port, host=host,
 
333
            command=command)
 
334
        (kind, io_object) = connection.get_sock_or_pipes()
 
335
        if kind == 'socket':
 
336
            return SSHSocketWrapper(io_object)
 
337
        else:
 
338
            raise AssertionError("Unknown io object kind %r'" % kind)
 
339
 
 
340
 
 
341
# dulwich.client.get_ssh_vendor = DulwichSSHVendor
169
342
 
170
343
 
171
344
class SSHGitSmartTransport(GitSmartTransport):
173
346
    _scheme = 'git+ssh'
174
347
 
175
348
    def _get_path(self):
176
 
        if self._path.startswith("/~/"):
177
 
            return self._path[3:]
178
 
        return self._path
 
349
        path = self._stripped_path
 
350
        if path.startswith("/~/"):
 
351
            return path[3:]
 
352
        return path
179
353
 
180
 
    def _get_client(self, thin_packs):
 
354
    def _get_client(self):
181
355
        if self._client is not None:
182
356
            ret = self._client
183
357
            self._client = None
184
358
            return ret
185
359
        location_config = config.LocationConfig(self.base)
186
 
        client = git.client.SSHGitClient(self._host, self._port, self._username,
187
 
            thin_packs=thin_packs, report_activity=self._report_activity)
 
360
        client = dulwich.client.SSHGitClient(
 
361
            self._host, self._port, self._username,
 
362
            report_activity=self._report_activity)
188
363
        # Set up alternate pack program paths
189
364
        upload_pack = location_config.get_user_option('git_upload_pack')
190
365
        if upload_pack:
195
370
        return client
196
371
 
197
372
 
 
373
class RemoteGitBranchFormat(GitBranchFormat):
 
374
 
 
375
    def get_format_description(self):
 
376
        return 'Remote Git Branch'
 
377
 
 
378
    @property
 
379
    def _matchingcontroldir(self):
 
380
        return RemoteGitControlDirFormat()
 
381
 
 
382
    def initialize(self, a_controldir, name=None, repository=None,
 
383
                   append_revisions_only=None):
 
384
        raise UninitializableFormat(self)
 
385
 
 
386
 
 
387
class DefaultProgressReporter(object):
 
388
 
 
389
    _GIT_PROGRESS_PARTIAL_RE = re.compile(r"(.*?): +(\d+)% \((\d+)/(\d+)\)")
 
390
    _GIT_PROGRESS_TOTAL_RE = re.compile(r"(.*?): (\d+)")
 
391
 
 
392
    def __init__(self, pb):
 
393
        self.pb = pb
 
394
 
 
395
    def progress(self, text):
 
396
        text = text.rstrip(b"\r\n")
 
397
        text = text.decode('utf-8')
 
398
        if text.lower().startswith('error: '):
 
399
            trace.show_error('git: %s', text[len(b'error: '):])
 
400
        else:
 
401
            trace.mutter("git: %s", text)
 
402
            g = self._GIT_PROGRESS_PARTIAL_RE.match(text)
 
403
            if g is not None:
 
404
                (text, pct, current, total) = g.groups()
 
405
                self.pb.update(text, int(current), int(total))
 
406
            else:
 
407
                g = self._GIT_PROGRESS_TOTAL_RE.match(text)
 
408
                if g is not None:
 
409
                    (text, total) = g.groups()
 
410
                    self.pb.update(text, None, int(total))
 
411
                else:
 
412
                    trace.note("%s", text)
 
413
 
 
414
 
198
415
class RemoteGitDir(GitDir):
199
416
 
200
 
    def __init__(self, transport, lockfiles, format):
 
417
    def __init__(self, transport, format, client, client_path):
201
418
        self._format = format
202
419
        self.root_transport = transport
203
420
        self.transport = transport
204
 
        self._lockfiles = lockfiles
205
421
        self._mode_check_done = None
206
 
 
207
 
    def _branch_name_to_ref(self, name, default=None):
208
 
        return branch_name_to_ref(name, default=default)
 
422
        self._client = client
 
423
        self._client_path = client_path
 
424
        self.base = self.root_transport.base
 
425
        self._refs = None
 
426
 
 
427
    @property
 
428
    def _gitrepository_class(self):
 
429
        return RemoteGitRepository
 
430
 
 
431
    def archive(self, format, committish, write_data, progress=None,
 
432
                write_error=None, subdirs=None, prefix=None):
 
433
        if progress is None:
 
434
            pb = ui.ui_factory.nested_progress_bar()
 
435
            progress = DefaultProgressReporter(pb).progress
 
436
        else:
 
437
            pb = None
 
438
        def progress_wrapper(message):
 
439
            if message.startswith(b"fatal: Unknown archive format \'"):
 
440
                format = message.strip()[len(b"fatal: Unknown archive format '"):-1]
 
441
                raise errors.NoSuchExportFormat(format.decode('ascii'))
 
442
            return progress(message)
 
443
        try:
 
444
            self._client.archive(
 
445
                self._client_path, committish, write_data, progress_wrapper,
 
446
                write_error,
 
447
                format=(format.encode('ascii') if format else None),
 
448
                subdirs=subdirs,
 
449
                prefix=(encode_git_path(prefix) if prefix else None))
 
450
        except HangupException as e:
 
451
            raise parse_git_hangup(self.transport.external_url(), e)
 
452
        except GitProtocolError as e:
 
453
            raise parse_git_error(self.transport.external_url(), e)
 
454
        finally:
 
455
            if pb is not None:
 
456
                pb.finished()
 
457
 
 
458
    def fetch_pack(self, determine_wants, graph_walker, pack_data,
 
459
                   progress=None):
 
460
        if progress is None:
 
461
            pb = ui.ui_factory.nested_progress_bar()
 
462
            progress = DefaultProgressReporter(pb).progress
 
463
        else:
 
464
            pb = None
 
465
        try:
 
466
            result = self._client.fetch_pack(
 
467
                self._client_path, determine_wants, graph_walker, pack_data,
 
468
                progress)
 
469
            if result.refs is None:
 
470
                result.refs = {}
 
471
            self._refs = remote_refs_dict_to_container(
 
472
                result.refs, result.symrefs)
 
473
            return result
 
474
        except HangupException as e:
 
475
            raise parse_git_hangup(self.transport.external_url(), e)
 
476
        except GitProtocolError as e:
 
477
            raise parse_git_error(self.transport.external_url(), e)
 
478
        finally:
 
479
            if pb is not None:
 
480
                pb.finished()
 
481
 
 
482
    def send_pack(self, get_changed_refs, generate_pack_data, progress=None):
 
483
        if progress is None:
 
484
            pb = ui.ui_factory.nested_progress_bar()
 
485
            progress = DefaultProgressReporter(pb).progress
 
486
        else:
 
487
            pb = None
 
488
 
 
489
        def get_changed_refs_wrapper(remote_refs):
 
490
            if self._refs is not None:
 
491
                update_refs_container(self._refs, remote_refs)
 
492
            return get_changed_refs(remote_refs)
 
493
        try:
 
494
            return self._client.send_pack(
 
495
                self._client_path, get_changed_refs_wrapper,
 
496
                generate_pack_data, progress)
 
497
        except HangupException as e:
 
498
            raise parse_git_hangup(self.transport.external_url(), e)
 
499
        except GitProtocolError as e:
 
500
            raise parse_git_error(self.transport.external_url(), e)
 
501
        finally:
 
502
            if pb is not None:
 
503
                pb.finished()
 
504
 
 
505
    def create_branch(self, name=None, repository=None,
 
506
                      append_revisions_only=None, ref=None):
 
507
        refname = self._get_selected_ref(name, ref)
 
508
        if refname != b'HEAD' and refname in self.get_refs_container():
 
509
            raise AlreadyBranchError(self.user_url)
 
510
        ref_chain, unused_sha = self.get_refs_container().follow(
 
511
            self._get_selected_ref(name))
 
512
        if ref_chain and ref_chain[0] == b'HEAD':
 
513
            refname = ref_chain[1]
 
514
        repo = self.open_repository()
 
515
        return RemoteGitBranch(self, repo, refname)
 
516
 
 
517
    def destroy_branch(self, name=None):
 
518
        refname = self._get_selected_ref(name)
 
519
 
 
520
        def get_changed_refs(old_refs):
 
521
            ret = {}
 
522
            if refname not in old_refs:
 
523
                raise NotBranchError(self.user_url)
 
524
            ret[refname] = dulwich.client.ZERO_SHA
 
525
            return ret
 
526
 
 
527
        def generate_pack_data(have, want, ofs_delta=False):
 
528
            return pack_objects_to_data([])
 
529
        result = self.send_pack(get_changed_refs, generate_pack_data)
 
530
        if result is not None and not isinstance(result, dict):
 
531
            error = result.ref_status.get(refname)
 
532
            if error:
 
533
                raise RemoteGitError(error)
 
534
 
 
535
    @property
 
536
    def user_url(self):
 
537
        return self.control_url
 
538
 
 
539
    @property
 
540
    def user_transport(self):
 
541
        return self.root_transport
 
542
 
 
543
    @property
 
544
    def control_url(self):
 
545
        return self.control_transport.base
 
546
 
 
547
    @property
 
548
    def control_transport(self):
 
549
        return self.root_transport
209
550
 
210
551
    def open_repository(self):
211
 
        return RemoteGitRepository(self, self._lockfiles)
212
 
 
213
 
    def _open_branch(self, name=None, ignore_fallbacks=False, 
214
 
                    unsupported=False):
 
552
        return RemoteGitRepository(self)
 
553
 
 
554
    def get_branch_reference(self, name=None):
 
555
        ref = branch_name_to_ref(name)
 
556
        val = self.get_refs_container().read_ref(ref)
 
557
        if val.startswith(SYMREF):
 
558
            return val[len(SYMREF):]
 
559
        return None
 
560
 
 
561
    def open_branch(self, name=None, unsupported=False,
 
562
                    ignore_fallbacks=False, ref=None, possible_transports=None,
 
563
                    nascent_ok=False):
215
564
        repo = self.open_repository()
216
 
        refname = self._branch_name_to_ref(name)
217
 
        return RemoteGitBranch(self, repo, refname, self._lockfiles)
 
565
        ref = self._get_selected_ref(name, ref)
 
566
        try:
 
567
            if not nascent_ok and ref not in self.get_refs_container():
 
568
                raise NotBranchError(
 
569
                    self.root_transport.base, controldir=self)
 
570
        except NotGitRepository:
 
571
            raise NotBranchError(self.root_transport.base,
 
572
                                 controldir=self)
 
573
        ref_chain, unused_sha = self.get_refs_container().follow(ref)
 
574
        return RemoteGitBranch(self, repo, ref_chain[-1])
218
575
 
219
576
    def open_workingtree(self, recommend_upgrade=False):
220
577
        raise NotLocalUrl(self.transport.base)
221
578
 
 
579
    def has_workingtree(self):
 
580
        return False
 
581
 
 
582
    def get_peeled(self, name):
 
583
        return self.get_refs_container().get_peeled(name)
 
584
 
 
585
    def get_refs_container(self):
 
586
        if self._refs is not None:
 
587
            return self._refs
 
588
        result = self.fetch_pack(lambda x: None, None,
 
589
                                 lambda x: None,
 
590
                                 lambda x: trace.mutter("git: %s" % x))
 
591
        self._refs = remote_refs_dict_to_container(
 
592
            result.refs, result.symrefs)
 
593
        return self._refs
 
594
 
 
595
    def push_branch(self, source, revision_id=None, overwrite=False,
 
596
                    remember=False, create_prefix=False, lossy=False,
 
597
                    name=None, tag_selector=None):
 
598
        """Push the source branch into this ControlDir."""
 
599
        if revision_id is None:
 
600
            # No revision supplied by the user, default to the branch
 
601
            # revision
 
602
            revision_id = source.last_revision()
 
603
        else:
 
604
            if not source.repository.has_revision(revision_id):
 
605
                raise NoSuchRevision(source, revision_id)
 
606
 
 
607
        push_result = GitPushResult()
 
608
        push_result.workingtree_updated = None
 
609
        push_result.master_branch = None
 
610
        push_result.source_branch = source
 
611
        push_result.stacked_on = None
 
612
        push_result.branch_push_result = None
 
613
        repo = self.find_repository()
 
614
        refname = self._get_selected_ref(name)
 
615
        try:
 
616
            ref_chain, old_sha = self.get_refs_container().follow(refname)
 
617
        except NotBranchError:
 
618
            actual_refname = refname
 
619
            old_sha = None
 
620
        else:
 
621
            if ref_chain:
 
622
                actual_refname = ref_chain[-1]
 
623
            else:
 
624
                actual_refname = refname
 
625
        if isinstance(source, GitBranch) and lossy:
 
626
            raise errors.LossyPushToSameVCS(source.controldir, self)
 
627
        source_store = get_object_store(source.repository)
 
628
        fetch_tags = source.get_config_stack().get('branch.fetch_tags')
 
629
        def get_changed_refs(remote_refs):
 
630
            if self._refs is not None:
 
631
                update_refs_container(self._refs, remote_refs)
 
632
            ret = {}
 
633
            # TODO(jelmer): Unpeel if necessary
 
634
            push_result.new_original_revid = revision_id
 
635
            if lossy:
 
636
                new_sha = source_store._lookup_revision_sha1(revision_id)
 
637
            else:
 
638
                try:
 
639
                    new_sha = repo.lookup_bzr_revision_id(revision_id)[0]
 
640
                except errors.NoSuchRevision:
 
641
                    raise errors.NoRoundtrippingSupport(
 
642
                        source, self.open_branch(name=name, nascent_ok=True))
 
643
            if not overwrite:
 
644
                old_sha = remote_refs.get(actual_refname)
 
645
                if remote_divergence(old_sha, new_sha, source_store):
 
646
                    raise DivergedBranches(
 
647
                        source, self.open_branch(name, nascent_ok=True))
 
648
            ret[actual_refname] = new_sha
 
649
            if fetch_tags:
 
650
                for tagname, revid in viewitems(source.tags.get_tag_dict()):
 
651
                    if tag_selector and not tag_selector(tagname):
 
652
                        continue
 
653
                    if lossy:
 
654
                        try:
 
655
                            new_sha = source_store._lookup_revision_sha1(revid)
 
656
                        except KeyError:
 
657
                            if source.repository.has_revision(revid):
 
658
                                raise
 
659
                    else:
 
660
                        try:
 
661
                            new_sha = repo.lookup_bzr_revision_id(revid)[0]
 
662
                        except errors.NoSuchRevision:
 
663
                            continue
 
664
                        else:
 
665
                            if not source.repository.has_revision(revid):
 
666
                                continue
 
667
                    ret[tag_name_to_ref(tagname)] = new_sha
 
668
            return ret
 
669
        with source_store.lock_read():
 
670
            def generate_pack_data(have, want, progress=None,
 
671
                                   ofs_delta=True):
 
672
                git_repo = getattr(source.repository, '_git', None)
 
673
                if git_repo:
 
674
                    shallow = git_repo.get_shallow()
 
675
                else:
 
676
                    shallow = None
 
677
                if lossy:
 
678
                    return source_store.generate_lossy_pack_data(
 
679
                        have, want, shallow=shallow,
 
680
                        progress=progress, ofs_delta=ofs_delta)
 
681
                elif shallow:
 
682
                    return source_store.generate_pack_data(
 
683
                        have, want, shallow=shallow,
 
684
                        progress=progress, ofs_delta=ofs_delta)
 
685
                else:
 
686
                    return source_store.generate_pack_data(
 
687
                        have, want, progress=progress, ofs_delta=ofs_delta)
 
688
            dw_result = self.send_pack(get_changed_refs, generate_pack_data)
 
689
            if not isinstance(dw_result, dict):
 
690
                new_refs = dw_result.refs
 
691
                error = dw_result.ref_status.get(actual_refname)
 
692
                if error:
 
693
                    raise RemoteGitError(error)
 
694
                for ref, error in dw_result.ref_status.items():
 
695
                    if error:
 
696
                        trace.warning('unable to open ref %s: %s',
 
697
                                      ref, error)
 
698
            else:  # dulwich < 0.20.4
 
699
                new_refs = dw_result
 
700
        push_result.new_revid = repo.lookup_foreign_revision_id(
 
701
            new_refs[actual_refname])
 
702
        if old_sha is not None:
 
703
            push_result.old_revid = repo.lookup_foreign_revision_id(old_sha)
 
704
        else:
 
705
            push_result.old_revid = NULL_REVISION
 
706
        if self._refs is not None:
 
707
            update_refs_container(self._refs, new_refs)
 
708
        push_result.target_branch = self.open_branch(name)
 
709
        if old_sha is not None:
 
710
            push_result.branch_push_result = GitBranchPushResult()
 
711
            push_result.branch_push_result.source_branch = source
 
712
            push_result.branch_push_result.target_branch = (
 
713
                push_result.target_branch)
 
714
            push_result.branch_push_result.local_branch = None
 
715
            push_result.branch_push_result.master_branch = (
 
716
                push_result.target_branch)
 
717
            push_result.branch_push_result.old_revid = push_result.old_revid
 
718
            push_result.branch_push_result.new_revid = push_result.new_revid
 
719
            push_result.branch_push_result.new_original_revid = (
 
720
                push_result.new_original_revid)
 
721
        if source.get_push_location() is None or remember:
 
722
            source.set_push_location(push_result.target_branch.base)
 
723
        return push_result
 
724
 
 
725
    def _find_commondir(self):
 
726
        # There is no way to find the commondir, if there is any.
 
727
        return self
 
728
 
222
729
 
223
730
class EmptyObjectStoreIterator(dict):
224
731
 
229
736
class TemporaryPackIterator(Pack):
230
737
 
231
738
    def __init__(self, path, resolve_ext_ref):
232
 
        super(TemporaryPackIterator, self).__init__(path)
233
 
        self.resolve_ext_ref = resolve_ext_ref
234
 
 
235
 
    @property
236
 
    def data(self):
237
 
        if self._data is None:
238
 
            self._data = ThinPackData(self.resolve_ext_ref, self._data_path)
239
 
        return self._data
240
 
 
241
 
    @property
242
 
    def index(self):
243
 
        if self._idx is None:
244
 
            if not os.path.exists(self._idx_path):
245
 
                pb = ui.ui_factory.nested_progress_bar()
246
 
                try:
247
 
                    def report_progress(cur, total):
248
 
                        pb.update("generating index", cur, total)
249
 
                    self.data.create_index(self._idx_path, 
250
 
                        progress=report_progress)
251
 
                finally:
252
 
                    pb.finished()
253
 
            self._idx = load_pack_index(self._idx_path)
254
 
        return self._idx
 
739
        super(TemporaryPackIterator, self).__init__(
 
740
            path, resolve_ext_ref=resolve_ext_ref)
 
741
        self._idx_load = lambda: self._idx_load_or_generate(self._idx_path)
 
742
 
 
743
    def _idx_load_or_generate(self, path):
 
744
        if not os.path.exists(path):
 
745
            with ui.ui_factory.nested_progress_bar() as pb:
 
746
                def report_progress(cur, total):
 
747
                    pb.update("generating index", cur, total)
 
748
                self.data.create_index(path, progress=report_progress)
 
749
        return load_pack_index(path)
255
750
 
256
751
    def __del__(self):
257
752
        if self._idx is not None:
262
757
            os.remove(self._data_path)
263
758
 
264
759
 
 
760
class BzrGitHttpClient(dulwich.client.HttpGitClient):
 
761
 
 
762
    def __init__(self, transport, *args, **kwargs):
 
763
        self.transport = transport
 
764
        url = urlutils.URL.from_string(transport.external_url())
 
765
        url.user = url.quoted_user = None
 
766
        url.password = url.quoted_password = None
 
767
        url = urlutils.strip_segment_parameters(str(url))
 
768
        super(BzrGitHttpClient, self).__init__(url, *args, **kwargs)
 
769
 
 
770
    def _http_request(self, url, headers=None, data=None,
 
771
                      allow_compression=False):
 
772
        """Perform HTTP request.
 
773
 
 
774
        :param url: Request URL.
 
775
        :param headers: Optional custom headers to override defaults.
 
776
        :param data: Request data.
 
777
        :param allow_compression: Allow GZipped communication.
 
778
        :return: Tuple (`response`, `read`), where response is an `urllib3`
 
779
            response object with additional `content_type` and
 
780
            `redirect_location` properties, and `read` is a consumable read
 
781
            method for the response data.
 
782
        """
 
783
        if is_github_url(url):
 
784
            headers['User-agent'] = user_agent_for_github()
 
785
        headers["Pragma"] = "no-cache"
 
786
        if allow_compression:
 
787
            headers["Accept-Encoding"] = "gzip"
 
788
        else:
 
789
            headers["Accept-Encoding"] = "identity"
 
790
 
 
791
        response = self.transport.request(
 
792
            ('GET' if data is None else 'POST'),
 
793
            url,
 
794
            body=data,
 
795
            headers=headers, retries=8)
 
796
 
 
797
        if response.status == 404:
 
798
            raise NotGitRepository()
 
799
        elif response.status != 200:
 
800
            raise GitProtocolError("unexpected http resp %d for %s" %
 
801
                                   (response.status, url))
 
802
 
 
803
        # TODO: Optimization available by adding `preload_content=False` to the
 
804
        # request and just passing the `read` method on instead of going via
 
805
        # `BytesIO`, if we can guarantee that the entire response is consumed
 
806
        # before issuing the next to still allow for connection reuse from the
 
807
        # pool.
 
808
        if response.getheader("Content-Encoding") == "gzip":
 
809
            read = gzip.GzipFile(fileobj=BytesIO(response.read())).read
 
810
        else:
 
811
            read = response.read
 
812
 
 
813
        class WrapResponse(object):
 
814
 
 
815
            def __init__(self, response):
 
816
                self._response = response
 
817
                self.status = response.status
 
818
                self.content_type = response.getheader("Content-Type")
 
819
                self.redirect_location = response._actual.geturl()
 
820
 
 
821
            def readlines(self):
 
822
                return self._response.readlines()
 
823
 
 
824
            def close(self):
 
825
                pass
 
826
 
 
827
        return WrapResponse(response), read
 
828
 
 
829
 
 
830
def _git_url_and_path_from_transport(external_url):
 
831
    url = urlutils.strip_segment_parameters(external_url)
 
832
    return urlparse.urlsplit(url)
 
833
 
 
834
 
 
835
class RemoteGitControlDirFormat(GitControlDirFormat):
 
836
    """The .git directory control format."""
 
837
 
 
838
    supports_workingtrees = False
 
839
 
 
840
    @classmethod
 
841
    def _known_formats(self):
 
842
        return set([RemoteGitControlDirFormat()])
 
843
 
 
844
    def get_branch_format(self):
 
845
        return RemoteGitBranchFormat()
 
846
 
 
847
    @property
 
848
    def repository_format(self):
 
849
        return GitRepositoryFormat()
 
850
 
 
851
    def is_initializable(self):
 
852
        return False
 
853
 
 
854
    def is_supported(self):
 
855
        return True
 
856
 
 
857
    def open(self, transport, _found=None):
 
858
        """Open this directory.
 
859
 
 
860
        """
 
861
        split_url = _git_url_and_path_from_transport(transport.external_url())
 
862
        if isinstance(transport, GitSmartTransport):
 
863
            client = transport._get_client()
 
864
        elif split_url.scheme in ("http", "https"):
 
865
            client = BzrGitHttpClient(transport)
 
866
        elif split_url.scheme in ('file', ):
 
867
            client = dulwich.client.LocalGitClient()
 
868
        else:
 
869
            raise NotBranchError(transport.base)
 
870
        if not _found:
 
871
            pass  # TODO(jelmer): Actually probe for something
 
872
        return RemoteGitDir(transport, self, client, split_url.path)
 
873
 
 
874
    def get_format_description(self):
 
875
        return "Remote Git Repository"
 
876
 
 
877
    def initialize_on_transport(self, transport):
 
878
        raise UninitializableFormat(self)
 
879
 
 
880
    def supports_transport(self, transport):
 
881
        try:
 
882
            external_url = transport.external_url()
 
883
        except InProcessTransport:
 
884
            raise NotBranchError(path=transport.base)
 
885
        return (external_url.startswith("http:")
 
886
                or external_url.startswith("https:")
 
887
                or external_url.startswith("git+")
 
888
                or external_url.startswith("git:"))
 
889
 
 
890
 
 
891
class GitRemoteRevisionTree(RevisionTree):
 
892
 
 
893
    def archive(self, format, name, root=None, subdir=None, force_mtime=None):
 
894
        """Create an archive of this tree.
 
895
 
 
896
        :param format: Format name (e.g. 'tar')
 
897
        :param name: target file name
 
898
        :param root: Root directory name (or None)
 
899
        :param subdir: Subdirectory to export (or None)
 
900
        :return: Iterator over archive chunks
 
901
        """
 
902
        commit = self._repository.lookup_bzr_revision_id(
 
903
            self.get_revision_id())[0]
 
904
        import tempfile
 
905
        f = tempfile.SpooledTemporaryFile()
 
906
        # git-upload-archive(1) generaly only supports refs. So let's see if we
 
907
        # can find one.
 
908
        reverse_refs = {
 
909
            v: k for (k, v) in
 
910
            self._repository.controldir.get_refs_container().as_dict().items()}
 
911
        try:
 
912
            committish = reverse_refs[commit]
 
913
        except KeyError:
 
914
            # No? Maybe the user has uploadArchive.allowUnreachable enabled.
 
915
            # Let's hope for the best.
 
916
            committish = commit
 
917
        self._repository.archive(
 
918
            format, committish, f.write,
 
919
            subdirs=([subdir] if subdir else None),
 
920
            prefix=(root + '/') if root else '')
 
921
        f.seek(0)
 
922
        return osutils.file_iterator(f)
 
923
 
 
924
    def is_versioned(self, path):
 
925
        raise GitSmartRemoteNotSupported(self.is_versioned, self)
 
926
 
 
927
    def has_filename(self, path):
 
928
        raise GitSmartRemoteNotSupported(self.has_filename, self)
 
929
 
 
930
    def get_file_text(self, path):
 
931
        raise GitSmartRemoteNotSupported(self.get_file_text, self)
 
932
 
 
933
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
934
        raise GitSmartRemoteNotSupported(self.list_files, self)
 
935
 
 
936
 
265
937
class RemoteGitRepository(GitRepository):
266
938
 
267
 
    def __init__(self, gitdir, lockfiles):
268
 
        GitRepository.__init__(self, gitdir, lockfiles)
269
 
        self._refs = None
270
 
 
271
 
    @property
272
 
    def inventories(self):
273
 
        raise GitSmartRemoteNotSupported()
274
 
 
275
 
    @property
276
 
    def revisions(self):
277
 
        raise GitSmartRemoteNotSupported()
278
 
 
279
 
    @property
280
 
    def texts(self):
281
 
        raise GitSmartRemoteNotSupported()
282
 
 
283
 
    def get_refs(self):
284
 
        if self._refs is not None:
285
 
            return self._refs
286
 
        self._refs = self.bzrdir.root_transport.fetch_pack(lambda x: [], None,
287
 
            lambda x: None, lambda x: trace.mutter("git: %s" % x))
288
 
        return self._refs
 
939
    supports_random_access = False
 
940
 
 
941
    @property
 
942
    def user_url(self):
 
943
        return self.control_url
 
944
 
 
945
    def get_parent_map(self, revids):
 
946
        raise GitSmartRemoteNotSupported(self.get_parent_map, self)
 
947
 
 
948
    def archive(self, *args, **kwargs):
 
949
        return self.controldir.archive(*args, **kwargs)
289
950
 
290
951
    def fetch_pack(self, determine_wants, graph_walker, pack_data,
291
952
                   progress=None):
292
 
        return self._transport.fetch_pack(determine_wants, graph_walker,
293
 
                                          pack_data, progress)
 
953
        return self.controldir.fetch_pack(
 
954
            determine_wants, graph_walker, pack_data, progress)
294
955
 
295
 
    def send_pack(self, get_changed_refs, generate_pack_contents):
296
 
        return self._transport.send_pack(get_changed_refs, generate_pack_contents)
 
956
    def send_pack(self, get_changed_refs, generate_pack_data):
 
957
        return self.controldir.send_pack(get_changed_refs, generate_pack_data)
297
958
 
298
959
    def fetch_objects(self, determine_wants, graph_walker, resolve_ext_ref,
299
960
                      progress=None):
 
961
        import tempfile
300
962
        fd, path = tempfile.mkstemp(suffix=".pack")
301
 
        self.fetch_pack(determine_wants, graph_walker,
302
 
            lambda x: os.write(fd, x), progress)
303
 
        os.close(fd)
 
963
        try:
 
964
            self.fetch_pack(determine_wants, graph_walker,
 
965
                            lambda x: os.write(fd, x), progress)
 
966
        finally:
 
967
            os.close(fd)
304
968
        if os.path.getsize(path) == 0:
305
969
            return EmptyObjectStoreIterator()
306
970
        return TemporaryPackIterator(path[:-len(".pack")], resolve_ext_ref)
307
971
 
308
 
    def lookup_bzr_revision_id(self, bzr_revid):
309
 
        # This won't work for any round-tripped bzr revisions, but it's a start..
 
972
    def lookup_bzr_revision_id(self, bzr_revid, mapping=None):
 
973
        # This won't work for any round-tripped bzr revisions, but it's a
 
974
        # start..
310
975
        try:
311
976
            return mapping_registry.revision_id_bzr_to_foreign(bzr_revid)
312
977
        except InvalidRevisionId:
321
986
        # Not really an easy way to parse foreign revids here..
322
987
        return mapping.revision_id_foreign_to_bzr(foreign_revid)
323
988
 
324
 
 
325
 
class RemoteGitTagDict(tag.BasicTags):
326
 
 
327
 
    def __init__(self, branch):
328
 
        self.branch = branch
329
 
        self.repository = branch.repository
330
 
 
331
 
    def get_tag_dict(self):
332
 
        tags = {}
333
 
        for k, v in extract_tags(self.repository.get_refs()).iteritems():
334
 
            tags[k] = self.branch.mapping.revision_id_foreign_to_bzr(v)
335
 
        return tags
 
989
    def revision_tree(self, revid):
 
990
        return GitRemoteRevisionTree(self, revid)
 
991
 
 
992
    def get_revisions(self, revids):
 
993
        raise GitSmartRemoteNotSupported(self.get_revisions, self)
 
994
 
 
995
    def has_revisions(self, revids):
 
996
        raise GitSmartRemoteNotSupported(self.get_revisions, self)
 
997
 
 
998
 
 
999
class RemoteGitTagDict(GitTags):
336
1000
 
337
1001
    def set_tag(self, name, revid):
338
 
        # FIXME: Not supported yet, should do a push of a new ref
339
 
        raise NotImplementedError(self.set_tag)
 
1002
        sha = self.branch.lookup_bzr_revision_id(revid)[0]
 
1003
        self._set_ref(name, sha)
 
1004
 
 
1005
    def delete_tag(self, name):
 
1006
        self._set_ref(name, dulwich.client.ZERO_SHA)
 
1007
 
 
1008
    def _set_ref(self, name, sha):
 
1009
        ref = tag_name_to_ref(name)
 
1010
 
 
1011
        def get_changed_refs(old_refs):
 
1012
            ret = {}
 
1013
            if sha == dulwich.client.ZERO_SHA and ref not in old_refs:
 
1014
                raise NoSuchTag(name)
 
1015
            ret[ref] = sha
 
1016
            return ret
 
1017
 
 
1018
        def generate_pack_data(have, want, ofs_delta=False):
 
1019
            return pack_objects_to_data([])
 
1020
        result = self.repository.send_pack(
 
1021
            get_changed_refs, generate_pack_data)
 
1022
        if result and not isinstance(result, dict):
 
1023
            error = result.ref_status.get(ref)
 
1024
            if error:
 
1025
                raise RemoteGitError(error)
340
1026
 
341
1027
 
342
1028
class RemoteGitBranch(GitBranch):
343
1029
 
344
 
    def __init__(self, bzrdir, repository, name, lockfiles):
 
1030
    def __init__(self, controldir, repository, name):
345
1031
        self._sha = None
346
 
        super(RemoteGitBranch, self).__init__(bzrdir, repository, name,
347
 
                lockfiles)
348
 
 
349
 
    def revision_history(self):
350
 
        raise GitSmartRemoteNotSupported()
 
1032
        super(RemoteGitBranch, self).__init__(controldir, repository, name,
 
1033
                                              RemoteGitBranchFormat())
 
1034
 
 
1035
    def last_revision_info(self):
 
1036
        raise GitSmartRemoteNotSupported(self.last_revision_info, self)
 
1037
 
 
1038
    @property
 
1039
    def user_url(self):
 
1040
        return self.control_url
 
1041
 
 
1042
    @property
 
1043
    def control_url(self):
 
1044
        return self.base
 
1045
 
 
1046
    def revision_id_to_revno(self, revision_id):
 
1047
        raise GitSmartRemoteNotSupported(self.revision_id_to_revno, self)
351
1048
 
352
1049
    def last_revision(self):
353
1050
        return self.lookup_foreign_revision_id(self.head)
354
1051
 
355
 
    def _get_config(self):
356
 
        class EmptyConfig(object):
357
 
 
358
 
            def _get_configobj(self):
359
 
                return config.ConfigObj()
360
 
 
361
 
        return EmptyConfig()
362
 
 
363
1052
    @property
364
1053
    def head(self):
365
1054
        if self._sha is not None:
366
1055
            return self._sha
367
 
        heads = self.repository.get_refs()
368
 
        name = self.bzrdir._branch_name_to_ref(self.name, "HEAD")
369
 
        if name in heads:
370
 
            self._sha = heads[name]
371
 
        else:
372
 
            raise NoSuchRef(self.name)
 
1056
        refs = self.controldir.get_refs_container()
 
1057
        name = branch_name_to_ref(self.name)
 
1058
        try:
 
1059
            self._sha = refs[name]
 
1060
        except KeyError:
 
1061
            raise NoSuchRef(name, self.repository.user_url, refs)
373
1062
        return self._sha
374
1063
 
375
1064
    def _synchronize_history(self, destination, revision_id):
376
1065
        """See Branch._synchronize_history()."""
377
 
        destination.generate_revision_history(self.last_revision())
 
1066
        if revision_id is None:
 
1067
            revision_id = self.last_revision()
 
1068
        destination.generate_revision_history(revision_id)
 
1069
 
 
1070
    def _get_parent_location(self):
 
1071
        return None
378
1072
 
379
1073
    def get_push_location(self):
380
1074
        return None
381
1075
 
382
1076
    def set_push_location(self, url):
383
1077
        pass
 
1078
 
 
1079
    def _iter_tag_refs(self):
 
1080
        """Iterate over the tag refs.
 
1081
 
 
1082
        :param refs: Refs dictionary (name -> git sha1)
 
1083
        :return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
 
1084
        """
 
1085
        refs = self.controldir.get_refs_container()
 
1086
        for ref_name, unpeeled in refs.as_dict().items():
 
1087
            try:
 
1088
                tag_name = ref_to_tag_name(ref_name)
 
1089
            except (ValueError, UnicodeDecodeError):
 
1090
                continue
 
1091
            peeled = refs.get_peeled(ref_name)
 
1092
            if peeled is None:
 
1093
                # Let's just hope it's a commit
 
1094
                peeled = unpeeled
 
1095
            if not isinstance(tag_name, text_type):
 
1096
                raise TypeError(tag_name)
 
1097
            yield (ref_name, tag_name, peeled, unpeeled)
 
1098
 
 
1099
    def set_last_revision_info(self, revno, revid):
 
1100
        self.generate_revision_history(revid)
 
1101
 
 
1102
    def generate_revision_history(self, revision_id, last_rev=None,
 
1103
                                  other_branch=None):
 
1104
        sha = self.lookup_bzr_revision_id(revision_id)[0]
 
1105
        def get_changed_refs(old_refs):
 
1106
            return {self.ref: sha}
 
1107
        def generate_pack_data(have, want, ofs_delta=False):
 
1108
            return pack_objects_to_data([])
 
1109
        result = self.repository.send_pack(
 
1110
            get_changed_refs, generate_pack_data)
 
1111
        if result is not None and not isinstance(result, dict):
 
1112
            error = result.ref_status.get(self.ref)
 
1113
            if error:
 
1114
                raise RemoteGitError(error)
 
1115
        self._sha = sha
 
1116
 
 
1117
 
 
1118
def remote_refs_dict_to_container(refs_dict, symrefs_dict={}):
 
1119
    base = {}
 
1120
    peeled = {}
 
1121
    for k, v in refs_dict.items():
 
1122
        if is_peeled(k):
 
1123
            peeled[k[:-3]] = v
 
1124
        else:
 
1125
            base[k] = v
 
1126
    for name, target in symrefs_dict.items():
 
1127
        base[name] = SYMREF + target
 
1128
    ret = DictRefsContainer(base)
 
1129
    ret._peeled = peeled
 
1130
    return ret
 
1131
 
 
1132
 
 
1133
def update_refs_container(container, refs_dict):
 
1134
    peeled = {}
 
1135
    base = {}
 
1136
    for k, v in refs_dict.items():
 
1137
        if is_peeled(k):
 
1138
            peeled[k[:-3]] = v
 
1139
        else:
 
1140
            base[k] = v
 
1141
    container._peeled = peeled
 
1142
    container._refs.update(base)