1
# Copyright (C) 2005 Canonical Ltd
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
from cStringIO import StringIO
20
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
21
import traceback, socket, fnmatch, difflib, time
22
from binascii import hexlify
20
from bzrlib.lazy_import import lazy_import
21
lazy_import(globals(), """
22
from copy import deepcopy
23
from unittest import TestSuite
24
from warnings import warn
25
from inventory import Inventory
26
from trace import mutter, note
27
from tree import Tree, EmptyTree, RevisionTree
28
from inventory import InventoryEntry, Inventory
29
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
30
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
31
joinpath, sha_string, file_kind, local_time_offset, appendpath
32
from store import ImmutableStore
33
from revision import Revision
34
from errors import bailout, BzrError
35
from textui import show_status
37
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
38
## TODO: Maybe include checks for common corruption of newlines, etc?
42
def find_branch(f, **args):
43
if f and (f.startswith('http://') or f.startswith('https://')):
45
return remotebranch.RemoteBranch(f, **args)
47
return Branch(f, **args)
50
def find_branch_root(f=None):
51
"""Find the branch root enclosing f, or pwd.
53
f may be a filename or a URL.
55
It is not necessary that f exists.
57
Basically we keep looking up until we find the control directory or
61
elif hasattr(os.path, 'realpath'):
62
f = os.path.realpath(f)
64
f = os.path.abspath(f)
65
if not os.path.exists(f):
66
raise BzrError('%r does not exist' % f)
72
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
74
head, tail = os.path.split(f)
76
# reached the root, whatever that may be
77
raise BzrError('%r is not in a branch' % orig_f)
30
config as _mod_config,
35
revision as _mod_revision,
41
from bzrlib.config import BranchConfig, TreeConfig
42
from bzrlib.lockable_files import LockableFiles, TransportLock
43
from bzrlib.tag import (
49
from bzrlib.decorators import needs_read_lock, needs_write_lock
50
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
51
HistoryMissing, InvalidRevisionId,
52
InvalidRevisionNumber, LockError, NoSuchFile,
53
NoSuchRevision, NoWorkingTree, NotVersionedError,
54
NotBranchError, UninitializableFormat,
55
UnlistableStore, UnlistableBranch,
57
from bzrlib.hooks import Hooks
58
from bzrlib.symbol_versioning import (deprecated_function,
62
zero_eight, zero_nine, zero_sixteen,
64
from bzrlib.trace import mutter, note
67
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
68
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
69
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
72
# TODO: Maybe include checks for common corruption of newlines, etc?
74
# TODO: Some operations like log might retrieve the same revisions
75
# repeatedly to calculate deltas. We could perhaps have a weakref
76
# cache in memory to make this faster. In general anything can be
77
# cached in memory between lock and unlock operations. .. nb thats
78
# what the transaction identity map provides
82
81
######################################################################
86
85
"""Branch holding a history of revisions.
89
Base directory of the branch.
88
Base directory/url of the branch.
90
hooks: An instance of BranchHooks.
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)
182
def lock_write(self):
183
raise NotImplementedError(self.lock_write)
186
raise NotImplementedError(self.lock_read)
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)
198
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
93
def __init__(self, base, init=False, find_root=True, lock_mode='w'):
94
"""Create new branch object at a particular location.
96
base -- Base directory for the branch.
98
init -- If True, create new control files in a previously
99
unversioned directory. If False, the branch must already
102
find_root -- If true and init is false, find the root of the
103
existing branch containing base.
105
In the test suite, creation of new trees is tested using the
106
`ScratchBranch` class.
109
self.base = os.path.realpath(base)
112
self.base = find_branch_root(base)
114
self.base = os.path.realpath(base)
115
if not isdir(self.controlfilename('.')):
116
bailout("not a bzr branch: %s" % quotefn(base),
117
['use "bzr init" to initialize a new working tree',
118
'current bzr can only operate from top-of-tree'])
122
self.text_store = ImmutableStore(self.controlfilename('text-store'))
123
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
124
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
128
return '%s(%r)' % (self.__class__.__name__, self.base)
135
def lock(self, mode='w'):
136
"""Lock the on-disk branch, excluding other processes."""
142
om = os.O_WRONLY | os.O_CREAT
147
raise BzrError("invalid locking mode %r" % mode)
150
lockfile = os.open(self.controlfilename('branch-lock'), om)
152
if e.errno == errno.ENOENT:
153
# might not exist on branches from <0.0.4
154
self.controlfile('branch-lock', 'w').close()
155
lockfile = os.open(self.controlfilename('branch-lock'), om)
159
fcntl.lockf(lockfile, lm)
161
fcntl.lockf(lockfile, fcntl.LOCK_UN)
163
self._lockmode = None
165
self._lockmode = mode
167
warning("please write a locking method for platform %r" % sys.platform)
169
self._lockmode = None
171
self._lockmode = mode
174
def _need_readlock(self):
175
if self._lockmode not in ['r', 'w']:
176
raise BzrError('need read lock on branch, only have %r' % self._lockmode)
178
def _need_writelock(self):
179
if self._lockmode not in ['w']:
180
raise BzrError('need write lock on branch, only have %r' % self._lockmode)
183
def abspath(self, name):
184
"""Return absolute filename for something in the branch"""
185
return os.path.join(self.base, name)
188
def relpath(self, path):
189
"""Return path relative to this branch of something inside it.
191
Raises an error if path is not in this branch."""
192
rp = os.path.realpath(path)
194
if not rp.startswith(self.base):
195
bailout("path %r is not within branch %r" % (rp, self.base))
196
rp = rp[len(self.base):]
197
rp = rp.lstrip(os.sep)
201
def controlfilename(self, file_or_path):
202
"""Return location relative to branch."""
203
if isinstance(file_or_path, types.StringTypes):
204
file_or_path = [file_or_path]
205
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
208
def controlfile(self, file_or_path, mode='r'):
209
"""Open a control file for this branch.
211
There are two classes of file in the control directory: text
212
and binary. binary files are untranslated byte streams. Text
213
control files are stored with Unix newlines and in UTF-8, even
214
if the platform or locale defaults are different.
216
Controlfiles should almost never be opened in write mode but
217
rather should be atomically copied and replaced using atomicfile.
220
fn = self.controlfilename(file_or_path)
222
if mode == 'rb' or mode == 'wb':
223
return file(fn, mode)
224
elif mode == 'r' or mode == 'w':
225
# open in binary mode anyhow so there's no newline translation;
226
# codecs uses line buffering by default; don't want that.
228
return codecs.open(fn, mode + 'b', 'utf-8',
231
raise BzrError("invalid controlfile mode %r" % mode)
235
def _make_control(self):
236
os.mkdir(self.controlfilename([]))
237
self.controlfile('README', 'w').write(
238
"This is a Bazaar-NG control directory.\n"
239
"Do not change any files in this directory.")
240
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
241
for d in ('text-store', 'inventory-store', 'revision-store'):
242
os.mkdir(self.controlfilename(d))
243
for f in ('revision-history', 'merged-patches',
244
'pending-merged-patches', 'branch-name',
246
self.controlfile(f, 'w').write('')
247
mutter('created control directory in ' + self.base)
248
Inventory().write_xml(self.controlfile('inventory','w'))
251
def _check_format(self):
252
"""Check this branch format is supported.
254
The current tool only supports the current unstable format.
256
In the future, we might need different in-memory Branch
257
classes to support downlevel branches. But not yet.
259
# This ignores newlines so that we can open branches created
260
# on Windows from Linux and so on. I think it might be better
261
# to always make all internal files in unix format.
262
fmt = self.controlfile('branch-format', 'r').read()
263
fmt.replace('\r\n', '')
264
if fmt != BZR_BRANCH_FORMAT:
265
bailout('sorry, branch format %r not supported' % fmt,
266
['use a different bzr version',
267
'or remove the .bzr directory and "bzr init" again'])
270
def read_working_inventory(self):
271
"""Read the working inventory."""
272
self._need_readlock()
274
# ElementTree does its own conversion from UTF-8, so open in
276
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
277
mutter("loaded inventory of %d items in %f"
278
% (len(inv), time.time() - before))
282
def _write_inventory(self, inv):
283
"""Update the working inventory.
285
That is to say, the inventory describing changes underway, that
286
will be committed to the next revision.
288
self._need_writelock()
289
## TODO: factor out to atomicfile? is rename safe on windows?
290
## TODO: Maybe some kind of clean/dirty marker on inventory?
291
tmpfname = self.controlfilename('inventory.tmp')
292
tmpf = file(tmpfname, 'wb')
295
inv_fname = self.controlfilename('inventory')
296
if sys.platform == 'win32':
298
os.rename(tmpfname, inv_fname)
299
mutter('wrote working inventory')
302
inventory = property(read_working_inventory, _write_inventory, None,
303
"""Inventory for the working copy.""")
306
def add(self, files, verbose=False):
307
"""Make files versioned.
309
Note that the command line normally calls smart_add instead.
311
This puts the files in the Added state, so that they will be
312
recorded by the next commit.
314
TODO: Perhaps have an option to add the ids even if the files do
317
TODO: Perhaps return the ids of the files? But then again it
318
is easy to retrieve them if they're needed.
320
TODO: Option to specify file id.
322
TODO: Adding a directory should optionally recurse down and
323
add all non-ignored children. Perhaps do that in a
326
self._need_writelock()
328
# TODO: Re-adding a file that is removed in the working copy
329
# should probably put it back with the previous ID.
330
if isinstance(files, types.StringTypes):
333
inv = self.read_working_inventory()
335
if is_control_file(f):
336
bailout("cannot add control file %s" % quotefn(f))
341
bailout("cannot add top-level %r" % f)
343
fullpath = os.path.normpath(self.abspath(f))
346
kind = file_kind(fullpath)
348
# maybe something better?
349
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
351
if kind != 'file' and kind != 'directory':
352
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
354
file_id = gen_file_id(f)
355
inv.add_path(f, kind=kind, file_id=file_id)
358
show_status('A', kind, quotefn(f))
360
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
362
self._write_inventory(inv)
365
def print_file(self, file, revno):
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):
366
311
"""Print `file` to stdout."""
367
self._need_readlock()
368
tree = self.revision_tree(self.lookup_revision(revno))
369
# use inventory as it was in that revision
370
file_id = tree.inventory.path2id(file)
372
bailout("%r is not present in revision %d" % (file, revno))
373
tree.print_file(file_id)
376
def remove(self, files, verbose=False):
377
"""Mark nominated files for removal from the inventory.
379
This does not remove their text. This does not run on
381
TODO: Refuse to remove modified files unless --force is given?
383
TODO: Do something useful with directories.
385
TODO: Should this remove the text or not? Tough call; not
386
removing may be useful and the user can just use use rm, and
387
is the opposite of add. Removing it is consistent with most
388
other tools. Maybe an option.
390
## TODO: Normalize names
391
## TODO: Remove nested loops; better scalability
392
self._need_writelock()
394
if isinstance(files, types.StringTypes):
397
tree = self.working_tree()
400
# do this before any modifications
404
bailout("cannot remove unversioned file %s" % quotefn(f))
405
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
407
# having remove it, it must be either ignored or unknown
408
if tree.is_ignored(f):
412
show_status(new_status, inv[fid].kind, quotefn(f))
415
self._write_inventory(inv)
419
"""Return all unknown files.
421
These are files in the working directory that are not versioned or
422
control files or ignored.
424
>>> b = ScratchBranch(files=['foo', 'foo~'])
425
>>> list(b.unknowns())
428
>>> list(b.unknowns())
431
>>> list(b.unknowns())
434
return self.working_tree().unknowns()
437
def append_revision(self, revision_id):
438
mutter("add {%s} to revision-history" % revision_id)
439
rev_history = self.revision_history()
441
tmprhname = self.controlfilename('revision-history.tmp')
442
rhname = self.controlfilename('revision-history')
444
f = file(tmprhname, 'wt')
445
rev_history.append(revision_id)
446
f.write('\n'.join(rev_history))
450
if sys.platform == 'win32':
452
os.rename(tmprhname, rhname)
456
def get_revision(self, revision_id):
457
"""Return the Revision object for a named revision"""
458
self._need_readlock()
459
r = Revision.read_xml(self.revision_store[revision_id])
460
assert r.revision_id == revision_id
464
def get_inventory(self, inventory_id):
465
"""Get Inventory object by hash.
467
TODO: Perhaps for this and similar methods, take a revision
468
parameter which can be either an integer revno or a
470
self._need_readlock()
471
i = Inventory.read_xml(self.inventory_store[inventory_id])
475
def get_revision_inventory(self, revision_id):
476
"""Return inventory of a past revision."""
477
self._need_readlock()
478
if revision_id == None:
481
return self.get_inventory(self.get_revision(revision_id).inventory_id)
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)
484
358
def revision_history(self):
485
359
"""Return sequence of revision hashes on to this branch.
487
>>> ScratchBranch().revision_history()
490
self._need_readlock()
491
return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
494
def enum_history(self, direction):
495
"""Return (revno, revision_id) for history of branch.
498
'forward' is from earliest to latest
499
'reverse' is from latest to earliest
501
rh = self.revision_history()
502
if direction == 'forward':
507
elif direction == 'reverse':
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
513
raise BzrError('invalid history direction %r' % direction)
367
history = self._gen_revision_history()
368
self._cache_revision_history(history)
517
372
"""Return current revision number for this branch.
642
495
Note that to_name is only the last component of the new name;
643
496
this doesn't change the directory.
645
self._need_writelock()
646
## TODO: Option to move IDs only
647
assert not isinstance(from_paths, basestring)
648
tree = self.working_tree()
650
to_abs = self.abspath(to_name)
651
if not isdir(to_abs):
652
bailout("destination %r is not a directory" % to_abs)
653
if not tree.has_filename(to_name):
654
bailout("destination %r not in working directory" % to_abs)
655
to_dir_id = inv.path2id(to_name)
656
if to_dir_id == None and to_name != '':
657
bailout("destination %r is not a versioned directory" % to_name)
658
to_dir_ie = inv[to_dir_id]
659
if to_dir_ie.kind not in ('directory', 'root_directory'):
660
bailout("destination %r is not a directory" % to_abs)
662
to_idpath = Set(inv.get_idpath(to_dir_id))
665
if not tree.has_filename(f):
666
bailout("%r does not exist in working tree" % f)
667
f_id = inv.path2id(f)
669
bailout("%r is not versioned" % f)
670
name_tail = splitpath(f)[-1]
671
dest_path = appendpath(to_name, name_tail)
672
if tree.has_filename(dest_path):
673
bailout("destination %r already exists" % dest_path)
674
if f_id in to_idpath:
675
bailout("can't move %r to a subdirectory of itself" % f)
677
# OK, so there's a race here, it's possible that someone will
678
# create a file in this interval and then the rename might be
679
# left half-done. But we should have caught most problems.
682
name_tail = splitpath(f)[-1]
683
dest_path = appendpath(to_name, name_tail)
684
print "%s => %s" % (f, dest_path)
685
inv.rename(inv.path2id(f), to_dir_id, name_tail)
687
os.rename(self.abspath(f), self.abspath(dest_path))
689
bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
690
["rename rolled back"])
692
self._write_inventory(inv)
697
class ScratchBranch(Branch):
698
"""Special test class: a branch that cleans up after itself.
700
>>> b = ScratchBranch()
708
def __init__(self, files=[], dirs=[]):
709
"""Make a test branch.
711
This creates a temporary directory and runs init-tree in it.
713
If any files are listed, they are created in the working copy.
715
Branch.__init__(self, tempfile.mkdtemp(), init=True)
717
os.mkdir(self.abspath(d))
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)
720
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
727
"""Destroy the test branch, removing the scratch directory."""
729
mutter("delete ScratchBranch %s" % self.base)
730
shutil.rmtree(self.base)
732
# Work around for shutil.rmtree failing on Windows when
733
# readonly files are encountered
734
mutter("hit exception in destroying ScratchBranch: %s" % e)
735
for root, dirs, files in os.walk(self.base, topdown=False):
737
os.chmod(os.path.join(root, name), 0700)
738
shutil.rmtree(self.base)
743
######################################################################
747
def is_control_file(filename):
748
## FIXME: better check
749
filename = os.path.normpath(filename)
750
while filename != '':
751
head, tail = os.path.split(filename)
752
## mutter('check %r for control file' % ((head, tail), ))
753
if tail == bzrlib.BZRDIR:
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')
762
def gen_file_id(name):
763
"""Return new file id.
765
This should probably generate proper UUIDs, but for the moment we
766
cope with just randomness because running uuidgen every time is
768
idx = name.rfind('/')
770
name = name[idx+1 : ]
771
idx = name.rfind('\\')
773
name = name[idx+1 : ]
775
name = name.lstrip('.')
777
s = hexlify(rand_bytes(8))
778
return '-'.join((name, compact_date(time.time()), s))
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)
added
removed
bzrlib/branch.py
