/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/branch.py

  • Committer: Jelmer Vernooij
  • Date: 2018-06-14 17:59:16 UTC
  • mto: This revision was merged to the branch mainline in revision 7065.
  • Revision ID: jelmer@jelmer.uk-20180614175916-a2e2xh5k533guq1x
Move breezy.plugins.git to breezy.git.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/branch.py
17
17
 
18
18
"""An adapter between a Git Branch and a Bazaar Branch"""
19
19
 
 
20
from __future__ import absolute_import
20
21
 
21
 
import contextlib
22
22
from io import BytesIO
23
23
from collections import defaultdict
24
24
 
25
 
from dulwich.config import (
26
 
    ConfigFile as GitConfigFile,
27
 
    parse_submodules,
28
 
    )
29
 
 
30
25
from dulwich.objects import (
31
26
    NotCommitError,
32
27
    ZERO_SHA,
41
36
    lock,
42
37
    repository as _mod_repository,
43
38
    revision,
 
39
    tag,
44
40
    trace,
45
41
    transport,
46
42
    urlutils,
47
43
    )
48
 
from ..foreign import ForeignBranch
49
44
from ..revision import (
50
45
    NULL_REVISION,
51
46
    )
52
 
from ..tag import (
53
 
    Tags,
54
 
    InterTags,
55
 
    )
56
47
from ..trace import (
57
48
    is_quiet,
58
49
    mutter,
59
50
    warning,
60
51
    )
61
52
 
 
53
from .config import (
 
54
    GitBranchConfig,
 
55
    GitBranchStack,
 
56
    )
62
57
from .errors import (
63
58
    NoPushSupport,
64
 
    )
65
 
from .mapping import (
66
 
    encode_git_path,
67
 
    decode_git_path,
 
59
    NoSuchRef,
68
60
    )
69
61
from .push import (
70
62
    remote_divergence,
80
72
from .unpeel_map import (
81
73
    UnpeelMap,
82
74
    )
83
 
from .urls import (
84
 
    git_url_to_bzr_url,
85
 
    bzr_url_to_git_url,
86
 
    )
87
 
 
88
 
 
89
 
def _calculate_revnos(branch):
90
 
    if branch._format.stores_revno():
91
 
        return True
92
 
    config = branch.get_config_stack()
93
 
    return config.get('calculate_revnos')
 
75
from .urls import git_url_to_bzr_url
 
76
 
 
77
from ..foreign import ForeignBranch
94
78
 
95
79
 
96
80
class GitPullResult(branch.PullResult):
97
81
    """Result of a pull from a Git branch."""
98
82
 
99
83
    def _lookup_revno(self, revid):
100
 
        if not isinstance(revid, bytes):
 
84
        if type(revid) is not str:
101
85
            raise TypeError(revid)
102
 
        if not _calculate_revnos(self.target_branch):
103
 
            return None
104
86
        # Try in source branch first, it'll be faster
105
87
        with self.target_branch.lock_read():
106
88
            return self.target_branch.revision_id_to_revno(revid)
114
96
        return self._lookup_revno(self.new_revid)
115
97
 
116
98
 
117
 
class InterTagsFromGitToRemoteGit(InterTags):
118
 
 
119
 
    @classmethod
120
 
    def is_compatible(klass, source, target):
121
 
        if not isinstance(source, GitTags):
122
 
            return False
123
 
        if not isinstance(target, GitTags):
124
 
            return False
125
 
        if getattr(target.branch.repository, "_git", None) is not None:
126
 
            return False
127
 
        return True
128
 
 
129
 
    def merge(self, overwrite=False, ignore_master=False, selector=None):
130
 
        if self.source.branch.repository.has_same_location(self.target.branch.repository):
131
 
            return {}, []
 
99
class GitTags(tag.BasicTags):
 
100
    """Ref-based tag dictionary."""
 
101
 
 
102
    def __init__(self, branch):
 
103
        self.branch = branch
 
104
        self.repository = branch.repository
 
105
 
 
106
    def _merge_to_remote_git(self, target_repo, source_tag_refs, overwrite=False):
132
107
        updates = {}
133
108
        conflicts = []
134
 
        source_tag_refs = self.source.branch.get_tag_refs()
135
 
        ref_to_tag_map = {}
136
 
 
137
109
        def get_changed_refs(old_refs):
138
110
            ret = dict(old_refs)
139
 
            for ref_name, tag_name, peeled, unpeeled in (
140
 
                    source_tag_refs.iteritems()):
141
 
                if selector and not selector(tag_name):
142
 
                    continue
 
111
            for ref_name, tag_name, peeled, unpeeled in source_tag_refs.iteritems():
143
112
                if old_refs.get(ref_name) == unpeeled:
144
113
                    pass
145
 
                elif overwrite or ref_name not in old_refs:
 
114
                elif overwrite or not ref_name in old_refs:
146
115
                    ret[ref_name] = unpeeled
147
 
                    updates[tag_name] = self.target.branch.repository.lookup_foreign_revision_id(
148
 
                        peeled)
149
 
                    ref_to_tag_map[ref_name] = tag_name
150
 
                    self.target.branch._tag_refs = None
 
116
                    updates[tag_name] = target_repo.lookup_foreign_revision_id(peeled)
151
117
                else:
152
118
                    conflicts.append(
153
119
                        (tag_name,
154
 
                         self.repository.lookup_foreign_revision_id(peeled),
155
 
                         self.target.branch.repository.lookup_foreign_revision_id(
156
 
                             old_refs[ref_name])))
 
120
                        self.repository.lookup_foreign_revision_id(peeled),
 
121
                        target_repo.lookup_foreign_revision_id(old_refs[ref_name])))
157
122
            return ret
158
 
        result = self.target.branch.repository.controldir.send_pack(
159
 
            get_changed_refs, lambda have, want: [])
160
 
        if result is not None and not isinstance(result, dict):
161
 
            for ref, error in result.ref_status.items():
162
 
                if error:
163
 
                    warning('unable to update ref %s: %s',
164
 
                            ref, error)
165
 
                    del updates[ref_to_tag_map[ref]]
166
 
        return updates, set(conflicts)
167
 
 
168
 
 
169
 
class InterTagsFromGitToLocalGit(InterTags):
170
 
 
171
 
    @classmethod
172
 
    def is_compatible(klass, source, target):
173
 
        if not isinstance(source, GitTags):
174
 
            return False
175
 
        if not isinstance(target, GitTags):
176
 
            return False
177
 
        if getattr(target.branch.repository, "_git", None) is None:
178
 
            return False
179
 
        return True
180
 
 
181
 
    def merge(self, overwrite=False, ignore_master=False, selector=None):
182
 
        if self.source.branch.repository.has_same_location(self.target.branch.repository):
183
 
            return {}, []
184
 
 
 
123
        target_repo.controldir.send_pack(get_changed_refs, lambda have, want: [])
 
124
        return updates, conflicts
 
125
 
 
126
    def _merge_to_local_git(self, target_repo, source_tag_refs, overwrite=False):
185
127
        conflicts = []
186
128
        updates = {}
187
 
        source_tag_refs = self.source.branch.get_tag_refs()
188
 
 
189
 
        target_repo = self.target.branch.repository
190
 
 
191
129
        for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
192
 
            if selector and not selector(tag_name):
193
 
                continue
194
130
            if target_repo._git.refs.get(ref_name) == unpeeled:
195
131
                pass
196
 
            elif overwrite or ref_name not in target_repo._git.refs:
197
 
                try:
198
 
                    updates[tag_name] = (
199
 
                        target_repo.lookup_foreign_revision_id(peeled))
200
 
                except KeyError:
201
 
                    trace.warning('%s does not point to a valid object',
202
 
                                  tag_name)
203
 
                    continue
204
 
                except NotCommitError:
205
 
                    trace.warning('%s points to a non-commit object',
206
 
                                  tag_name)
207
 
                    continue
 
132
            elif overwrite or not ref_name in target_repo._git.refs:
208
133
                target_repo._git.refs[ref_name] = unpeeled or peeled
209
 
                self.target.branch._tag_refs = None
 
134
                updates[tag_name] = self.repository.lookup_foreign_revision_id(peeled)
210
135
            else:
 
136
                source_revid = self.repository.lookup_foreign_revision_id(peeled)
211
137
                try:
212
 
                    source_revid = self.source.branch.repository.lookup_foreign_revision_id(
213
 
                        peeled)
214
138
                    target_revid = target_repo.lookup_foreign_revision_id(
215
 
                        target_repo._git.refs[ref_name])
 
139
                            target_repo._git.refs[ref_name])
216
140
                except KeyError:
217
141
                    trace.warning('%s does not point to a valid object',
218
142
                                  ref_name)
219
143
                    continue
220
 
                except NotCommitError:
221
 
                    trace.warning('%s points to a non-commit object',
222
 
                                  tag_name)
223
 
                    continue
224
144
                conflicts.append((tag_name, source_revid, target_revid))
225
 
        return updates, set(conflicts)
226
 
 
227
 
 
228
 
class InterTagsFromGitToNonGit(InterTags):
229
 
 
230
 
    @classmethod
231
 
    def is_compatible(klass, source, target):
232
 
        if not isinstance(source, GitTags):
233
 
            return False
234
 
        if isinstance(target, GitTags):
235
 
            return False
236
 
        return True
237
 
 
238
 
    def merge(self, overwrite=False, ignore_master=False, selector=None):
239
 
        """See Tags.merge_to."""
240
 
        source_tag_refs = self.source.branch.get_tag_refs()
241
 
        if ignore_master:
242
 
            master = None
243
 
        else:
244
 
            master = self.target.branch.get_master_branch()
245
 
        with contextlib.ExitStack() as es:
246
 
            if master is not None:
247
 
                es.enter_context(master.lock_write())
248
 
            updates, conflicts = self._merge_to(
249
 
                self.target, source_tag_refs, overwrite=overwrite,
250
 
                selector=selector)
251
 
            if master is not None:
252
 
                extra_updates, extra_conflicts = self._merge_to(
253
 
                    master.tags, overwrite=overwrite,
254
 
                    source_tag_refs=source_tag_refs,
255
 
                    ignore_master=ignore_master, selector=selector)
256
 
                updates.update(extra_updates)
257
 
                conflicts.update(extra_conflicts)
258
 
            return updates, conflicts
259
 
 
260
 
    def _merge_to(self, to_tags, source_tag_refs, overwrite=False,
261
 
                  selector=None):
 
145
        return updates, conflicts
 
146
 
 
147
    def _merge_to_git(self, to_tags, source_tag_refs, overwrite=False):
 
148
        target_repo = to_tags.repository
 
149
        if self.repository.has_same_location(target_repo):
 
150
            return {}, []
 
151
        try:
 
152
            if getattr(target_repo, "_git", None):
 
153
                return self._merge_to_local_git(target_repo, source_tag_refs, overwrite)
 
154
            else:
 
155
                return self._merge_to_remote_git(target_repo, source_tag_refs, overwrite)
 
156
        finally:
 
157
            to_tags.branch._tag_refs = None
 
158
 
 
159
    def _merge_to_non_git(self, to_tags, source_tag_refs, overwrite=False):
262
160
        unpeeled_map = defaultdict(set)
263
161
        conflicts = []
264
162
        updates = {}
265
163
        result = dict(to_tags.get_tag_dict())
266
164
        for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
267
 
            if selector and not selector(tag_name):
268
 
                continue
269
165
            if unpeeled is not None:
270
166
                unpeeled_map[peeled].add(unpeeled)
271
167
            try:
272
 
                bzr_revid = self.source.branch.lookup_foreign_revision_id(peeled)
 
168
                bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
273
169
            except NotCommitError:
274
170
                continue
275
171
            if result.get(tag_name) == bzr_revid:
278
174
                result[tag_name] = bzr_revid
279
175
                updates[tag_name] = bzr_revid
280
176
            else:
281
 
                conflicts.append((tag_name, bzr_revid, result[tag_name]))
 
177
                conflicts.append((tag_name, bzr_revid, result[n]))
282
178
        to_tags._set_tag_dict(result)
283
179
        if len(unpeeled_map) > 0:
284
180
            map_file = UnpeelMap.from_repository(to_tags.branch.repository)
285
181
            map_file.update(unpeeled_map)
286
182
            map_file.save_in_repository(to_tags.branch.repository)
287
 
        return updates, set(conflicts)
288
 
 
289
 
 
290
 
InterTags.register_optimiser(InterTagsFromGitToRemoteGit)
291
 
InterTags.register_optimiser(InterTagsFromGitToLocalGit)
292
 
InterTags.register_optimiser(InterTagsFromGitToNonGit)
293
 
 
294
 
 
295
 
class GitTags(Tags):
296
 
    """Ref-based tag dictionary."""
297
 
 
298
 
    def __init__(self, branch):
299
 
        self.branch = branch
300
 
        self.repository = branch.repository
 
183
        return updates, conflicts
 
184
 
 
185
    def merge_to(self, to_tags, overwrite=False, ignore_master=False,
 
186
                 source_tag_refs=None):
 
187
        """See Tags.merge_to."""
 
188
        if source_tag_refs is None:
 
189
            source_tag_refs = self.branch.get_tag_refs()
 
190
        if self == to_tags:
 
191
            return {}, []
 
192
        if isinstance(to_tags, GitTags):
 
193
            return self._merge_to_git(to_tags, source_tag_refs,
 
194
                                      overwrite=overwrite)
 
195
        else:
 
196
            if ignore_master:
 
197
                master = None
 
198
            else:
 
199
                master = to_tags.branch.get_master_branch()
 
200
            if master is not None:
 
201
                master.lock_write()
 
202
            try:
 
203
                updates, conflicts = self._merge_to_non_git(to_tags, source_tag_refs,
 
204
                                                  overwrite=overwrite)
 
205
                if master is not None:
 
206
                    extra_updates, extra_conflicts = self.merge_to(
 
207
                        master.tags, overwrite=overwrite,
 
208
                                               source_tag_refs=source_tag_refs,
 
209
                                               ignore_master=ignore_master)
 
210
                    updates.update(extra_updates)
 
211
                    conflicts += extra_conflicts
 
212
                return updates, conflicts
 
213
            finally:
 
214
                if master is not None:
 
215
                    master.unlock()
301
216
 
302
217
    def get_tag_dict(self):
303
218
        ret = {}
304
 
        for (ref_name, tag_name, peeled, unpeeled) in (
305
 
                self.branch.get_tag_refs()):
 
219
        for (ref_name, tag_name, peeled, unpeeled) in self.branch.get_tag_refs():
306
220
            try:
307
221
                bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
308
222
            except NotCommitError:
311
225
                ret[tag_name] = bzr_revid
312
226
        return ret
313
227
 
314
 
    def lookup_tag(self, tag_name):
315
 
        """Return the referent string of a tag"""
316
 
        # TODO(jelmer): Replace with something more efficient for local tags.
317
 
        td = self.get_tag_dict()
318
 
        try:
319
 
            return td[tag_name]
320
 
        except KeyError:
321
 
            raise errors.NoSuchTag(tag_name)
322
 
 
323
228
 
324
229
class LocalGitTagDict(GitTags):
325
230
    """Dictionary with tags in a local repository."""
330
235
 
331
236
    def _set_tag_dict(self, to_dict):
332
237
        extra = set(self.refs.allkeys())
333
 
        for k, revid in to_dict.items():
 
238
        for k, revid in to_dict.iteritems():
334
239
            name = tag_name_to_ref(k)
335
240
            if name in extra:
336
241
                extra.remove(name)
337
 
            try:
338
 
                self.set_tag(k, revid)
339
 
            except errors.GhostTagsNotSupported:
340
 
                pass
 
242
            self.set_tag(k, revid)
341
243
        for name in extra:
342
244
            if is_tag(name):
343
245
                del self.repository._git[name]
352
254
 
353
255
    def delete_tag(self, name):
354
256
        ref = tag_name_to_ref(name)
355
 
        if ref not in self.refs:
 
257
        if not ref in self.refs:
356
258
            raise errors.NoSuchTag(name)
357
259
        del self.refs[ref]
358
260
        self.branch._tag_refs = None
361
263
class GitBranchFormat(branch.BranchFormat):
362
264
 
363
265
    def network_name(self):
364
 
        return b"git"
 
266
        return "git"
365
267
 
366
268
    def supports_tags(self):
367
269
        return True
395
297
        raise NotImplementedError(self.initialize)
396
298
 
397
299
    def get_reference(self, controldir, name=None):
398
 
        return controldir.get_branch_reference(name=name)
 
300
        return controldir.get_branch_reference(name)
399
301
 
400
302
    def set_reference(self, controldir, name, target):
401
303
        return controldir.set_branch_reference(target, name)
402
304
 
403
 
    def stores_revno(self):
404
 
        """True if this branch format store revision numbers."""
405
 
        return False
406
 
 
407
 
    supports_reference_locations = False
408
 
 
409
305
 
410
306
class LocalGitBranchFormat(GitBranchFormat):
411
307
 
422
318
        from .dir import LocalGitDir
423
319
        if not isinstance(a_controldir, LocalGitDir):
424
320
            raise errors.IncompatibleFormat(self, a_controldir._format)
425
 
        return a_controldir.create_branch(
426
 
            repository=repository, name=name,
 
321
        return a_controldir.create_branch(repository=repository, name=name,
427
322
            append_revisions_only=append_revisions_only)
428
323
 
429
324
 
482
377
        return "git"
483
378
 
484
379
    def get_config(self):
485
 
        from .config import GitBranchConfig
486
380
        return GitBranchConfig(self)
487
381
 
488
382
    def get_config_stack(self):
489
 
        from .config import GitBranchStack
490
383
        return GitBranchStack(self)
491
384
 
492
385
    def _get_nick(self, local=False, possible_master_transports=None):
494
387
 
495
388
        :return: Branch nick
496
389
        """
497
 
        if getattr(self.repository, '_git', None):
498
 
            cs = self.repository._git.get_config_stack()
499
 
            try:
500
 
                return cs.get((b"branch", self.name.encode('utf-8')),
501
 
                        b"nick").decode("utf-8")
502
 
            except KeyError:
503
 
                pass
 
390
        cs = self.repository._git.get_config_stack()
 
391
        try:
 
392
            return cs.get((b"branch", self.name.encode('utf-8')), b"nick").decode("utf-8")
 
393
        except KeyError:
 
394
            pass
504
395
        return self.name or u"HEAD"
505
396
 
506
397
    def _set_nick(self, nick):
507
398
        cf = self.repository._git.get_config()
508
 
        cf.set((b"branch", self.name.encode('utf-8')),
509
 
               b"nick", nick.encode("utf-8"))
 
399
        cf.set((b"branch", self.name.encode('utf-8')), b"nick", nick.encode("utf-8"))
510
400
        f = BytesIO()
511
401
        cf.write_to_file(f)
512
402
        self.repository._git._put_named_file('config', f.getvalue())
515
405
 
516
406
    def __repr__(self):
517
407
        return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
518
 
                                 self.name)
 
408
            self.name)
519
409
 
520
 
    def generate_revision_history(self, revid, last_rev=None,
521
 
                                  other_branch=None):
 
410
    def generate_revision_history(self, revid, last_rev=None, other_branch=None):
522
411
        if last_rev is not None:
523
412
            graph = self.repository.get_graph()
524
413
            if not graph.is_ancestor(last_rev, revid):
551
440
        # Git doesn't do stacking (yet...)
552
441
        raise branch.UnstackableBranchFormat(self._format, self.base)
553
442
 
554
 
    def _get_push_origin(self, cs):
555
 
        """Get the name for the push origin.
556
 
 
557
 
        The exact behaviour is documented in the git-config(1) manpage.
558
 
        """
559
 
        try:
560
 
            return cs.get((b'branch', self.name.encode('utf-8')), b'pushRemote')
561
 
        except KeyError:
562
 
            try:
563
 
                return cs.get((b'branch', ), b'remote')
564
 
            except KeyError:
565
 
                try:
566
 
                    return cs.get((b'branch', self.name.encode('utf-8')), b'remote')
567
 
                except KeyError:
568
 
                    return b'origin'
569
 
 
570
 
    def _get_origin(self, cs):
571
 
        try:
572
 
            return cs.get((b'branch', self.name.encode('utf-8')), b'remote')
573
 
        except KeyError:
574
 
            return b'origin'
575
 
 
576
 
    def _get_related_push_branch(self, cs):
577
 
        remote = self._get_push_origin(cs)
578
 
        try:
579
 
            location = cs.get((b"remote", remote), b"url")
580
 
        except KeyError:
581
 
            return None
582
 
 
583
 
        return git_url_to_bzr_url(location.decode('utf-8'), ref=self.ref)
584
 
 
585
 
    def _get_related_merge_branch(self, cs):
586
 
        remote = self._get_origin(cs)
587
 
        try:
588
 
            location = cs.get((b"remote", remote), b"url")
589
 
        except KeyError:
590
 
            return None
591
 
 
592
 
        try:
593
 
            ref = cs.get((b"branch", remote), b"merge")
594
 
        except KeyError:
595
 
            ref = self.ref
596
 
 
597
 
        return git_url_to_bzr_url(location.decode('utf-8'), ref=ref)
598
 
 
599
443
    def _get_parent_location(self):
600
444
        """See Branch.get_parent()."""
 
445
        # FIXME: Set "origin" url from .git/config ?
601
446
        cs = self.repository._git.get_config_stack()
602
 
        return self._get_related_merge_branch(cs)
603
 
 
604
 
    def _write_git_config(self, cs):
605
 
        f = BytesIO()
606
 
        cs.write_to_file(f)
607
 
        self.repository._git._put_named_file('config', f.getvalue())
 
447
        try:
 
448
            location = cs.get((b"remote", b'origin'), b"url")
 
449
        except KeyError:
 
450
            return None
 
451
 
 
452
        params = {}
 
453
        try:
 
454
            ref = cs.get((b"remote", b"origin"), b"merge")
 
455
        except KeyError:
 
456
            pass
 
457
        else:
 
458
            if ref != 'HEAD':
 
459
                try:
 
460
                    params['branch'] = ref_to_branch_name(ref).encode('utf-8')
 
461
                except ValueError:
 
462
                    params['ref'] = ref.encode('utf-8')
 
463
 
 
464
        url = git_url_to_bzr_url(location)
 
465
        return urlutils.join_segment_parameters(url, params)
608
466
 
609
467
    def set_parent(self, location):
 
468
        # FIXME: Set "origin" url in .git/config ?
610
469
        cs = self.repository._git.get_config()
611
 
        remote = self._get_origin(cs)
612
 
        this_url = urlutils.strip_segment_parameters(self.user_url)
613
 
        target_url, branch, ref = bzr_url_to_git_url(location)
 
470
        this_url = urlutils.split_segment_parameters(self.user_url)[0]
 
471
        target_url, target_params = urlutils.split_segment_parameters(location)
614
472
        location = urlutils.relative_url(this_url, target_url)
615
 
        cs.set((b"remote", remote), b"url", location)
616
 
        if branch:
617
 
            cs.set((b"branch", remote), b"merge", branch_name_to_ref(branch))
618
 
        elif ref:
619
 
            cs.set((b"branch", remote), b"merge", ref)
 
473
        cs.set((b"remote", b"origin"), b"url", location)
 
474
        if 'branch' in target_params:
 
475
            cs.set((b"remote", b"origin"), b"merge",
 
476
                   branch_name_to_ref(target_params['branch']))
 
477
        elif 'ref' in target_params:
 
478
            cs.set((b"remote", b"origin"), b"merge",
 
479
                   target_params['ref'])
620
480
        else:
621
481
            # TODO(jelmer): Maybe unset rather than setting to HEAD?
622
 
            cs.set((b"branch", remote), b"merge", b'HEAD')
623
 
        self._write_git_config(cs)
 
482
            cs.set((b"remote", b"origin"), b"merge", 'HEAD')
 
483
        f = BytesIO()
 
484
        cs.write_to_file(f)
 
485
        self.repository._git._put_named_file('config', f.getvalue())
624
486
 
625
487
    def break_lock(self):
626
488
        raise NotImplementedError(self.break_lock)
672
534
                return revision.NULL_REVISION
673
535
            return self.lookup_foreign_revision_id(self.head)
674
536
 
675
 
    def _basic_push(self, target, overwrite=False, stop_revision=None,
676
 
                    tag_selector=None):
 
537
    def _basic_push(self, target, overwrite=False, stop_revision=None):
677
538
        return branch.InterBranch.get(self, target)._basic_push(
678
 
            overwrite, stop_revision, tag_selector=tag_selector)
 
539
            overwrite, stop_revision)
679
540
 
680
541
    def lookup_foreign_revision_id(self, foreign_revid):
681
542
        try:
682
543
            return self.repository.lookup_foreign_revision_id(foreign_revid,
683
 
                                                              self.mapping)
 
544
                self.mapping)
684
545
        except KeyError:
685
546
            # Let's try..
686
547
            return self.mapping.revision_id_foreign_to_bzr(foreign_revid)
710
571
                self._tag_refs = list(self._iter_tag_refs())
711
572
            return self._tag_refs
712
573
 
713
 
    def import_last_revision_info_and_tags(self, source, revno, revid,
714
 
                                           lossy=False):
715
 
        """Set the last revision info, importing from another repo if necessary.
716
 
 
717
 
        This is used by the bound branch code to upload a revision to
718
 
        the master branch first before updating the tip of the local branch.
719
 
        Revisions referenced by source's tags are also transferred.
720
 
 
721
 
        :param source: Source branch to optionally fetch from
722
 
        :param revno: Revision number of the new tip
723
 
        :param revid: Revision id of the new tip
724
 
        :param lossy: Whether to discard metadata that can not be
725
 
            natively represented
726
 
        :return: Tuple with the new revision number and revision id
727
 
            (should only be different from the arguments when lossy=True)
728
 
        """
729
 
        push_result = source.push(
730
 
            self, stop_revision=revid, lossy=lossy, _stop_revno=revno)
731
 
        return (push_result.new_revno, push_result.new_revid)
732
 
 
733
 
    def reconcile(self, thorough=True):
734
 
        """Make sure the data stored in this branch is consistent."""
735
 
        from ..reconcile import ReconcileResult
736
 
        # Nothing to do here
737
 
        return ReconcileResult()
738
 
 
739
574
 
740
575
class LocalGitBranch(GitBranch):
741
576
    """A local Git branch."""
742
577
 
743
578
    def __init__(self, controldir, repository, ref):
744
579
        super(LocalGitBranch, self).__init__(controldir, repository, ref,
745
 
                                             LocalGitBranchFormat())
 
580
                LocalGitBranchFormat())
746
581
 
747
582
    def create_checkout(self, to_location, revision_id=None, lightweight=False,
748
 
                        accelerator_tree=None, hardlink=False):
 
583
        accelerator_tree=None, hardlink=False):
749
584
        t = transport.get_transport(to_location)
750
585
        t.ensure_base()
751
586
        format = self._get_checkout_format(lightweight=lightweight)
754
589
            from_branch = checkout.set_branch_reference(target_branch=self)
755
590
        else:
756
591
            policy = checkout.determine_repository_policy()
757
 
            policy.acquire_repository()
 
592
            repo = policy.acquire_repository()[0]
 
593
 
758
594
            checkout_branch = checkout.create_branch()
759
595
            checkout_branch.bind(self)
760
596
            checkout_branch.pull(self, stop_revision=revision_id)
761
597
            from_branch = None
762
 
        return checkout.create_workingtree(
763
 
            revision_id, from_branch=from_branch, hardlink=hardlink)
 
598
        return checkout.create_workingtree(revision_id,
 
599
                from_branch=from_branch, hardlink=hardlink)
764
600
 
765
601
    def _lock_ref(self):
766
602
        self._ref_lock = self.repository._git.refs.lock_ref(self.ref)
771
607
    def break_lock(self):
772
608
        self.repository._git.refs.unlock_ref(self.ref)
773
609
 
 
610
    def fetch(self, from_branch, last_revision=None, limit=None):
 
611
        return branch.InterBranch.get(from_branch, self).fetch(
 
612
            stop_revision=last_revision, limit=limit)
 
613
 
774
614
    def _gen_revision_history(self):
775
615
        if self.head is None:
776
616
            return []
777
617
        last_revid = self.last_revision()
778
618
        graph = self.repository.get_graph()
779
619
        try:
780
 
            ret = list(graph.iter_lefthand_ancestry(
781
 
                last_revid, (revision.NULL_REVISION, )))
 
620
            ret = list(graph.iter_lefthand_ancestry(last_revid,
 
621
                (revision.NULL_REVISION, )))
782
622
        except errors.RevisionNotPresent as e:
783
623
            raise errors.GhostRevisionsHaveNoRevno(last_revid, e.revision_id)
784
624
        ret.reverse()
793
633
    def _read_last_revision_info(self):
794
634
        last_revid = self.last_revision()
795
635
        graph = self.repository.get_graph()
796
 
        try:
797
 
            revno = graph.find_distance_to_null(
798
 
                last_revid, [(revision.NULL_REVISION, 0)])
799
 
        except errors.GhostRevisionsHaveNoRevno:
800
 
            revno = None
 
636
        revno = graph.find_distance_to_null(last_revid,
 
637
            [(revision.NULL_REVISION, 0)])
801
638
        return revno, last_revid
802
639
 
803
640
    def set_last_revision_info(self, revno, revision_id):
810
647
        if revid == NULL_REVISION:
811
648
            newhead = None
812
649
        else:
813
 
            (newhead, self.mapping) = self.repository.lookup_bzr_revision_id(
814
 
                revid)
 
650
            (newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)
815
651
            if self.mapping is None:
816
652
                raise AssertionError
817
653
        self._set_head(newhead)
831
667
    def get_push_location(self):
832
668
        """See Branch.get_push_location."""
833
669
        push_loc = self.get_config_stack().get('push_location')
834
 
        if push_loc is not None:
835
 
            return push_loc
836
 
        cs = self.repository._git.get_config_stack()
837
 
        return self._get_related_push_branch(cs)
 
670
        return push_loc
838
671
 
839
672
    def set_push_location(self, location):
840
673
        """See Branch.set_push_location."""
853
686
        :param refs: Refs dictionary (name -> git sha1)
854
687
        :return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
855
688
        """
856
 
        refs = self.repository.controldir.get_refs_container()
857
 
        for ref_name, unpeeled in refs.as_dict().items():
 
689
        refs = self.repository._git.refs
 
690
        for ref_name, unpeeled in refs.as_dict().iteritems():
858
691
            try:
859
692
                tag_name = ref_to_tag_name(ref_name)
860
693
            except (ValueError, UnicodeDecodeError):
862
695
            peeled = refs.get_peeled(ref_name)
863
696
            if peeled is None:
864
697
                peeled = unpeeled
865
 
            if not isinstance(tag_name, str):
 
698
            if type(tag_name) is not unicode:
866
699
                raise TypeError(tag_name)
867
700
            yield (ref_name, tag_name, peeled, unpeeled)
868
701
 
869
702
    def create_memorytree(self):
870
703
        from .memorytree import GitMemoryTree
871
 
        return GitMemoryTree(self, self.repository._git.object_store,
872
 
                             self.head)
 
704
        return GitMemoryTree(self, self.repository._git.object_store, self.head)
 
705
 
 
706
    def reference_parent(self, path, file_id=None, possible_transports=None):
 
707
        """Return the parent branch for a tree-reference file_id
 
708
 
 
709
        :param path: The path of the file_id in the tree
 
710
        :param file_id: Optional file_id of the tree reference
 
711
        :return: A branch associated with the file_id
 
712
        """
 
713
        # FIXME should provide multiple branches, based on config
 
714
        url = urlutils.join(self.user_url, path)
 
715
        return branch.Branch.open(
 
716
                url,
 
717
                possible_transports=possible_transports)
 
718
 
873
719
 
874
720
 
875
721
def _quick_lookup_revno(local_branch, remote_branch, revid):
876
 
    if not isinstance(revid, bytes):
 
722
    if type(revid) is not str:
877
723
        raise TypeError(revid)
878
724
    # Try in source branch first, it'll be faster
879
725
    with local_branch.lock_read():
880
 
        if not _calculate_revnos(local_branch):
881
 
            return None
882
726
        try:
883
727
            return local_branch.revision_id_to_revno(revid)
884
728
        except errors.NoSuchRevision:
885
729
            graph = local_branch.repository.get_graph()
886
730
            try:
887
 
                return graph.find_distance_to_null(
888
 
                    revid, [(revision.NULL_REVISION, 0)])
 
731
                return graph.find_distance_to_null(revid,
 
732
                    [(revision.NULL_REVISION, 0)])
889
733
            except errors.GhostRevisionsHaveNoRevno:
890
 
                if not _calculate_revnos(remote_branch):
891
 
                    return None
892
734
                # FIXME: Check using graph.find_distance_to_null() ?
893
735
                with remote_branch.lock_read():
894
736
                    return remote_branch.revision_id_to_revno(revid)
908
750
                to_file.write('No revisions to pull.\n')
909
751
            elif self.new_git_head is not None:
910
752
                to_file.write('Now on revision %d (git sha: %s).\n' %
911
 
                              (self.new_revno, self.new_git_head))
 
753
                        (self.new_revno, self.new_git_head))
912
754
            else:
913
755
                to_file.write('Now on revision %d.\n' % (self.new_revno,))
914
756
        self._show_tag_conficts(to_file)
915
757
 
916
758
    def _lookup_revno(self, revid):
917
759
        return _quick_lookup_revno(self.target_branch, self.source_branch,
918
 
                                   revid)
 
760
            revid)
919
761
 
920
762
    def _get_old_revno(self):
921
763
        if self._old_revno is not None:
942
784
 
943
785
    def _lookup_revno(self, revid):
944
786
        return _quick_lookup_revno(self.source_branch, self.target_branch,
945
 
                                   revid)
 
787
            revid)
946
788
 
947
789
    @property
948
790
    def old_revno(self):
974
816
 
975
817
    @classmethod
976
818
    def _get_interrepo(self, source, target):
977
 
        return _mod_repository.InterRepository.get(
978
 
            source.repository, target.repository)
 
819
        return _mod_repository.InterRepository.get(source.repository, target.repository)
979
820
 
980
821
    @classmethod
981
822
    def is_compatible(cls, source, target):
984
825
        if isinstance(target, GitBranch):
985
826
            # InterLocalGitRemoteGitBranch or InterToGitBranch should be used
986
827
            return False
987
 
        if (getattr(cls._get_interrepo(source, target), "fetch_objects", None)
988
 
                is None):
 
828
        if getattr(cls._get_interrepo(source, target), "fetch_objects", None) is None:
989
829
            # fetch_objects is necessary for this to work
990
830
            return False
991
831
        return True
992
832
 
993
 
    def fetch(self, stop_revision=None, fetch_tags=None, limit=None, lossy=False):
994
 
        self.fetch_objects(
995
 
            stop_revision, fetch_tags=fetch_tags, limit=limit, lossy=lossy)
996
 
        return _mod_repository.FetchResult()
 
833
    def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
 
834
        self.fetch_objects(stop_revision, fetch_tags=fetch_tags, limit=limit)
997
835
 
998
 
    def fetch_objects(self, stop_revision, fetch_tags, limit=None, lossy=False, tag_selector=None):
 
836
    def fetch_objects(self, stop_revision, fetch_tags, limit=None):
999
837
        interrepo = self._get_interrepo(self.source, self.target)
1000
838
        if fetch_tags is None:
1001
839
            c = self.source.get_config_stack()
1002
840
            fetch_tags = c.get('branch.fetch_tags')
1003
 
 
1004
841
        def determine_wants(heads):
1005
842
            if stop_revision is None:
1006
843
                try:
1008
845
                except KeyError:
1009
846
                    self._last_revid = revision.NULL_REVISION
1010
847
                else:
1011
 
                    self._last_revid = self.source.lookup_foreign_revision_id(
1012
 
                        head)
 
848
                    self._last_revid = self.source.lookup_foreign_revision_id(head)
1013
849
            else:
1014
850
                self._last_revid = stop_revision
1015
851
            real = interrepo.get_determine_wants_revids(
1016
 
                [self._last_revid], include_tags=fetch_tags, tag_selector=tag_selector)
 
852
                [self._last_revid], include_tags=fetch_tags)
1017
853
            return real(heads)
1018
854
        pack_hint, head, refs = interrepo.fetch_objects(
1019
 
            determine_wants, self.source.mapping, limit=limit,
1020
 
            lossy=lossy)
 
855
            determine_wants, self.source.mapping, limit=limit)
1021
856
        if (pack_hint is not None and
1022
 
                self.target.repository._format.pack_compresses):
 
857
            self.target.repository._format.pack_compresses):
1023
858
            self.target.repository.pack(hint=pack_hint)
1024
859
        return head, refs
1025
860
 
1026
 
    def _update_revisions(self, stop_revision=None, overwrite=False, tag_selector=None):
1027
 
        head, refs = self.fetch_objects(stop_revision, fetch_tags=None, tag_selector=tag_selector)
 
861
    def _update_revisions(self, stop_revision=None, overwrite=False):
 
862
        head, refs = self.fetch_objects(stop_revision, fetch_tags=None)
1028
863
        if overwrite:
1029
864
            prev_last_revid = None
1030
865
        else:
1031
866
            prev_last_revid = self.target.last_revision()
1032
 
        self.target.generate_revision_history(
1033
 
            self._last_revid, last_rev=prev_last_revid,
1034
 
            other_branch=self.source)
 
867
        self.target.generate_revision_history(self._last_revid,
 
868
            last_rev=prev_last_revid, other_branch=self.source)
1035
869
        return head, refs
1036
870
 
1037
 
    def update_references(self, revid=None):
1038
 
        if revid is None:
1039
 
            revid = self.target.last_revision()
1040
 
        tree = self.target.repository.revision_tree(revid)
1041
 
        try:
1042
 
            with tree.get_file('.gitmodules') as f:
1043
 
                for path, url, section in parse_submodules(
1044
 
                        GitConfigFile.from_file(f)):
1045
 
                    self.target.set_reference_info(
1046
 
                        tree.path2id(decode_git_path(path)), url.decode('utf-8'),
1047
 
                        decode_git_path(path))
1048
 
        except errors.NoSuchFile:
1049
 
            pass
1050
 
 
1051
871
    def _basic_pull(self, stop_revision, overwrite, run_hooks,
1052
 
                    _override_hook_target, _hook_master, tag_selector=None):
 
872
              _override_hook_target, _hook_master):
1053
873
        if overwrite is True:
1054
874
            overwrite = set(["history", "tags"])
1055
 
        elif not overwrite:
 
875
        else:
1056
876
            overwrite = set()
1057
877
        result = GitBranchPullResult()
1058
878
        result.source_branch = self.source
1066
886
            (result.old_revno, result.old_revid) = \
1067
887
                self.target.last_revision_info()
1068
888
            result.new_git_head, remote_refs = self._update_revisions(
1069
 
                stop_revision, overwrite=("history" in overwrite),
1070
 
                tag_selector=tag_selector)
1071
 
            tags_ret = self.source.tags.merge_to(
1072
 
                self.target.tags, ("tags" in overwrite), ignore_master=True)
 
889
                stop_revision, overwrite=("history" in overwrite))
 
890
            tags_ret  = self.source.tags.merge_to(
 
891
                    self.target.tags, ("tags" in overwrite), ignore_master=True)
1073
892
            if isinstance(tags_ret, tuple):
1074
893
                result.tag_updates, result.tag_conflicts = tags_ret
1075
894
            else:
1076
895
                result.tag_conflicts = tags_ret
1077
896
            (result.new_revno, result.new_revid) = \
1078
897
                self.target.last_revision_info()
1079
 
            self.update_references(revid=result.new_revid)
1080
898
            if _hook_master:
1081
899
                result.master_branch = _hook_master
1082
900
                result.local_branch = result.target_branch
1090
908
 
1091
909
    def pull(self, overwrite=False, stop_revision=None,
1092
910
             possible_transports=None, _hook_master=None, run_hooks=True,
1093
 
             _override_hook_target=None, local=False, tag_selector=None):
 
911
             _override_hook_target=None, local=False):
1094
912
        """See Branch.pull.
1095
913
 
1096
914
        :param _hook_master: Private parameter - set the branch to
1105
923
        bound_location = self.target.get_bound_location()
1106
924
        if local and not bound_location:
1107
925
            raise errors.LocalRequiresBoundBranch()
 
926
        master_branch = None
1108
927
        source_is_master = False
1109
 
        with contextlib.ExitStack() as es:
1110
 
            es.enter_context(self.source.lock_read())
1111
 
            if bound_location:
1112
 
                # bound_location comes from a config file, some care has to be
1113
 
                # taken to relate it to source.user_url
1114
 
                normalized = urlutils.normalize_url(bound_location)
1115
 
                try:
1116
 
                    relpath = self.source.user_transport.relpath(normalized)
1117
 
                    source_is_master = (relpath == '')
1118
 
                except (errors.PathNotChild, urlutils.InvalidURL):
1119
 
                    source_is_master = False
1120
 
            if not local and bound_location and not source_is_master:
1121
 
                # not pulling from master, so we need to update master.
1122
 
                master_branch = self.target.get_master_branch(possible_transports)
1123
 
                es.enter_context(master_branch.lock_write())
1124
 
                # pull from source into master.
1125
 
                master_branch.pull(self.source, overwrite, stop_revision,
1126
 
                                   run_hooks=False)
1127
 
            else:
1128
 
                master_branch = None
1129
 
            return self._basic_pull(stop_revision, overwrite, run_hooks,
1130
 
                                    _override_hook_target,
1131
 
                                    _hook_master=master_branch,
1132
 
                                    tag_selector=tag_selector)
 
928
        self.source.lock_read()
 
929
        if bound_location:
 
930
            # bound_location comes from a config file, some care has to be
 
931
            # taken to relate it to source.user_url
 
932
            normalized = urlutils.normalize_url(bound_location)
 
933
            try:
 
934
                relpath = self.source.user_transport.relpath(normalized)
 
935
                source_is_master = (relpath == '')
 
936
            except (errors.PathNotChild, urlutils.InvalidURL):
 
937
                source_is_master = False
 
938
        if not local and bound_location and not source_is_master:
 
939
            # not pulling from master, so we need to update master.
 
940
            master_branch = self.target.get_master_branch(possible_transports)
 
941
            master_branch.lock_write()
 
942
        try:
 
943
            try:
 
944
                if master_branch:
 
945
                    # pull from source into master.
 
946
                    master_branch.pull(self.source, overwrite, stop_revision,
 
947
                        run_hooks=False)
 
948
                result = self._basic_pull(stop_revision, overwrite, run_hooks,
 
949
                    _override_hook_target, _hook_master=master_branch)
 
950
            finally:
 
951
                self.source.unlock()
 
952
        finally:
 
953
            if master_branch:
 
954
                master_branch.unlock()
 
955
        return result
1133
956
 
1134
 
    def _basic_push(self, overwrite, stop_revision, tag_selector=None):
 
957
    def _basic_push(self, overwrite, stop_revision):
1135
958
        if overwrite is True:
1136
959
            overwrite = set(["history", "tags"])
1137
 
        elif not overwrite:
 
960
        else:
1138
961
            overwrite = set()
1139
962
        result = branch.BranchPushResult()
1140
963
        result.source_branch = self.source
1141
964
        result.target_branch = self.target
1142
965
        result.old_revno, result.old_revid = self.target.last_revision_info()
1143
966
        result.new_git_head, remote_refs = self._update_revisions(
1144
 
            stop_revision, overwrite=("history" in overwrite),
1145
 
            tag_selector=tag_selector)
1146
 
        tags_ret = self.source.tags.merge_to(
1147
 
            self.target.tags, "tags" in overwrite, ignore_master=True,
1148
 
            selector=tag_selector)
 
967
            stop_revision, overwrite=("history" in overwrite))
 
968
        tags_ret = self.source.tags.merge_to(self.target.tags,
 
969
            "tags" in overwrite, ignore_master=True)
1149
970
        (result.tag_updates, result.tag_conflicts) = tags_ret
1150
971
        result.new_revno, result.new_revid = self.target.last_revision_info()
1151
 
        self.update_references(revid=result.new_revid)
1152
972
        return result
1153
973
 
1154
974
 
1155
975
class InterGitBranch(branch.GenericInterBranch):
1156
976
    """InterBranch implementation that pulls between Git branches."""
1157
977
 
1158
 
    def fetch(self, stop_revision=None, fetch_tags=None, limit=None, lossy=False):
 
978
    def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
1159
979
        raise NotImplementedError(self.fetch)
1160
980
 
1161
981
 
1174
994
        return (isinstance(source, LocalGitBranch) and
1175
995
                isinstance(target, RemoteGitBranch))
1176
996
 
1177
 
    def _basic_push(self, overwrite, stop_revision, tag_selector=None):
1178
 
        from .remote import parse_git_error
 
997
    def _basic_push(self, overwrite, stop_revision):
1179
998
        result = GitBranchPushResult()
1180
999
        result.source_branch = self.source
1181
1000
        result.target_branch = self.target
1182
1001
        if stop_revision is None:
1183
1002
            stop_revision = self.source.last_revision()
1184
 
 
1185
1003
        def get_changed_refs(old_refs):
1186
1004
            old_ref = old_refs.get(self.target.ref, None)
1187
1005
            if old_ref is None:
1188
1006
                result.old_revid = revision.NULL_REVISION
1189
1007
            else:
1190
 
                result.old_revid = self.target.lookup_foreign_revision_id(
1191
 
                    old_ref)
1192
 
            new_ref = self.source.repository.lookup_bzr_revision_id(
1193
 
                stop_revision)[0]
 
1008
                result.old_revid = self.target.lookup_foreign_revision_id(old_ref)
 
1009
            new_ref = self.source.repository.lookup_bzr_revision_id(stop_revision)[0]
1194
1010
            if not overwrite:
1195
 
                if remote_divergence(
1196
 
                        old_ref, new_ref,
1197
 
                        self.source.repository._git.object_store):
 
1011
                if remote_divergence(old_ref, new_ref, self.source.repository._git.object_store):
1198
1012
                    raise errors.DivergedBranches(self.source, self.target)
1199
 
            refs = {self.target.ref: new_ref}
 
1013
            refs = { self.target.ref: new_ref }
1200
1014
            result.new_revid = stop_revision
1201
 
            for name, sha in (
1202
 
                    self.source.repository._git.refs.as_dict(b"refs/tags").items()):
1203
 
                if tag_selector and not tag_selector(name):
1204
 
                    continue
1205
 
                if sha not in self.source.repository._git:
1206
 
                    trace.mutter('Ignoring missing SHA: %s', sha)
1207
 
                    continue
 
1015
            for name, sha in self.source.repository._git.refs.as_dict("refs/tags").iteritems():
1208
1016
                refs[tag_name_to_ref(name)] = sha
1209
1017
            return refs
1210
 
        dw_result = self.target.repository.send_pack(
1211
 
            get_changed_refs,
1212
 
            self.source.repository._git.generate_pack_data)
1213
 
        if dw_result is not None and not isinstance(dw_result, dict):
1214
 
            error = dw_result.ref_status.get(self.target.ref)
1215
 
            if error:
1216
 
                raise parse_git_error(self.target.user_url, error)
1217
 
            for ref, error in dw_result.ref_status.items():
1218
 
                if error:
1219
 
                    trace.warning('unable to open ref %s: %s', ref, error)
 
1018
        self.target.repository.send_pack(get_changed_refs,
 
1019
            self.source.repository._git.object_store.generate_pack_data)
1220
1020
        return result
1221
1021
 
1222
1022
 
1235
1035
        return (isinstance(source, GitBranch) and
1236
1036
                isinstance(target, LocalGitBranch))
1237
1037
 
1238
 
    def fetch(self, stop_revision=None, fetch_tags=None, limit=None, lossy=False):
1239
 
        interrepo = _mod_repository.InterRepository.get(
1240
 
            self.source.repository, self.target.repository)
 
1038
    def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
 
1039
        interrepo = _mod_repository.InterRepository.get(self.source.repository,
 
1040
            self.target.repository)
1241
1041
        if stop_revision is None:
1242
1042
            stop_revision = self.source.last_revision()
1243
 
        if fetch_tags is None:
1244
 
            c = self.source.get_config_stack()
1245
 
            fetch_tags = c.get('branch.fetch_tags')
1246
1043
        determine_wants = interrepo.get_determine_wants_revids(
1247
1044
            [stop_revision], include_tags=fetch_tags)
1248
 
        interrepo.fetch_objects(determine_wants, limit=limit, lossy=lossy)
1249
 
        return _mod_repository.FetchResult()
 
1045
        interrepo.fetch_objects(determine_wants, limit=limit)
1250
1046
 
1251
 
    def _basic_push(self, overwrite=False, stop_revision=None, tag_selector=None):
 
1047
    def _basic_push(self, overwrite=False, stop_revision=None):
1252
1048
        if overwrite is True:
1253
1049
            overwrite = set(["history", "tags"])
1254
 
        elif not overwrite:
 
1050
        else:
1255
1051
            overwrite = set()
1256
1052
        result = GitBranchPushResult()
1257
1053
        result.source_branch = self.source
1258
1054
        result.target_branch = self.target
1259
1055
        result.old_revid = self.target.last_revision()
1260
1056
        refs, stop_revision = self.update_refs(stop_revision)
1261
 
        self.target.generate_revision_history(
1262
 
            stop_revision,
1263
 
            (result.old_revid if ("history" not in overwrite) else None),
1264
 
            other_branch=self.source)
1265
 
        tags_ret = self.source.tags.merge_to(
1266
 
            self.target.tags,
1267
 
            overwrite=("tags" in overwrite),
1268
 
            selector=tag_selector)
 
1057
        self.target.generate_revision_history(stop_revision,
 
1058
                (result.old_revid if ("history" not in overwrite) else None),
 
1059
                other_branch=self.source)
 
1060
        tags_ret = self.source.tags.merge_to(self.target.tags,
 
1061
            source_tag_refs=remote_refs_dict_to_tag_refs(refs),
 
1062
            overwrite=("tags" in overwrite))
1269
1063
        if isinstance(tags_ret, tuple):
1270
1064
            (result.tag_updates, result.tag_conflicts) = tags_ret
1271
1065
        else:
1275
1069
 
1276
1070
    def update_refs(self, stop_revision=None):
1277
1071
        interrepo = _mod_repository.InterRepository.get(
1278
 
            self.source.repository, self.target.repository)
 
1072
                self.source.repository, self.target.repository)
1279
1073
        c = self.source.get_config_stack()
1280
1074
        fetch_tags = c.get('branch.fetch_tags')
1281
1075
 
1282
1076
        if stop_revision is None:
1283
 
            result = interrepo.fetch(branches=[self.source.ref], include_tags=fetch_tags)
 
1077
            refs = interrepo.fetch(branches=["HEAD"], include_tags=fetch_tags)
1284
1078
            try:
1285
 
                head = result.refs[self.source.ref]
 
1079
                head = refs["HEAD"]
1286
1080
            except KeyError:
1287
1081
                stop_revision = revision.NULL_REVISION
1288
1082
            else:
1289
1083
                stop_revision = self.target.lookup_foreign_revision_id(head)
1290
1084
        else:
1291
 
            result = interrepo.fetch(
1292
 
                revision_id=stop_revision, include_tags=fetch_tags)
1293
 
        return result.refs, stop_revision
 
1085
            refs = interrepo.fetch(revision_id=stop_revision, include_tags=fetch_tags)
 
1086
        return refs, stop_revision
1294
1087
 
1295
1088
    def pull(self, stop_revision=None, overwrite=False,
1296
 
             possible_transports=None, run_hooks=True, local=False,
1297
 
             tag_selector=None):
 
1089
             possible_transports=None, run_hooks=True, local=False):
1298
1090
        # This type of branch can't be bound.
1299
1091
        if local:
1300
1092
            raise errors.LocalRequiresBoundBranch()
1301
1093
        if overwrite is True:
1302
1094
            overwrite = set(["history", "tags"])
1303
 
        elif not overwrite:
 
1095
        else:
1304
1096
            overwrite = set()
1305
1097
 
1306
1098
        result = GitPullResult()
1309
1101
        with self.target.lock_write(), self.source.lock_read():
1310
1102
            result.old_revid = self.target.last_revision()
1311
1103
            refs, stop_revision = self.update_refs(stop_revision)
1312
 
            self.target.generate_revision_history(
1313
 
                stop_revision,
1314
 
                (result.old_revid if ("history" not in overwrite) else None),
1315
 
                other_branch=self.source)
1316
 
            tags_ret = self.source.tags.merge_to(
1317
 
                self.target.tags, overwrite=("tags" in overwrite),
1318
 
                selector=tag_selector)
 
1104
            self.target.generate_revision_history(stop_revision,
 
1105
                    (result.old_revid if ("history" not in overwrite) else None),
 
1106
                    other_branch=self.source)
 
1107
            tags_ret = self.source.tags.merge_to(self.target.tags,
 
1108
                overwrite=("tags" in overwrite),
 
1109
                source_tag_refs=remote_refs_dict_to_tag_refs(refs))
1319
1110
            if isinstance(tags_ret, tuple):
1320
1111
                (result.tag_updates, result.tag_conflicts) = tags_ret
1321
1112
            else:
1330
1121
 
1331
1122
 
1332
1123
class InterToGitBranch(branch.GenericInterBranch):
1333
 
    """InterBranch implementation that pulls into a Git branch."""
 
1124
    """InterBranch implementation that pulls from a non-bzr into a Git branch."""
1334
1125
 
1335
1126
    def __init__(self, source, target):
1336
1127
        super(InterToGitBranch, self).__init__(source, target)
1337
1128
        self.interrepo = _mod_repository.InterRepository.get(source.repository,
1338
 
                                                             target.repository)
 
1129
                                           target.repository)
1339
1130
 
1340
1131
    @staticmethod
1341
1132
    def _get_branch_formats_to_test():
1353
1144
        return (not isinstance(source, GitBranch) and
1354
1145
                isinstance(target, GitBranch))
1355
1146
 
1356
 
    def _get_new_refs(self, stop_revision=None, fetch_tags=None,
1357
 
                      stop_revno=None):
 
1147
    def _get_new_refs(self, stop_revision=None, fetch_tags=None):
1358
1148
        if not self.source.is_locked():
1359
1149
            raise errors.ObjectNotLocked(self.source)
1360
1150
        if stop_revision is None:
1361
1151
            (stop_revno, stop_revision) = self.source.last_revision_info()
1362
 
        elif stop_revno is None:
1363
 
            try:
1364
 
                stop_revno = self.source.revision_id_to_revno(stop_revision)
1365
 
            except errors.NoSuchRevision:
1366
 
                stop_revno = None
1367
 
        if not isinstance(stop_revision, bytes):
 
1152
        else:
 
1153
            stop_revno = self.source.revision_id_to_revno(stop_revision)
 
1154
        if type(stop_revision) is not str:
1368
1155
            raise TypeError(stop_revision)
1369
1156
        main_ref = self.target.ref
1370
 
        refs = {main_ref: (None, stop_revision)}
 
1157
        refs = { main_ref: (None, stop_revision) }
1371
1158
        if fetch_tags is None:
1372
1159
            c = self.source.get_config_stack()
1373
1160
            fetch_tags = c.get('branch.fetch_tags')
1374
 
        for name, revid in self.source.tags.get_tag_dict().items():
 
1161
        for name, revid in self.source.tags.get_tag_dict().iteritems():
1375
1162
            if self.source.repository.has_revision(revid):
1376
1163
                ref = tag_name_to_ref(name)
1377
1164
                if not check_ref_format(ref):
1378
1165
                    warning("skipping tag with invalid characters %s (%s)",
1379
 
                            name, ref)
 
1166
                        name, ref)
1380
1167
                    continue
1381
1168
                if fetch_tags:
1382
1169
                    # FIXME: Skip tags that are not in the ancestry
1383
1170
                    refs[ref] = (None, revid)
1384
1171
        return refs, main_ref, (stop_revno, stop_revision)
1385
1172
 
1386
 
    def _update_refs(self, result, old_refs, new_refs, overwrite, tag_selector):
 
1173
    def _update_refs(self, result, old_refs, new_refs, overwrite):
1387
1174
        mutter("updating refs. old refs: %r, new refs: %r",
1388
1175
               old_refs, new_refs)
1389
1176
        result.tag_updates = {}
1390
1177
        result.tag_conflicts = []
1391
 
        ret = {}
1392
 
 
 
1178
        ret = dict(old_refs)
1393
1179
        def ref_equals(refs, ref, git_sha, revid):
1394
1180
            try:
1395
1181
                value = refs[ref]
1397
1183
                return False
1398
1184
            if (value[0] is not None and
1399
1185
                git_sha is not None and
1400
 
                    value[0] == git_sha):
 
1186
                value[0] == git_sha):
1401
1187
                return True
1402
1188
            if (value[1] is not None and
1403
1189
                revid is not None and
1404
 
                    value[1] == revid):
 
1190
                value[1] == revid):
1405
1191
                return True
1406
 
            # FIXME: If one side only has the git sha available and the other
1407
 
            # only has the bzr revid, then this will cause us to show a tag as
1408
 
            # updated that hasn't actually been updated.
 
1192
            # FIXME: If one side only has the git sha available and the other only
 
1193
            # has the bzr revid, then this will cause us to show a tag as updated
 
1194
            # that hasn't actually been updated.
1409
1195
            return False
1410
1196
        # FIXME: Check for diverged branches
1411
 
        for ref, (git_sha, revid) in new_refs.items():
 
1197
        for ref, (git_sha, revid) in new_refs.iteritems():
1412
1198
            if ref_equals(ret, ref, git_sha, revid):
1413
1199
                # Already up to date
1414
1200
                if git_sha is None:
1422
1208
                except ValueError:
1423
1209
                    pass
1424
1210
                else:
1425
 
                    if tag_selector and not tag_selector(tag_name):
1426
 
                        continue
1427
1211
                    result.tag_updates[tag_name] = revid
1428
1212
                ret[ref] = (git_sha, revid)
1429
1213
            else:
1435
1219
                    except ValueError:
1436
1220
                        pass
1437
1221
                    else:
1438
 
                        result.tag_conflicts.append(
1439
 
                            (name, revid, ret[name][1]))
 
1222
                        result.tag_conflicts.append((name, revid, ret[name][1]))
1440
1223
                else:
1441
1224
                    ret[ref] = (git_sha, revid)
1442
1225
        return ret
1443
1226
 
1444
 
    def fetch(self, stop_revision=None, fetch_tags=None, lossy=False,
1445
 
              limit=None):
 
1227
    def fetch(self, stop_revision=None, fetch_tags=None, lossy=False, limit=None):
1446
1228
        if stop_revision is None:
1447
1229
            stop_revision = self.source.last_revision()
1448
1230
        ret = []
1449
1231
        if fetch_tags:
1450
 
            for k, v in self.source.tags.get_tag_dict().items():
 
1232
            for k, v in self.source.tags.get_tag_dict().iteritems():
1451
1233
                ret.append((None, v))
1452
1234
        ret.append((None, stop_revision))
1453
1235
        try:
1454
 
            revidmap = self.interrepo.fetch_objects(ret, lossy=lossy, limit=limit)
 
1236
            self.interrepo.fetch_objects(ret, lossy=lossy, limit=limit)
1455
1237
        except NoPushSupport:
1456
1238
            raise errors.NoRoundtrippingSupport(self.source, self.target)
1457
 
        return _mod_repository.FetchResult(revidmap={
1458
 
            old_revid: new_revid
1459
 
            for (old_revid, (new_sha, new_revid)) in revidmap.items()})
1460
1239
 
1461
1240
    def pull(self, overwrite=False, stop_revision=None, local=False,
1462
 
             possible_transports=None, run_hooks=True, _stop_revno=None,
1463
 
             tag_selector=None):
 
1241
             possible_transports=None, run_hooks=True):
1464
1242
        result = GitBranchPullResult()
1465
1243
        result.source_branch = self.source
1466
1244
        result.target_branch = self.target
1467
1245
        with self.source.lock_read(), self.target.lock_write():
1468
1246
            new_refs, main_ref, stop_revinfo = self._get_new_refs(
1469
 
                stop_revision, stop_revno=_stop_revno)
1470
 
 
 
1247
                stop_revision)
1471
1248
            def update_refs(old_refs):
1472
 
                return self._update_refs(result, old_refs, new_refs, overwrite, tag_selector)
 
1249
                return self._update_refs(result, old_refs, new_refs, overwrite)
1473
1250
            try:
1474
 
                result.revidmap, old_refs, new_refs = (
1475
 
                    self.interrepo.fetch_refs(update_refs, lossy=False))
 
1251
                result.revidmap, old_refs, new_refs = self.interrepo.fetch_refs(
 
1252
                    update_refs, lossy=False)
1476
1253
            except NoPushSupport:
1477
1254
                raise errors.NoRoundtrippingSupport(self.source, self.target)
1478
 
            (old_sha1, result.old_revid) = old_refs.get(
1479
 
                main_ref, (ZERO_SHA, NULL_REVISION))
 
1255
            (old_sha1, result.old_revid) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
1480
1256
            if result.old_revid is None:
1481
 
                result.old_revid = self.target.lookup_foreign_revision_id(
1482
 
                    old_sha1)
 
1257
                result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
1483
1258
            result.new_revid = new_refs[main_ref][1]
1484
1259
            result.local_branch = None
1485
1260
            result.master_branch = self.target
1489
1264
        return result
1490
1265
 
1491
1266
    def push(self, overwrite=False, stop_revision=None, lossy=False,
1492
 
             _override_hook_source_branch=None, _stop_revno=None,
1493
 
             tag_selector=None):
 
1267
             _override_hook_source_branch=None):
1494
1268
        result = GitBranchPushResult()
1495
1269
        result.source_branch = self.source
1496
1270
        result.target_branch = self.target
1497
1271
        result.local_branch = None
1498
1272
        result.master_branch = result.target_branch
1499
1273
        with self.source.lock_read(), self.target.lock_write():
1500
 
            new_refs, main_ref, stop_revinfo = self._get_new_refs(
1501
 
                stop_revision, stop_revno=_stop_revno)
1502
 
 
 
1274
            new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
1503
1275
            def update_refs(old_refs):
1504
 
                return self._update_refs(result, old_refs, new_refs, overwrite, tag_selector)
 
1276
                return self._update_refs(result, old_refs, new_refs, overwrite)
1505
1277
            try:
1506
 
                result.revidmap, old_refs, new_refs = (
1507
 
                    self.interrepo.fetch_refs(
1508
 
                        update_refs, lossy=lossy, overwrite=overwrite))
 
1278
                result.revidmap, old_refs, new_refs = self.interrepo.fetch_refs(
 
1279
                    update_refs, lossy=lossy, overwrite=overwrite)
1509
1280
            except NoPushSupport:
1510
1281
                raise errors.NoRoundtrippingSupport(self.source, self.target)
1511
 
            (old_sha1, result.old_revid) = old_refs.get(
1512
 
                main_ref, (ZERO_SHA, NULL_REVISION))
1513
 
            if lossy or result.old_revid is None:
1514
 
                result.old_revid = self.target.lookup_foreign_revision_id(
1515
 
                    old_sha1)
 
1282
            (old_sha1, result.old_revid) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
 
1283
            if result.old_revid is None:
 
1284
                result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
1516
1285
            result.new_revid = new_refs[main_ref][1]
1517
 
            (result.new_original_revno,
1518
 
                result.new_original_revid) = stop_revinfo
 
1286
            (result.new_original_revno, result.new_original_revid) = stop_revinfo
1519
1287
            for hook in branch.Branch.hooks['post_push']:
1520
1288
                hook(result)
1521
1289
        return result