130
126
Basically we keep looking up until we find the control directory or
131
127
run into the root. If there isn't one, raises NotBranchError.
132
If there is one and it is either an unrecognised format or an unsupported
133
format, UnknownFormatError or UnsupportedFormatError are raised.
134
128
If there is one, it is returned, along with the unused portion of url.
136
control, relpath = bzrdir.BzrDir.open_containing(url)
137
return control.open_branch(), relpath
130
t = get_transport(url)
133
return _Branch(t), t.relpath(url)
134
except NotBranchError:
136
new_t = t.clone('..')
137
if new_t.base == t.base:
138
# reached the root, whatever that may be
139
raise NotBranchError(path=url)
140
@deprecated_function(zero_eight)
141
143
def initialize(base):
142
"""Create a new working tree and branch, rooted at 'base' (url)
144
NOTE: This will soon be deprecated in favour of creation
147
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
149
@deprecated_function(zero_eight)
144
"""Create a new branch, rooted at 'base' (url)"""
145
t = get_transport(base)
146
return _Branch(t, init=True)
150
148
def setup_caching(self, cache_root):
151
149
"""Subclasses that care about caching should override this, and set
152
150
up cached stores located under cache_root.
152
self.cache_root = cache_root
155
class _Branch(Branch):
156
"""A branch stored in the actual filesystem.
158
Note that it's "local" in the context of the filesystem; it doesn't
159
really matter if it's on an nfs/smb/afs/coda/... share, as long as
160
it's writable, and can be accessed via the normal filesystem API.
166
If _lock_mode is true, a positive count of the number of times the
170
Lock object from bzrlib.lock.
172
# We actually expect this class to be somewhat short-lived; part of its
173
# purpose is to try to isolate what bits of the branch logic are tied to
174
# filesystem access, so that in a later step, we can extricate them to
175
# a separarte ("storage") class.
179
_inventory_weave = None
181
# Map some sort of prefix into a namespace
182
# stuff like "revno:10", "revid:", etc.
183
# This should match a prefix with a function which accepts
184
REVISION_NAMESPACES = {}
186
def push_stores(self, branch_to):
187
"""Copy the content of this branches store to branch_to."""
188
if (self._branch_format != branch_to._branch_format
189
or self._branch_format != 4):
190
from bzrlib.fetch import greedy_fetch
191
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
192
self, self._branch_format, branch_to, branch_to._branch_format)
193
greedy_fetch(to_branch=branch_to, from_branch=self,
194
revision=self.last_revision())
197
store_pairs = ((self.text_store, branch_to.text_store),
198
(self.inventory_store, branch_to.inventory_store),
199
(self.revision_store, branch_to.revision_store))
201
for from_store, to_store in store_pairs:
202
copy_all(from_store, to_store)
203
except UnlistableStore:
204
raise UnlistableBranch(from_store)
206
def __init__(self, transport, init=False,
207
relax_version_check=False):
208
"""Create new branch object at a particular location.
210
transport -- A Transport object, defining how to access files.
211
(If a string, transport.transport() will be used to
212
create a Transport object)
154
NOTE: This is unused.
158
def get_config(self):
159
return BranchConfig(self)
162
return self.get_config().get_nickname()
164
def _set_nick(self, nick):
165
self.get_config().set_user_option('nickname', nick)
167
nick = property(_get_nick, _set_nick)
170
raise NotImplementedError(self.is_locked)
214
init -- If True, create new control files in a previously
215
unversioned directory. If False, the branch must already
218
relax_version_check -- If true, the usual check for the branch
219
version is not applied. This is intended only for
220
upgrade/recovery type use; it's not guaranteed that
221
all operations will work on old format branches.
223
In the test suite, creation of new trees is tested using the
224
`ScratchBranch` class.
226
assert isinstance(transport, Transport), \
227
"%r is not a Transport" % transport
228
self._transport = transport
231
self._check_format(relax_version_check)
233
def get_store(name, compressed=True, prefixed=False):
234
# FIXME: This approach of assuming stores are all entirely compressed
235
# or entirely uncompressed is tidy, but breaks upgrade from
236
# some existing branches where there's a mixture; we probably
237
# still want the option to look for both.
238
relpath = self._rel_controlfilename(name)
240
store = CompressedTextStore(self._transport.clone(relpath),
243
store = TextStore(self._transport.clone(relpath),
245
#if self._transport.should_cache():
246
# cache_path = os.path.join(self.cache_root, name)
247
# os.mkdir(cache_path)
248
# store = bzrlib.store.CachedStore(store, cache_path)
250
def get_weave(name, prefixed=False):
251
relpath = self._rel_controlfilename(name)
252
ws = WeaveStore(self._transport.clone(relpath), prefixed=prefixed)
253
if self._transport.should_cache():
254
ws.enable_cache = True
257
if self._branch_format == 4:
258
self.inventory_store = get_store('inventory-store')
259
self.text_store = get_store('text-store')
260
self.revision_store = get_store('revision-store')
261
elif self._branch_format == 5:
262
self.control_weaves = get_weave([])
263
self.weave_store = get_weave('weaves')
264
self.revision_store = get_store('revision-store', compressed=False)
265
elif self._branch_format == 6:
266
self.control_weaves = get_weave([])
267
self.weave_store = get_weave('weaves', prefixed=True)
268
self.revision_store = get_store('revision-store', compressed=False,
270
self.revision_store.register_suffix('sig')
271
self._transaction = None
274
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
281
if self._lock_mode or self._lock:
282
# XXX: This should show something every time, and be suitable for
283
# headless operation and embedding
284
warn("branch %r was not explicitly unlocked" % self)
287
# TODO: It might be best to do this somewhere else,
288
# but it is nice for a Branch object to automatically
289
# cache it's information.
290
# Alternatively, we could have the Transport objects cache requests
291
# See the earlier discussion about how major objects (like Branch)
292
# should never expect their __del__ function to run.
293
if hasattr(self, 'cache_root') and self.cache_root is not None:
296
shutil.rmtree(self.cache_root)
299
self.cache_root = None
303
return self._transport.base
306
base = property(_get_base, doc="The URL for the root of this branch.")
308
def _finish_transaction(self):
309
"""Exit the current transaction."""
310
if self._transaction is None:
311
raise errors.LockError('Branch %s is not in a transaction' %
313
transaction = self._transaction
314
self._transaction = None
317
def get_transaction(self):
318
"""Return the current active transaction.
320
If no transaction is active, this returns a passthrough object
321
for which all data is immedaitely flushed and no caching happens.
323
if self._transaction is None:
324
return transactions.PassThroughTransaction()
326
return self._transaction
328
def _set_transaction(self, new_transaction):
329
"""Set a new active transaction."""
330
if self._transaction is not None:
331
raise errors.LockError('Branch %s is in a transaction already.' %
333
self._transaction = new_transaction
172
335
def lock_write(self):
173
raise NotImplementedError(self.lock_write)
336
mutter("lock write: %s (%s)", self, self._lock_count)
337
# TODO: Upgrade locking to support using a Transport,
338
# and potentially a remote locking protocol
340
if self._lock_mode != 'w':
341
raise LockError("can't upgrade to a write lock from %r" %
343
self._lock_count += 1
345
self._lock = self._transport.lock_write(
346
self._rel_controlfilename('branch-lock'))
347
self._lock_mode = 'w'
349
self._set_transaction(transactions.PassThroughTransaction())
175
351
def lock_read(self):
176
raise NotImplementedError(self.lock_read)
352
mutter("lock read: %s (%s)", self, self._lock_count)
354
assert self._lock_mode in ('r', 'w'), \
355
"invalid lock mode %r" % self._lock_mode
356
self._lock_count += 1
358
self._lock = self._transport.lock_read(
359
self._rel_controlfilename('branch-lock'))
360
self._lock_mode = 'r'
362
self._set_transaction(transactions.ReadOnlyTransaction())
363
# 5K may be excessive, but hey, its a knob.
364
self.get_transaction().set_cache_size(5000)
178
366
def unlock(self):
179
raise NotImplementedError(self.unlock)
181
def peek_lock_mode(self):
182
"""Return lock mode for the Branch: 'r', 'w' or None"""
183
raise NotImplementedError(self.peek_lock_mode)
185
def get_physical_lock_status(self):
186
raise NotImplementedError(self.get_physical_lock_status)
367
mutter("unlock: %s (%s)", self, self._lock_count)
368
if not self._lock_mode:
369
raise LockError('branch %r is not locked' % (self))
371
if self._lock_count > 1:
372
self._lock_count -= 1
374
self._finish_transaction()
377
self._lock_mode = self._lock_count = None
188
379
def abspath(self, name):
189
380
"""Return absolute filename for something in the branch
191
382
XXX: Robert Collins 20051017 what is this used for? why is it a branch
192
383
method and not a tree method.
194
raise NotImplementedError(self.abspath)
196
def bind(self, other):
197
"""Bind the local branch the other branch.
199
:param other: The branch to bind to
202
raise errors.UpgradeRequired(self.base)
205
def fetch(self, from_branch, last_revision=None, pb=None):
206
"""Copy revisions from from_branch into this branch.
208
:param from_branch: Where to copy from.
209
:param last_revision: What revision to stop at (None for at the end
211
:param pb: An optional progress bar to use.
213
Returns the copied revision count and the failed revisions in a tuple:
216
if self.base == from_branch.base:
219
nested_pb = ui.ui_factory.nested_progress_bar()
385
return self._transport.abspath(name)
387
def _rel_controlfilename(self, file_or_path):
388
if isinstance(file_or_path, basestring):
389
file_or_path = [file_or_path]
390
return [bzrlib.BZRDIR] + file_or_path
392
def controlfilename(self, file_or_path):
393
"""Return location relative to branch."""
394
return self._transport.abspath(self._rel_controlfilename(file_or_path))
397
def controlfile(self, file_or_path, mode='r'):
398
"""Open a control file for this branch.
400
There are two classes of file in the control directory: text
401
and binary. binary files are untranslated byte streams. Text
402
control files are stored with Unix newlines and in UTF-8, even
403
if the platform or locale defaults are different.
405
Controlfiles should almost never be opened in write mode but
406
rather should be atomically copied and replaced using atomicfile.
410
relpath = self._rel_controlfilename(file_or_path)
411
#TODO: codecs.open() buffers linewise, so it was overloaded with
412
# a much larger buffer, do we need to do the same for getreader/getwriter?
414
return self._transport.get(relpath)
416
raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
418
return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
420
raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
224
from_branch.lock_read()
226
if last_revision is None:
227
pb.update('get source history')
228
from_history = from_branch.revision_history()
230
last_revision = from_history[-1]
422
raise BzrError("invalid controlfile mode %r" % mode)
424
def put_controlfile(self, path, f, encode=True):
425
"""Write an entry as a controlfile.
427
:param path: The path to put the file, relative to the .bzr control
429
:param f: A file-like or string object whose contents should be copied.
430
:param encode: If true, encode the contents as utf-8
432
self.put_controlfiles([(path, f)], encode=encode)
434
def put_controlfiles(self, files, encode=True):
435
"""Write several entries as controlfiles.
437
:param files: A list of [(path, file)] pairs, where the path is the directory
438
underneath the bzr control directory
439
:param encode: If true, encode the contents as utf-8
443
for path, f in files:
445
if isinstance(f, basestring):
446
f = f.encode('utf-8', 'replace')
232
# no history in the source branch
233
last_revision = _mod_revision.NULL_REVISION
234
return self.repository.fetch(from_branch.repository,
235
revision_id=last_revision,
238
if nested_pb is not None:
242
def get_bound_location(self):
243
"""Return the URL of the branch we are bound to.
245
Older format branches cannot bind, please be sure to use a metadir
250
def get_commit_builder(self, parents, config=None, timestamp=None,
251
timezone=None, committer=None, revprops=None,
253
"""Obtain a CommitBuilder for this branch.
255
:param parents: Revision ids of the parents of the new revision.
256
:param config: Optional configuration to use.
257
:param timestamp: Optional timestamp recorded for commit.
258
:param timezone: Optional timezone for timestamp.
259
:param committer: Optional committer to set for commit.
260
:param revprops: Optional dictionary of revision properties.
261
:param revision_id: Optional revision id.
265
config = self.get_config()
267
return self.repository.get_commit_builder(self, parents, config,
268
timestamp, timezone, committer, revprops, revision_id)
270
def get_master_branch(self):
271
"""Return the branch we are bound to.
273
:return: Either a Branch, or None
448
f = codecs.getwriter('utf-8')(f, errors='replace')
449
path = self._rel_controlfilename(path)
450
ctrl_files.append((path, f))
451
self._transport.put_multi(ctrl_files)
453
def _make_control(self):
454
from bzrlib.inventory import Inventory
455
from bzrlib.weavefile import write_weave_v5
456
from bzrlib.weave import Weave
458
# Create an empty inventory
460
# if we want per-tree root ids then this is the place to set
461
# them; they're not needed for now and so ommitted for
463
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
464
empty_inv = sio.getvalue()
466
bzrlib.weavefile.write_weave_v5(Weave(), sio)
467
empty_weave = sio.getvalue()
469
dirs = [[], 'revision-store', 'weaves']
471
"This is a Bazaar-NG control directory.\n"
472
"Do not change any files in this directory.\n"),
473
('branch-format', BZR_BRANCH_FORMAT_6),
474
('revision-history', ''),
477
('pending-merges', ''),
478
('inventory', empty_inv),
479
('inventory.weave', empty_weave),
480
('ancestry.weave', empty_weave)
482
cfn = self._rel_controlfilename
483
self._transport.mkdir_multi([cfn(d) for d in dirs])
484
self.put_controlfiles(files)
485
mutter('created control directory in ' + self._transport.base)
487
def _check_format(self, relax_version_check):
488
"""Check this branch format is supported.
490
The format level is stored, as an integer, in
491
self._branch_format for code that needs to check it later.
493
In the future, we might need different in-memory Branch
494
classes to support downlevel branches. But not yet.
497
fmt = self.controlfile('branch-format', 'r').read()
499
raise NotBranchError(path=self.base)
500
mutter("got branch format %r", fmt)
501
if fmt == BZR_BRANCH_FORMAT_6:
502
self._branch_format = 6
503
elif fmt == BZR_BRANCH_FORMAT_5:
504
self._branch_format = 5
505
elif fmt == BZR_BRANCH_FORMAT_4:
506
self._branch_format = 4
508
if (not relax_version_check
509
and self._branch_format not in (5, 6)):
510
raise errors.UnsupportedFormatError(
511
'sorry, branch format %r not supported' % fmt,
512
['use a different bzr version',
513
'or remove the .bzr directory'
514
' and "bzr init" again'])
516
def get_root_id(self):
517
"""Return the id of this branches root"""
518
inv = self.read_working_inventory()
519
return inv.root.file_id
521
def set_root_id(self, file_id):
522
inv = self.read_working_inventory()
523
orig_root_id = inv.root.file_id
524
del inv._byid[inv.root.file_id]
525
inv.root.file_id = file_id
526
inv._byid[inv.root.file_id] = inv.root
529
if entry.parent_id in (None, orig_root_id):
530
entry.parent_id = inv.root.file_id
531
self._write_inventory(inv)
534
def read_working_inventory(self):
535
"""Read the working inventory."""
536
# ElementTree does its own conversion from UTF-8, so open in
538
f = self.controlfile('inventory', 'rb')
539
return bzrlib.xml5.serializer_v5.read_inventory(f)
542
def _write_inventory(self, inv):
543
"""Update the working inventory.
545
That is to say, the inventory describing changes underway, that
546
will be committed to the next revision.
548
from cStringIO import StringIO
550
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
552
# Transport handles atomicity
553
self.put_controlfile('inventory', sio)
555
mutter('wrote working inventory')
557
inventory = property(read_working_inventory, _write_inventory, None,
558
"""Inventory for the working copy.""")
561
def add(self, files, ids=None):
562
"""Make files versioned.
564
Note that the command line normally calls smart_add instead,
565
which can automatically recurse.
567
This puts the files in the Added state, so that they will be
568
recorded by the next commit.
571
List of paths to add, relative to the base of the tree.
574
If set, use these instead of automatically generated ids.
575
Must be the same length as the list of files, but may
576
contain None for ids that are to be autogenerated.
578
TODO: Perhaps have an option to add the ids even if the files do
581
TODO: Perhaps yield the ids and paths as they're added.
583
# TODO: Re-adding a file that is removed in the working copy
584
# should probably put it back with the previous ID.
585
if isinstance(files, basestring):
586
assert(ids is None or isinstance(ids, basestring))
592
ids = [None] * len(files)
594
assert(len(ids) == len(files))
596
inv = self.read_working_inventory()
597
for f,file_id in zip(files, ids):
598
if is_control_file(f):
599
raise BzrError("cannot add control file %s" % quotefn(f))
604
raise BzrError("cannot add top-level %r" % f)
606
fullpath = os.path.normpath(self.abspath(f))
609
kind = file_kind(fullpath)
611
# maybe something better?
612
raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
614
if not InventoryEntry.versionable_kind(kind):
615
raise BzrError('cannot add: not a versionable file ('
616
'i.e. regular file, symlink or directory): %s' % quotefn(f))
619
file_id = gen_file_id(f)
620
inv.add_path(f, kind=kind, file_id=file_id)
622
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
624
self._write_inventory(inv)
627
def print_file(self, file, revno):
628
"""Print `file` to stdout."""
629
tree = self.revision_tree(self.get_rev_id(revno))
630
# use inventory as it was in that revision
631
file_id = tree.inventory.path2id(file)
633
raise BzrError("%r is not present in revision %s" % (file, revno))
634
tree.print_file(file_id)
636
# FIXME: this doesn't need to be a branch method
637
def set_inventory(self, new_inventory_list):
638
from bzrlib.inventory import Inventory, InventoryEntry
639
inv = Inventory(self.get_root_id())
640
for path, file_id, parent, kind in new_inventory_list:
641
name = os.path.basename(path)
644
# fixme, there should be a factory function inv,add_??
645
if kind == 'directory':
646
inv.add(inventory.InventoryDirectory(file_id, name, parent))
648
inv.add(inventory.InventoryFile(file_id, name, parent))
649
elif kind == 'symlink':
650
inv.add(inventory.InventoryLink(file_id, name, parent))
652
raise BzrError("unknown kind %r" % kind)
653
self._write_inventory(inv)
656
"""Return all unknown files.
658
These are files in the working directory that are not versioned or
659
control files or ignored.
661
>>> from bzrlib.workingtree import WorkingTree
662
>>> b = ScratchBranch(files=['foo', 'foo~'])
663
>>> map(str, b.unknowns())
666
>>> list(b.unknowns())
668
>>> WorkingTree(b.base, b).remove('foo')
669
>>> list(b.unknowns())
672
return self.working_tree().unknowns()
675
def append_revision(self, *revision_ids):
676
for revision_id in revision_ids:
677
mutter("add {%s} to revision-history" % revision_id)
678
rev_history = self.revision_history()
679
rev_history.extend(revision_ids)
680
self.set_revision_history(rev_history)
683
def set_revision_history(self, rev_history):
684
self.put_controlfile('revision-history', '\n'.join(rev_history))
686
def has_revision(self, revision_id):
687
"""True if this branch has a copy of the revision.
689
This does not necessarily imply the revision is merge
690
or on the mainline."""
691
return (revision_id is None
692
or self.revision_store.has_id(revision_id))
695
def get_revision_xml_file(self, revision_id):
696
"""Return XML file object for revision object."""
697
if not revision_id or not isinstance(revision_id, basestring):
698
raise InvalidRevisionId(revision_id)
700
return self.revision_store.get(revision_id)
701
except (IndexError, KeyError):
702
raise bzrlib.errors.NoSuchRevision(self, revision_id)
705
get_revision_xml = get_revision_xml_file
707
def get_revision_xml(self, revision_id):
708
return self.get_revision_xml_file(revision_id).read()
711
def get_revision(self, revision_id):
712
"""Return the Revision object for a named revision"""
713
xml_file = self.get_revision_xml_file(revision_id)
716
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
717
except SyntaxError, e:
718
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
722
assert r.revision_id == revision_id
277
725
def get_revision_delta(self, revno):
278
726
"""Return the delta for one revision.
469
1195
if revno < 1 or revno > self.revno():
470
1196
raise InvalidRevisionNumber(revno)
473
def clone(self, *args, **kwargs):
474
"""Clone this branch into to_bzrdir preserving all semantic values.
476
revision_id: if not None, the revision history in the new branch will
477
be truncated to end with revision_id.
479
# for API compatibility, until 0.8 releases we provide the old api:
480
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
481
# after 0.8 releases, the *args and **kwargs should be changed:
482
# def clone(self, to_bzrdir, revision_id=None):
483
if (kwargs.get('to_location', None) or
484
kwargs.get('revision', None) or
485
kwargs.get('basis_branch', None) or
486
(len(args) and isinstance(args[0], basestring))):
487
# backwards compatibility api:
488
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
489
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
492
basis_branch = args[2]
494
basis_branch = kwargs.get('basis_branch', None)
496
basis = basis_branch.bzrdir
501
revision_id = args[1]
503
revision_id = kwargs.get('revision', None)
508
# no default to raise if not provided.
509
url = kwargs.get('to_location')
510
return self.bzrdir.clone(url,
511
revision_id=revision_id,
512
basis=basis).open_branch()
514
# generate args by hand
516
revision_id = args[1]
518
revision_id = kwargs.get('revision_id', None)
522
# no default to raise if not provided.
523
to_bzrdir = kwargs.get('to_bzrdir')
524
result = self._format.initialize(to_bzrdir)
525
self.copy_content_into(result, revision_id=revision_id)
529
def sprout(self, to_bzrdir, revision_id=None):
530
"""Create a new line of development from the branch, into to_bzrdir.
532
revision_id: if not None, the revision history in the new branch will
533
be truncated to end with revision_id.
535
result = self._format.initialize(to_bzrdir)
536
self.copy_content_into(result, revision_id=revision_id)
537
result.set_parent(self.bzrdir.root_transport.base)
541
def copy_content_into(self, destination, revision_id=None):
542
"""Copy the content of self into destination.
544
revision_id: if not None, the revision history in the new branch will
545
be truncated to end with revision_id.
547
new_history = self.revision_history()
548
if revision_id is not None:
549
revision_id = osutils.safe_revision_id(revision_id)
551
new_history = new_history[:new_history.index(revision_id) + 1]
553
rev = self.repository.get_revision(revision_id)
554
new_history = rev.get_history(self.repository)[1:]
555
destination.set_revision_history(new_history)
557
parent = self.get_parent()
558
except errors.InaccessibleParent, e:
559
mutter('parent was not accessible to copy: %s', e)
562
destination.set_parent(parent)
566
"""Check consistency of the branch.
568
In particular this checks that revisions given in the revision-history
569
do actually match up in the revision graph, and that they're all
570
present in the repository.
572
Callers will typically also want to check the repository.
574
:return: A BranchCheckResult.
576
mainline_parent_id = None
577
for revision_id in self.revision_history():
579
revision = self.repository.get_revision(revision_id)
580
except errors.NoSuchRevision, e:
581
raise errors.BzrCheckError("mainline revision {%s} not in repository"
583
# In general the first entry on the revision history has no parents.
584
# But it's not illegal for it to have parents listed; this can happen
585
# in imports from Arch when the parents weren't reachable.
586
if mainline_parent_id is not None:
587
if mainline_parent_id not in revision.parent_ids:
588
raise errors.BzrCheckError("previous revision {%s} not listed among "
590
% (mainline_parent_id, revision_id))
591
mainline_parent_id = revision_id
592
return BranchCheckResult(self)
594
def _get_checkout_format(self):
595
"""Return the most suitable metadir for a checkout of this branch.
596
Weaves are used if this branch's repostory uses weaves.
598
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
599
from bzrlib import repository
600
format = bzrdir.BzrDirMetaFormat1()
601
format.repository_format = repository.RepositoryFormat7()
603
format = self.repository.bzrdir.cloning_metadir()
606
def create_checkout(self, to_location, revision_id=None,
608
"""Create a checkout of a branch.
610
:param to_location: The url to produce the checkout at
611
:param revision_id: The revision to check out
612
:param lightweight: If True, produce a lightweight checkout, otherwise,
613
produce a bound branch (heavyweight checkout)
614
:return: The tree of the created checkout
616
t = transport.get_transport(to_location)
619
except errors.FileExists:
622
checkout = bzrdir.BzrDirMetaFormat1().initialize_on_transport(t)
623
BranchReferenceFormat().initialize(checkout, self)
625
format = self._get_checkout_format()
626
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
627
to_location, force_new_tree=False, format=format)
628
checkout = checkout_branch.bzrdir
629
checkout_branch.bind(self)
630
# pull up to the specified revision_id to set the initial
631
# branch tip correctly, and seed it with history.
632
checkout_branch.pull(self, stop_revision=revision_id)
633
return checkout.create_workingtree(revision_id)
636
class BranchFormat(object):
637
"""An encapsulation of the initialization and open routines for a format.
639
Formats provide three things:
640
* An initialization routine,
644
Formats are placed in an dict by their format string for reference
645
during branch opening. Its not required that these be instances, they
646
can be classes themselves with class methods - it simply depends on
647
whether state is needed for a given format or not.
649
Once a format is deprecated, just deprecate the initialize and open
650
methods on the format class. Do not deprecate the object, as the
651
object will be created every time regardless.
654
_default_format = None
655
"""The default format used for new branches."""
658
"""The known formats."""
661
def find_format(klass, a_bzrdir):
662
"""Return the format for the branch object in a_bzrdir."""
664
transport = a_bzrdir.get_branch_transport(None)
665
format_string = transport.get("format").read()
666
return klass._formats[format_string]
668
raise NotBranchError(path=transport.base)
670
raise errors.UnknownFormatError(format=format_string)
673
def get_default_format(klass):
674
"""Return the current default format."""
675
return klass._default_format
677
def get_format_string(self):
678
"""Return the ASCII format string that identifies this format."""
679
raise NotImplementedError(self.get_format_string)
681
def get_format_description(self):
682
"""Return the short format description for this format."""
683
raise NotImplementedError(self.get_format_string)
685
def initialize(self, a_bzrdir):
686
"""Create a branch of this format in a_bzrdir."""
687
raise NotImplementedError(self.initialize)
689
def is_supported(self):
690
"""Is this format supported?
692
Supported formats can be initialized and opened.
693
Unsupported formats may not support initialization or committing or
694
some other features depending on the reason for not being supported.
698
def open(self, a_bzrdir, _found=False):
699
"""Return the branch object for a_bzrdir
701
_found is a private parameter, do not use it. It is used to indicate
702
if format probing has already be done.
704
raise NotImplementedError(self.open)
707
def register_format(klass, format):
708
klass._formats[format.get_format_string()] = format
711
def set_default_format(klass, format):
712
klass._default_format = format
715
def unregister_format(klass, format):
716
assert klass._formats[format.get_format_string()] is format
717
del klass._formats[format.get_format_string()]
720
return self.get_format_string().rstrip()
723
class BranchHooks(dict):
724
"""A dictionary mapping hook name to a list of callables for branch hooks.
726
e.g. ['set_rh'] Is the list of items to be called when the
727
set_revision_history function is invoked.
731
"""Create the default hooks.
733
These are all empty initially, because by default nothing should get
737
# invoked whenever the revision history has been set
738
# with set_revision_history. The api signature is
739
# (branch, revision_history), and the branch will
740
# be write-locked. Introduced in 0.15.
743
def install_hook(self, hook_name, a_callable):
744
"""Install a_callable in to the hook hook_name.
746
:param hook_name: A hook name. See the __init__ method of BranchHooks
747
for the complete list of hooks.
748
:param a_callable: The callable to be invoked when the hook triggers.
749
The exact signature will depend on the hook - see the __init__
750
method of BranchHooks for details on each hook.
753
self[hook_name].append(a_callable)
755
raise errors.UnknownHook('branch', hook_name)
758
# install the default hooks into the Branch class.
759
Branch.hooks = BranchHooks()
762
class BzrBranchFormat4(BranchFormat):
763
"""Bzr branch format 4.
766
- a revision-history file.
767
- a branch-lock lock file [ to be shared with the bzrdir ]
770
def get_format_description(self):
771
"""See BranchFormat.get_format_description()."""
772
return "Branch format 4"
774
def initialize(self, a_bzrdir):
775
"""Create a branch of this format in a_bzrdir."""
776
mutter('creating branch in %s', a_bzrdir.transport.base)
777
branch_transport = a_bzrdir.get_branch_transport(self)
778
utf8_files = [('revision-history', ''),
781
control_files = lockable_files.LockableFiles(branch_transport,
782
'branch-lock', lockable_files.TransportLock)
783
control_files.create_lock()
784
control_files.lock_write()
786
for file, content in utf8_files:
787
control_files.put_utf8(file, content)
789
control_files.unlock()
790
return self.open(a_bzrdir, _found=True)
793
super(BzrBranchFormat4, self).__init__()
794
self._matchingbzrdir = bzrdir.BzrDirFormat6()
796
def open(self, a_bzrdir, _found=False):
797
"""Return the branch object for a_bzrdir
799
_found is a private parameter, do not use it. It is used to indicate
800
if format probing has already be done.
803
# we are being called directly and must probe.
804
raise NotImplementedError
805
return BzrBranch(_format=self,
806
_control_files=a_bzrdir._control_files,
808
_repository=a_bzrdir.open_repository())
811
return "Bazaar-NG branch format 4"
814
class BzrBranchFormat5(BranchFormat):
815
"""Bzr branch format 5.
818
- a revision-history file.
820
- a lock dir guarding the branch itself
821
- all of this stored in a branch/ subdirectory
822
- works with shared repositories.
824
This format is new in bzr 0.8.
827
def get_format_string(self):
828
"""See BranchFormat.get_format_string()."""
829
return "Bazaar-NG branch format 5\n"
831
def get_format_description(self):
832
"""See BranchFormat.get_format_description()."""
833
return "Branch format 5"
835
def initialize(self, a_bzrdir):
836
"""Create a branch of this format in a_bzrdir."""
837
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
838
branch_transport = a_bzrdir.get_branch_transport(self)
839
utf8_files = [('revision-history', ''),
842
control_files = lockable_files.LockableFiles(branch_transport, 'lock',
844
control_files.create_lock()
845
control_files.lock_write()
846
control_files.put_utf8('format', self.get_format_string())
848
for file, content in utf8_files:
849
control_files.put_utf8(file, content)
851
control_files.unlock()
852
return self.open(a_bzrdir, _found=True, )
855
super(BzrBranchFormat5, self).__init__()
856
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
858
def open(self, a_bzrdir, _found=False):
859
"""Return the branch object for a_bzrdir
861
_found is a private parameter, do not use it. It is used to indicate
862
if format probing has already be done.
865
format = BranchFormat.find_format(a_bzrdir)
866
assert format.__class__ == self.__class__
867
transport = a_bzrdir.get_branch_transport(None)
868
control_files = lockable_files.LockableFiles(transport, 'lock',
870
return BzrBranch5(_format=self,
871
_control_files=control_files,
873
_repository=a_bzrdir.find_repository())
876
return "Bazaar-NG Metadir branch format 5"
879
class BranchReferenceFormat(BranchFormat):
880
"""Bzr branch reference format.
882
Branch references are used in implementing checkouts, they
883
act as an alias to the real branch which is at some other url.
890
def get_format_string(self):
891
"""See BranchFormat.get_format_string()."""
892
return "Bazaar-NG Branch Reference Format 1\n"
894
def get_format_description(self):
895
"""See BranchFormat.get_format_description()."""
896
return "Checkout reference format 1"
898
def initialize(self, a_bzrdir, target_branch=None):
899
"""Create a branch of this format in a_bzrdir."""
900
if target_branch is None:
901
# this format does not implement branch itself, thus the implicit
902
# creation contract must see it as uninitializable
903
raise errors.UninitializableFormat(self)
904
mutter('creating branch reference in %s', a_bzrdir.transport.base)
905
branch_transport = a_bzrdir.get_branch_transport(self)
906
branch_transport.put_bytes('location',
907
target_branch.bzrdir.root_transport.base)
908
branch_transport.put_bytes('format', self.get_format_string())
909
return self.open(a_bzrdir, _found=True)
912
super(BranchReferenceFormat, self).__init__()
913
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
915
def _make_reference_clone_function(format, a_branch):
916
"""Create a clone() routine for a branch dynamically."""
917
def clone(to_bzrdir, revision_id=None):
918
"""See Branch.clone()."""
919
return format.initialize(to_bzrdir, a_branch)
920
# cannot obey revision_id limits when cloning a reference ...
921
# FIXME RBC 20060210 either nuke revision_id for clone, or
922
# emit some sort of warning/error to the caller ?!
925
def open(self, a_bzrdir, _found=False):
926
"""Return the branch that the branch reference in a_bzrdir points at.
928
_found is a private parameter, do not use it. It is used to indicate
929
if format probing has already be done.
932
format = BranchFormat.find_format(a_bzrdir)
933
assert format.__class__ == self.__class__
934
transport = a_bzrdir.get_branch_transport(None)
935
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
936
result = real_bzrdir.open_branch()
937
# this changes the behaviour of result.clone to create a new reference
938
# rather than a copy of the content of the branch.
939
# I did not use a proxy object because that needs much more extensive
940
# testing, and we are only changing one behaviour at the moment.
941
# If we decide to alter more behaviours - i.e. the implicit nickname
942
# then this should be refactored to introduce a tested proxy branch
943
# and a subclass of that for use in overriding clone() and ....
945
result.clone = self._make_reference_clone_function(result)
949
# formats which have no format string are not discoverable
950
# and not independently creatable, so are not registered.
951
__default_format = BzrBranchFormat5()
952
BranchFormat.register_format(__default_format)
953
BranchFormat.register_format(BranchReferenceFormat())
954
BranchFormat.set_default_format(__default_format)
955
_legacy_formats = [BzrBranchFormat4(),
958
class BzrBranch(Branch):
959
"""A branch stored in the actual filesystem.
961
Note that it's "local" in the context of the filesystem; it doesn't
962
really matter if it's on an nfs/smb/afs/coda/... share, as long as
963
it's writable, and can be accessed via the normal filesystem API.
966
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
967
relax_version_check=DEPRECATED_PARAMETER, _format=None,
968
_control_files=None, a_bzrdir=None, _repository=None):
969
"""Create new branch object at a particular location.
971
transport -- A Transport object, defining how to access files.
973
init -- If True, create new control files in a previously
974
unversioned directory. If False, the branch must already
977
relax_version_check -- If true, the usual check for the branch
978
version is not applied. This is intended only for
979
upgrade/recovery type use; it's not guaranteed that
980
all operations will work on old format branches.
983
self.bzrdir = bzrdir.BzrDir.open(transport.base)
985
self.bzrdir = a_bzrdir
986
self._transport = self.bzrdir.transport.clone('..')
987
self._base = self._transport.base
988
self._format = _format
989
if _control_files is None:
990
raise ValueError('BzrBranch _control_files is None')
991
self.control_files = _control_files
992
if deprecated_passed(init):
993
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
994
"deprecated as of bzr 0.8. Please use Branch.create().",
998
# this is slower than before deprecation, oh well never mind.
1000
self._initialize(transport.base)
1001
self._check_format(_format)
1002
if deprecated_passed(relax_version_check):
1003
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
1004
"relax_version_check parameter is deprecated as of bzr 0.8. "
1005
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
1009
if (not relax_version_check
1010
and not self._format.is_supported()):
1011
raise errors.UnsupportedFormatError(format=fmt)
1012
if deprecated_passed(transport):
1013
warn("BzrBranch.__init__(transport=XXX...): The transport "
1014
"parameter is deprecated as of bzr 0.8. "
1015
"Please use Branch.open, or bzrdir.open_branch().",
1018
self.repository = _repository
1021
return '%s(%r)' % (self.__class__.__name__, self.base)
1025
def _get_base(self):
1028
base = property(_get_base, doc="The URL for the root of this branch.")
1030
def _finish_transaction(self):
1031
"""Exit the current transaction."""
1032
return self.control_files._finish_transaction()
1034
def get_transaction(self):
1035
"""Return the current active transaction.
1037
If no transaction is active, this returns a passthrough object
1038
for which all data is immediately flushed and no caching happens.
1040
# this is an explicit function so that we can do tricky stuff
1041
# when the storage in rev_storage is elsewhere.
1042
# we probably need to hook the two 'lock a location' and
1043
# 'have a transaction' together more delicately, so that
1044
# we can have two locks (branch and storage) and one transaction
1045
# ... and finishing the transaction unlocks both, but unlocking
1046
# does not. - RBC 20051121
1047
return self.control_files.get_transaction()
1049
def _set_transaction(self, transaction):
1050
"""Set a new active transaction."""
1051
return self.control_files._set_transaction(transaction)
1053
def abspath(self, name):
1054
"""See Branch.abspath."""
1055
return self.control_files._transport.abspath(name)
1057
def _check_format(self, format):
1058
"""Identify the branch format if needed.
1060
The format is stored as a reference to the format object in
1061
self._format for code that needs to check it later.
1063
The format parameter is either None or the branch format class
1064
used to open this branch.
1066
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
1069
format = BranchFormat.find_format(self.bzrdir)
1070
self._format = format
1071
mutter("got branch format %s", self._format)
1074
def get_root_id(self):
1075
"""See Branch.get_root_id."""
1076
tree = self.repository.revision_tree(self.last_revision())
1077
return tree.inventory.root.file_id
1079
def is_locked(self):
1080
return self.control_files.is_locked()
1082
def lock_write(self):
1083
self.repository.lock_write()
1085
self.control_files.lock_write()
1087
self.repository.unlock()
1090
def lock_read(self):
1091
self.repository.lock_read()
1093
self.control_files.lock_read()
1095
self.repository.unlock()
1099
# TODO: test for failed two phase locks. This is known broken.
1101
self.control_files.unlock()
1103
self.repository.unlock()
1105
def peek_lock_mode(self):
1106
if self.control_files._lock_count == 0:
1109
return self.control_files._lock_mode
1111
def get_physical_lock_status(self):
1112
return self.control_files.get_physical_lock_status()
1115
def print_file(self, file, revision_id):
1116
"""See Branch.print_file."""
1117
return self.repository.print_file(file, revision_id)
1120
def append_revision(self, *revision_ids):
1121
"""See Branch.append_revision."""
1122
for revision_id in revision_ids:
1123
_mod_revision.check_not_reserved_id(revision_id)
1124
mutter("add {%s} to revision-history" % revision_id)
1125
rev_history = self.revision_history()
1126
rev_history.extend(revision_ids)
1127
self.set_revision_history(rev_history)
1130
def set_revision_history(self, rev_history):
1131
"""See Branch.set_revision_history."""
1132
rev_history = [osutils.safe_revision_id(r) for r in rev_history]
1133
self.control_files.put_bytes(
1134
'revision-history', '\n'.join(rev_history))
1135
transaction = self.get_transaction()
1136
history = transaction.map.find_revision_history()
1137
if history is not None:
1138
# update the revision history in the identity map.
1139
history[:] = list(rev_history)
1140
# this call is disabled because revision_history is
1141
# not really an object yet, and the transaction is for objects.
1142
# transaction.register_dirty(history)
1144
transaction.map.add_revision_history(rev_history)
1145
# this call is disabled because revision_history is
1146
# not really an object yet, and the transaction is for objects.
1147
# transaction.register_clean(history)
1148
for hook in Branch.hooks['set_rh']:
1149
hook(self, rev_history)
1152
def revision_history(self):
1153
"""See Branch.revision_history."""
1154
transaction = self.get_transaction()
1155
history = transaction.map.find_revision_history()
1156
if history is not None:
1157
# mutter("cache hit for revision-history in %s", self)
1158
return list(history)
1159
get_cached_utf8 = cache_utf8.get_cached_utf8
1160
history = [get_cached_utf8(l.rstrip('\r\n')) for l in
1161
self.control_files.get('revision-history').readlines()]
1162
transaction.map.add_revision_history(history)
1163
# this call is disabled because revision_history is
1164
# not really an object yet, and the transaction is for objects.
1165
# transaction.register_clean(history, precious=True)
1166
return list(history)
1169
def generate_revision_history(self, revision_id, last_rev=None,
1171
"""Create a new revision history that will finish with revision_id.
1173
:param revision_id: the new tip to use.
1174
:param last_rev: The previous last_revision. If not None, then this
1175
must be a ancestory of revision_id, or DivergedBranches is raised.
1176
:param other_branch: The other branch that DivergedBranches should
1177
raise with respect to.
1179
revision_id = osutils.safe_revision_id(revision_id)
1180
# stop_revision must be a descendant of last_revision
1181
stop_graph = self.repository.get_revision_graph(revision_id)
1182
if last_rev is not None and last_rev not in stop_graph:
1183
# our previous tip is not merged into stop_revision
1184
raise errors.DivergedBranches(self, other_branch)
1185
# make a new revision history from the graph
1186
current_rev_id = revision_id
1188
while current_rev_id not in (None, _mod_revision.NULL_REVISION):
1189
new_history.append(current_rev_id)
1190
current_rev_id_parents = stop_graph[current_rev_id]
1192
current_rev_id = current_rev_id_parents[0]
1194
current_rev_id = None
1195
new_history.reverse()
1196
self.set_revision_history(new_history)
1199
def update_revisions(self, other, stop_revision=None):
1200
"""See Branch.update_revisions."""
1203
if stop_revision is None:
1204
stop_revision = other.last_revision()
1205
if stop_revision is None:
1206
# if there are no commits, we're done.
1209
stop_revision = osutils.safe_revision_id(stop_revision)
1210
# whats the current last revision, before we fetch [and change it
1212
last_rev = self.last_revision()
1213
# we fetch here regardless of whether we need to so that we pickup
1215
self.fetch(other, stop_revision)
1216
my_ancestry = self.repository.get_ancestry(last_rev)
1217
if stop_revision in my_ancestry:
1218
# last_revision is a descendant of stop_revision
1220
self.generate_revision_history(stop_revision, last_rev=last_rev,
1225
def basis_tree(self):
1226
"""See Branch.basis_tree."""
1227
return self.repository.revision_tree(self.last_revision())
1229
@deprecated_method(zero_eight)
1230
def working_tree(self):
1231
"""Create a Working tree object for this branch."""
1233
from bzrlib.transport.local import LocalTransport
1234
if (self.base.find('://') != -1 or
1235
not isinstance(self._transport, LocalTransport)):
1236
raise NoWorkingTree(self.base)
1237
return self.bzrdir.open_workingtree()
1240
def pull(self, source, overwrite=False, stop_revision=None):
1241
"""See Branch.pull."""
1244
old_count = len(self.revision_history())
1246
self.update_revisions(source, stop_revision)
1247
except DivergedBranches:
1251
self.set_revision_history(source.revision_history())
1252
new_count = len(self.revision_history())
1253
return new_count - old_count
1257
def get_parent(self):
1258
"""See Branch.get_parent."""
1260
_locs = ['parent', 'pull', 'x-pull']
1261
assert self.base[-1] == '/'
1264
parent = self.control_files.get(l).read().strip('\n')
1267
# This is an old-format absolute path to a local branch
1268
# turn it into a url
1269
if parent.startswith('/'):
1270
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1272
return urlutils.join(self.base[:-1], parent)
1273
except errors.InvalidURLJoin, e:
1274
raise errors.InaccessibleParent(parent, self.base)
1277
def get_push_location(self):
1278
"""See Branch.get_push_location."""
1279
push_loc = self.get_config().get_user_option('push_location')
1282
def set_push_location(self, location):
1283
"""See Branch.set_push_location."""
1284
self.get_config().set_user_option(
1285
'push_location', location,
1286
store=_mod_config.STORE_LOCATION_NORECURSE)
1289
def set_parent(self, url):
1290
"""See Branch.set_parent."""
1291
# TODO: Maybe delete old location files?
1292
# URLs should never be unicode, even on the local fs,
1293
# FIXUP this and get_parent in a future branch format bump:
1294
# read and rewrite the file, and have the new format code read
1295
# using .get not .get_utf8. RBC 20060125
1297
self.control_files._transport.delete('parent')
1299
if isinstance(url, unicode):
1301
url = url.encode('ascii')
1302
except UnicodeEncodeError:
1303
raise bzrlib.errors.InvalidURL(url,
1304
"Urls must be 7-bit ascii, "
1305
"use bzrlib.urlutils.escape")
1307
url = urlutils.relative_url(self.base, url)
1308
self.control_files.put_bytes('parent', url + '\n')
1310
@deprecated_function(zero_nine)
1311
def tree_config(self):
1312
"""DEPRECATED; call get_config instead.
1313
TreeConfig has become part of BranchConfig."""
1314
return TreeConfig(self)
1317
class BzrBranch5(BzrBranch):
1318
"""A format 5 branch. This supports new features over plan branches.
1320
It has support for a master_branch which is the data for bound branches.
1328
super(BzrBranch5, self).__init__(_format=_format,
1329
_control_files=_control_files,
1331
_repository=_repository)
1334
def pull(self, source, overwrite=False, stop_revision=None):
1335
"""Updates branch.pull to be bound branch aware."""
1336
bound_location = self.get_bound_location()
1337
if source.base != bound_location:
1338
# not pulling from master, so we need to update master.
1339
master_branch = self.get_master_branch()
1341
master_branch.pull(source)
1342
source = master_branch
1343
return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1345
def get_bound_location(self):
1347
return self.control_files.get_utf8('bound').read()[:-1]
1348
except errors.NoSuchFile:
1352
def get_master_branch(self):
1353
"""Return the branch we are bound to.
1355
:return: Either a Branch, or None
1357
This could memoise the branch, but if thats done
1358
it must be revalidated on each new lock.
1359
So for now we just don't memoise it.
1360
# RBC 20060304 review this decision.
1362
bound_loc = self.get_bound_location()
1366
return Branch.open(bound_loc)
1367
except (errors.NotBranchError, errors.ConnectionError), e:
1368
raise errors.BoundBranchConnectionFailure(
1372
def set_bound_location(self, location):
1373
"""Set the target where this branch is bound to.
1375
:param location: URL to the target branch
1378
self.control_files.put_utf8('bound', location+'\n')
1381
self.control_files._transport.delete('bound')
1198
def sign_revision(self, revision_id, gpg_strategy):
1199
plaintext = Testament.from_revision(self, revision_id).as_short_text()
1200
self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1203
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1204
self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)),
1208
class ScratchBranch(_Branch):
1209
"""Special test class: a branch that cleans up after itself.
1211
>>> b = ScratchBranch()
1215
>>> b._transport.__del__()
1220
def __init__(self, files=[], dirs=[], transport=None):
1221
"""Make a test branch.
1223
This creates a temporary directory and runs init-tree in it.
1225
If any files are listed, they are created in the working copy.
1227
if transport is None:
1228
transport = bzrlib.transport.local.ScratchTransport()
1229
super(ScratchBranch, self).__init__(transport, init=True)
1231
super(ScratchBranch, self).__init__(transport)
1234
self._transport.mkdir(d)
1237
self._transport.put(f, 'content of %s' % f)
1242
>>> orig = ScratchBranch(files=["file1", "file2"])
1243
>>> clone = orig.clone()
1244
>>> if os.name != 'nt':
1245
... os.path.samefile(orig.base, clone.base)
1247
... orig.base == clone.base
1250
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1253
from shutil import copytree
1254
from tempfile import mkdtemp
1257
copytree(self.base, base, symlinks=True)
1258
return ScratchBranch(
1259
transport=bzrlib.transport.local.ScratchTransport(base))
1262
######################################################################
1266
def is_control_file(filename):
1267
## FIXME: better check
1268
filename = os.path.normpath(filename)
1269
while filename != '':
1270
head, tail = os.path.split(filename)
1271
## mutter('check %r for control file' % ((head, tail), ))
1272
if tail == bzrlib.BZRDIR:
1387
def bind(self, other):
1388
"""Bind this branch to the branch other.
1390
This does not push or pull data between the branches, though it does
1391
check for divergence to raise an error when the branches are not
1392
either the same, or one a prefix of the other. That behaviour may not
1393
be useful, so that check may be removed in future.
1395
:param other: The branch to bind to
1398
# TODO: jam 20051230 Consider checking if the target is bound
1399
# It is debatable whether you should be able to bind to
1400
# a branch which is itself bound.
1401
# Committing is obviously forbidden,
1402
# but binding itself may not be.
1403
# Since we *have* to check at commit time, we don't
1404
# *need* to check here
1406
# we want to raise diverged if:
1407
# last_rev is not in the other_last_rev history, AND
1408
# other_last_rev is not in our history, and do it without pulling
1410
last_rev = self.last_revision()
1411
if last_rev is not None:
1414
other_last_rev = other.last_revision()
1415
if other_last_rev is not None:
1416
# neither branch is new, we have to do some work to
1417
# ascertain diversion.
1418
remote_graph = other.repository.get_revision_graph(
1420
local_graph = self.repository.get_revision_graph(last_rev)
1421
if (last_rev not in remote_graph and
1422
other_last_rev not in local_graph):
1423
raise errors.DivergedBranches(self, other)
1426
self.set_bound_location(other.base)
1430
"""If bound, unbind"""
1431
return self.set_bound_location(None)
1435
"""Synchronise this branch with the master branch if any.
1437
:return: None or the last_revision that was pivoted out during the
1440
master = self.get_master_branch()
1441
if master is not None:
1442
old_tip = self.last_revision()
1443
self.pull(master, overwrite=True)
1444
if old_tip in self.repository.get_ancestry(self.last_revision()):
1450
class BranchTestProviderAdapter(object):
1451
"""A tool to generate a suite testing multiple branch formats at once.
1453
This is done by copying the test once for each transport and injecting
1454
the transport_server, transport_readonly_server, and branch_format
1455
classes into each copy. Each copy is also given a new id() to make it
1459
def __init__(self, transport_server, transport_readonly_server, formats):
1460
self._transport_server = transport_server
1461
self._transport_readonly_server = transport_readonly_server
1462
self._formats = formats
1464
def adapt(self, test):
1465
result = TestSuite()
1466
for branch_format, bzrdir_format in self._formats:
1467
new_test = deepcopy(test)
1468
new_test.transport_server = self._transport_server
1469
new_test.transport_readonly_server = self._transport_readonly_server
1470
new_test.bzrdir_format = bzrdir_format
1471
new_test.branch_format = branch_format
1472
def make_new_test_id():
1473
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1474
return lambda: new_id
1475
new_test.id = make_new_test_id()
1476
result.addTest(new_test)
1480
class BranchCheckResult(object):
1481
"""Results of checking branch consistency.
1486
def __init__(self, branch):
1487
self.branch = branch
1489
def report_results(self, verbose):
1490
"""Report the check results via trace.note.
1492
:param verbose: Requests more detailed display of what was checked,
1495
note('checked branch %s format %s',
1497
self.branch._format)
1500
######################################################################
1504
@deprecated_function(zero_eight)
1505
def is_control_file(*args, **kwargs):
1506
"""See bzrlib.workingtree.is_control_file."""
1507
from bzrlib import workingtree
1508
return workingtree.is_control_file(*args, **kwargs)
1274
if filename == head:
1281
def gen_file_id(name):
1282
"""Return new file id.
1284
This should probably generate proper UUIDs, but for the moment we
1285
cope with just randomness because running uuidgen every time is
1288
from binascii import hexlify
1289
from time import time
1291
# get last component
1292
idx = name.rfind('/')
1294
name = name[idx+1 : ]
1295
idx = name.rfind('\\')
1297
name = name[idx+1 : ]
1299
# make it not a hidden file
1300
name = name.lstrip('.')
1302
# remove any wierd characters; we don't escape them but rather
1303
# just pull them out
1304
name = re.sub(r'[^\w.]', '', name)
1306
s = hexlify(rand_bytes(8))
1307
return '-'.join((name, compact_date(time()), s))
1311
"""Return a new tree-root file id."""
1312
return gen_file_id('TREE_ROOT')
added
removed
bzrlib/branch.py
