« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 5273.1.5
- compare with another revision
- compare with revision 5452
- download diff
- download tarball
- view history from revision 5273.1.5
- Committer: Vincent Ladeuil
- Date: 2010-06-17 09:23:19 UTC
- mfrom: (5301 +trunk)
- mto: (5247.1.8 first-try)
- mto: This revision was merged to the branch mainline in revision 5326.
- Revision ID: v.ladeuil+lp@free.fr-20100617092319-da2bzdtf3j0voynf
Merge bzr.dev into cleanup
- files modified:
- INSTALL
added
removed
bzrlib/branch.py
29
29
errors,
30
30
lockdir,
31
31
lockable_files,
32
remote,
32
33
repository,
33
34
revision as _mod_revision,
34
35
rio,
197
198
return self.supports_tags() and self.tags.get_tag_dict()
198
199
199
200
def get_config(self):
201
"""Get a bzrlib.config.BranchConfig for this Branch.
202
203
This can then be used to get and set configuration options for the
204
branch.
205
206
:return: A bzrlib.config.BranchConfig.
207
"""
200
208
return BranchConfig(self)
201
209
202
210
def _get_config(self):
961
969
raise errors.NoSuchRevision(self, stop_revision)
962
970
return other_history[self_len:stop_revision]
963
971
964
@needs_write_lock
965
972
def update_revisions(self, other, stop_revision=None, overwrite=False,
966
973
graph=None):
967
974
"""Pull in new perfect-fit revisions.
1016
1023
self._extend_partial_history(distance_from_last)
1017
1024
return self._partial_revision_history_cache[distance_from_last]
1018
1025
1019
@needs_write_lock
1020
1026
def pull(self, source, overwrite=False, stop_revision=None,
1021
1027
possible_transports=None, *args, **kwargs):
1022
1028
"""Mirror source into this branch.
1265
1271
revno = 1
1266
1272
destination.set_last_revision_info(revno, revision_id)
1267
1273
1268
@needs_read_lock
1269
1274
def copy_content_into(self, destination, revision_id=None):
1270
1275
"""Copy the content of self into destination.
1271
1276
1272
1277
revision_id: if not None, the revision history in the new branch will
1273
1278
be truncated to end with revision_id.
1274
1279
"""
1275
self.update_references(destination)
1276
self._synchronize_history(destination, revision_id)
1277
try:
1278
parent = self.get_parent()
1279
except errors.InaccessibleParent, e:
1280
mutter('parent was not accessible to copy: %s', e)
1281
else:
1282
if parent:
1283
destination.set_parent(parent)
1284
if self._push_should_merge_tags():
1285
self.tags.merge_to(destination.tags)
1280
return InterBranch.get(self, destination).copy_content_into(
1281
revision_id=revision_id)
1286
1282
1287
1283
def update_references(self, target):
1288
1284
if not getattr(self._format, 'supports_reference_locations', False):
3188
3184
_optimisers = []
3189
3185
"""The available optimised InterBranch types."""
3190
3186
3191
@staticmethod
3192
def _get_branch_formats_to_test():
3193
"""Return a tuple with the Branch formats to use when testing."""
3194
raise NotImplementedError(InterBranch._get_branch_formats_to_test)
3187
@classmethod
3188
def _get_branch_formats_to_test(klass):
3189
"""Return an iterable of format tuples for testing.
3190
3191
:return: An iterable of (from_format, to_format) to use when testing
3192
this InterBranch class. Each InterBranch class should define this
3193
method itself.
3194
"""
3195
raise NotImplementedError(klass._get_branch_formats_to_test)
3195
3196
3197
@needs_write_lock
3196
3198
def pull(self, overwrite=False, stop_revision=None,
3197
3199
possible_transports=None, local=False):
3198
3200
"""Mirror source into target branch.
3203
3205
"""
3204
3206
raise NotImplementedError(self.pull)
3205
3207
3208
@needs_write_lock
3206
3209
def update_revisions(self, stop_revision=None, overwrite=False,
3207
3210
graph=None):
3208
3211
"""Pull in new perfect-fit revisions.
3216
3219
"""
3217
3220
raise NotImplementedError(self.update_revisions)
3218
3221
3222
@needs_write_lock
3219
3223
def push(self, overwrite=False, stop_revision=None,
3220
3224
_override_hook_source_branch=None):
3221
3225
"""Mirror the source branch into the target branch.
3226
3230
3227
3231
3228
3232
class GenericInterBranch(InterBranch):
3229
"""InterBranch implementation that uses public Branch functions.
3230
"""
3231
3232
@staticmethod
3233
def _get_branch_formats_to_test():
3234
return BranchFormat._default_format, BranchFormat._default_format
3235
3233
"""InterBranch implementation that uses public Branch functions."""
3234
3235
@classmethod
3236
def is_compatible(klass, source, target):
3237
# GenericBranch uses the public API, so always compatible
3238
return True
3239
3240
@classmethod
3241
def _get_branch_formats_to_test(klass):
3242
return [(BranchFormat._default_format, BranchFormat._default_format)]
3243
3244
@classmethod
3245
def unwrap_format(klass, format):
3246
if isinstance(format, remote.RemoteBranchFormat):
3247
format._ensure_real()
3248
return format._custom_format
3249
return format
3250
3251
@needs_write_lock
3252
def copy_content_into(self, revision_id=None):
3253
"""Copy the content of source into target
3254
3255
revision_id: if not None, the revision history in the new branch will
3256
be truncated to end with revision_id.
3257
"""
3258
self.source.update_references(self.target)
3259
self.source._synchronize_history(self.target, revision_id)
3260
try:
3261
parent = self.source.get_parent()
3262
except errors.InaccessibleParent, e:
3263
mutter('parent was not accessible to copy: %s', e)
3264
else:
3265
if parent:
3266
self.target.set_parent(parent)
3267
if self.source._push_should_merge_tags():
3268
self.source.tags.merge_to(self.target.tags)
3269
3270
@needs_write_lock
3236
3271
def update_revisions(self, stop_revision=None, overwrite=False,
3237
3272
graph=None):
3238
3273
"""See InterBranch.update_revisions()."""
3239
self.source.lock_read()
3240
try:
3241
other_revno, other_last_revision = self.source.last_revision_info()
3242
stop_revno = None # unknown
3243
if stop_revision is None:
3244
stop_revision = other_last_revision
3245
if _mod_revision.is_null(stop_revision):
3246
# if there are no commits, we're done.
3247
return
3248
stop_revno = other_revno
3249
3250
# what's the current last revision, before we fetch [and change it
3251
# possibly]
3252
last_rev = _mod_revision.ensure_null(self.target.last_revision())
3253
# we fetch here so that we don't process data twice in the common
3254
# case of having something to pull, and so that the check for
3255
# already merged can operate on the just fetched graph, which will
3256
# be cached in memory.
3257
self.target.fetch(self.source, stop_revision)
3258
# Check to see if one is an ancestor of the other
3259
if not overwrite:
3260
if graph is None:
3261
graph = self.target.repository.get_graph()
3262
if self.target._check_if_descendant_or_diverged(
3263
stop_revision, last_rev, graph, self.source):
3264
# stop_revision is a descendant of last_rev, but we aren't
3265
# overwriting, so we're done.
3266
return
3267
if stop_revno is None:
3268
if graph is None:
3269
graph = self.target.repository.get_graph()
3270
this_revno, this_last_revision = \
3271
self.target.last_revision_info()
3272
stop_revno = graph.find_distance_to_null(stop_revision,
3273
[(other_last_revision, other_revno),
3274
(this_last_revision, this_revno)])
3275
self.target.set_last_revision_info(stop_revno, stop_revision)
3276
finally:
3277
self.source.unlock()
3278
3274
other_revno, other_last_revision = self.source.last_revision_info()
3275
stop_revno = None # unknown
3276
if stop_revision is None:
3277
stop_revision = other_last_revision
3278
if _mod_revision.is_null(stop_revision):
3279
# if there are no commits, we're done.
3280
return
3281
stop_revno = other_revno
3282
3283
# what's the current last revision, before we fetch [and change it
3284
# possibly]
3285
last_rev = _mod_revision.ensure_null(self.target.last_revision())
3286
# we fetch here so that we don't process data twice in the common
3287
# case of having something to pull, and so that the check for
3288
# already merged can operate on the just fetched graph, which will
3289
# be cached in memory.
3290
self.target.fetch(self.source, stop_revision)
3291
# Check to see if one is an ancestor of the other
3292
if not overwrite:
3293
if graph is None:
3294
graph = self.target.repository.get_graph()
3295
if self.target._check_if_descendant_or_diverged(
3296
stop_revision, last_rev, graph, self.source):
3297
# stop_revision is a descendant of last_rev, but we aren't
3298
# overwriting, so we're done.
3299
return
3300
if stop_revno is None:
3301
if graph is None:
3302
graph = self.target.repository.get_graph()
3303
this_revno, this_last_revision = \
3304
self.target.last_revision_info()
3305
stop_revno = graph.find_distance_to_null(stop_revision,
3306
[(other_last_revision, other_revno),
3307
(this_last_revision, this_revno)])
3308
self.target.set_last_revision_info(stop_revno, stop_revision)
3309
3310
@needs_write_lock
3279
3311
def pull(self, overwrite=False, stop_revision=None,
3280
possible_transports=None, _hook_master=None, run_hooks=True,
3312
possible_transports=None, run_hooks=True,
3281
3313
_override_hook_target=None, local=False):
3282
"""See Branch.pull.
3314
"""Pull from source into self, updating my master if any.
3283
3315
3284
:param _hook_master: Private parameter - set the branch to
3285
be supplied as the master to pull hooks.
3286
3316
:param run_hooks: Private parameter - if false, this branch
3287
3317
is being called because it's the master of the primary branch,
3288
3318
so it should not run its hooks.
3289
:param _override_hook_target: Private parameter - set the branch to be
3290
supplied as the target_branch to pull hooks.
3291
:param local: Only update the local branch, and not the bound branch.
3292
3319
"""
3293
# This type of branch can't be bound.
3294
if local:
3320
bound_location = self.target.get_bound_location()
3321
if local and not bound_location:
3295
3322
raise errors.LocalRequiresBoundBranch()
3296
result = PullResult()
3297
result.source_branch = self.source
3298
if _override_hook_target is None:
3299
result.target_branch = self.target
3300
else:
3301
result.target_branch = _override_hook_target
3302
self.source.lock_read()
3323
master_branch = None
3324
if not local and bound_location and self.source.user_url != bound_location:
3325
# not pulling from master, so we need to update master.
3326
master_branch = self.target.get_master_branch(possible_transports)
3327
master_branch.lock_write()
3303
3328
try:
3304
# We assume that during 'pull' the target repository is closer than
3305
# the source one.
3306
self.source.update_references(self.target)
3307
graph = self.target.repository.get_graph(self.source.repository)
3308
# TODO: Branch formats should have a flag that indicates
3309
# that revno's are expensive, and pull() should honor that flag.
3310
# -- JRV20090506
3311
result.old_revno, result.old_revid = \
3312
self.target.last_revision_info()
3313
self.target.update_revisions(self.source, stop_revision,
3314
overwrite=overwrite, graph=graph)
3315
# TODO: The old revid should be specified when merging tags,
3316
# so a tags implementation that versions tags can only
3317
# pull in the most recent changes. -- JRV20090506
3318
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3319
overwrite)
3320
result.new_revno, result.new_revid = self.target.last_revision_info()
3321
if _hook_master:
3322
result.master_branch = _hook_master
3323
result.local_branch = result.target_branch
3324
else:
3325
result.master_branch = result.target_branch
3326
result.local_branch = None
3327
if run_hooks:
3328
for hook in Branch.hooks['post_pull']:
3329
hook(result)
3329
if master_branch:
3330
# pull from source into master.
3331
master_branch.pull(self.source, overwrite, stop_revision,
3332
run_hooks=False)
3333
return self._pull(overwrite,
3334
stop_revision, _hook_master=master_branch,
3335
run_hooks=run_hooks,
3336
_override_hook_target=_override_hook_target)
3330
3337
finally:
3331
self.source.unlock()
3332
return result
3338
if master_branch:
3339
master_branch.unlock()
3333
3340
3334
3341
def push(self, overwrite=False, stop_revision=None,
3335
3342
_override_hook_source_branch=None):
3397
3404
_run_hooks()
3398
3405
return result
3399
3406
3400
@classmethod
3401
def is_compatible(self, source, target):
3402
# GenericBranch uses the public API, so always compatible
3403
return True
3404
3405
3406
class InterToBranch5(GenericInterBranch):
3407
3408
@staticmethod
3409
def _get_branch_formats_to_test():
3410
return BranchFormat._default_format, BzrBranchFormat5()
3411
3412
def pull(self, overwrite=False, stop_revision=None,
3413
possible_transports=None, run_hooks=True,
3407
def _pull(self, overwrite=False, stop_revision=None,
3408
possible_transports=None, _hook_master=None, run_hooks=True,
3414
3409
_override_hook_target=None, local=False):
3415
"""Pull from source into self, updating my master if any.
3416
3410
"""See Branch.pull.
3411
3412
This function is the core worker, used by GenericInterBranch.pull to
3413
avoid duplication when pulling source->master and source->local.
3414
3415
:param _hook_master: Private parameter - set the branch to
3416
be supplied as the master to pull hooks.
3417
3417
:param run_hooks: Private parameter - if false, this branch
3418
3418
is being called because it's the master of the primary branch,
3419
3419
so it should not run its hooks.
3420
:param _override_hook_target: Private parameter - set the branch to be
3421
supplied as the target_branch to pull hooks.
3422
:param local: Only update the local branch, and not the bound branch.
3420
3423
"""
3421
bound_location = self.target.get_bound_location()
3422
if local and not bound_location:
3424
# This type of branch can't be bound.
3425
if local:
3423
3426
raise errors.LocalRequiresBoundBranch()
3424
master_branch = None
3425
if not local and bound_location and self.source.user_url != bound_location:
3426
# not pulling from master, so we need to update master.
3427
master_branch = self.target.get_master_branch(possible_transports)
3428
master_branch.lock_write()
3427
result = PullResult()
3428
result.source_branch = self.source
3429
if _override_hook_target is None:
3430
result.target_branch = self.target
3431
else:
3432
result.target_branch = _override_hook_target
3433
self.source.lock_read()
3429
3434
try:
3430
if master_branch:
3431
# pull from source into master.
3432
master_branch.pull(self.source, overwrite, stop_revision,
3433
run_hooks=False)
3434
return super(InterToBranch5, self).pull(overwrite,
3435
stop_revision, _hook_master=master_branch,
3436
run_hooks=run_hooks,
3437
_override_hook_target=_override_hook_target)
3435
# We assume that during 'pull' the target repository is closer than
3436
# the source one.
3437
self.source.update_references(self.target)
3438
graph = self.target.repository.get_graph(self.source.repository)
3439
# TODO: Branch formats should have a flag that indicates
3440
# that revno's are expensive, and pull() should honor that flag.
3441
# -- JRV20090506
3442
result.old_revno, result.old_revid = \
3443
self.target.last_revision_info()
3444
self.target.update_revisions(self.source, stop_revision,
3445
overwrite=overwrite, graph=graph)
3446
# TODO: The old revid should be specified when merging tags,
3447
# so a tags implementation that versions tags can only
3448
# pull in the most recent changes. -- JRV20090506
3449
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3450
overwrite)
3451
result.new_revno, result.new_revid = self.target.last_revision_info()
3452
if _hook_master:
3453
result.master_branch = _hook_master
3454
result.local_branch = result.target_branch
3455
else:
3456
result.master_branch = result.target_branch
3457
result.local_branch = None
3458
if run_hooks:
3459
for hook in Branch.hooks['post_pull']:
3460
hook(result)
3438
3461
finally:
3439
if master_branch:
3440
master_branch.unlock()
3462
self.source.unlock()
3463
return result
3441
3464
3442
3465
3443
3466
InterBranch.register_optimiser(GenericInterBranch)
3444
InterBranch.register_optimiser(InterToBranch5)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1