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

Merge tree reference fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/branch.py
51
51
    text_type,
52
52
    viewitems,
53
53
    )
54
 
from .trace import mutter, mutter_callsite, note, is_quiet
 
54
from .trace import mutter, mutter_callsite, note, is_quiet, warning
55
55
 
56
56
 
57
57
class UnstackableBranchFormat(errors.BzrError):
1273
1273
    def update_references(self, target):
1274
1274
        if not getattr(self._format, 'supports_reference_locations', False):
1275
1275
            return
1276
 
        reference_dict = self._get_all_reference_info()
1277
 
        if len(reference_dict) == 0:
1278
 
            return
1279
 
        old_base = self.base
1280
 
        new_base = target.base
1281
 
        target_reference_dict = target._get_all_reference_info()
1282
 
        for tree_path, (branch_location, file_id) in viewitems(reference_dict):
1283
 
            branch_location = urlutils.rebase_url(branch_location,
1284
 
                                                  old_base, new_base)
1285
 
            target_reference_dict.setdefault(
1286
 
                tree_path, (branch_location, file_id))
1287
 
        target._set_all_reference_info(target_reference_dict)
 
1276
        return InterBranch.get(self, target).update_references()
1288
1277
 
1289
1278
    def check(self, refs):
1290
1279
        """Check consistency of the branch.
1405
1394
        with basis_tree.lock_read():
1406
1395
            for path in basis_tree.iter_references():
1407
1396
                reference_parent = tree.reference_parent(path)
 
1397
                if reference_parent is None:
 
1398
                    warning('Branch location for %s unknown.', path)
 
1399
                    continue
1408
1400
                reference_parent.create_checkout(
1409
1401
                    tree.abspath(path),
1410
1402
                    basis_tree.get_reference_revision(path), lightweight)
2101
2093
        """
2102
2094
        raise NotImplementedError(self.fetch)
2103
2095
 
 
2096
    def update_references(self):
 
2097
        """Import reference information from source to target.
 
2098
        """
 
2099
        raise NotImplementedError(self.update_references)
 
2100
 
2104
2101
 
2105
2102
def _fix_overwrite_type(overwrite):
2106
2103
    if isinstance(overwrite, bool):
2137
2134
                     be truncated to end with revision_id.
2138
2135
        """
2139
2136
        with self.source.lock_read(), self.target.lock_write():
2140
 
            self.source.update_references(self.target)
2141
2137
            self.source._synchronize_history(self.target, revision_id)
 
2138
            self.update_references()
2142
2139
            try:
2143
2140
                parent = self.source.get_parent()
2144
2141
            except errors.InaccessibleParent as e:
2307
2304
        result.source_branch = self.source
2308
2305
        result.target_branch = self.target
2309
2306
        result.old_revno, result.old_revid = self.target.last_revision_info()
2310
 
        self.source.update_references(self.target)
2311
2307
        overwrite = _fix_overwrite_type(overwrite)
2312
2308
        if result.old_revid != stop_revision:
2313
2309
            # We assume that during 'push' this repository is closer than
2319
2315
            result.tag_updates, result.tag_conflicts = (
2320
2316
                self.source.tags.merge_to(
2321
2317
                    self.target.tags, "tags" in overwrite))
 
2318
        self.update_references()
2322
2319
        result.new_revno, result.new_revid = self.target.last_revision_info()
2323
2320
        return result
2324
2321
 
2354
2351
        with self.source.lock_read():
2355
2352
            # We assume that during 'pull' the target repository is closer than
2356
2353
            # the source one.
2357
 
            self.source.update_references(self.target)
2358
2354
            graph = self.target.repository.get_graph(self.source.repository)
2359
2355
            # TODO: Branch formats should have a flag that indicates
2360
2356
            # that revno's are expensive, and pull() should honor that flag.
2371
2367
                self.source.tags.merge_to(
2372
2368
                    self.target.tags, "tags" in overwrite,
2373
2369
                    ignore_master=not merge_tags_to_master))
 
2370
            self.update_references()
2374
2371
            result.new_revno, result.new_revid = (
2375
2372
                self.target.last_revision_info())
2376
2373
            if _hook_master:
2384
2381
                    hook(result)
2385
2382
            return result
2386
2383
 
 
2384
    def update_references(self):
 
2385
        if not getattr(self.source._format, 'supports_reference_locations', False):
 
2386
            return
 
2387
        reference_dict = self.source._get_all_reference_info()
 
2388
        if len(reference_dict) == 0:
 
2389
            return
 
2390
        old_base = self.source.base
 
2391
        new_base = self.target.base
 
2392
        target_reference_dict = self.target._get_all_reference_info()
 
2393
        for tree_path, (branch_location, file_id) in viewitems(reference_dict):
 
2394
            branch_location = urlutils.rebase_url(branch_location,
 
2395
                                                  old_base, new_base)
 
2396
            target_reference_dict.setdefault(
 
2397
                tree_path, (branch_location, file_id))
 
2398
        self.target._set_all_reference_info(target_reference_dict)
 
2399
 
2387
2400
 
2388
2401
InterBranch.register_optimiser(GenericInterBranch)