/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: Vincent Ladeuil
  • Date: 2019-11-19 17:16:42 UTC
  • mto: (7290.1.43 work)
  • mto: This revision was merged to the branch mainline in revision 7414.
  • Revision ID: v.ladeuil+brz@free.fr-20191119171642-2hn0o07eq32l4sfs
Open 3.0.3 for bugfixes.

Show diffs side-by-side

added added

removed removed

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