/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/plugins/git/remote.py

  • Committer: Jelmer Vernooij
  • Date: 2018-05-19 13:16:11 UTC
  • mto: (6968.4.3 git-archive)
  • mto: This revision was merged to the branch mainline in revision 6972.
  • Revision ID: jelmer@jelmer.uk-20180519131611-l9h9ud41j7qg1m03
Move tar/zip to breezy.archive.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/plugins/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 re
 
22
 
 
23
from ... import (
18
24
    config,
19
25
    debug,
20
 
    tag,
 
26
    errors,
21
27
    trace,
22
28
    ui,
23
29
    urlutils,
24
30
    )
25
 
from bzrlib.errors import (
 
31
from ...push import (
 
32
    PushResult,
 
33
    )
 
34
from ...errors import (
 
35
    AlreadyBranchError,
26
36
    BzrError,
 
37
    DivergedBranches,
 
38
    InProcessTransport,
27
39
    InvalidRevisionId,
28
40
    NoSuchFile,
29
41
    NoSuchRevision,
 
42
    NoSuchTag,
 
43
    NotBranchError,
30
44
    NotLocalUrl,
 
45
    NoWorkingTree,
 
46
    UninitializableFormat,
31
47
    )
32
 
from bzrlib.transport import (
 
48
from ...transport import (
33
49
    Transport,
 
50
    register_urlparse_netloc_protocol,
34
51
    )
35
52
 
36
 
from bzrlib.plugins.git import (
 
53
from . import (
37
54
    lazy_check_versions,
 
55
    user_agent_for_github,
38
56
    )
39
57
lazy_check_versions()
40
58
 
41
 
from bzrlib.plugins.git.branch import (
 
59
from .branch import (
42
60
    GitBranch,
43
 
    )
44
 
from bzrlib.plugins.git.errors import (
 
61
    GitBranchFormat,
 
62
    GitBranchPushResult,
 
63
    GitTags,
 
64
    _quick_lookup_revno,
 
65
    )
 
66
from .dir import (
 
67
    GitControlDirFormat,
 
68
    GitDir,
 
69
    BareLocalGitControlDirFormat,
 
70
    )
 
71
from .errors import (
45
72
    GitSmartRemoteNotSupported,
46
73
    NoSuchRef,
47
74
    )
48
 
from bzrlib.plugins.git.dir import (
49
 
    GitDir,
50
 
    )
51
 
from bzrlib.plugins.git.mapping import (
 
75
from .mapping import (
52
76
    mapping_registry,
53
77
    )
54
 
from bzrlib.plugins.git.repository import (
 
78
from .object_store import (
 
79
    get_object_store,
 
80
    )
 
81
from .push import (
 
82
    remote_divergence,
 
83
    )
 
84
from .repository import (
55
85
    GitRepository,
56
86
    )
57
 
from bzrlib.plugins.git.refs import (
58
 
    extract_tags,
 
87
from .refs import (
59
88
    branch_name_to_ref,
 
89
    is_peeled,
 
90
    ref_to_tag_name,
 
91
    tag_name_to_ref,
60
92
    )
61
93
 
62
 
import dulwich as git
 
94
import dulwich
 
95
import dulwich.client
63
96
from dulwich.errors import (
64
97
    GitProtocolError,
65
98
    )
66
99
from dulwich.pack import (
67
100
    Pack,
68
 
    ThinPackData,
 
101
    pack_objects_to_data,
 
102
    )
 
103
from dulwich.protocol import ZERO_SHA
 
104
from dulwich.refs import (
 
105
    DictRefsContainer,
 
106
    SYMREF,
 
107
    )
 
108
from dulwich.repo import (
 
109
    NotGitRepository,
69
110
    )
70
111
import os
 
112
import select
71
113
import tempfile
72
114
import urllib
73
 
import urlparse
74
 
urlparse.uses_netloc.extend(['git', 'git+ssh'])
 
115
 
 
116
try:
 
117
    import urllib.parse as urlparse
 
118
    from urllib.parse import splituser, splitnport
 
119
except ImportError:
 
120
    import urlparse
 
121
    from urllib import splituser, splitnport
 
122
 
 
123
# urlparse only supports a limited number of schemes by default
 
124
register_urlparse_netloc_protocol('git')
 
125
register_urlparse_netloc_protocol('git+ssh')
75
126
 
76
127
from dulwich.pack import load_pack_index
77
128
 
78
129
 
 
130
class GitPushResult(PushResult):
 
131
 
 
132
    def _lookup_revno(self, revid):
 
133
        try:
 
134
            return _quick_lookup_revno(self.source_branch, self.target_branch,
 
135
                revid)
 
136
        except GitSmartRemoteNotSupported:
 
137
            return None
 
138
 
 
139
    @property
 
140
    def old_revno(self):
 
141
        return self._lookup_revno(self.old_revid)
 
142
 
 
143
    @property
 
144
    def new_revno(self):
 
145
        return self._lookup_revno(self.new_revid)
 
146
 
 
147
 
79
148
# Don't run any tests on GitSmartTransport as it is not intended to be
80
149
# a full implementation of Transport
81
150
def get_test_permutations():
89
158
    :return: Tuple with host, port, username, path.
90
159
    """
91
160
    (scheme, netloc, loc, _, _) = urlparse.urlsplit(url)
92
 
    path = urllib.unquote(loc)
 
161
    path = urlparse.unquote(loc)
93
162
    if path.startswith("/~"):
94
163
        path = path[1:]
95
 
    (username, hostport) = urllib.splituser(netloc)
96
 
    (host, port) = urllib.splitnport(hostport, None)
 
164
    (username, hostport) = splituser(netloc)
 
165
    (host, port) = splitnport(hostport, None)
97
166
    return (host, port, username, path)
98
167
 
99
168
 
 
169
class RemoteGitError(BzrError):
 
170
 
 
171
    _fmt = "Remote server error: %(msg)s"
 
172
 
 
173
 
 
174
def parse_git_error(url, message):
 
175
    """Parse a remote git server error and return a bzr exception.
 
176
 
 
177
    :param url: URL of the remote repository
 
178
    :param message: Message sent by the remote git server
 
179
    """
 
180
    message = str(message).strip()
 
181
    if message.startswith("Could not find Repository "):
 
182
        return NotBranchError(url, message)
 
183
    if message == "HEAD failed to update":
 
184
        base_url, _ = urlutils.split_segment_parameters(url)
 
185
        raise BzrError(
 
186
            ("Unable to update remote HEAD branch. To update the master "
 
187
             "branch, specify the URL %s,branch=master.") % base_url)
 
188
    # Don't know, just return it to the user as-is
 
189
    return RemoteGitError(message)
 
190
 
 
191
 
100
192
class GitSmartTransport(Transport):
101
193
 
102
194
    def __init__(self, url, _client=None):
107
199
            trace.mutter('host: %r, user: %r, port: %r, path: %r',
108
200
                         self._host, self._username, self._port, self._path)
109
201
        self._client = _client
 
202
        self._stripped_path = self._path.rsplit(",", 1)[0]
110
203
 
111
204
    def external_url(self):
112
205
        return self.base
114
207
    def has(self, relpath):
115
208
        return False
116
209
 
117
 
    def _get_client(self, thin_packs):
 
210
    def _get_client(self):
118
211
        raise NotImplementedError(self._get_client)
119
212
 
120
213
    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)
 
214
        return self._stripped_path
141
215
 
142
216
    def get(self, path):
143
217
        raise NoSuchFile(path)
159
233
 
160
234
    _scheme = 'git'
161
235
 
162
 
    def _get_client(self, thin_packs):
 
236
    def _get_client(self):
163
237
        if self._client is not None:
164
238
            ret = self._client
165
239
            self._client = None
166
240
            return ret
167
 
        return git.client.TCPGitClient(self._host, self._port,
168
 
            thin_packs=thin_packs, report_activity=self._report_activity)
 
241
        if self._host == '':
 
242
            # return dulwich.client.LocalGitClient()
 
243
            return dulwich.client.SubprocessGitClient()
 
244
        return dulwich.client.TCPGitClient(self._host, self._port,
 
245
            report_activity=self._report_activity)
 
246
 
 
247
 
 
248
class SSHSocketWrapper(object):
 
249
 
 
250
    def __init__(self, sock):
 
251
        self.sock = sock
 
252
 
 
253
    def read(self, len=None):
 
254
        return self.sock.recv(len)
 
255
 
 
256
    def write(self, data):
 
257
        return self.sock.write(data)
 
258
 
 
259
    def can_read(self):
 
260
        return len(select.select([self.sock.fileno()], [], [], 0)[0]) > 0
 
261
 
 
262
 
 
263
class DulwichSSHVendor(dulwich.client.SSHVendor):
 
264
 
 
265
    def __init__(self):
 
266
        from ...transport import ssh
 
267
        self.bzr_ssh_vendor = ssh._get_ssh_vendor()
 
268
 
 
269
    def run_command(self, host, command, username=None, port=None):
 
270
        connection = self.bzr_ssh_vendor.connect_ssh(username=username,
 
271
            password=None, port=port, host=host, command=command)
 
272
        (kind, io_object) = connection.get_sock_or_pipes()
 
273
        if kind == 'socket':
 
274
            return SSHSocketWrapper(io_object)
 
275
        else:
 
276
            raise AssertionError("Unknown io object kind %r'" % kind)
 
277
 
 
278
 
 
279
#dulwich.client.get_ssh_vendor = DulwichSSHVendor
169
280
 
170
281
 
171
282
class SSHGitSmartTransport(GitSmartTransport):
173
284
    _scheme = 'git+ssh'
174
285
 
175
286
    def _get_path(self):
176
 
        if self._path.startswith("/~/"):
177
 
            return self._path[3:]
178
 
        return self._path
 
287
        path = self._stripped_path
 
288
        if path.startswith("/~/"):
 
289
            return path[3:]
 
290
        return path
179
291
 
180
 
    def _get_client(self, thin_packs):
 
292
    def _get_client(self):
181
293
        if self._client is not None:
182
294
            ret = self._client
183
295
            self._client = None
184
296
            return ret
185
297
        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)
 
298
        client = dulwich.client.SSHGitClient(self._host, self._port, self._username,
 
299
            report_activity=self._report_activity)
188
300
        # Set up alternate pack program paths
189
301
        upload_pack = location_config.get_user_option('git_upload_pack')
190
302
        if upload_pack:
195
307
        return client
196
308
 
197
309
 
 
310
class RemoteGitBranchFormat(GitBranchFormat):
 
311
 
 
312
    def get_format_description(self):
 
313
        return 'Remote Git Branch'
 
314
 
 
315
    @property
 
316
    def _matchingcontroldir(self):
 
317
        return RemoteGitControlDirFormat()
 
318
 
 
319
    def initialize(self, a_controldir, name=None, repository=None,
 
320
                   append_revisions_only=None):
 
321
        raise UninitializableFormat(self)
 
322
 
 
323
 
 
324
class DefaultProgressReporter(object):
 
325
 
 
326
    _GIT_PROGRESS_PARTIAL_RE = re.compile(r"(.*?): +(\d+)% \((\d+)/(\d+)\)")
 
327
    _GIT_PROGRESS_TOTAL_RE = re.compile(r"(.*?): (\d+)")
 
328
 
 
329
    def __init__(self, pb):
 
330
        self.pb = pb
 
331
 
 
332
    def progress(self, text):
 
333
        text = text.rstrip("\r\n")
 
334
        if text.startswith('error: '):
 
335
            trace.show_error('git: %s', text[len('error: '):])
 
336
        else:
 
337
            trace.mutter("git: %s", text)
 
338
            g = self._GIT_PROGRESS_PARTIAL_RE.match(text)
 
339
            if g is not None:
 
340
                (text, pct, current, total) = g.groups()
 
341
                self.pb.update(text, int(current), int(total))
 
342
            else:
 
343
                g = self._GIT_PROGRESS_TOTAL_RE.match(text)
 
344
                if g is not None:
 
345
                    (text, total) = g.groups()
 
346
                    self.pb.update(text, None, int(total))
 
347
                else:
 
348
                    trace.note("%s", text)
 
349
 
 
350
 
198
351
class RemoteGitDir(GitDir):
199
352
 
200
 
    def __init__(self, transport, lockfiles, format):
 
353
    def __init__(self, transport, format, client, client_path):
201
354
        self._format = format
202
355
        self.root_transport = transport
203
356
        self.transport = transport
204
 
        self._lockfiles = lockfiles
205
357
        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)
 
358
        self._client = client
 
359
        self._client_path = client_path
 
360
        self.base = self.root_transport.base
 
361
        self._refs = None
 
362
 
 
363
    @property
 
364
    def _gitrepository_class(self):
 
365
        return RemoteGitRepository
 
366
 
 
367
    def fetch_pack(self, determine_wants, graph_walker, pack_data, progress=None):
 
368
        if progress is None:
 
369
            pb = ui.ui_factory.nested_progress_bar()
 
370
            progress = DefaultProgressReporter(pb).progress
 
371
        else:
 
372
            pb = None
 
373
        try:
 
374
            result = self._client.fetch_pack(self._client_path, determine_wants,
 
375
                graph_walker, pack_data, progress)
 
376
            if result.refs is None:
 
377
                result.refs = {}
 
378
            self._refs = remote_refs_dict_to_container(result.refs, result.symrefs)
 
379
            return result
 
380
        except GitProtocolError as e:
 
381
            raise parse_git_error(self.transport.external_url(), e)
 
382
        finally:
 
383
            if pb is not None:
 
384
                pb.finished()
 
385
 
 
386
    def send_pack(self, get_changed_refs, generate_pack_data, progress=None):
 
387
        if progress is None:
 
388
            pb = ui.ui_factory.nested_progress_bar()
 
389
            progress = DefaultProgressReporter(pb).progress
 
390
        else:
 
391
            pb = None
 
392
        def get_changed_refs_wrapper(refs):
 
393
            # TODO(jelmer): This drops symref information
 
394
            self._refs = remote_refs_dict_to_container(refs)
 
395
            return get_changed_refs(refs)
 
396
        try:
 
397
            return self._client.send_pack(self._client_path,
 
398
                    get_changed_refs_wrapper, generate_pack_data, progress)
 
399
        except GitProtocolError as e:
 
400
            raise parse_git_error(self.transport.external_url(), e)
 
401
        finally:
 
402
            if pb is not None:
 
403
                pb.finished()
 
404
 
 
405
    def create_branch(self, name=None, repository=None,
 
406
                      append_revisions_only=None, ref=None):
 
407
        refname = self._get_selected_ref(name, ref)
 
408
        if refname != b'HEAD' and refname in self.get_refs_container():
 
409
            raise AlreadyBranchError(self.user_url)
 
410
        if refname in self.get_refs_container():
 
411
            ref_chain, unused_sha = self.get_refs_container().follow(self._get_selected_ref(None))
 
412
            if ref_chain[0] == b'HEAD':
 
413
                refname = ref_chain[1]
 
414
        repo = self.open_repository()
 
415
        return RemoteGitBranch(self, repo, refname)
 
416
 
 
417
    def destroy_branch(self, name=None):
 
418
        refname = self._get_selected_ref(name)
 
419
        def get_changed_refs(old_refs):
 
420
            ret = dict(old_refs)
 
421
            if not refname in ret:
 
422
                raise NotBranchError(self.user_url)
 
423
            ret[refname] = dulwich.client.ZERO_SHA
 
424
            return ret
 
425
        def generate_pack_data(have, want, ofs_delta=False):
 
426
            return pack_objects_to_data([])
 
427
        self.send_pack(get_changed_refs, generate_pack_data)
 
428
 
 
429
    @property
 
430
    def user_url(self):
 
431
        return self.control_url
 
432
 
 
433
    @property
 
434
    def user_transport(self):
 
435
        return self.root_transport
 
436
 
 
437
    @property
 
438
    def control_url(self):
 
439
        return self.control_transport.base
 
440
 
 
441
    @property
 
442
    def control_transport(self):
 
443
        return self.root_transport
209
444
 
210
445
    def open_repository(self):
211
 
        return RemoteGitRepository(self, self._lockfiles)
 
446
        return RemoteGitRepository(self)
212
447
 
213
 
    def _open_branch(self, name=None, ignore_fallbacks=False, 
214
 
                    unsupported=False):
 
448
    def open_branch(self, name=None, unsupported=False,
 
449
            ignore_fallbacks=False, ref=None, possible_transports=None,
 
450
            nascent_ok=False):
215
451
        repo = self.open_repository()
216
 
        refname = self._branch_name_to_ref(name)
217
 
        return RemoteGitBranch(self, repo, refname, self._lockfiles)
 
452
        ref = self._get_selected_ref(name, ref)
 
453
        if not nascent_ok and ref not in self.get_refs_container():
 
454
            raise NotBranchError(self.root_transport.base,
 
455
                    controldir=self)
 
456
        ref_chain, unused_sha = self.get_refs_container().follow(ref)
 
457
        return RemoteGitBranch(self, repo, ref_chain[-1])
218
458
 
219
459
    def open_workingtree(self, recommend_upgrade=False):
220
460
        raise NotLocalUrl(self.transport.base)
221
461
 
 
462
    def has_workingtree(self):
 
463
        return False
 
464
 
 
465
    def get_peeled(self, name):
 
466
        return self.get_refs_container().get_peeled(name)
 
467
 
 
468
    def get_refs_container(self):
 
469
        if self._refs is not None:
 
470
            return self._refs
 
471
        result = self.fetch_pack(lambda x: None, None,
 
472
            lambda x: None, lambda x: trace.mutter("git: %s" % x))
 
473
        self._refs = remote_refs_dict_to_container(
 
474
                result.refs, result.symrefs)
 
475
        return self._refs
 
476
 
 
477
    def push_branch(self, source, revision_id=None, overwrite=False,
 
478
                    remember=False, create_prefix=False, lossy=False,
 
479
                    name=None):
 
480
        """Push the source branch into this ControlDir."""
 
481
        if revision_id is None:
 
482
            # No revision supplied by the user, default to the branch
 
483
            # revision
 
484
            revision_id = source.last_revision()
 
485
 
 
486
        push_result = GitPushResult()
 
487
        push_result.workingtree_updated = None
 
488
        push_result.master_branch = None
 
489
        push_result.source_branch = source
 
490
        push_result.stacked_on = None
 
491
        push_result.branch_push_result = None
 
492
        repo = self.find_repository()
 
493
        refname = self._get_selected_ref(name)
 
494
        if isinstance(source, GitBranch) and lossy:
 
495
            raise errors.LossyPushToSameVCS(source.controldir, self)
 
496
        source_store = get_object_store(source.repository)
 
497
        with source_store.lock_read():
 
498
            def get_changed_refs(refs):
 
499
                self._refs = remote_refs_dict_to_container(refs)
 
500
                ret = dict(refs)
 
501
                # TODO(jelmer): Unpeel if necessary
 
502
                push_result.new_original_revid = revision_id
 
503
                if lossy:
 
504
                    new_sha = source_store._lookup_revision_sha1(revision_id)
 
505
                else:
 
506
                    new_sha = repo.lookup_bzr_revision_id(revision_id)[0]
 
507
                if not overwrite:
 
508
                    if remote_divergence(ret.get(refname), new_sha, source_store):
 
509
                        raise DivergedBranches(
 
510
                                source, self.open_branch(name, nascent_ok=True))
 
511
                ret[refname] = new_sha
 
512
                return ret
 
513
            if lossy:
 
514
                generate_pack_data = source_store.generate_lossy_pack_data
 
515
            else:
 
516
                generate_pack_data = source_store.generate_pack_data
 
517
            new_refs = self.send_pack(get_changed_refs, generate_pack_data)
 
518
        push_result.new_revid = repo.lookup_foreign_revision_id(
 
519
                new_refs[refname])
 
520
        try:
 
521
            old_remote = self._refs[refname]
 
522
        except KeyError:
 
523
            old_remote = ZERO_SHA
 
524
        push_result.old_revid = repo.lookup_foreign_revision_id(old_remote)
 
525
        self._refs = remote_refs_dict_to_container(new_refs)
 
526
        push_result.target_branch = self.open_branch(name)
 
527
        if old_remote != ZERO_SHA:
 
528
            push_result.branch_push_result = GitBranchPushResult()
 
529
            push_result.branch_push_result.source_branch = source
 
530
            push_result.branch_push_result.target_branch = push_result.target_branch
 
531
            push_result.branch_push_result.local_branch = None
 
532
            push_result.branch_push_result.master_branch = push_result.target_branch
 
533
            push_result.branch_push_result.old_revid = push_result.old_revid
 
534
            push_result.branch_push_result.new_revid = push_result.new_revid
 
535
            push_result.branch_push_result.new_original_revid = push_result.new_original_revid
 
536
        if source.get_push_location() is None or remember:
 
537
            source.set_push_location(push_result.target_branch.base)
 
538
        return push_result
 
539
 
 
540
    def _find_commondir(self):
 
541
        # There is no way to find the commondir, if there is any.
 
542
        return self
 
543
 
222
544
 
223
545
class EmptyObjectStoreIterator(dict):
224
546
 
229
551
class TemporaryPackIterator(Pack):
230
552
 
231
553
    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
 
554
        super(TemporaryPackIterator, self).__init__(
 
555
            path, resolve_ext_ref=resolve_ext_ref)
 
556
        self._idx_load = lambda: self._idx_load_or_generate(self._idx_path)
 
557
 
 
558
    def _idx_load_or_generate(self, path):
 
559
        if not os.path.exists(path):
 
560
            pb = ui.ui_factory.nested_progress_bar()
 
561
            try:
 
562
                def report_progress(cur, total):
 
563
                    pb.update("generating index", cur, total)
 
564
                self.data.create_index(path,
 
565
                    progress=report_progress)
 
566
            finally:
 
567
                pb.finished()
 
568
        return load_pack_index(path)
255
569
 
256
570
    def __del__(self):
257
571
        if self._idx is not None:
262
576
            os.remove(self._data_path)
263
577
 
264
578
 
 
579
class BzrGitHttpClient(dulwich.client.HttpGitClient):
 
580
 
 
581
    def __init__(self, transport, *args, **kwargs):
 
582
        self.transport = transport
 
583
        super(BzrGitHttpClient, self).__init__(transport.external_url(), *args, **kwargs)
 
584
 
 
585
    def _http_request(self, url, headers=None, data=None,
 
586
                      allow_compression=False):
 
587
        """Perform HTTP request.
 
588
 
 
589
        :param url: Request URL.
 
590
        :param headers: Optional custom headers to override defaults.
 
591
        :param data: Request data.
 
592
        :param allow_compression: Allow GZipped communication.
 
593
        :return: Tuple (`response`, `read`), where response is an `urllib3`
 
594
            response object with additional `content_type` and
 
595
            `redirect_location` properties, and `read` is a consumable read
 
596
            method for the response data.
 
597
        """
 
598
        from breezy.transport.http._urllib2_wrappers import Request
 
599
        headers['User-agent'] = user_agent_for_github()
 
600
        headers["Pragma"] = "no-cache"
 
601
        if allow_compression:
 
602
            headers["Accept-Encoding"] = "gzip"
 
603
        else:
 
604
            headers["Accept-Encoding"] = "identity"
 
605
 
 
606
        request = Request(
 
607
            ('GET' if data is None else 'POST'),
 
608
            url, data, headers,
 
609
            accepted_errors=[200, 404])
 
610
 
 
611
        response = self.transport._perform(request)
 
612
 
 
613
        if response.code == 404:
 
614
            raise NotGitRepository()
 
615
        elif response.code != 200:
 
616
            raise GitProtocolError("unexpected http resp %d for %s" %
 
617
                                   (response.code, url))
 
618
 
 
619
        # TODO: Optimization available by adding `preload_content=False` to the
 
620
        # request and just passing the `read` method on instead of going via
 
621
        # `BytesIO`, if we can guarantee that the entire response is consumed
 
622
        # before issuing the next to still allow for connection reuse from the
 
623
        # pool.
 
624
        if response.getheader("Content-Encoding") == "gzip":
 
625
            read = gzip.GzipFile(fileobj=response).read
 
626
        else:
 
627
            read = response.read
 
628
 
 
629
        class WrapResponse(object):
 
630
 
 
631
            def __init__(self, response):
 
632
                self._response = response
 
633
                self.status = response.code
 
634
                self.content_type = response.getheader("Content-Type")
 
635
                self.redirect_location = response.geturl()
 
636
 
 
637
            def close(self):
 
638
                self._response.close()
 
639
 
 
640
        return WrapResponse(response), read
 
641
 
 
642
 
 
643
class RemoteGitControlDirFormat(GitControlDirFormat):
 
644
    """The .git directory control format."""
 
645
 
 
646
    supports_workingtrees = False
 
647
 
 
648
    @classmethod
 
649
    def _known_formats(self):
 
650
        return set([RemoteGitControlDirFormat()])
 
651
 
 
652
    def get_branch_format(self):
 
653
        return RemoteGitBranchFormat()
 
654
 
 
655
    def is_initializable(self):
 
656
        return False
 
657
 
 
658
    def is_supported(self):
 
659
        return True
 
660
 
 
661
    def open(self, transport, _found=None):
 
662
        """Open this directory.
 
663
 
 
664
        """
 
665
        # we dont grok readonly - git isn't integrated with transport.
 
666
        url = transport.base
 
667
        if url.startswith('readonly+'):
 
668
            url = url[len('readonly+'):]
 
669
        scheme = urlparse.urlsplit(transport.external_url())[0]
 
670
        if isinstance(transport, GitSmartTransport):
 
671
            client = transport._get_client()
 
672
            client_path = transport._get_path()
 
673
        elif scheme in ("http", "https"):
 
674
            client = BzrGitHttpClient(transport)
 
675
            client_path, _ = urlutils.split_segment_parameters(transport._path)
 
676
        elif scheme == 'file':
 
677
            client = dulwich.client.LocalGitClient()
 
678
            client_path = transport.local_abspath('.')
 
679
        else:
 
680
            raise NotBranchError(transport.base)
 
681
        if not _found:
 
682
            pass # TODO(jelmer): Actually probe for something
 
683
        return RemoteGitDir(transport, self, client, client_path)
 
684
 
 
685
    def get_format_description(self):
 
686
        return "Remote Git Repository"
 
687
 
 
688
    def initialize_on_transport(self, transport):
 
689
        raise UninitializableFormat(self)
 
690
 
 
691
    def supports_transport(self, transport):
 
692
        try:
 
693
            external_url = transport.external_url()
 
694
        except InProcessTransport:
 
695
            raise NotBranchError(path=transport.base)
 
696
        return (external_url.startswith("http:") or
 
697
                external_url.startswith("https:") or
 
698
                external_url.startswith("git+") or
 
699
                external_url.startswith("git:"))
 
700
 
 
701
 
265
702
class RemoteGitRepository(GitRepository):
266
703
 
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
 
704
    @property
 
705
    def user_url(self):
 
706
        return self.control_url
 
707
 
 
708
    def get_parent_map(self, revids):
 
709
        raise GitSmartRemoteNotSupported(self.get_parent_map, self)
289
710
 
290
711
    def fetch_pack(self, determine_wants, graph_walker, pack_data,
291
712
                   progress=None):
292
 
        return self._transport.fetch_pack(determine_wants, graph_walker,
 
713
        return self.controldir.fetch_pack(determine_wants, graph_walker,
293
714
                                          pack_data, progress)
294
715
 
295
 
    def send_pack(self, get_changed_refs, generate_pack_contents):
296
 
        return self._transport.send_pack(get_changed_refs, generate_pack_contents)
 
716
    def send_pack(self, get_changed_refs, generate_pack_data):
 
717
        return self.controldir.send_pack(get_changed_refs, generate_pack_data)
297
718
 
298
719
    def fetch_objects(self, determine_wants, graph_walker, resolve_ext_ref,
299
720
                      progress=None):
300
721
        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)
 
722
        try:
 
723
            self.fetch_pack(determine_wants, graph_walker,
 
724
                lambda x: os.write(fd, x), progress)
 
725
        finally:
 
726
            os.close(fd)
304
727
        if os.path.getsize(path) == 0:
305
728
            return EmptyObjectStoreIterator()
306
729
        return TemporaryPackIterator(path[:-len(".pack")], resolve_ext_ref)
307
730
 
308
 
    def lookup_bzr_revision_id(self, bzr_revid):
 
731
    def lookup_bzr_revision_id(self, bzr_revid, mapping=None):
309
732
        # This won't work for any round-tripped bzr revisions, but it's a start..
310
733
        try:
311
734
            return mapping_registry.revision_id_bzr_to_foreign(bzr_revid)
321
744
        # Not really an easy way to parse foreign revids here..
322
745
        return mapping.revision_id_foreign_to_bzr(foreign_revid)
323
746
 
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
 
747
    def revision_tree(self, revid):
 
748
        raise GitSmartRemoteNotSupported(self.revision_tree, self)
 
749
 
 
750
    def get_revisions(self, revids):
 
751
        raise GitSmartRemoteNotSupported(self.get_revisions, self)
 
752
 
 
753
    def has_revisions(self, revids):
 
754
        raise GitSmartRemoteNotSupported(self.get_revisions, self)
 
755
 
 
756
 
 
757
class RemoteGitTagDict(GitTags):
336
758
 
337
759
    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)
 
760
        sha = self.branch.lookup_bzr_revision_id(revid)[0]
 
761
        self._set_ref(name, sha)
 
762
 
 
763
    def delete_tag(self, name):
 
764
        self._set_ref(name, dulwich.client.ZERO_SHA)
 
765
 
 
766
    def _set_ref(self, name, sha):
 
767
        ref = tag_name_to_ref(name)
 
768
        def get_changed_refs(old_refs):
 
769
            ret = dict(old_refs)
 
770
            if sha == dulwich.client.ZERO_SHA and ref not in ret:
 
771
                raise NoSuchTag(name)
 
772
            ret[ref] = sha
 
773
            return ret
 
774
        def generate_pack_data(have, want, ofs_delta=False):
 
775
            return pack_objects_to_data([])
 
776
        self.repository.send_pack(get_changed_refs, generate_pack_data)
340
777
 
341
778
 
342
779
class RemoteGitBranch(GitBranch):
343
780
 
344
 
    def __init__(self, bzrdir, repository, name, lockfiles):
 
781
    def __init__(self, controldir, repository, name):
345
782
        self._sha = None
346
 
        super(RemoteGitBranch, self).__init__(bzrdir, repository, name,
347
 
                lockfiles)
348
 
 
349
 
    def revision_history(self):
350
 
        raise GitSmartRemoteNotSupported()
 
783
        super(RemoteGitBranch, self).__init__(controldir, repository, name,
 
784
                RemoteGitBranchFormat())
 
785
 
 
786
    def last_revision_info(self):
 
787
        raise GitSmartRemoteNotSupported(self.last_revision_info, self)
 
788
 
 
789
    @property
 
790
    def user_url(self):
 
791
        return self.control_url
 
792
 
 
793
    @property
 
794
    def control_url(self):
 
795
        return self.base
 
796
 
 
797
    def revision_id_to_revno(self, revision_id):
 
798
        raise GitSmartRemoteNotSupported(self.revision_id_to_revno, self)
351
799
 
352
800
    def last_revision(self):
353
801
        return self.lookup_foreign_revision_id(self.head)
354
802
 
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
803
    @property
364
804
    def head(self):
365
805
        if self._sha is not None:
366
806
            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)
 
807
        refs = self.controldir.get_refs_container()
 
808
        name = branch_name_to_ref(self.name)
 
809
        try:
 
810
            self._sha = refs[name]
 
811
        except KeyError:
 
812
            raise NoSuchRef(name, self.repository.user_url, refs)
373
813
        return self._sha
374
814
 
375
815
    def _synchronize_history(self, destination, revision_id):
376
816
        """See Branch._synchronize_history()."""
377
817
        destination.generate_revision_history(self.last_revision())
378
818
 
 
819
    def _get_parent_location(self):
 
820
        return None
 
821
 
379
822
    def get_push_location(self):
380
823
        return None
381
824
 
382
825
    def set_push_location(self, url):
383
826
        pass
 
827
 
 
828
    def _iter_tag_refs(self):
 
829
        """Iterate over the tag refs.
 
830
 
 
831
        :param refs: Refs dictionary (name -> git sha1)
 
832
        :return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
 
833
        """
 
834
        refs = self.controldir.get_refs_container()
 
835
        for ref_name, unpeeled in refs.as_dict().items():
 
836
            try:
 
837
                tag_name = ref_to_tag_name(ref_name)
 
838
            except (ValueError, UnicodeDecodeError):
 
839
                continue
 
840
            peeled = refs.get_peeled(ref_name)
 
841
            if peeled is None:
 
842
                try:
 
843
                    peeled = refs.peel_sha(unpeeled).id
 
844
                except KeyError:
 
845
                    # Let's just hope it's a commit
 
846
                    peeled = unpeeled
 
847
            if type(tag_name) is not unicode:
 
848
                raise TypeError(tag_name)
 
849
            yield (ref_name, tag_name, peeled, unpeeled)
 
850
 
 
851
 
 
852
def remote_refs_dict_to_container(refs_dict, symrefs_dict={}):
 
853
    base = {}
 
854
    peeled = {}
 
855
    for k, v in refs_dict.items():
 
856
        if is_peeled(k):
 
857
            peeled[k[:-3]] = v
 
858
        else:
 
859
            base[k] = v
 
860
            peeled[k] = v
 
861
    for name, target in symrefs_dict.items():
 
862
        base[name] = SYMREF + target
 
863
    ret = DictRefsContainer(base)
 
864
    ret._peeled = peeled
 
865
    return ret