85
142
"""Branch holding a history of revisions.
88
Base directory/url of the branch.
90
hooks: An instance of BranchHooks.
145
Base directory of the branch.
151
If _lock_mode is true, a positive count of the number of times the
155
Lock object from bzrlib.lock.
92
# this is really an instance variable - FIXME move it there
96
# override this to set the strategy for storing tags
98
return DisabledTags(self)
100
def __init__(self, *ignored, **ignored_too):
101
self.tags = self._make_tags()
102
self._revision_history_cache = None
104
def break_lock(self):
105
"""Break a lock if one is present from another instance.
107
Uses the ui factory to ask for confirmation if the lock may be from
110
This will probe the repository for its lock as well.
112
self.control_files.break_lock()
113
self.repository.break_lock()
114
master = self.get_master_branch()
115
if master is not None:
119
@deprecated_method(zero_eight)
120
def open_downlevel(base):
121
"""Open a branch which may be of an old format."""
122
return Branch.open(base, _unsupported=True)
125
def open(base, _unsupported=False):
126
"""Open the branch rooted at base.
128
For instance, if the branch is at URL/.bzr/branch,
129
Branch.open(URL) -> a Branch instance.
131
control = bzrdir.BzrDir.open(base, _unsupported)
132
return control.open_branch(_unsupported)
135
def open_containing(url):
136
"""Open an existing branch which contains url.
138
This probes for a branch at url, and searches upwards from there.
140
Basically we keep looking up until we find the control directory or
141
run into the root. If there isn't one, raises NotBranchError.
142
If there is one and it is either an unrecognised format or an unsupported
143
format, UnknownFormatError or UnsupportedFormatError are raised.
144
If there is one, it is returned, along with the unused portion of url.
146
control, relpath = bzrdir.BzrDir.open_containing(url)
147
return control.open_branch(), relpath
150
@deprecated_function(zero_eight)
151
def initialize(base):
152
"""Create a new working tree and branch, rooted at 'base' (url)
154
NOTE: This will soon be deprecated in favour of creation
157
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
159
@deprecated_function(zero_eight)
160
def setup_caching(self, cache_root):
161
"""Subclasses that care about caching should override this, and set
162
up cached stores located under cache_root.
164
NOTE: This is unused.
168
def get_config(self):
169
return BranchConfig(self)
172
return self.get_config().get_nickname()
174
def _set_nick(self, nick):
175
self.get_config().set_user_option('nickname', nick)
177
nick = property(_get_nick, _set_nick)
180
raise NotImplementedError(self.is_locked)
162
def __init__(self, base, init=False, find_root=True):
163
"""Create new branch object at a particular location.
165
base -- Base directory for the branch.
167
init -- If True, create new control files in a previously
168
unversioned directory. If False, the branch must already
171
find_root -- If true and init is false, find the root of the
172
existing branch containing base.
174
In the test suite, creation of new trees is tested using the
175
`ScratchBranch` class.
178
self.base = os.path.realpath(base)
181
self.base = find_branch_root(base)
183
self.base = os.path.realpath(base)
184
if not isdir(self.controlfilename('.')):
185
from errors import NotBranchError
186
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
187
['use "bzr init" to initialize a new working tree',
188
'current bzr can only operate from top-of-tree'])
191
self.text_store = ImmutableStore(self.controlfilename('text-store'))
192
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
193
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
197
return '%s(%r)' % (self.__class__.__name__, self.base)
204
if self._lock_mode or self._lock:
205
from warnings import warn
206
warn("branch %r was not explicitly unlocked" % self)
182
211
def lock_write(self):
183
raise NotImplementedError(self.lock_write)
213
if self._lock_mode != 'w':
214
from errors import LockError
215
raise LockError("can't upgrade to a write lock from %r" %
217
self._lock_count += 1
219
from bzrlib.lock import WriteLock
221
self._lock = WriteLock(self.controlfilename('branch-lock'))
222
self._lock_mode = 'w'
185
227
def lock_read(self):
186
raise NotImplementedError(self.lock_read)
229
assert self._lock_mode in ('r', 'w'), \
230
"invalid lock mode %r" % self._lock_mode
231
self._lock_count += 1
233
from bzrlib.lock import ReadLock
235
self._lock = ReadLock(self.controlfilename('branch-lock'))
236
self._lock_mode = 'r'
188
241
def unlock(self):
189
raise NotImplementedError(self.unlock)
191
def peek_lock_mode(self):
192
"""Return lock mode for the Branch: 'r', 'w' or None"""
193
raise NotImplementedError(self.peek_lock_mode)
195
def get_physical_lock_status(self):
196
raise NotImplementedError(self.get_physical_lock_status)
242
if not self._lock_mode:
243
from errors import LockError
244
raise LockError('branch %r is not locked' % (self))
246
if self._lock_count > 1:
247
self._lock_count -= 1
251
self._lock_mode = self._lock_count = None
198
254
def abspath(self, name):
199
"""Return absolute filename for something in the branch
201
XXX: Robert Collins 20051017 what is this used for? why is it a branch
202
method and not a tree method.
204
raise NotImplementedError(self.abspath)
206
def bind(self, other):
207
"""Bind the local branch the other branch.
209
:param other: The branch to bind to
212
raise errors.UpgradeRequired(self.base)
215
def fetch(self, from_branch, last_revision=None, pb=None):
216
"""Copy revisions from from_branch into this branch.
218
:param from_branch: Where to copy from.
219
:param last_revision: What revision to stop at (None for at the end
221
:param pb: An optional progress bar to use.
223
Returns the copied revision count and the failed revisions in a tuple:
226
if self.base == from_branch.base:
229
nested_pb = ui.ui_factory.nested_progress_bar()
234
from_branch.lock_read()
236
if last_revision is None:
237
pb.update('get source history')
238
last_revision = from_branch.last_revision()
239
if last_revision is None:
240
last_revision = _mod_revision.NULL_REVISION
241
return self.repository.fetch(from_branch.repository,
242
revision_id=last_revision,
245
if nested_pb is not None:
249
def get_bound_location(self):
250
"""Return the URL of the branch we are bound to.
252
Older format branches cannot bind, please be sure to use a metadir
257
def get_old_bound_location(self):
258
"""Return the URL of the branch we used to be bound to
260
raise errors.UpgradeRequired(self.base)
262
def get_commit_builder(self, parents, config=None, timestamp=None,
263
timezone=None, committer=None, revprops=None,
265
"""Obtain a CommitBuilder for this branch.
267
:param parents: Revision ids of the parents of the new revision.
268
:param config: Optional configuration to use.
269
:param timestamp: Optional timestamp recorded for commit.
270
:param timezone: Optional timezone for timestamp.
271
:param committer: Optional committer to set for commit.
272
:param revprops: Optional dictionary of revision properties.
273
:param revision_id: Optional revision id.
277
config = self.get_config()
279
return self.repository.get_commit_builder(self, parents, config,
280
timestamp, timezone, committer, revprops, revision_id)
282
def get_master_branch(self):
283
"""Return the branch we are bound to.
285
:return: Either a Branch, or None
289
def get_revision_delta(self, revno):
290
"""Return the delta for one revision.
292
The delta is relative to its mainline predecessor, or the
293
empty tree for revision 1.
295
assert isinstance(revno, int)
296
rh = self.revision_history()
297
if not (1 <= revno <= len(rh)):
298
raise InvalidRevisionNumber(revno)
299
return self.repository.get_revision_delta(rh[revno-1])
301
@deprecated_method(zero_sixteen)
302
def get_root_id(self):
303
"""Return the id of this branches root
305
Deprecated: branches don't have root ids-- trees do.
306
Use basis_tree().get_root_id() instead.
308
raise NotImplementedError(self.get_root_id)
310
def print_file(self, file, revision_id):
255
"""Return absolute filename for something in the branch"""
256
return os.path.join(self.base, name)
259
def relpath(self, path):
260
"""Return path relative to this branch of something inside it.
262
Raises an error if path is not in this branch."""
263
return _relpath(self.base, path)
266
def controlfilename(self, file_or_path):
267
"""Return location relative to branch."""
268
if isinstance(file_or_path, types.StringTypes):
269
file_or_path = [file_or_path]
270
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
273
def controlfile(self, file_or_path, mode='r'):
274
"""Open a control file for this branch.
276
There are two classes of file in the control directory: text
277
and binary. binary files are untranslated byte streams. Text
278
control files are stored with Unix newlines and in UTF-8, even
279
if the platform or locale defaults are different.
281
Controlfiles should almost never be opened in write mode but
282
rather should be atomically copied and replaced using atomicfile.
285
fn = self.controlfilename(file_or_path)
287
if mode == 'rb' or mode == 'wb':
288
return file(fn, mode)
289
elif mode == 'r' or mode == 'w':
290
# open in binary mode anyhow so there's no newline translation;
291
# codecs uses line buffering by default; don't want that.
293
return codecs.open(fn, mode + 'b', 'utf-8',
296
raise BzrError("invalid controlfile mode %r" % mode)
300
def _make_control(self):
301
os.mkdir(self.controlfilename([]))
302
self.controlfile('README', 'w').write(
303
"This is a Bazaar-NG control directory.\n"
304
"Do not change any files in this directory.\n")
305
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
306
for d in ('text-store', 'inventory-store', 'revision-store'):
307
os.mkdir(self.controlfilename(d))
308
for f in ('revision-history', 'merged-patches',
309
'pending-merged-patches', 'branch-name',
311
self.controlfile(f, 'w').write('')
312
mutter('created control directory in ' + self.base)
313
Inventory().write_xml(self.controlfile('inventory','w'))
316
def _check_format(self):
317
"""Check this branch format is supported.
319
The current tool only supports the current unstable format.
321
In the future, we might need different in-memory Branch
322
classes to support downlevel branches. But not yet.
324
# This ignores newlines so that we can open branches created
325
# on Windows from Linux and so on. I think it might be better
326
# to always make all internal files in unix format.
327
fmt = self.controlfile('branch-format', 'r').read()
328
fmt.replace('\r\n', '')
329
if fmt != BZR_BRANCH_FORMAT:
330
raise BzrError('sorry, branch format %r not supported' % fmt,
331
['use a different bzr version',
332
'or remove the .bzr directory and "bzr init" again'])
336
def read_working_inventory(self):
337
"""Read the working inventory."""
339
# ElementTree does its own conversion from UTF-8, so open in
343
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
344
mutter("loaded inventory of %d items in %f"
345
% (len(inv), time.time() - before))
351
def _write_inventory(self, inv):
352
"""Update the working inventory.
354
That is to say, the inventory describing changes underway, that
355
will be committed to the next revision.
359
from bzrlib.atomicfile import AtomicFile
361
f = AtomicFile(self.controlfilename('inventory'), 'wb')
370
mutter('wrote working inventory')
373
inventory = property(read_working_inventory, _write_inventory, None,
374
"""Inventory for the working copy.""")
377
def add(self, files, verbose=False, ids=None):
378
"""Make files versioned.
380
Note that the command line normally calls smart_add instead.
382
This puts the files in the Added state, so that they will be
383
recorded by the next commit.
386
List of paths to add, relative to the base of the tree.
389
If set, use these instead of automatically generated ids.
390
Must be the same length as the list of files, but may
391
contain None for ids that are to be autogenerated.
393
TODO: Perhaps have an option to add the ids even if the files do
396
TODO: Perhaps return the ids of the files? But then again it
397
is easy to retrieve them if they're needed.
399
TODO: Adding a directory should optionally recurse down and
400
add all non-ignored children. Perhaps do that in a
403
# TODO: Re-adding a file that is removed in the working copy
404
# should probably put it back with the previous ID.
405
if isinstance(files, types.StringTypes):
406
assert(ids is None or isinstance(ids, types.StringTypes))
412
ids = [None] * len(files)
414
assert(len(ids) == len(files))
418
inv = self.read_working_inventory()
419
for f,file_id in zip(files, ids):
420
if is_control_file(f):
421
raise BzrError("cannot add control file %s" % quotefn(f))
426
raise BzrError("cannot add top-level %r" % f)
428
fullpath = os.path.normpath(self.abspath(f))
431
kind = file_kind(fullpath)
433
# maybe something better?
434
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
436
if kind != 'file' and kind != 'directory':
437
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
440
file_id = gen_file_id(f)
441
inv.add_path(f, kind=kind, file_id=file_id)
444
print 'added', quotefn(f)
446
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
448
self._write_inventory(inv)
453
def print_file(self, file, revno):
311
454
"""Print `file` to stdout."""
312
raise NotImplementedError(self.print_file)
314
def append_revision(self, *revision_ids):
315
raise NotImplementedError(self.append_revision)
317
def set_revision_history(self, rev_history):
318
raise NotImplementedError(self.set_revision_history)
320
def _cache_revision_history(self, rev_history):
321
"""Set the cached revision history to rev_history.
323
The revision_history method will use this cache to avoid regenerating
324
the revision history.
326
This API is semi-public; it only for use by subclasses, all other code
327
should consider it to be private.
329
self._revision_history_cache = rev_history
331
def _clear_cached_state(self):
332
"""Clear any cached data on this branch, e.g. cached revision history.
334
This means the next call to revision_history will need to call
335
_gen_revision_history.
337
This API is semi-public; it only for use by subclasses, all other code
338
should consider it to be private.
340
self._revision_history_cache = None
342
def _gen_revision_history(self):
343
"""Return sequence of revision hashes on to this branch.
345
Unlike revision_history, this method always regenerates or rereads the
346
revision history, i.e. it does not cache the result, so repeated calls
349
Concrete subclasses should override this instead of revision_history so
350
that subclasses do not need to deal with caching logic.
352
This API is semi-public; it only for use by subclasses, all other code
353
should consider it to be private.
355
raise NotImplementedError(self._gen_revision_history)
457
tree = self.revision_tree(self.lookup_revision(revno))
458
# use inventory as it was in that revision
459
file_id = tree.inventory.path2id(file)
461
raise BzrError("%r is not present in revision %d" % (file, revno))
462
tree.print_file(file_id)
467
def remove(self, files, verbose=False):
468
"""Mark nominated files for removal from the inventory.
470
This does not remove their text. This does not run on
472
TODO: Refuse to remove modified files unless --force is given?
474
TODO: Do something useful with directories.
476
TODO: Should this remove the text or not? Tough call; not
477
removing may be useful and the user can just use use rm, and
478
is the opposite of add. Removing it is consistent with most
479
other tools. Maybe an option.
481
## TODO: Normalize names
482
## TODO: Remove nested loops; better scalability
483
if isinstance(files, types.StringTypes):
489
tree = self.working_tree()
492
# do this before any modifications
496
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
497
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
499
# having remove it, it must be either ignored or unknown
500
if tree.is_ignored(f):
504
show_status(new_status, inv[fid].kind, quotefn(f))
507
self._write_inventory(inv)
512
# FIXME: this doesn't need to be a branch method
513
def set_inventory(self, new_inventory_list):
515
for path, file_id, parent, kind in new_inventory_list:
516
name = os.path.basename(path)
519
inv.add(InventoryEntry(file_id, name, kind, parent))
520
self._write_inventory(inv)
524
"""Return all unknown files.
526
These are files in the working directory that are not versioned or
527
control files or ignored.
529
>>> b = ScratchBranch(files=['foo', 'foo~'])
530
>>> list(b.unknowns())
533
>>> list(b.unknowns())
536
>>> list(b.unknowns())
539
return self.working_tree().unknowns()
542
def append_revision(self, revision_id):
543
from bzrlib.atomicfile import AtomicFile
545
mutter("add {%s} to revision-history" % revision_id)
546
rev_history = self.revision_history() + [revision_id]
548
f = AtomicFile(self.controlfilename('revision-history'))
550
for rev_id in rev_history:
557
def get_revision(self, revision_id):
558
"""Return the Revision object for a named revision"""
559
if not revision_id or not isinstance(revision_id, basestring):
560
raise ValueError('invalid revision-id: %r' % revision_id)
561
r = Revision.read_xml(self.revision_store[revision_id])
562
assert r.revision_id == revision_id
565
def get_revision_sha1(self, revision_id):
566
"""Hash the stored value of a revision, and return it."""
567
# In the future, revision entries will be signed. At that
568
# point, it is probably best *not* to include the signature
569
# in the revision hash. Because that lets you re-sign
570
# the revision, (add signatures/remove signatures) and still
571
# have all hash pointers stay consistent.
572
# But for now, just hash the contents.
573
return sha_file(self.revision_store[revision_id])
576
def get_inventory(self, inventory_id):
577
"""Get Inventory object by hash.
579
TODO: Perhaps for this and similar methods, take a revision
580
parameter which can be either an integer revno or a
582
i = Inventory.read_xml(self.inventory_store[inventory_id])
585
def get_inventory_sha1(self, inventory_id):
586
"""Return the sha1 hash of the inventory entry
588
return sha_file(self.inventory_store[inventory_id])
591
def get_revision_inventory(self, revision_id):
592
"""Return inventory of a past revision."""
593
if revision_id == None:
596
return self.get_inventory(self.get_revision(revision_id).inventory_id)
358
599
def revision_history(self):
359
600
"""Return sequence of revision hashes on to this branch.
361
This method will cache the revision history for as long as it is safe to
364
if self._revision_history_cache is not None:
365
history = self._revision_history_cache
602
>>> ScratchBranch().revision_history()
607
return [l.rstrip('\r\n') for l in
608
self.controlfile('revision-history', 'r').readlines()]
613
def common_ancestor(self, other, self_revno=None, other_revno=None):
616
>>> sb = ScratchBranch(files=['foo', 'foo~'])
617
>>> sb.common_ancestor(sb) == (None, None)
619
>>> commit.commit(sb, "Committing first revision", verbose=False)
620
>>> sb.common_ancestor(sb)[0]
622
>>> clone = sb.clone()
623
>>> commit.commit(sb, "Committing second revision", verbose=False)
624
>>> sb.common_ancestor(sb)[0]
626
>>> sb.common_ancestor(clone)[0]
628
>>> commit.commit(clone, "Committing divergent second revision",
630
>>> sb.common_ancestor(clone)[0]
632
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
634
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
636
>>> clone2 = sb.clone()
637
>>> sb.common_ancestor(clone2)[0]
639
>>> sb.common_ancestor(clone2, self_revno=1)[0]
641
>>> sb.common_ancestor(clone2, other_revno=1)[0]
644
my_history = self.revision_history()
645
other_history = other.revision_history()
646
if self_revno is None:
647
self_revno = len(my_history)
648
if other_revno is None:
649
other_revno = len(other_history)
650
indices = range(min((self_revno, other_revno)))
653
if my_history[r] == other_history[r]:
654
return r+1, my_history[r]
657
def enum_history(self, direction):
658
"""Return (revno, revision_id) for history of branch.
661
'forward' is from earliest to latest
662
'reverse' is from latest to earliest
664
rh = self.revision_history()
665
if direction == 'forward':
670
elif direction == 'reverse':
367
history = self._gen_revision_history()
368
self._cache_revision_history(history)
676
raise ValueError('invalid history direction', direction)
372
680
"""Return current revision number for this branch.
495
919
Note that to_name is only the last component of the new name;
496
920
this doesn't change the directory.
498
This returns a list of (from_path, to_path) pairs for each
501
raise NotImplementedError(self.move)
503
def get_parent(self):
504
"""Return the parent location of the branch.
506
This is the default location for push/pull/missing. The usual
507
pattern is that the user can override it by specifying a
510
raise NotImplementedError(self.get_parent)
512
def _set_config_location(self, name, url, config=None,
513
make_relative=False):
515
config = self.get_config()
519
url = urlutils.relative_url(self.base, url)
520
config.set_user_option(name, url)
522
def _get_config_location(self, name, config=None):
524
config = self.get_config()
525
location = config.get_user_option(name)
530
def get_submit_branch(self):
531
"""Return the submit location of the branch.
533
This is the default location for bundle. The usual
534
pattern is that the user can override it by specifying a
537
return self.get_config().get_user_option('submit_branch')
539
def set_submit_branch(self, location):
540
"""Return the submit location of the branch.
542
This is the default location for bundle. The usual
543
pattern is that the user can override it by specifying a
546
self.get_config().set_user_option('submit_branch', location)
548
def get_public_branch(self):
549
"""Return the public location of the branch.
551
This is is used by merge directives.
553
return self._get_config_location('public_branch')
555
def set_public_branch(self, location):
556
"""Return the submit location of the branch.
558
This is the default location for bundle. The usual
559
pattern is that the user can override it by specifying a
562
self._set_config_location('public_branch', location)
564
def get_push_location(self):
565
"""Return the None or the location to push this branch to."""
566
raise NotImplementedError(self.get_push_location)
568
def set_push_location(self, location):
569
"""Set a new push location for this branch."""
570
raise NotImplementedError(self.set_push_location)
572
def set_parent(self, url):
573
raise NotImplementedError(self.set_parent)
577
"""Synchronise this branch with the master branch if any.
579
:return: None or the last_revision pivoted out during the update.
583
def check_revno(self, revno):
585
Check whether a revno corresponds to any revision.
586
Zero (the NULL revision) is considered valid.
589
self.check_real_revno(revno)
591
def check_real_revno(self, revno):
593
Check whether a revno corresponds to a real revision.
594
Zero (the NULL revision) is considered invalid
596
if revno < 1 or revno > self.revno():
597
raise InvalidRevisionNumber(revno)
600
def clone(self, to_bzrdir, revision_id=None):
601
"""Clone this branch into to_bzrdir preserving all semantic values.
603
revision_id: if not None, the revision history in the new branch will
604
be truncated to end with revision_id.
606
result = self._format.initialize(to_bzrdir)
607
self.copy_content_into(result, revision_id=revision_id)
611
def sprout(self, to_bzrdir, revision_id=None):
612
"""Create a new line of development from the branch, into to_bzrdir.
614
revision_id: if not None, the revision history in the new branch will
615
be truncated to end with revision_id.
617
result = self._format.initialize(to_bzrdir)
618
self.copy_content_into(result, revision_id=revision_id)
619
result.set_parent(self.bzrdir.root_transport.base)
622
def _synchronize_history(self, destination, revision_id):
623
"""Synchronize last revision and revision history between branches.
625
This version is most efficient when the destination is also a
626
BzrBranch5, but works for BzrBranch6 as long as the revision
627
history is the true lefthand parent history, and all of the revisions
628
are in the destination's repository. If not, set_revision_history
631
:param destination: The branch to copy the history into
632
:param revision_id: The revision-id to truncate history at. May
633
be None to copy complete history.
635
new_history = self.revision_history()
636
if revision_id is not None:
637
revision_id = osutils.safe_revision_id(revision_id)
639
new_history = new_history[:new_history.index(revision_id) + 1]
641
rev = self.repository.get_revision(revision_id)
642
new_history = rev.get_history(self.repository)[1:]
643
destination.set_revision_history(new_history)
646
def copy_content_into(self, destination, revision_id=None):
647
"""Copy the content of self into destination.
649
revision_id: if not None, the revision history in the new branch will
650
be truncated to end with revision_id.
652
self._synchronize_history(destination, revision_id)
654
parent = self.get_parent()
655
except errors.InaccessibleParent, e:
656
mutter('parent was not accessible to copy: %s', e)
659
destination.set_parent(parent)
660
self.tags.merge_to(destination.tags)
664
"""Check consistency of the branch.
666
In particular this checks that revisions given in the revision-history
667
do actually match up in the revision graph, and that they're all
668
present in the repository.
670
Callers will typically also want to check the repository.
672
:return: A BranchCheckResult.
674
mainline_parent_id = None
675
for revision_id in self.revision_history():
677
revision = self.repository.get_revision(revision_id)
678
except errors.NoSuchRevision, e:
679
raise errors.BzrCheckError("mainline revision {%s} not in repository"
681
# In general the first entry on the revision history has no parents.
682
# But it's not illegal for it to have parents listed; this can happen
683
# in imports from Arch when the parents weren't reachable.
684
if mainline_parent_id is not None:
685
if mainline_parent_id not in revision.parent_ids:
686
raise errors.BzrCheckError("previous revision {%s} not listed among "
688
% (mainline_parent_id, revision_id))
689
mainline_parent_id = revision_id
690
return BranchCheckResult(self)
692
def _get_checkout_format(self):
693
"""Return the most suitable metadir for a checkout of this branch.
694
Weaves are used if this branch's repostory uses weaves.
696
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
697
from bzrlib.repofmt import weaverepo
698
format = bzrdir.BzrDirMetaFormat1()
699
format.repository_format = weaverepo.RepositoryFormat7()
701
format = self.repository.bzrdir.checkout_metadir()
702
format.set_branch_format(self._format)
705
def create_checkout(self, to_location, revision_id=None,
707
"""Create a checkout of a branch.
709
:param to_location: The url to produce the checkout at
710
:param revision_id: The revision to check out
711
:param lightweight: If True, produce a lightweight checkout, otherwise,
712
produce a bound branch (heavyweight checkout)
713
:return: The tree of the created checkout
715
t = transport.get_transport(to_location)
718
except errors.FileExists:
721
format = self._get_checkout_format()
722
checkout = format.initialize_on_transport(t)
723
BranchReferenceFormat().initialize(checkout, self)
725
format = self._get_checkout_format()
726
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
727
to_location, force_new_tree=False, format=format)
728
checkout = checkout_branch.bzrdir
729
checkout_branch.bind(self)
730
# pull up to the specified revision_id to set the initial
731
# branch tip correctly, and seed it with history.
732
checkout_branch.pull(self, stop_revision=revision_id)
733
tree = checkout.create_workingtree(revision_id)
734
basis_tree = tree.basis_tree()
735
basis_tree.lock_read()
737
for path, file_id in basis_tree.iter_references():
738
reference_parent = self.reference_parent(file_id, path)
739
reference_parent.create_checkout(tree.abspath(path),
740
basis_tree.get_reference_revision(file_id, path),
746
def reference_parent(self, file_id, path):
747
"""Return the parent branch for a tree-reference file_id
748
:param file_id: The file_id of the tree reference
749
:param path: The path of the file_id in the tree
750
:return: A branch associated with the file_id
752
# FIXME should provide multiple branches, based on config
753
return Branch.open(self.bzrdir.root_transport.clone(path).base)
755
def supports_tags(self):
756
return self._format.supports_tags()
759
class BranchFormat(object):
760
"""An encapsulation of the initialization and open routines for a format.
762
Formats provide three things:
763
* An initialization routine,
767
Formats are placed in an dict by their format string for reference
768
during branch opening. Its not required that these be instances, they
769
can be classes themselves with class methods - it simply depends on
770
whether state is needed for a given format or not.
772
Once a format is deprecated, just deprecate the initialize and open
773
methods on the format class. Do not deprecate the object, as the
774
object will be created every time regardless.
777
_default_format = None
778
"""The default format used for new branches."""
781
"""The known formats."""
784
def find_format(klass, a_bzrdir):
785
"""Return the format for the branch object in a_bzrdir."""
787
transport = a_bzrdir.get_branch_transport(None)
788
format_string = transport.get("format").read()
789
return klass._formats[format_string]
791
raise NotBranchError(path=transport.base)
793
raise errors.UnknownFormatError(format=format_string)
796
def get_default_format(klass):
797
"""Return the current default format."""
798
return klass._default_format
800
def get_format_string(self):
801
"""Return the ASCII format string that identifies this format."""
802
raise NotImplementedError(self.get_format_string)
804
def get_format_description(self):
805
"""Return the short format description for this format."""
806
raise NotImplementedError(self.get_format_description)
808
def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
810
"""Initialize a branch in a bzrdir, with specified files
812
:param a_bzrdir: The bzrdir to initialize the branch in
813
:param utf8_files: The files to create as a list of
814
(filename, content) tuples
815
:param set_format: If True, set the format with
816
self.get_format_string. (BzrBranch4 has its format set
818
:return: a branch in this format
820
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
821
branch_transport = a_bzrdir.get_branch_transport(self)
823
'metadir': ('lock', lockdir.LockDir),
824
'branch4': ('branch-lock', lockable_files.TransportLock),
826
lock_name, lock_class = lock_map[lock_type]
827
control_files = lockable_files.LockableFiles(branch_transport,
828
lock_name, lock_class)
829
control_files.create_lock()
830
control_files.lock_write()
832
control_files.put_utf8('format', self.get_format_string())
834
for file, content in utf8_files:
835
control_files.put_utf8(file, content)
837
control_files.unlock()
838
return self.open(a_bzrdir, _found=True)
840
def initialize(self, a_bzrdir):
841
"""Create a branch of this format in a_bzrdir."""
842
raise NotImplementedError(self.initialize)
844
def is_supported(self):
845
"""Is this format supported?
847
Supported formats can be initialized and opened.
848
Unsupported formats may not support initialization or committing or
849
some other features depending on the reason for not being supported.
853
def open(self, a_bzrdir, _found=False):
854
"""Return the branch object for a_bzrdir
856
_found is a private parameter, do not use it. It is used to indicate
857
if format probing has already be done.
859
raise NotImplementedError(self.open)
862
def register_format(klass, format):
863
klass._formats[format.get_format_string()] = format
866
def set_default_format(klass, format):
867
klass._default_format = format
870
def unregister_format(klass, format):
871
assert klass._formats[format.get_format_string()] is format
872
del klass._formats[format.get_format_string()]
875
return self.get_format_string().rstrip()
877
def supports_tags(self):
878
"""True if this format supports tags stored in the branch"""
879
return False # by default
881
# XXX: Probably doesn't really belong here -- mbp 20070212
882
def _initialize_control_files(self, a_bzrdir, utf8_files, lock_filename,
884
branch_transport = a_bzrdir.get_branch_transport(self)
885
control_files = lockable_files.LockableFiles(branch_transport,
886
lock_filename, lock_class)
887
control_files.create_lock()
888
control_files.lock_write()
890
for filename, content in utf8_files:
891
control_files.put_utf8(filename, content)
893
control_files.unlock()
896
class BranchHooks(Hooks):
897
"""A dictionary mapping hook name to a list of callables for branch hooks.
899
e.g. ['set_rh'] Is the list of items to be called when the
900
set_revision_history function is invoked.
904
"""Create the default hooks.
906
These are all empty initially, because by default nothing should get
910
# Introduced in 0.15:
911
# invoked whenever the revision history has been set
912
# with set_revision_history. The api signature is
913
# (branch, revision_history), and the branch will
916
# invoked after a push operation completes.
917
# the api signature is
919
# containing the members
920
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
921
# where local is the local branch or None, master is the target
922
# master branch, and the rest should be self explanatory. The source
923
# is read locked and the target branches write locked. Source will
924
# be the local low-latency branch.
925
self['post_push'] = []
926
# invoked after a pull operation completes.
927
# the api signature is
929
# containing the members
930
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
931
# where local is the local branch or None, master is the target
932
# master branch, and the rest should be self explanatory. The source
933
# is read locked and the target branches write locked. The local
934
# branch is the low-latency branch.
935
self['post_pull'] = []
936
# invoked after a commit operation completes.
937
# the api signature is
938
# (local, master, old_revno, old_revid, new_revno, new_revid)
939
# old_revid is NULL_REVISION for the first commit to a branch.
940
self['post_commit'] = []
941
# invoked after a uncommit operation completes.
942
# the api signature is
943
# (local, master, old_revno, old_revid, new_revno, new_revid) where
944
# local is the local branch or None, master is the target branch,
945
# and an empty branch recieves new_revno of 0, new_revid of None.
946
self['post_uncommit'] = []
949
# install the default hooks into the Branch class.
950
Branch.hooks = BranchHooks()
953
class BzrBranchFormat4(BranchFormat):
954
"""Bzr branch format 4.
957
- a revision-history file.
958
- a branch-lock lock file [ to be shared with the bzrdir ]
961
def get_format_description(self):
962
"""See BranchFormat.get_format_description()."""
963
return "Branch format 4"
965
def initialize(self, a_bzrdir):
966
"""Create a branch of this format in a_bzrdir."""
967
utf8_files = [('revision-history', ''),
970
return self._initialize_helper(a_bzrdir, utf8_files,
971
lock_type='branch4', set_format=False)
974
super(BzrBranchFormat4, self).__init__()
975
self._matchingbzrdir = bzrdir.BzrDirFormat6()
977
def open(self, a_bzrdir, _found=False):
978
"""Return the branch object for a_bzrdir
980
_found is a private parameter, do not use it. It is used to indicate
981
if format probing has already be done.
984
# we are being called directly and must probe.
985
raise NotImplementedError
986
return BzrBranch(_format=self,
987
_control_files=a_bzrdir._control_files,
989
_repository=a_bzrdir.open_repository())
992
return "Bazaar-NG branch format 4"
995
class BzrBranchFormat5(BranchFormat):
996
"""Bzr branch format 5.
999
- a revision-history file.
1001
- a lock dir guarding the branch itself
1002
- all of this stored in a branch/ subdirectory
1003
- works with shared repositories.
1005
This format is new in bzr 0.8.
1008
def get_format_string(self):
1009
"""See BranchFormat.get_format_string()."""
1010
return "Bazaar-NG branch format 5\n"
1012
def get_format_description(self):
1013
"""See BranchFormat.get_format_description()."""
1014
return "Branch format 5"
1016
def initialize(self, a_bzrdir):
1017
"""Create a branch of this format in a_bzrdir."""
1018
utf8_files = [('revision-history', ''),
1019
('branch-name', ''),
1021
return self._initialize_helper(a_bzrdir, utf8_files)
1024
super(BzrBranchFormat5, self).__init__()
1025
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1027
def open(self, a_bzrdir, _found=False):
1028
"""Return the branch object for a_bzrdir
1030
_found is a private parameter, do not use it. It is used to indicate
1031
if format probing has already be done.
1034
format = BranchFormat.find_format(a_bzrdir)
1035
assert format.__class__ == self.__class__
1036
transport = a_bzrdir.get_branch_transport(None)
1037
control_files = lockable_files.LockableFiles(transport, 'lock',
1039
return BzrBranch5(_format=self,
1040
_control_files=control_files,
1042
_repository=a_bzrdir.find_repository())
1045
class BzrBranchFormat6(BzrBranchFormat5):
1046
"""Branch format with last-revision
1048
Unlike previous formats, this has no explicit revision history. Instead,
1049
this just stores the last-revision, and the left-hand history leading
1050
up to there is the history.
1052
This format was introduced in bzr 0.15
1055
def get_format_string(self):
1056
"""See BranchFormat.get_format_string()."""
1057
return "Bazaar Branch Format 6 (bzr 0.15)\n"
1059
def get_format_description(self):
1060
"""See BranchFormat.get_format_description()."""
1061
return "Branch format 6"
1063
def initialize(self, a_bzrdir):
1064
"""Create a branch of this format in a_bzrdir."""
1065
utf8_files = [('last-revision', '0 null:\n'),
1066
('branch-name', ''),
1067
('branch.conf', ''),
1070
return self._initialize_helper(a_bzrdir, utf8_files)
1072
def open(self, a_bzrdir, _found=False):
1073
"""Return the branch object for a_bzrdir
1075
_found is a private parameter, do not use it. It is used to indicate
1076
if format probing has already be done.
1079
format = BranchFormat.find_format(a_bzrdir)
1080
assert format.__class__ == self.__class__
1081
transport = a_bzrdir.get_branch_transport(None)
1082
control_files = lockable_files.LockableFiles(transport, 'lock',
1084
return BzrBranch6(_format=self,
1085
_control_files=control_files,
1087
_repository=a_bzrdir.find_repository())
1089
def supports_tags(self):
1093
class BranchReferenceFormat(BranchFormat):
1094
"""Bzr branch reference format.
1096
Branch references are used in implementing checkouts, they
1097
act as an alias to the real branch which is at some other url.
1104
def get_format_string(self):
1105
"""See BranchFormat.get_format_string()."""
1106
return "Bazaar-NG Branch Reference Format 1\n"
1108
def get_format_description(self):
1109
"""See BranchFormat.get_format_description()."""
1110
return "Checkout reference format 1"
1112
def initialize(self, a_bzrdir, target_branch=None):
1113
"""Create a branch of this format in a_bzrdir."""
1114
if target_branch is None:
1115
# this format does not implement branch itself, thus the implicit
1116
# creation contract must see it as uninitializable
1117
raise errors.UninitializableFormat(self)
1118
mutter('creating branch reference in %s', a_bzrdir.transport.base)
1119
branch_transport = a_bzrdir.get_branch_transport(self)
1120
branch_transport.put_bytes('location',
1121
target_branch.bzrdir.root_transport.base)
1122
branch_transport.put_bytes('format', self.get_format_string())
1123
return self.open(a_bzrdir, _found=True)
1126
super(BranchReferenceFormat, self).__init__()
1127
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1129
def _make_reference_clone_function(format, a_branch):
1130
"""Create a clone() routine for a branch dynamically."""
1131
def clone(to_bzrdir, revision_id=None):
1132
"""See Branch.clone()."""
1133
return format.initialize(to_bzrdir, a_branch)
1134
# cannot obey revision_id limits when cloning a reference ...
1135
# FIXME RBC 20060210 either nuke revision_id for clone, or
1136
# emit some sort of warning/error to the caller ?!
1139
def open(self, a_bzrdir, _found=False):
1140
"""Return the branch that the branch reference in a_bzrdir points at.
1142
_found is a private parameter, do not use it. It is used to indicate
1143
if format probing has already be done.
1146
format = BranchFormat.find_format(a_bzrdir)
1147
assert format.__class__ == self.__class__
1148
transport = a_bzrdir.get_branch_transport(None)
1149
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
1150
result = real_bzrdir.open_branch()
1151
# this changes the behaviour of result.clone to create a new reference
1152
# rather than a copy of the content of the branch.
1153
# I did not use a proxy object because that needs much more extensive
1154
# testing, and we are only changing one behaviour at the moment.
1155
# If we decide to alter more behaviours - i.e. the implicit nickname
1156
# then this should be refactored to introduce a tested proxy branch
1157
# and a subclass of that for use in overriding clone() and ....
1159
result.clone = self._make_reference_clone_function(result)
1163
# formats which have no format string are not discoverable
1164
# and not independently creatable, so are not registered.
1165
__default_format = BzrBranchFormat5()
1166
BranchFormat.register_format(__default_format)
1167
BranchFormat.register_format(BranchReferenceFormat())
1168
BranchFormat.register_format(BzrBranchFormat6())
1169
BranchFormat.set_default_format(__default_format)
1170
_legacy_formats = [BzrBranchFormat4(),
1173
class BzrBranch(Branch):
1174
"""A branch stored in the actual filesystem.
1176
Note that it's "local" in the context of the filesystem; it doesn't
1177
really matter if it's on an nfs/smb/afs/coda/... share, as long as
1178
it's writable, and can be accessed via the normal filesystem API.
1181
def __init__(self, _format=None,
1182
_control_files=None, a_bzrdir=None, _repository=None):
1183
"""Create new branch object at a particular location."""
1184
Branch.__init__(self)
1185
if a_bzrdir is None:
1186
raise ValueError('a_bzrdir must be supplied')
1188
self.bzrdir = a_bzrdir
1189
# self._transport used to point to the directory containing the
1190
# control directory, but was not used - now it's just the transport
1191
# for the branch control files. mbp 20070212
1192
self._base = self.bzrdir.transport.clone('..').base
1193
self._format = _format
1194
if _control_files is None:
1195
raise ValueError('BzrBranch _control_files is None')
1196
self.control_files = _control_files
1197
self._transport = _control_files._transport
1198
self.repository = _repository
1201
return '%s(%r)' % (self.__class__.__name__, self.base)
1205
def _get_base(self):
1206
"""Returns the directory containing the control directory."""
1209
base = property(_get_base, doc="The URL for the root of this branch.")
1211
def abspath(self, name):
1212
"""See Branch.abspath."""
1213
return self.control_files._transport.abspath(name)
1216
@deprecated_method(zero_sixteen)
1218
def get_root_id(self):
1219
"""See Branch.get_root_id."""
1220
tree = self.repository.revision_tree(self.last_revision())
1221
return tree.inventory.root.file_id
1223
def is_locked(self):
1224
return self.control_files.is_locked()
1226
def lock_write(self):
1227
self.repository.lock_write()
1229
self.control_files.lock_write()
1231
self.repository.unlock()
1234
def lock_read(self):
1235
self.repository.lock_read()
1237
self.control_files.lock_read()
1239
self.repository.unlock()
1243
# TODO: test for failed two phase locks. This is known broken.
1245
self.control_files.unlock()
1247
self.repository.unlock()
1248
if not self.control_files.is_locked():
1249
# we just released the lock
1250
self._clear_cached_state()
1252
def peek_lock_mode(self):
1253
if self.control_files._lock_count == 0:
1256
return self.control_files._lock_mode
1258
def get_physical_lock_status(self):
1259
return self.control_files.get_physical_lock_status()
1262
def print_file(self, file, revision_id):
1263
"""See Branch.print_file."""
1264
return self.repository.print_file(file, revision_id)
1267
def append_revision(self, *revision_ids):
1268
"""See Branch.append_revision."""
1269
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1270
for revision_id in revision_ids:
1271
_mod_revision.check_not_reserved_id(revision_id)
1272
mutter("add {%s} to revision-history" % revision_id)
1273
rev_history = self.revision_history()
1274
rev_history.extend(revision_ids)
1275
self.set_revision_history(rev_history)
1277
def _write_revision_history(self, history):
1278
"""Factored out of set_revision_history.
1280
This performs the actual writing to disk.
1281
It is intended to be called by BzrBranch5.set_revision_history."""
1282
self.control_files.put_bytes(
1283
'revision-history', '\n'.join(history))
1286
def set_revision_history(self, rev_history):
1287
"""See Branch.set_revision_history."""
1288
rev_history = [osutils.safe_revision_id(r) for r in rev_history]
1289
self._write_revision_history(rev_history)
1290
self._cache_revision_history(rev_history)
1291
for hook in Branch.hooks['set_rh']:
1292
hook(self, rev_history)
1295
def set_last_revision_info(self, revno, revision_id):
1296
revision_id = osutils.safe_revision_id(revision_id)
1297
history = self._lefthand_history(revision_id)
1298
assert len(history) == revno, '%d != %d' % (len(history), revno)
1299
self.set_revision_history(history)
1301
def _gen_revision_history(self):
1302
history = self.control_files.get('revision-history').read().split('\n')
1303
if history[-1:] == ['']:
1304
# There shouldn't be a trailing newline, but just in case.
1308
def _lefthand_history(self, revision_id, last_rev=None,
1310
# stop_revision must be a descendant of last_revision
1311
stop_graph = self.repository.get_revision_graph(revision_id)
1312
if last_rev is not None and last_rev not in stop_graph:
1313
# our previous tip is not merged into stop_revision
1314
raise errors.DivergedBranches(self, other_branch)
1315
# make a new revision history from the graph
1316
current_rev_id = revision_id
1318
while current_rev_id not in (None, _mod_revision.NULL_REVISION):
1319
new_history.append(current_rev_id)
1320
current_rev_id_parents = stop_graph[current_rev_id]
1322
current_rev_id = current_rev_id_parents[0]
1324
current_rev_id = None
1325
new_history.reverse()
1329
def generate_revision_history(self, revision_id, last_rev=None,
1331
"""Create a new revision history that will finish with revision_id.
1333
:param revision_id: the new tip to use.
1334
:param last_rev: The previous last_revision. If not None, then this
1335
must be a ancestory of revision_id, or DivergedBranches is raised.
1336
:param other_branch: The other branch that DivergedBranches should
1337
raise with respect to.
1339
revision_id = osutils.safe_revision_id(revision_id)
1340
self.set_revision_history(self._lefthand_history(revision_id,
1341
last_rev, other_branch))
1344
def update_revisions(self, other, stop_revision=None):
1345
"""See Branch.update_revisions."""
1348
if stop_revision is None:
1349
stop_revision = other.last_revision()
1350
if stop_revision is None:
1351
# if there are no commits, we're done.
1354
stop_revision = osutils.safe_revision_id(stop_revision)
1355
# whats the current last revision, before we fetch [and change it
1357
last_rev = self.last_revision()
1358
# we fetch here regardless of whether we need to so that we pickup
1360
self.fetch(other, stop_revision)
1361
my_ancestry = self.repository.get_ancestry(last_rev)
1362
if stop_revision in my_ancestry:
1363
# last_revision is a descendant of stop_revision
1365
self.generate_revision_history(stop_revision, last_rev=last_rev,
1370
def basis_tree(self):
1371
"""See Branch.basis_tree."""
1372
return self.repository.revision_tree(self.last_revision())
1374
@deprecated_method(zero_eight)
1375
def working_tree(self):
1376
"""Create a Working tree object for this branch."""
1378
from bzrlib.transport.local import LocalTransport
1379
if (self.base.find('://') != -1 or
1380
not isinstance(self._transport, LocalTransport)):
1381
raise NoWorkingTree(self.base)
1382
return self.bzrdir.open_workingtree()
1385
def pull(self, source, overwrite=False, stop_revision=None,
1386
_hook_master=None, _run_hooks=True):
1389
:param _hook_master: Private parameter - set the branch to
1390
be supplied as the master to push hooks.
1391
:param _run_hooks: Private parameter - allow disabling of
1392
hooks, used when pushing to a master branch.
1394
result = PullResult()
1395
result.source_branch = source
1396
result.target_branch = self
1399
result.old_revno, result.old_revid = self.last_revision_info()
1401
self.update_revisions(source, stop_revision)
1402
except DivergedBranches:
1406
if stop_revision is None:
1407
stop_revision = source.last_revision()
1408
self.generate_revision_history(stop_revision)
1409
result.tag_conflicts = source.tags.merge_to(self.tags)
1410
result.new_revno, result.new_revid = self.last_revision_info()
1412
result.master_branch = _hook_master
1413
result.local_branch = self
1415
result.master_branch = self
1416
result.local_branch = None
1418
for hook in Branch.hooks['post_pull']:
1424
def _get_parent_location(self):
1425
_locs = ['parent', 'pull', 'x-pull']
1428
return self.control_files.get(l).read().strip('\n')
1434
def push(self, target, overwrite=False, stop_revision=None,
1435
_hook_master=None, _run_hooks=True):
1438
:param _hook_master: Private parameter - set the branch to
1439
be supplied as the master to push hooks.
1440
:param _run_hooks: Private parameter - allow disabling of
1441
hooks, used when pushing to a master branch.
1443
result = PushResult()
1444
result.source_branch = self
1445
result.target_branch = target
1448
result.old_revno, result.old_revid = target.last_revision_info()
1450
target.update_revisions(self, stop_revision)
1451
except DivergedBranches:
1455
target.set_revision_history(self.revision_history())
1456
result.tag_conflicts = self.tags.merge_to(target.tags)
1457
result.new_revno, result.new_revid = target.last_revision_info()
1459
result.master_branch = _hook_master
1460
result.local_branch = target
1462
result.master_branch = target
1463
result.local_branch = None
1465
for hook in Branch.hooks['post_push']:
1471
def get_parent(self):
1472
"""See Branch.get_parent."""
1474
assert self.base[-1] == '/'
1475
parent = self._get_parent_location()
1478
# This is an old-format absolute path to a local branch
1479
# turn it into a url
1480
if parent.startswith('/'):
1481
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1483
return urlutils.join(self.base[:-1], parent)
1484
except errors.InvalidURLJoin, e:
1485
raise errors.InaccessibleParent(parent, self.base)
1487
def get_push_location(self):
1488
"""See Branch.get_push_location."""
1489
push_loc = self.get_config().get_user_option('push_location')
1492
def set_push_location(self, location):
1493
"""See Branch.set_push_location."""
1494
self.get_config().set_user_option(
1495
'push_location', location,
1496
store=_mod_config.STORE_LOCATION_NORECURSE)
1499
def set_parent(self, url):
1500
"""See Branch.set_parent."""
1501
# TODO: Maybe delete old location files?
1502
# URLs should never be unicode, even on the local fs,
1503
# FIXUP this and get_parent in a future branch format bump:
1504
# read and rewrite the file, and have the new format code read
1505
# using .get not .get_utf8. RBC 20060125
1507
if isinstance(url, unicode):
1509
url = url.encode('ascii')
1510
except UnicodeEncodeError:
1511
raise bzrlib.errors.InvalidURL(url,
1512
"Urls must be 7-bit ascii, "
1513
"use bzrlib.urlutils.escape")
1514
url = urlutils.relative_url(self.base, url)
1515
self._set_parent_location(url)
1517
def _set_parent_location(self, url):
1519
self.control_files._transport.delete('parent')
1521
assert isinstance(url, str)
1522
self.control_files.put_bytes('parent', url + '\n')
1524
@deprecated_function(zero_nine)
1525
def tree_config(self):
1526
"""DEPRECATED; call get_config instead.
1527
TreeConfig has become part of BranchConfig."""
1528
return TreeConfig(self)
1531
class BzrBranch5(BzrBranch):
1532
"""A format 5 branch. This supports new features over plan branches.
1534
It has support for a master_branch which is the data for bound branches.
1542
super(BzrBranch5, self).__init__(_format=_format,
1543
_control_files=_control_files,
1545
_repository=_repository)
1548
def pull(self, source, overwrite=False, stop_revision=None,
1550
"""Extends branch.pull to be bound branch aware.
1552
:param _run_hooks: Private parameter used to force hook running
1553
off during bound branch double-pushing.
1555
bound_location = self.get_bound_location()
1556
master_branch = None
1557
if bound_location and source.base != bound_location:
1558
# not pulling from master, so we need to update master.
1559
master_branch = self.get_master_branch()
1560
master_branch.lock_write()
1563
# pull from source into master.
1564
master_branch.pull(source, overwrite, stop_revision,
1566
return super(BzrBranch5, self).pull(source, overwrite,
1567
stop_revision, _hook_master=master_branch,
1568
_run_hooks=_run_hooks)
1571
master_branch.unlock()
1574
def push(self, target, overwrite=False, stop_revision=None):
1575
"""Updates branch.push to be bound branch aware."""
1576
bound_location = target.get_bound_location()
1577
master_branch = None
1578
if bound_location and target.base != bound_location:
1579
# not pushing to master, so we need to update master.
1580
master_branch = target.get_master_branch()
1581
master_branch.lock_write()
1584
# push into the master from this branch.
1585
super(BzrBranch5, self).push(master_branch, overwrite,
1586
stop_revision, _run_hooks=False)
1587
# and push into the target branch from this. Note that we push from
1588
# this branch again, because its considered the highest bandwidth
1590
return super(BzrBranch5, self).push(target, overwrite,
1591
stop_revision, _hook_master=master_branch)
1594
master_branch.unlock()
1596
def get_bound_location(self):
1598
return self.control_files.get_utf8('bound').read()[:-1]
1599
except errors.NoSuchFile:
1603
def get_master_branch(self):
1604
"""Return the branch we are bound to.
1606
:return: Either a Branch, or None
1608
This could memoise the branch, but if thats done
1609
it must be revalidated on each new lock.
1610
So for now we just don't memoise it.
1611
# RBC 20060304 review this decision.
1613
bound_loc = self.get_bound_location()
1617
return Branch.open(bound_loc)
1618
except (errors.NotBranchError, errors.ConnectionError), e:
1619
raise errors.BoundBranchConnectionFailure(
1623
def set_bound_location(self, location):
1624
"""Set the target where this branch is bound to.
1626
:param location: URL to the target branch
1629
self.control_files.put_utf8('bound', location+'\n')
1632
self.control_files._transport.delete('bound')
924
## TODO: Option to move IDs only
925
assert not isinstance(from_paths, basestring)
926
tree = self.working_tree()
928
to_abs = self.abspath(to_name)
929
if not isdir(to_abs):
930
raise BzrError("destination %r is not a directory" % to_abs)
931
if not tree.has_filename(to_name):
932
raise BzrError("destination %r not in working directory" % to_abs)
933
to_dir_id = inv.path2id(to_name)
934
if to_dir_id == None and to_name != '':
935
raise BzrError("destination %r is not a versioned directory" % to_name)
936
to_dir_ie = inv[to_dir_id]
937
if to_dir_ie.kind not in ('directory', 'root_directory'):
938
raise BzrError("destination %r is not a directory" % to_abs)
940
to_idpath = inv.get_idpath(to_dir_id)
943
if not tree.has_filename(f):
944
raise BzrError("%r does not exist in working tree" % f)
945
f_id = inv.path2id(f)
947
raise BzrError("%r is not versioned" % f)
948
name_tail = splitpath(f)[-1]
949
dest_path = appendpath(to_name, name_tail)
950
if tree.has_filename(dest_path):
951
raise BzrError("destination %r already exists" % dest_path)
952
if f_id in to_idpath:
953
raise BzrError("can't move %r to a subdirectory of itself" % f)
955
# OK, so there's a race here, it's possible that someone will
956
# create a file in this interval and then the rename might be
957
# left half-done. But we should have caught most problems.
960
name_tail = splitpath(f)[-1]
961
dest_path = appendpath(to_name, name_tail)
962
print "%s => %s" % (f, dest_path)
963
inv.rename(inv.path2id(f), to_dir_id, name_tail)
965
os.rename(self.abspath(f), self.abspath(dest_path))
967
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
968
["rename rolled back"])
970
self._write_inventory(inv)
975
def revert(self, filenames, old_tree=None, backups=True):
976
"""Restore selected files to the versions from a previous tree.
979
If true (default) backups are made of files before
982
from bzrlib.errors import NotVersionedError, BzrError
983
from bzrlib.atomicfile import AtomicFile
984
from bzrlib.osutils import backup_file
986
inv = self.read_working_inventory()
988
old_tree = self.basis_tree()
989
old_inv = old_tree.inventory
993
file_id = inv.path2id(fn)
995
raise NotVersionedError("not a versioned file", fn)
996
if not old_inv.has_id(file_id):
997
raise BzrError("file not present in old tree", fn, file_id)
998
nids.append((fn, file_id))
1000
# TODO: Rename back if it was previously at a different location
1002
# TODO: If given a directory, restore the entire contents from
1003
# the previous version.
1005
# TODO: Make a backup to a temporary file.
1007
# TODO: If the file previously didn't exist, delete it?
1008
for fn, file_id in nids:
1011
f = AtomicFile(fn, 'wb')
1013
f.write(old_tree.get_file(file_id).read())
1020
class ScratchBranch(Branch):
1021
"""Special test class: a branch that cleans up after itself.
1023
>>> b = ScratchBranch()
1031
def __init__(self, files=[], dirs=[], base=None):
1032
"""Make a test branch.
1034
This creates a temporary directory and runs init-tree in it.
1036
If any files are listed, they are created in the working copy.
1040
base = tempfile.mkdtemp()
1042
Branch.__init__(self, base, init=init)
1044
os.mkdir(self.abspath(d))
1047
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1052
>>> orig = ScratchBranch(files=["file1", "file2"])
1053
>>> clone = orig.clone()
1054
>>> os.path.samefile(orig.base, clone.base)
1056
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1059
base = tempfile.mkdtemp()
1061
shutil.copytree(self.base, base, symlinks=True)
1062
return ScratchBranch(base=base)
1068
"""Destroy the test branch, removing the scratch directory."""
1071
mutter("delete ScratchBranch %s" % self.base)
1072
shutil.rmtree(self.base)
1074
# Work around for shutil.rmtree failing on Windows when
1075
# readonly files are encountered
1076
mutter("hit exception in destroying ScratchBranch: %s" % e)
1077
for root, dirs, files in os.walk(self.base, topdown=False):
1079
os.chmod(os.path.join(root, name), 0700)
1080
shutil.rmtree(self.base)
1085
######################################################################
1089
def is_control_file(filename):
1090
## FIXME: better check
1091
filename = os.path.normpath(filename)
1092
while filename != '':
1093
head, tail = os.path.split(filename)
1094
## mutter('check %r for control file' % ((head, tail), ))
1095
if tail == bzrlib.BZRDIR:
1638
def bind(self, other):
1639
"""Bind this branch to the branch other.
1641
This does not push or pull data between the branches, though it does
1642
check for divergence to raise an error when the branches are not
1643
either the same, or one a prefix of the other. That behaviour may not
1644
be useful, so that check may be removed in future.
1646
:param other: The branch to bind to
1649
# TODO: jam 20051230 Consider checking if the target is bound
1650
# It is debatable whether you should be able to bind to
1651
# a branch which is itself bound.
1652
# Committing is obviously forbidden,
1653
# but binding itself may not be.
1654
# Since we *have* to check at commit time, we don't
1655
# *need* to check here
1657
# we want to raise diverged if:
1658
# last_rev is not in the other_last_rev history, AND
1659
# other_last_rev is not in our history, and do it without pulling
1661
last_rev = self.last_revision()
1662
if last_rev is not None:
1665
other_last_rev = other.last_revision()
1666
if other_last_rev is not None:
1667
# neither branch is new, we have to do some work to
1668
# ascertain diversion.
1669
remote_graph = other.repository.get_revision_graph(
1671
local_graph = self.repository.get_revision_graph(last_rev)
1672
if (last_rev not in remote_graph and
1673
other_last_rev not in local_graph):
1674
raise errors.DivergedBranches(self, other)
1677
self.set_bound_location(other.base)
1681
"""If bound, unbind"""
1682
return self.set_bound_location(None)
1686
"""Synchronise this branch with the master branch if any.
1688
:return: None or the last_revision that was pivoted out during the
1691
master = self.get_master_branch()
1692
if master is not None:
1693
old_tip = self.last_revision()
1694
self.pull(master, overwrite=True)
1695
if old_tip in self.repository.get_ancestry(self.last_revision()):
1701
class BzrBranchExperimental(BzrBranch5):
1702
"""Bzr experimental branch format
1705
- a revision-history file.
1707
- a lock dir guarding the branch itself
1708
- all of this stored in a branch/ subdirectory
1709
- works with shared repositories.
1710
- a tag dictionary in the branch
1712
This format is new in bzr 0.15, but shouldn't be used for real data,
1715
This class acts as it's own BranchFormat.
1718
_matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1721
def get_format_string(cls):
1722
"""See BranchFormat.get_format_string()."""
1723
return "Bazaar-NG branch format experimental\n"
1726
def get_format_description(cls):
1727
"""See BranchFormat.get_format_description()."""
1728
return "Experimental branch format"
1731
def _initialize_control_files(cls, a_bzrdir, utf8_files, lock_filename,
1733
branch_transport = a_bzrdir.get_branch_transport(cls)
1734
control_files = lockable_files.LockableFiles(branch_transport,
1735
lock_filename, lock_class)
1736
control_files.create_lock()
1737
control_files.lock_write()
1739
for filename, content in utf8_files:
1740
control_files.put_utf8(filename, content)
1742
control_files.unlock()
1745
def initialize(cls, a_bzrdir):
1746
"""Create a branch of this format in a_bzrdir."""
1747
utf8_files = [('format', cls.get_format_string()),
1748
('revision-history', ''),
1749
('branch-name', ''),
1752
cls._initialize_control_files(a_bzrdir, utf8_files,
1753
'lock', lockdir.LockDir)
1754
return cls.open(a_bzrdir, _found=True)
1757
def open(cls, a_bzrdir, _found=False):
1758
"""Return the branch object for a_bzrdir
1760
_found is a private parameter, do not use it. It is used to indicate
1761
if format probing has already be done.
1764
format = BranchFormat.find_format(a_bzrdir)
1765
assert format.__class__ == cls
1766
transport = a_bzrdir.get_branch_transport(None)
1767
control_files = lockable_files.LockableFiles(transport, 'lock',
1769
return cls(_format=cls,
1770
_control_files=control_files,
1772
_repository=a_bzrdir.find_repository())
1775
def is_supported(cls):
1778
def _make_tags(self):
1779
return BasicTags(self)
1782
def supports_tags(cls):
1786
BranchFormat.register_format(BzrBranchExperimental)
1789
class BzrBranch6(BzrBranch5):
1792
def last_revision_info(self):
1793
revision_string = self.control_files.get('last-revision').read()
1794
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
1795
revision_id = cache_utf8.get_cached_utf8(revision_id)
1797
return revno, revision_id
1799
def last_revision(self):
1800
"""Return last revision id, or None"""
1801
revision_id = self.last_revision_info()[1]
1802
if revision_id == _mod_revision.NULL_REVISION:
1806
def _write_last_revision_info(self, revno, revision_id):
1807
"""Simply write out the revision id, with no checks.
1809
Use set_last_revision_info to perform this safely.
1811
Does not update the revision_history cache.
1812
Intended to be called by set_last_revision_info and
1813
_write_revision_history.
1815
if revision_id is None:
1816
revision_id = 'null:'
1817
out_string = '%d %s\n' % (revno, revision_id)
1818
self.control_files.put_bytes('last-revision', out_string)
1821
def set_last_revision_info(self, revno, revision_id):
1822
revision_id = osutils.safe_revision_id(revision_id)
1823
if self._get_append_revisions_only():
1824
self._check_history_violation(revision_id)
1825
self._write_last_revision_info(revno, revision_id)
1826
self._clear_cached_state()
1828
def _check_history_violation(self, revision_id):
1829
last_revision = self.last_revision()
1830
if last_revision is None:
1832
if last_revision not in self._lefthand_history(revision_id):
1833
raise errors.AppendRevisionsOnlyViolation(self.base)
1835
def _gen_revision_history(self):
1836
"""Generate the revision history from last revision
1838
history = list(self.repository.iter_reverse_revision_history(
1839
self.last_revision()))
1843
def _write_revision_history(self, history):
1844
"""Factored out of set_revision_history.
1846
This performs the actual writing to disk, with format-specific checks.
1847
It is intended to be called by BzrBranch5.set_revision_history.
1849
if len(history) == 0:
1850
last_revision = 'null:'
1852
if history != self._lefthand_history(history[-1]):
1853
raise errors.NotLefthandHistory(history)
1854
last_revision = history[-1]
1855
if self._get_append_revisions_only():
1856
self._check_history_violation(last_revision)
1857
self._write_last_revision_info(len(history), last_revision)
1860
def append_revision(self, *revision_ids):
1861
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1862
if len(revision_ids) == 0:
1864
prev_revno, prev_revision = self.last_revision_info()
1865
for revision in self.repository.get_revisions(revision_ids):
1866
if prev_revision == _mod_revision.NULL_REVISION:
1867
if revision.parent_ids != []:
1868
raise errors.NotLeftParentDescendant(self, prev_revision,
1869
revision.revision_id)
1871
if revision.parent_ids[0] != prev_revision:
1872
raise errors.NotLeftParentDescendant(self, prev_revision,
1873
revision.revision_id)
1874
prev_revision = revision.revision_id
1875
self.set_last_revision_info(prev_revno + len(revision_ids),
1879
def _set_parent_location(self, url):
1880
"""Set the parent branch"""
1881
self._set_config_location('parent_location', url, make_relative=True)
1884
def _get_parent_location(self):
1885
"""Set the parent branch"""
1886
return self._get_config_location('parent_location')
1888
def set_push_location(self, location):
1889
"""See Branch.set_push_location."""
1890
self._set_config_location('push_location', location)
1892
def set_bound_location(self, location):
1893
"""See Branch.set_push_location."""
1895
config = self.get_config()
1896
if location is None:
1897
if config.get_user_option('bound') != 'True':
1900
config.set_user_option('bound', 'False')
1903
self._set_config_location('bound_location', location,
1905
config.set_user_option('bound', 'True')
1908
def _get_bound_location(self, bound):
1909
"""Return the bound location in the config file.
1911
Return None if the bound parameter does not match"""
1912
config = self.get_config()
1913
config_bound = (config.get_user_option('bound') == 'True')
1914
if config_bound != bound:
1916
return self._get_config_location('bound_location', config=config)
1918
def get_bound_location(self):
1919
"""See Branch.set_push_location."""
1920
return self._get_bound_location(True)
1922
def get_old_bound_location(self):
1923
"""See Branch.get_old_bound_location"""
1924
return self._get_bound_location(False)
1926
def set_append_revisions_only(self, enabled):
1931
self.get_config().set_user_option('append_revisions_only', value)
1933
def _get_append_revisions_only(self):
1934
value = self.get_config().get_user_option('append_revisions_only')
1935
return value == 'True'
1937
def _synchronize_history(self, destination, revision_id):
1938
"""Synchronize last revision and revision history between branches.
1940
This version is most efficient when the destination is also a
1941
BzrBranch6, but works for BzrBranch5, as long as the destination's
1942
repository contains all the lefthand ancestors of the intended
1943
last_revision. If not, set_last_revision_info will fail.
1945
:param destination: The branch to copy the history into
1946
:param revision_id: The revision-id to truncate history at. May
1947
be None to copy complete history.
1949
if revision_id is None:
1950
revno, revision_id = self.last_revision_info()
1952
revno = self.revision_id_to_revno(revision_id)
1953
destination.set_last_revision_info(revno, revision_id)
1955
def _make_tags(self):
1956
return BasicTags(self)
1959
class BranchTestProviderAdapter(object):
1960
"""A tool to generate a suite testing multiple branch formats at once.
1962
This is done by copying the test once for each transport and injecting
1963
the transport_server, transport_readonly_server, and branch_format
1964
classes into each copy. Each copy is also given a new id() to make it
1968
def __init__(self, transport_server, transport_readonly_server, formats):
1969
self._transport_server = transport_server
1970
self._transport_readonly_server = transport_readonly_server
1971
self._formats = formats
1973
def adapt(self, test):
1974
result = TestSuite()
1975
for branch_format, bzrdir_format in self._formats:
1976
new_test = deepcopy(test)
1977
new_test.transport_server = self._transport_server
1978
new_test.transport_readonly_server = self._transport_readonly_server
1979
new_test.bzrdir_format = bzrdir_format
1980
new_test.branch_format = branch_format
1981
def make_new_test_id():
1982
# the format can be either a class or an instance
1983
name = getattr(branch_format, '__name__',
1984
branch_format.__class__.__name__)
1985
new_id = "%s(%s)" % (new_test.id(), name)
1986
return lambda: new_id
1987
new_test.id = make_new_test_id()
1988
result.addTest(new_test)
1992
######################################################################
1993
# results of operations
1996
class _Result(object):
1998
def _show_tag_conficts(self, to_file):
1999
if not getattr(self, 'tag_conflicts', None):
2001
to_file.write('Conflicting tags:\n')
2002
for name, value1, value2 in self.tag_conflicts:
2003
to_file.write(' %s\n' % (name, ))
2006
class PullResult(_Result):
2007
"""Result of a Branch.pull operation.
2009
:ivar old_revno: Revision number before pull.
2010
:ivar new_revno: Revision number after pull.
2011
:ivar old_revid: Tip revision id before pull.
2012
:ivar new_revid: Tip revision id after pull.
2013
:ivar source_branch: Source (local) branch object.
2014
:ivar master_branch: Master branch of the target, or None.
2015
:ivar target_branch: Target/destination branch object.
2019
# DEPRECATED: pull used to return the change in revno
2020
return self.new_revno - self.old_revno
2022
def report(self, to_file):
2023
if self.old_revid == self.new_revid:
2024
to_file.write('No revisions to pull.\n')
2026
to_file.write('Now on revision %d.\n' % self.new_revno)
2027
self._show_tag_conficts(to_file)
2030
class PushResult(_Result):
2031
"""Result of a Branch.push operation.
2033
:ivar old_revno: Revision number before push.
2034
:ivar new_revno: Revision number after push.
2035
:ivar old_revid: Tip revision id before push.
2036
:ivar new_revid: Tip revision id after push.
2037
:ivar source_branch: Source branch object.
2038
:ivar master_branch: Master branch of the target, or None.
2039
:ivar target_branch: Target/destination branch object.
2043
# DEPRECATED: push used to return the change in revno
2044
return self.new_revno - self.old_revno
2046
def report(self, to_file):
2047
"""Write a human-readable description of the result."""
2048
if self.old_revid == self.new_revid:
2049
to_file.write('No new revisions to push.\n')
2051
to_file.write('Pushed up to revision %d.\n' % self.new_revno)
2052
self._show_tag_conficts(to_file)
2055
class BranchCheckResult(object):
2056
"""Results of checking branch consistency.
2061
def __init__(self, branch):
2062
self.branch = branch
2064
def report_results(self, verbose):
2065
"""Report the check results via trace.note.
2067
:param verbose: Requests more detailed display of what was checked,
2070
note('checked branch %s format %s',
2072
self.branch._format)
2075
class Converter5to6(object):
2076
"""Perform an in-place upgrade of format 5 to format 6"""
2078
def convert(self, branch):
2079
# Data for 5 and 6 can peacefully coexist.
2080
format = BzrBranchFormat6()
2081
new_branch = format.open(branch.bzrdir, _found=True)
2083
# Copy source data into target
2084
new_branch.set_last_revision_info(*branch.last_revision_info())
2085
new_branch.set_parent(branch.get_parent())
2086
new_branch.set_bound_location(branch.get_bound_location())
2087
new_branch.set_push_location(branch.get_push_location())
2089
# New branch has no tags by default
2090
new_branch.tags._set_tag_dict({})
2092
# Copying done; now update target format
2093
new_branch.control_files.put_utf8('format',
2094
format.get_format_string())
2096
# Clean up old files
2097
new_branch.control_files._transport.delete('revision-history')
2099
branch.set_parent(None)
2102
branch.set_bound_location(None)
1097
if filename == head:
1104
def gen_file_id(name):
1105
"""Return new file id.
1107
This should probably generate proper UUIDs, but for the moment we
1108
cope with just randomness because running uuidgen every time is
1112
# get last component
1113
idx = name.rfind('/')
1115
name = name[idx+1 : ]
1116
idx = name.rfind('\\')
1118
name = name[idx+1 : ]
1120
# make it not a hidden file
1121
name = name.lstrip('.')
1123
# remove any wierd characters; we don't escape them but rather
1124
# just pull them out
1125
name = re.sub(r'[^\w.]', '', name)
1127
s = hexlify(rand_bytes(8))
1128
return '-'.join((name, compact_date(time.time()), s))
added
removed
bzrlib/branch.py
