« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 2255.2.220
- compare with another revision
- download diff
- download tarball
- view history from revision 2255.2.220
- Committer: Robert Collins
- Date: 2007-03-06 10:51:27 UTC
- mto: (2321.1.1 integration)
- mto: This revision was merged to the branch mainline in revision 2322.
- Revision ID: robertc@robertcollins.net-20070306105127-tdec4zgv1tkfgi1d
Fix failing detection of changes restricted to subtrees causing spurious pointless commit errors.
- files added:
- BRANCH.TODO
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/bundle
- bzrlib/bundle/old
- bzrlib/bundle/serializer
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/plugins
- bzrlib/plugins/launchpad
- bzrlib/repofmt
- bzrlib/store
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests
- bzrlib/tests/blackbox
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/intertree_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/test_patches_data
- bzrlib/tests/tree_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport
- bzrlib/transport/http
- bzrlib/ui
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/version_info_formats
- contrib/emacs
- tools
- tools/doc_generate
- tools/win32
- files removed:
- bzrlib/cache.py
- notes
- urlgrabber
- files renamed:
- bzrlib/store.py => bzrlib/store/__init__.py
- elementtree/ => bzrlib/util/elementtree/
- bzrlib/xml.py => bzrlib/xml_serializer.py
- contrib/bash/bzr => contrib/bash/bzr.simple
- bzrlib/newinventory.py => contrib/newinventory.py
- files modified:
- .bzrignore
- bzr *
added
removed
bzrlib/branch.py
1
# Copyright (C) 2005 Canonical Ltd
2
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
#
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.
7
7
#
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.
12
12
#
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
16
16
17
17
18
from sets import Set
18
from cStringIO import StringIO
19
19
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
23
25
24
26
import bzrlib
25
from inventory import Inventory
26
from trace import mutter, note
27
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
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
36
from diff import diff_trees
37
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
39
## TODO: Maybe include checks for common corruption of newlines, etc?
40
41
42
43
def find_branch_root(f=None):
44
"""Find the branch root enclosing f, or pwd.
45
46
It is not necessary that f exists.
47
48
Basically we keep looking up until we find the control directory or
49
run into the root."""
50
if f == None:
51
f = os.getcwd()
52
elif hasattr(os.path, 'realpath'):
53
f = os.path.realpath(f)
54
else:
55
f = os.path.abspath(f)
56
57
orig_f = f
58
59
while True:
60
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
61
return f
62
head, tail = os.path.split(f)
63
if head == f:
64
# reached the root, whatever that may be
65
raise BzrError('%r is not in a branch' % orig_f)
66
f = head
67
27
from bzrlib import (
28
bzrdir,
29
cache_utf8,
30
config as _mod_config,
31
errors,
32
lockdir,
33
lockable_files,
34
osutils,
35
revision as _mod_revision,
36
transport,
37
tree,
38
ui,
39
urlutils,
40
)
41
from bzrlib.config import BranchConfig, TreeConfig
42
from bzrlib.lockable_files import LockableFiles, TransportLock
43
from bzrlib.tag import (
44
BasicTags,
45
DisabledTags,
46
)
47
""")
48
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,
56
)
57
from bzrlib.symbol_versioning import (deprecated_function,
58
deprecated_method,
59
DEPRECATED_PARAMETER,
60
deprecated_passed,
61
zero_eight, zero_nine,
62
)
63
from bzrlib.trace import mutter, note
64
65
66
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
67
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
68
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
69
70
71
# TODO: Maybe include checks for common corruption of newlines, etc?
72
73
# TODO: Some operations like log might retrieve the same revisions
74
# repeatedly to calculate deltas. We could perhaps have a weakref
75
# cache in memory to make this faster. In general anything can be
76
# cached in memory between lock and unlock operations. .. nb thats
77
# what the transaction identity map provides
68
78
69
79
70
80
######################################################################
71
81
# branch objects
72
82
73
class Branch:
83
class Branch(object):
74
84
"""Branch holding a history of revisions.
75
85
76
86
base
77
Base directory of the branch.
87
Base directory/url of the branch.
88
89
hooks: An instance of BranchHooks.
78
90
"""
79
_lockmode = None
91
# this is really an instance variable - FIXME move it there
92
# - RBC 20060112
93
base = None
94
95
# override this to set the strategy for storing tags
96
def _make_tags(self):
97
return DisabledTags(self)
98
99
def __init__(self, *ignored, **ignored_too):
100
self.tags = self._make_tags()
101
102
def break_lock(self):
103
"""Break a lock if one is present from another instance.
104
105
Uses the ui factory to ask for confirmation if the lock may be from
106
an active process.
107
108
This will probe the repository for its lock as well.
109
"""
110
self.control_files.break_lock()
111
self.repository.break_lock()
112
master = self.get_master_branch()
113
if master is not None:
114
master.break_lock()
115
116
@staticmethod
117
@deprecated_method(zero_eight)
118
def open_downlevel(base):
119
"""Open a branch which may be of an old format."""
120
return Branch.open(base, _unsupported=True)
121
122
@staticmethod
123
def open(base, _unsupported=False):
124
"""Open the branch rooted at base.
125
126
For instance, if the branch is at URL/.bzr/branch,
127
Branch.open(URL) -> a Branch instance.
128
"""
129
control = bzrdir.BzrDir.open(base, _unsupported)
130
return control.open_branch(_unsupported)
131
132
@staticmethod
133
def open_containing(url):
134
"""Open an existing branch which contains url.
135
136
This probes for a branch at url, and searches upwards from there.
137
138
Basically we keep looking up until we find the control directory or
139
run into the root. If there isn't one, raises NotBranchError.
140
If there is one and it is either an unrecognised format or an unsupported
141
format, UnknownFormatError or UnsupportedFormatError are raised.
142
If there is one, it is returned, along with the unused portion of url.
143
"""
144
control, relpath = bzrdir.BzrDir.open_containing(url)
145
return control.open_branch(), relpath
146
147
@staticmethod
148
@deprecated_function(zero_eight)
149
def initialize(base):
150
"""Create a new working tree and branch, rooted at 'base' (url)
151
152
NOTE: This will soon be deprecated in favour of creation
153
through a BzrDir.
154
"""
155
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
156
157
@deprecated_function(zero_eight)
158
def setup_caching(self, cache_root):
159
"""Subclasses that care about caching should override this, and set
160
up cached stores located under cache_root.
161
162
NOTE: This is unused.
163
"""
164
pass
165
166
def get_config(self):
167
return BranchConfig(self)
168
169
def _get_nick(self):
170
return self.get_config().get_nickname()
171
172
def _set_nick(self, nick):
173
self.get_config().set_user_option('nickname', nick)
174
175
nick = property(_get_nick, _set_nick)
176
177
def is_locked(self):
178
raise NotImplementedError(self.is_locked)
179
180
def lock_write(self):
181
raise NotImplementedError(self.lock_write)
182
183
def lock_read(self):
184
raise NotImplementedError(self.lock_read)
185
186
def unlock(self):
187
raise NotImplementedError(self.unlock)
188
189
def peek_lock_mode(self):
190
"""Return lock mode for the Branch: 'r', 'w' or None"""
191
raise NotImplementedError(self.peek_lock_mode)
192
193
def get_physical_lock_status(self):
194
raise NotImplementedError(self.get_physical_lock_status)
195
196
def abspath(self, name):
197
"""Return absolute filename for something in the branch
198
199
XXX: Robert Collins 20051017 what is this used for? why is it a branch
200
method and not a tree method.
201
"""
202
raise NotImplementedError(self.abspath)
203
204
def bind(self, other):
205
"""Bind the local branch the other branch.
206
207
:param other: The branch to bind to
208
:type other: Branch
209
"""
210
raise errors.UpgradeRequired(self.base)
211
212
@needs_write_lock
213
def fetch(self, from_branch, last_revision=None, pb=None):
214
"""Copy revisions from from_branch into this branch.
215
216
:param from_branch: Where to copy from.
217
:param last_revision: What revision to stop at (None for at the end
218
of the branch.
219
:param pb: An optional progress bar to use.
220
221
Returns the copied revision count and the failed revisions in a tuple:
222
(copied, failures).
223
"""
224
if self.base == from_branch.base:
225
return (0, [])
226
if pb is None:
227
nested_pb = ui.ui_factory.nested_progress_bar()
228
pb = nested_pb
229
else:
230
nested_pb = None
231
232
from_branch.lock_read()
233
try:
234
if last_revision is None:
235
pb.update('get source history')
236
last_revision = from_branch.last_revision()
237
if last_revision is None:
238
last_revision = _mod_revision.NULL_REVISION
239
return self.repository.fetch(from_branch.repository,
240
revision_id=last_revision,
241
pb=nested_pb)
242
finally:
243
if nested_pb is not None:
244
nested_pb.finished()
245
from_branch.unlock()
246
247
def get_bound_location(self):
248
"""Return the URL of the branch we are bound to.
249
250
Older format branches cannot bind, please be sure to use a metadir
251
branch.
252
"""
253
return None
80
254
81
def __init__(self, base, init=False, find_root=True, lock_mode='w'):
82
"""Create new branch object at a particular location.
83
84
base -- Base directory for the branch.
85
86
init -- If True, create new control files in a previously
87
unversioned directory. If False, the branch must already
88
be versioned.
89
90
find_root -- If true and init is false, find the root of the
91
existing branch containing base.
92
93
In the test suite, creation of new trees is tested using the
94
`ScratchBranch` class.
95
"""
96
if init:
97
self.base = os.path.realpath(base)
98
self._make_control()
99
elif find_root:
100
self.base = find_branch_root(base)
101
else:
102
self.base = os.path.realpath(base)
103
if not isdir(self.controlfilename('.')):
104
bailout("not a bzr branch: %s" % quotefn(base),
105
['use "bzr init" to initialize a new working tree',
106
'current bzr can only operate from top-of-tree'])
107
self._check_format()
108
self.lock(lock_mode)
109
110
self.text_store = ImmutableStore(self.controlfilename('text-store'))
111
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
112
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
113
114
115
def __str__(self):
116
return '%s(%r)' % (self.__class__.__name__, self.base)
117
118
119
__repr__ = __str__
120
121
122
123
def lock(self, mode='w'):
124
"""Lock the on-disk branch, excluding other processes."""
125
try:
126
import fcntl, errno
127
128
if mode == 'w':
129
lm = fcntl.LOCK_EX
130
om = os.O_WRONLY | os.O_CREAT
131
elif mode == 'r':
132
lm = fcntl.LOCK_SH
133
om = os.O_RDONLY
134
else:
135
raise BzrError("invalid locking mode %r" % mode)
136
137
try:
138
lockfile = os.open(self.controlfilename('branch-lock'), om)
139
except OSError, e:
140
if e.errno == errno.ENOENT:
141
# might not exist on branches from <0.0.4
142
self.controlfile('branch-lock', 'w').close()
143
lockfile = os.open(self.controlfilename('branch-lock'), om)
144
else:
145
raise e
146
147
fcntl.lockf(lockfile, lm)
148
def unlock():
149
fcntl.lockf(lockfile, fcntl.LOCK_UN)
150
os.close(lockfile)
151
self._lockmode = None
152
self.unlock = unlock
153
self._lockmode = mode
154
except ImportError:
155
warning("please write a locking method for platform %r" % sys.platform)
156
def unlock():
157
self._lockmode = None
158
self.unlock = unlock
159
self._lockmode = mode
160
161
162
def _need_readlock(self):
163
if self._lockmode not in ['r', 'w']:
164
raise BzrError('need read lock on branch, only have %r' % self._lockmode)
165
166
def _need_writelock(self):
167
if self._lockmode not in ['w']:
168
raise BzrError('need write lock on branch, only have %r' % self._lockmode)
169
170
171
def abspath(self, name):
172
"""Return absolute filename for something in the branch"""
173
return os.path.join(self.base, name)
174
175
176
def relpath(self, path):
177
"""Return path relative to this branch of something inside it.
178
179
Raises an error if path is not in this branch."""
180
rp = os.path.realpath(path)
181
# FIXME: windows
182
if not rp.startswith(self.base):
183
bailout("path %r is not within branch %r" % (rp, self.base))
184
rp = rp[len(self.base):]
185
rp = rp.lstrip(os.sep)
186
return rp
187
188
189
def controlfilename(self, file_or_path):
190
"""Return location relative to branch."""
191
if isinstance(file_or_path, types.StringTypes):
192
file_or_path = [file_or_path]
193
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
194
195
196
def controlfile(self, file_or_path, mode='r'):
197
"""Open a control file for this branch.
198
199
There are two classes of file in the control directory: text
200
and binary. binary files are untranslated byte streams. Text
201
control files are stored with Unix newlines and in UTF-8, even
202
if the platform or locale defaults are different.
203
"""
204
205
fn = self.controlfilename(file_or_path)
206
207
if mode == 'rb' or mode == 'wb':
208
return file(fn, mode)
209
elif mode == 'r' or mode == 'w':
210
# open in binary mode anyhow so there's no newline translation;
211
# codecs uses line buffering by default; don't want that.
212
import codecs
213
return codecs.open(fn, mode + 'b', 'utf-8',
214
buffering=60000)
215
else:
216
raise BzrError("invalid controlfile mode %r" % mode)
217
218
219
220
def _make_control(self):
221
os.mkdir(self.controlfilename([]))
222
self.controlfile('README', 'w').write(
223
"This is a Bazaar-NG control directory.\n"
224
"Do not change any files in this directory.")
225
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
226
for d in ('text-store', 'inventory-store', 'revision-store'):
227
os.mkdir(self.controlfilename(d))
228
for f in ('revision-history', 'merged-patches',
229
'pending-merged-patches', 'branch-name',
230
'branch-lock'):
231
self.controlfile(f, 'w').write('')
232
mutter('created control directory in ' + self.base)
233
Inventory().write_xml(self.controlfile('inventory','w'))
234
235
236
def _check_format(self):
237
"""Check this branch format is supported.
238
239
The current tool only supports the current unstable format.
240
241
In the future, we might need different in-memory Branch
242
classes to support downlevel branches. But not yet.
243
"""
244
# This ignores newlines so that we can open branches created
245
# on Windows from Linux and so on. I think it might be better
246
# to always make all internal files in unix format.
247
fmt = self.controlfile('branch-format', 'r').read()
248
fmt.replace('\r\n', '')
249
if fmt != BZR_BRANCH_FORMAT:
250
bailout('sorry, branch format %r not supported' % fmt,
251
['use a different bzr version',
252
'or remove the .bzr directory and "bzr init" again'])
253
254
255
def read_working_inventory(self):
256
"""Read the working inventory."""
257
self._need_readlock()
258
before = time.time()
259
# ElementTree does its own conversion from UTF-8, so open in
260
# binary.
261
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
262
mutter("loaded inventory of %d items in %f"
263
% (len(inv), time.time() - before))
264
return inv
265
266
267
def _write_inventory(self, inv):
268
"""Update the working inventory.
269
270
That is to say, the inventory describing changes underway, that
271
will be committed to the next revision.
272
"""
273
self._need_writelock()
274
## TODO: factor out to atomicfile? is rename safe on windows?
275
## TODO: Maybe some kind of clean/dirty marker on inventory?
276
tmpfname = self.controlfilename('inventory.tmp')
277
tmpf = file(tmpfname, 'wb')
278
inv.write_xml(tmpf)
279
tmpf.close()
280
inv_fname = self.controlfilename('inventory')
281
if sys.platform == 'win32':
282
os.remove(inv_fname)
283
os.rename(tmpfname, inv_fname)
284
mutter('wrote working inventory')
285
286
287
inventory = property(read_working_inventory, _write_inventory, None,
288
"""Inventory for the working copy.""")
289
290
291
def add(self, files, verbose=False):
292
"""Make files versioned.
293
294
Note that the command line normally calls smart_add instead.
295
296
This puts the files in the Added state, so that they will be
297
recorded by the next commit.
298
299
TODO: Perhaps have an option to add the ids even if the files do
300
not (yet) exist.
301
302
TODO: Perhaps return the ids of the files? But then again it
303
is easy to retrieve them if they're needed.
304
305
TODO: Option to specify file id.
306
307
TODO: Adding a directory should optionally recurse down and
308
add all non-ignored children. Perhaps do that in a
309
higher-level method.
310
311
>>> b = ScratchBranch(files=['foo'])
312
>>> 'foo' in b.unknowns()
313
True
314
>>> b.show_status()
315
? foo
316
>>> b.add('foo')
317
>>> 'foo' in b.unknowns()
318
False
319
>>> bool(b.inventory.path2id('foo'))
320
True
321
>>> b.show_status()
322
A foo
323
324
>>> b.add('foo')
325
Traceback (most recent call last):
326
...
327
BzrError: ('foo is already versioned', [])
328
329
>>> b.add(['nothere'])
330
Traceback (most recent call last):
331
BzrError: ('cannot add: not a regular file or directory: nothere', [])
332
"""
333
self._need_writelock()
334
335
# TODO: Re-adding a file that is removed in the working copy
336
# should probably put it back with the previous ID.
337
if isinstance(files, types.StringTypes):
338
files = [files]
339
340
inv = self.read_working_inventory()
341
for f in files:
342
if is_control_file(f):
343
bailout("cannot add control file %s" % quotefn(f))
344
345
fp = splitpath(f)
346
347
if len(fp) == 0:
348
bailout("cannot add top-level %r" % f)
349
350
fullpath = os.path.normpath(self.abspath(f))
351
352
try:
353
kind = file_kind(fullpath)
354
except OSError:
355
# maybe something better?
356
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
357
358
if kind != 'file' and kind != 'directory':
359
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
360
361
file_id = gen_file_id(f)
362
inv.add_path(f, kind=kind, file_id=file_id)
363
364
if verbose:
365
show_status('A', kind, quotefn(f))
366
367
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
368
369
self._write_inventory(inv)
370
371
372
def print_file(self, file, revno):
255
def get_old_bound_location(self):
256
"""Return the URL of the branch we used to be bound to
257
"""
258
raise errors.UpgradeRequired(self.base)
259
260
def get_commit_builder(self, parents, config=None, timestamp=None,
261
timezone=None, committer=None, revprops=None,
262
revision_id=None):
263
"""Obtain a CommitBuilder for this branch.
264
265
:param parents: Revision ids of the parents of the new revision.
266
:param config: Optional configuration to use.
267
:param timestamp: Optional timestamp recorded for commit.
268
:param timezone: Optional timezone for timestamp.
269
:param committer: Optional committer to set for commit.
270
:param revprops: Optional dictionary of revision properties.
271
:param revision_id: Optional revision id.
272
"""
273
274
if config is None:
275
config = self.get_config()
276
277
return self.repository.get_commit_builder(self, parents, config,
278
timestamp, timezone, committer, revprops, revision_id)
279
280
def get_master_branch(self):
281
"""Return the branch we are bound to.
282
283
:return: Either a Branch, or None
284
"""
285
return None
286
287
def get_revision_delta(self, revno):
288
"""Return the delta for one revision.
289
290
The delta is relative to its mainline predecessor, or the
291
empty tree for revision 1.
292
"""
293
assert isinstance(revno, int)
294
rh = self.revision_history()
295
if not (1 <= revno <= len(rh)):
296
raise InvalidRevisionNumber(revno)
297
return self.repository.get_revision_delta(rh[revno-1])
298
299
def get_root_id(self):
300
"""Return the id of this branches root"""
301
raise NotImplementedError(self.get_root_id)
302
303
def print_file(self, file, revision_id):
373
304
"""Print `file` to stdout."""
374
self._need_readlock()
375
tree = self.revision_tree(self.lookup_revision(revno))
376
# use inventory as it was in that revision
377
file_id = tree.inventory.path2id(file)
378
if not file_id:
379
bailout("%r is not present in revision %d" % (file, revno))
380
tree.print_file(file_id)
381
382
383
def remove(self, files, verbose=False):
384
"""Mark nominated files for removal from the inventory.
385
386
This does not remove their text. This does not run on
387
388
TODO: Refuse to remove modified files unless --force is given?
389
390
>>> b = ScratchBranch(files=['foo'])
391
>>> b.add('foo')
392
>>> b.inventory.has_filename('foo')
393
True
394
>>> b.remove('foo')
395
>>> b.working_tree().has_filename('foo')
396
True
397
>>> b.inventory.has_filename('foo')
398
False
399
400
>>> b = ScratchBranch(files=['foo'])
401
>>> b.add('foo')
402
>>> b.commit('one')
403
>>> b.remove('foo')
404
>>> b.commit('two')
405
>>> b.inventory.has_filename('foo')
406
False
407
>>> b.basis_tree().has_filename('foo')
408
False
409
>>> b.working_tree().has_filename('foo')
410
True
411
412
TODO: Do something useful with directories.
413
414
TODO: Should this remove the text or not? Tough call; not
415
removing may be useful and the user can just use use rm, and
416
is the opposite of add. Removing it is consistent with most
417
other tools. Maybe an option.
418
"""
419
## TODO: Normalize names
420
## TODO: Remove nested loops; better scalability
421
self._need_writelock()
422
423
if isinstance(files, types.StringTypes):
424
files = [files]
425
426
tree = self.working_tree()
427
inv = tree.inventory
428
429
# do this before any modifications
430
for f in files:
431
fid = inv.path2id(f)
432
if not fid:
433
bailout("cannot remove unversioned file %s" % quotefn(f))
434
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
435
if verbose:
436
# having remove it, it must be either ignored or unknown
437
if tree.is_ignored(f):
438
new_status = 'I'
439
else:
440
new_status = '?'
441
show_status(new_status, inv[fid].kind, quotefn(f))
442
del inv[fid]
443
444
self._write_inventory(inv)
445
446
447
def unknowns(self):
448
"""Return all unknown files.
449
450
These are files in the working directory that are not versioned or
451
control files or ignored.
452
453
>>> b = ScratchBranch(files=['foo', 'foo~'])
454
>>> list(b.unknowns())
455
['foo']
456
>>> b.add('foo')
457
>>> list(b.unknowns())
458
[]
459
>>> b.remove('foo')
460
>>> list(b.unknowns())
461
['foo']
462
"""
463
return self.working_tree().unknowns()
464
465
466
def commit(self, message, timestamp=None, timezone=None,
467
committer=None,
468
verbose=False):
469
"""Commit working copy as a new revision.
470
471
The basic approach is to add all the file texts into the
472
store, then the inventory, then make a new revision pointing
473
to that inventory and store that.
474
475
This is not quite safe if the working copy changes during the
476
commit; for the moment that is simply not allowed. A better
477
approach is to make a temporary copy of the files before
478
computing their hashes, and then add those hashes in turn to
479
the inventory. This should mean at least that there are no
480
broken hash pointers. There is no way we can get a snapshot
481
of the whole directory at an instant. This would also have to
482
be robust against files disappearing, moving, etc. So the
483
whole thing is a bit hard.
484
485
timestamp -- if not None, seconds-since-epoch for a
486
postdated/predated commit.
487
"""
488
self._need_writelock()
489
490
## TODO: Show branch names
491
492
# TODO: Don't commit if there are no changes, unless forced?
493
494
# First walk over the working inventory; and both update that
495
# and also build a new revision inventory. The revision
496
# inventory needs to hold the text-id, sha1 and size of the
497
# actual file versions committed in the revision. (These are
498
# not present in the working inventory.) We also need to
499
# detect missing/deleted files, and remove them from the
500
# working inventory.
501
502
work_inv = self.read_working_inventory()
503
inv = Inventory()
504
basis = self.basis_tree()
505
basis_inv = basis.inventory
506
missing_ids = []
507
for path, entry in work_inv.iter_entries():
508
## TODO: Cope with files that have gone missing.
509
510
## TODO: Check that the file kind has not changed from the previous
511
## revision of this file (if any).
512
513
entry = entry.copy()
514
515
p = self.abspath(path)
516
file_id = entry.file_id
517
mutter('commit prep file %s, id %r ' % (p, file_id))
518
519
if not os.path.exists(p):
520
mutter(" file is missing, removing from inventory")
521
if verbose:
522
show_status('D', entry.kind, quotefn(path))
523
missing_ids.append(file_id)
524
continue
525
526
# TODO: Handle files that have been deleted
527
528
# TODO: Maybe a special case for empty files? Seems a
529
# waste to store them many times.
530
531
inv.add(entry)
532
533
if basis_inv.has_id(file_id):
534
old_kind = basis_inv[file_id].kind
535
if old_kind != entry.kind:
536
bailout("entry %r changed kind from %r to %r"
537
% (file_id, old_kind, entry.kind))
538
539
if entry.kind == 'directory':
540
if not isdir(p):
541
bailout("%s is entered as directory but not a directory" % quotefn(p))
542
elif entry.kind == 'file':
543
if not isfile(p):
544
bailout("%s is entered as file but is not a file" % quotefn(p))
545
546
content = file(p, 'rb').read()
547
548
entry.text_sha1 = sha_string(content)
549
entry.text_size = len(content)
550
551
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
552
if (old_ie
553
and (old_ie.text_size == entry.text_size)
554
and (old_ie.text_sha1 == entry.text_sha1)):
555
## assert content == basis.get_file(file_id).read()
556
entry.text_id = basis_inv[file_id].text_id
557
mutter(' unchanged from previous text_id {%s}' %
558
entry.text_id)
559
560
else:
561
entry.text_id = gen_file_id(entry.name)
562
self.text_store.add(content, entry.text_id)
563
mutter(' stored with text_id {%s}' % entry.text_id)
564
if verbose:
565
if not old_ie:
566
state = 'A'
567
elif (old_ie.name == entry.name
568
and old_ie.parent_id == entry.parent_id):
569
state = 'M'
570
else:
571
state = 'R'
572
573
show_status(state, entry.kind, quotefn(path))
574
575
for file_id in missing_ids:
576
# have to do this later so we don't mess up the iterator.
577
# since parents may be removed before their children we
578
# have to test.
579
580
# FIXME: There's probably a better way to do this; perhaps
581
# the workingtree should know how to filter itself.
582
if work_inv.has_id(file_id):
583
del work_inv[file_id]
584
585
586
inv_id = rev_id = _gen_revision_id(time.time())
587
588
inv_tmp = tempfile.TemporaryFile()
589
inv.write_xml(inv_tmp)
590
inv_tmp.seek(0)
591
self.inventory_store.add(inv_tmp, inv_id)
592
mutter('new inventory_id is {%s}' % inv_id)
593
594
self._write_inventory(work_inv)
595
596
if timestamp == None:
597
timestamp = time.time()
598
599
if committer == None:
600
committer = username()
601
602
if timezone == None:
603
timezone = local_time_offset()
604
605
mutter("building commit log message")
606
rev = Revision(timestamp=timestamp,
607
timezone=timezone,
608
committer=committer,
609
precursor = self.last_patch(),
610
message = message,
611
inventory_id=inv_id,
612
revision_id=rev_id)
613
614
rev_tmp = tempfile.TemporaryFile()
615
rev.write_xml(rev_tmp)
616
rev_tmp.seek(0)
617
self.revision_store.add(rev_tmp, rev_id)
618
mutter("new revision_id is {%s}" % rev_id)
619
620
## XXX: Everything up to here can simply be orphaned if we abort
621
## the commit; it will leave junk files behind but that doesn't
622
## matter.
623
624
## TODO: Read back the just-generated changeset, and make sure it
625
## applies and recreates the right state.
626
627
## TODO: Also calculate and store the inventory SHA1
628
mutter("committing patch r%d" % (self.revno() + 1))
629
630
631
self.append_revision(rev_id)
632
633
if verbose:
634
note("commited r%d" % self.revno())
635
636
637
def append_revision(self, revision_id):
638
mutter("add {%s} to revision-history" % revision_id)
639
rev_history = self.revision_history()
640
641
tmprhname = self.controlfilename('revision-history.tmp')
642
rhname = self.controlfilename('revision-history')
643
644
f = file(tmprhname, 'wt')
645
rev_history.append(revision_id)
646
f.write('\n'.join(rev_history))
647
f.write('\n')
648
f.close()
649
650
if sys.platform == 'win32':
651
os.remove(rhname)
652
os.rename(tmprhname, rhname)
653
654
655
656
def get_revision(self, revision_id):
657
"""Return the Revision object for a named revision"""
658
self._need_readlock()
659
r = Revision.read_xml(self.revision_store[revision_id])
660
assert r.revision_id == revision_id
661
return r
662
663
664
def get_inventory(self, inventory_id):
665
"""Get Inventory object by hash.
666
667
TODO: Perhaps for this and similar methods, take a revision
668
parameter which can be either an integer revno or a
669
string hash."""
670
self._need_readlock()
671
i = Inventory.read_xml(self.inventory_store[inventory_id])
672
return i
673
674
675
def get_revision_inventory(self, revision_id):
676
"""Return inventory of a past revision."""
677
self._need_readlock()
678
if revision_id == None:
679
return Inventory()
680
else:
681
return self.get_inventory(self.get_revision(revision_id).inventory_id)
682
305
raise NotImplementedError(self.print_file)
306
307
def append_revision(self, *revision_ids):
308
raise NotImplementedError(self.append_revision)
309
310
def set_revision_history(self, rev_history):
311
raise NotImplementedError(self.set_revision_history)
683
312
684
313
def revision_history(self):
685
"""Return sequence of revision hashes on to this branch.
686
687
>>> ScratchBranch().revision_history()
688
[]
689
"""
690
self._need_readlock()
691
return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
692
693
694
def enum_history(self, direction):
695
"""Return (revno, revision_id) for history of branch.
696
697
direction
698
'forward' is from earliest to latest
699
'reverse' is from latest to earliest
700
"""
701
rh = self.revision_history()
702
if direction == 'forward':
703
i = 1
704
for rid in rh:
705
yield i, rid
706
i += 1
707
elif direction == 'reverse':
708
i = len(rh)
709
while i > 0:
710
yield i, rh[i-1]
711
i -= 1
712
else:
713
raise BzrError('invalid history direction %r' % direction)
714
314
"""Return sequence of revision hashes on to this branch."""
315
raise NotImplementedError(self.revision_history)
715
316
716
317
def revno(self):
717
318
"""Return current revision number for this branch.
718
319
719
320
That is equivalent to the number of revisions committed to
720
321
this branch.
721
722
>>> b = ScratchBranch()
723
>>> b.revno()
724
0
725
>>> b.commit('no foo')
726
>>> b.revno()
727
1
728
322
"""
729
323
return len(self.revision_history())
730
324
731
732
def last_patch(self):
733
"""Return last patch hash, or None if no history.
734
735
>>> ScratchBranch().last_patch() == None
736
True
737
"""
325
def unbind(self):
326
"""Older format branches cannot bind or unbind."""
327
raise errors.UpgradeRequired(self.base)
328
329
def set_append_revisions_only(self, enabled):
330
"""Older format branches are never restricted to append-only"""
331
raise errors.UpgradeRequired(self.base)
332
333
def last_revision(self):
334
"""Return last revision id, or None"""
738
335
ph = self.revision_history()
739
336
if ph:
740
337
return ph[-1]
741
338
else:
742
339
return None
340
341
def last_revision_info(self):
342
"""Return information about the last revision.
343
344
:return: A tuple (revno, last_revision_id).
345
"""
346
rh = self.revision_history()
347
revno = len(rh)
348
if revno:
349
return (revno, rh[-1])
350
else:
351
return (0, _mod_revision.NULL_REVISION)
352
353
def missing_revisions(self, other, stop_revision=None):
354
"""Return a list of new revisions that would perfectly fit.
743
355
744
745
def lookup_revision(self, revno):
746
"""Return revision hash for revision number."""
356
If self and other have not diverged, return a list of the revisions
357
present in other, but missing from self.
358
"""
359
self_history = self.revision_history()
360
self_len = len(self_history)
361
other_history = other.revision_history()
362
other_len = len(other_history)
363
common_index = min(self_len, other_len) -1
364
if common_index >= 0 and \
365
self_history[common_index] != other_history[common_index]:
366
raise DivergedBranches(self, other)
367
368
if stop_revision is None:
369
stop_revision = other_len
370
else:
371
assert isinstance(stop_revision, int)
372
if stop_revision > other_len:
373
raise errors.NoSuchRevision(self, stop_revision)
374
return other_history[self_len:stop_revision]
375
376
def update_revisions(self, other, stop_revision=None):
377
"""Pull in new perfect-fit revisions.
378
379
:param other: Another Branch to pull from
380
:param stop_revision: Updated until the given revision
381
:return: None
382
"""
383
raise NotImplementedError(self.update_revisions)
384
385
def revision_id_to_revno(self, revision_id):
386
"""Given a revision id, return its revno"""
387
if revision_id is None:
388
return 0
389
revision_id = osutils.safe_revision_id(revision_id)
390
history = self.revision_history()
391
try:
392
return history.index(revision_id) + 1
393
except ValueError:
394
raise bzrlib.errors.NoSuchRevision(self, revision_id)
395
396
def get_rev_id(self, revno, history=None):
397
"""Find the revision id of the specified revno."""
747
398
if revno == 0:
748
399
return None
749
750
try:
751
# list is 0-based; revisions are 1-based
752
return self.revision_history()[revno-1]
753
except IndexError:
754
raise BzrError("no such revision %s" % revno)
755
756
757
def revision_tree(self, revision_id):
758
"""Return Tree for a revision on this branch.
759
760
`revision_id` may be None for the null revision, in which case
761
an `EmptyTree` is returned."""
762
self._need_readlock()
763
if revision_id == None:
764
return EmptyTree()
765
else:
766
inv = self.get_revision_inventory(revision_id)
767
return RevisionTree(self.text_store, inv)
768
769
770
def working_tree(self):
771
"""Return a `Tree` for the working copy."""
772
return WorkingTree(self.base, self.read_working_inventory())
773
400
if history is None:
401
history = self.revision_history()
402
if revno <= 0 or revno > len(history):
403
raise bzrlib.errors.NoSuchRevision(self, revno)
404
return history[revno - 1]
405
406
def pull(self, source, overwrite=False, stop_revision=None):
407
"""Mirror source into this branch.
408
409
This branch is considered to be 'local', having low latency.
410
411
:returns: PullResult instance
412
"""
413
raise NotImplementedError(self.pull)
414
415
def push(self, target, overwrite=False, stop_revision=None):
416
"""Mirror this branch into target.
417
418
This branch is considered to be 'local', having low latency.
419
"""
420
raise NotImplementedError(self.push)
774
421
775
422
def basis_tree(self):
776
"""Return `Tree` object for last revision.
777
778
If there are no revisions yet, return an `EmptyTree`.
779
780
>>> b = ScratchBranch(files=['foo'])
781
>>> b.basis_tree().has_filename('foo')
782
False
783
>>> b.working_tree().has_filename('foo')
784
True
785
>>> b.add('foo')
786
>>> b.commit('add foo')
787
>>> b.basis_tree().has_filename('foo')
788
True
789
"""
790
r = self.last_patch()
791
if r == None:
792
return EmptyTree()
793
else:
794
return RevisionTree(self.text_store, self.get_revision_inventory(r))
795
796
423
"""Return `Tree` object for last revision."""
424
return self.repository.revision_tree(self.last_revision())
797
425
798
426
def rename_one(self, from_rel, to_rel):
799
427
"""Rename one file.
800
428
801
429
This can change the directory or the filename or both.
802
430
"""
803
self._need_writelock()
804
tree = self.working_tree()
805
inv = tree.inventory
806
if not tree.has_filename(from_rel):
807
bailout("can't rename: old working file %r does not exist" % from_rel)
808
if tree.has_filename(to_rel):
809
bailout("can't rename: new working file %r already exists" % to_rel)
810
811
file_id = inv.path2id(from_rel)
812
if file_id == None:
813
bailout("can't rename: old name %r is not versioned" % from_rel)
814
815
if inv.path2id(to_rel):
816
bailout("can't rename: new name %r is already versioned" % to_rel)
817
818
to_dir, to_tail = os.path.split(to_rel)
819
to_dir_id = inv.path2id(to_dir)
820
if to_dir_id == None and to_dir != '':
821
bailout("can't determine destination directory id for %r" % to_dir)
822
823
mutter("rename_one:")
824
mutter(" file_id {%s}" % file_id)
825
mutter(" from_rel %r" % from_rel)
826
mutter(" to_rel %r" % to_rel)
827
mutter(" to_dir %r" % to_dir)
828
mutter(" to_dir_id {%s}" % to_dir_id)
829
830
inv.rename(file_id, to_dir_id, to_tail)
831
832
print "%s => %s" % (from_rel, to_rel)
833
834
from_abs = self.abspath(from_rel)
835
to_abs = self.abspath(to_rel)
836
try:
837
os.rename(from_abs, to_abs)
838
except OSError, e:
839
bailout("failed to rename %r to %r: %s"
840
% (from_abs, to_abs, e[1]),
841
["rename rolled back"])
842
843
self._write_inventory(inv)
844
845
431
raise NotImplementedError(self.rename_one)
846
432
847
433
def move(self, from_paths, to_name):
848
434
"""Rename files.
854
440
855
441
Note that to_name is only the last component of the new name;
856
442
this doesn't change the directory.
857
"""
858
self._need_writelock()
859
## TODO: Option to move IDs only
860
assert not isinstance(from_paths, basestring)
861
tree = self.working_tree()
862
inv = tree.inventory
863
to_abs = self.abspath(to_name)
864
if not isdir(to_abs):
865
bailout("destination %r is not a directory" % to_abs)
866
if not tree.has_filename(to_name):
867
bailout("destination %r not in working directory" % to_abs)
868
to_dir_id = inv.path2id(to_name)
869
if to_dir_id == None and to_name != '':
870
bailout("destination %r is not a versioned directory" % to_name)
871
to_dir_ie = inv[to_dir_id]
872
if to_dir_ie.kind not in ('directory', 'root_directory'):
873
bailout("destination %r is not a directory" % to_abs)
874
875
to_idpath = Set(inv.get_idpath(to_dir_id))
876
877
for f in from_paths:
878
if not tree.has_filename(f):
879
bailout("%r does not exist in working tree" % f)
880
f_id = inv.path2id(f)
881
if f_id == None:
882
bailout("%r is not versioned" % f)
883
name_tail = splitpath(f)[-1]
884
dest_path = appendpath(to_name, name_tail)
885
if tree.has_filename(dest_path):
886
bailout("destination %r already exists" % dest_path)
887
if f_id in to_idpath:
888
bailout("can't move %r to a subdirectory of itself" % f)
889
890
# OK, so there's a race here, it's possible that someone will
891
# create a file in this interval and then the rename might be
892
# left half-done. But we should have caught most problems.
893
894
for f in from_paths:
895
name_tail = splitpath(f)[-1]
896
dest_path = appendpath(to_name, name_tail)
897
print "%s => %s" % (f, dest_path)
898
inv.rename(inv.path2id(f), to_dir_id, name_tail)
899
try:
900
os.rename(self.abspath(f), self.abspath(dest_path))
901
except OSError, e:
902
bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
903
["rename rolled back"])
904
905
self._write_inventory(inv)
906
907
908
909
def show_status(self, show_all=False):
910
"""Display single-line status for non-ignored working files.
911
912
The list is show sorted in order by file name.
913
914
>>> b = ScratchBranch(files=['foo', 'foo~'])
915
>>> b.show_status()
916
? foo
917
>>> b.add('foo')
918
>>> b.show_status()
919
A foo
920
>>> b.commit("add foo")
921
>>> b.show_status()
922
>>> os.unlink(b.abspath('foo'))
923
>>> b.show_status()
924
D foo
925
926
TODO: Get state for single files.
927
"""
928
self._need_readlock()
929
930
# We have to build everything into a list first so that it can
931
# sorted by name, incorporating all the different sources.
932
933
# FIXME: Rather than getting things in random order and then sorting,
934
# just step through in order.
935
936
# Interesting case: the old ID for a file has been removed,
937
# but a new file has been created under that name.
938
939
old = self.basis_tree()
940
new = self.working_tree()
941
942
for fs, fid, oldname, newname, kind in diff_trees(old, new):
943
if fs == 'R':
944
show_status(fs, kind,
945
oldname + ' => ' + newname)
946
elif fs == 'A' or fs == 'M':
947
show_status(fs, kind, newname)
948
elif fs == 'D':
949
show_status(fs, kind, oldname)
950
elif fs == '.':
951
if show_all:
952
show_status(fs, kind, newname)
953
elif fs == 'I':
954
if show_all:
955
show_status(fs, kind, newname)
956
elif fs == '?':
957
show_status(fs, kind, newname)
958
else:
959
bailout("weird file state %r" % ((fs, fid),))
960
961
962
963
class ScratchBranch(Branch):
964
"""Special test class: a branch that cleans up after itself.
965
966
>>> b = ScratchBranch()
967
>>> isdir(b.base)
968
True
969
>>> bd = b.base
970
>>> b.destroy()
971
>>> isdir(bd)
972
False
973
"""
974
def __init__(self, files=[], dirs=[]):
975
"""Make a test branch.
976
977
This creates a temporary directory and runs init-tree in it.
978
979
If any files are listed, they are created in the working copy.
980
"""
981
Branch.__init__(self, tempfile.mkdtemp(), init=True)
982
for d in dirs:
983
os.mkdir(self.abspath(d))
443
444
This returns a list of (from_path, to_path) pairs for each
445
entry that is moved.
446
"""
447
raise NotImplementedError(self.move)
448
449
def get_parent(self):
450
"""Return the parent location of the branch.
451
452
This is the default location for push/pull/missing. The usual
453
pattern is that the user can override it by specifying a
454
location.
455
"""
456
raise NotImplementedError(self.get_parent)
457
458
def get_submit_branch(self):
459
"""Return the submit location of the branch.
460
461
This is the default location for bundle. The usual
462
pattern is that the user can override it by specifying a
463
location.
464
"""
465
return self.get_config().get_user_option('submit_branch')
466
467
def set_submit_branch(self, location):
468
"""Return the submit location of the branch.
469
470
This is the default location for bundle. The usual
471
pattern is that the user can override it by specifying a
472
location.
473
"""
474
self.get_config().set_user_option('submit_branch', location)
475
476
def get_push_location(self):
477
"""Return the None or the location to push this branch to."""
478
raise NotImplementedError(self.get_push_location)
479
480
def set_push_location(self, location):
481
"""Set a new push location for this branch."""
482
raise NotImplementedError(self.set_push_location)
483
484
def set_parent(self, url):
485
raise NotImplementedError(self.set_parent)
486
487
@needs_write_lock
488
def update(self):
489
"""Synchronise this branch with the master branch if any.
490
491
:return: None or the last_revision pivoted out during the update.
492
"""
493
return None
494
495
def check_revno(self, revno):
496
"""\
497
Check whether a revno corresponds to any revision.
498
Zero (the NULL revision) is considered valid.
499
"""
500
if revno != 0:
501
self.check_real_revno(revno)
984
502
985
for f in files:
986
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
987
988
989
def __del__(self):
990
self.destroy()
991
992
def destroy(self):
993
"""Destroy the test branch, removing the scratch directory."""
994
try:
995
mutter("delete ScratchBranch %s" % self.base)
996
shutil.rmtree(self.base)
997
except OSError, e:
998
# Work around for shutil.rmtree failing on Windows when
999
# readonly files are encountered
1000
mutter("hit exception in destroying ScratchBranch: %s" % e)
1001
for root, dirs, files in os.walk(self.base, topdown=False):
1002
for name in files:
1003
os.chmod(os.path.join(root, name), 0700)
1004
shutil.rmtree(self.base)
1005
self.base = None
1006
1007
1008
1009
######################################################################
1010
# predicates
1011
1012
1013
def is_control_file(filename):
1014
## FIXME: better check
1015
filename = os.path.normpath(filename)
1016
while filename != '':
1017
head, tail = os.path.split(filename)
1018
## mutter('check %r for control file' % ((head, tail), ))
1019
if tail == bzrlib.BZRDIR:
503
def check_real_revno(self, revno):
504
"""\
505
Check whether a revno corresponds to a real revision.
506
Zero (the NULL revision) is considered invalid
507
"""
508
if revno < 1 or revno > self.revno():
509
raise InvalidRevisionNumber(revno)
510
511
@needs_read_lock
512
def clone(self, *args, **kwargs):
513
"""Clone this branch into to_bzrdir preserving all semantic values.
514
515
revision_id: if not None, the revision history in the new branch will
516
be truncated to end with revision_id.
517
"""
518
# for API compatibility, until 0.8 releases we provide the old api:
519
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
520
# after 0.8 releases, the *args and **kwargs should be changed:
521
# def clone(self, to_bzrdir, revision_id=None):
522
if (kwargs.get('to_location', None) or
523
kwargs.get('revision', None) or
524
kwargs.get('basis_branch', None) or
525
(len(args) and isinstance(args[0], basestring))):
526
# backwards compatibility api:
527
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
528
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
529
# get basis_branch
530
if len(args) > 2:
531
basis_branch = args[2]
532
else:
533
basis_branch = kwargs.get('basis_branch', None)
534
if basis_branch:
535
basis = basis_branch.bzrdir
536
else:
537
basis = None
538
# get revision
539
if len(args) > 1:
540
revision_id = args[1]
541
else:
542
revision_id = kwargs.get('revision', None)
543
# get location
544
if len(args):
545
url = args[0]
546
else:
547
# no default to raise if not provided.
548
url = kwargs.get('to_location')
549
return self.bzrdir.clone(url,
550
revision_id=revision_id,
551
basis=basis).open_branch()
552
# new cleaner api.
553
# generate args by hand
554
if len(args) > 1:
555
revision_id = args[1]
556
else:
557
revision_id = kwargs.get('revision_id', None)
558
if len(args):
559
to_bzrdir = args[0]
560
else:
561
# no default to raise if not provided.
562
to_bzrdir = kwargs.get('to_bzrdir')
563
result = self._format.initialize(to_bzrdir)
564
self.copy_content_into(result, revision_id=revision_id)
565
return result
566
567
@needs_read_lock
568
def sprout(self, to_bzrdir, revision_id=None):
569
"""Create a new line of development from the branch, into to_bzrdir.
570
571
revision_id: if not None, the revision history in the new branch will
572
be truncated to end with revision_id.
573
"""
574
result = self._format.initialize(to_bzrdir)
575
self.copy_content_into(result, revision_id=revision_id)
576
result.set_parent(self.bzrdir.root_transport.base)
577
return result
578
579
def _synchronize_history(self, destination, revision_id):
580
"""Synchronize last revision and revision history between branches.
581
582
This version is most efficient when the destination is also a
583
BzrBranch5, but works for BzrBranch6 as long as the revision
584
history is the true lefthand parent history, and all of the revisions
585
are in the destination's repository. If not, set_revision_history
586
will fail.
587
588
:param destination: The branch to copy the history into
589
:param revision_id: The revision-id to truncate history at. May
590
be None to copy complete history.
591
"""
592
new_history = self.revision_history()
593
if revision_id is not None:
594
revision_id = osutils.safe_revision_id(revision_id)
595
try:
596
new_history = new_history[:new_history.index(revision_id) + 1]
597
except ValueError:
598
rev = self.repository.get_revision(revision_id)
599
new_history = rev.get_history(self.repository)[1:]
600
destination.set_revision_history(new_history)
601
602
@needs_read_lock
603
def copy_content_into(self, destination, revision_id=None):
604
"""Copy the content of self into destination.
605
606
revision_id: if not None, the revision history in the new branch will
607
be truncated to end with revision_id.
608
"""
609
self._synchronize_history(destination, revision_id)
610
try:
611
parent = self.get_parent()
612
except errors.InaccessibleParent, e:
613
mutter('parent was not accessible to copy: %s', e)
614
else:
615
if parent:
616
destination.set_parent(parent)
617
618
@needs_read_lock
619
def check(self):
620
"""Check consistency of the branch.
621
622
In particular this checks that revisions given in the revision-history
623
do actually match up in the revision graph, and that they're all
624
present in the repository.
625
626
Callers will typically also want to check the repository.
627
628
:return: A BranchCheckResult.
629
"""
630
mainline_parent_id = None
631
for revision_id in self.revision_history():
632
try:
633
revision = self.repository.get_revision(revision_id)
634
except errors.NoSuchRevision, e:
635
raise errors.BzrCheckError("mainline revision {%s} not in repository"
636
% revision_id)
637
# In general the first entry on the revision history has no parents.
638
# But it's not illegal for it to have parents listed; this can happen
639
# in imports from Arch when the parents weren't reachable.
640
if mainline_parent_id is not None:
641
if mainline_parent_id not in revision.parent_ids:
642
raise errors.BzrCheckError("previous revision {%s} not listed among "
643
"parents of {%s}"
644
% (mainline_parent_id, revision_id))
645
mainline_parent_id = revision_id
646
return BranchCheckResult(self)
647
648
def _get_checkout_format(self):
649
"""Return the most suitable metadir for a checkout of this branch.
650
Weaves are used if this branch's repostory uses weaves.
651
"""
652
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
653
from bzrlib.repofmt import weaverepo
654
format = bzrdir.BzrDirMetaFormat1()
655
format.repository_format = weaverepo.RepositoryFormat7()
656
else:
657
format = self.repository.bzrdir.checkout_metadir()
658
format.branch_format = self._format
659
return format
660
661
def create_checkout(self, to_location, revision_id=None,
662
lightweight=False):
663
"""Create a checkout of a branch.
664
665
:param to_location: The url to produce the checkout at
666
:param revision_id: The revision to check out
667
:param lightweight: If True, produce a lightweight checkout, otherwise,
668
produce a bound branch (heavyweight checkout)
669
:return: The tree of the created checkout
670
"""
671
t = transport.get_transport(to_location)
672
try:
673
t.mkdir('.')
674
except errors.FileExists:
675
pass
676
if lightweight:
677
format = self._get_checkout_format()
678
checkout = format.initialize_on_transport(t)
679
BranchReferenceFormat().initialize(checkout, self)
680
else:
681
format = self._get_checkout_format()
682
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
683
to_location, force_new_tree=False, format=format)
684
checkout = checkout_branch.bzrdir
685
checkout_branch.bind(self)
686
# pull up to the specified revision_id to set the initial
687
# branch tip correctly, and seed it with history.
688
checkout_branch.pull(self, stop_revision=revision_id)
689
tree = checkout.create_workingtree(revision_id)
690
for path, entry in tree.iter_reference_entries():
691
path = tree.id2path(entry.file_id)
692
reference_parent = self.reference_parent(entry.file_id, path)
693
reference_parent.create_checkout(tree.abspath(path),
694
entry.reference_revision,
695
lightweight)
696
return tree
697
698
def reference_parent(self, file_id, path):
699
"""Return the parent branch for a tree-reference file_id
700
:param file_id: The file_id of the tree reference
701
:param path: The path of the file_id in the tree
702
:return: A branch associated with the file_id
703
"""
704
# FIXME should provide multiple branches, based on config
705
return Branch.open(self.bzrdir.root_transport.clone(path).base)
706
707
def supports_tags(self):
708
return self._format.supports_tags()
709
710
711
class BranchFormat(object):
712
"""An encapsulation of the initialization and open routines for a format.
713
714
Formats provide three things:
715
* An initialization routine,
716
* a format string,
717
* an open routine.
718
719
Formats are placed in an dict by their format string for reference
720
during branch opening. Its not required that these be instances, they
721
can be classes themselves with class methods - it simply depends on
722
whether state is needed for a given format or not.
723
724
Once a format is deprecated, just deprecate the initialize and open
725
methods on the format class. Do not deprecate the object, as the
726
object will be created every time regardless.
727
"""
728
729
_default_format = None
730
"""The default format used for new branches."""
731
732
_formats = {}
733
"""The known formats."""
734
735
@classmethod
736
def find_format(klass, a_bzrdir):
737
"""Return the format for the branch object in a_bzrdir."""
738
try:
739
transport = a_bzrdir.get_branch_transport(None)
740
format_string = transport.get("format").read()
741
return klass._formats[format_string]
742
except NoSuchFile:
743
raise NotBranchError(path=transport.base)
744
except KeyError:
745
raise errors.UnknownFormatError(format=format_string)
746
747
@classmethod
748
def get_default_format(klass):
749
"""Return the current default format."""
750
return klass._default_format
751
752
def get_format_string(self):
753
"""Return the ASCII format string that identifies this format."""
754
raise NotImplementedError(self.get_format_string)
755
756
def get_format_description(self):
757
"""Return the short format description for this format."""
758
raise NotImplementedError(self.get_format_description)
759
760
def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
761
set_format=True):
762
"""Initialize a branch in a bzrdir, with specified files
763
764
:param a_bzrdir: The bzrdir to initialize the branch in
765
:param utf8_files: The files to create as a list of
766
(filename, content) tuples
767
:param set_format: If True, set the format with
768
self.get_format_string. (BzrBranch4 has its format set
769
elsewhere)
770
:return: a branch in this format
771
"""
772
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
773
branch_transport = a_bzrdir.get_branch_transport(self)
774
lock_map = {
775
'metadir': ('lock', lockdir.LockDir),
776
'branch4': ('branch-lock', lockable_files.TransportLock),
777
}
778
lock_name, lock_class = lock_map[lock_type]
779
control_files = lockable_files.LockableFiles(branch_transport,
780
lock_name, lock_class)
781
control_files.create_lock()
782
control_files.lock_write()
783
if set_format:
784
control_files.put_utf8('format', self.get_format_string())
785
try:
786
for file, content in utf8_files:
787
control_files.put_utf8(file, content)
788
finally:
789
control_files.unlock()
790
return self.open(a_bzrdir, _found=True)
791
792
def initialize(self, a_bzrdir):
793
"""Create a branch of this format in a_bzrdir."""
794
raise NotImplementedError(self.initialize)
795
796
def is_supported(self):
797
"""Is this format supported?
798
799
Supported formats can be initialized and opened.
800
Unsupported formats may not support initialization or committing or
801
some other features depending on the reason for not being supported.
802
"""
803
return True
804
805
def open(self, a_bzrdir, _found=False):
806
"""Return the branch object for a_bzrdir
807
808
_found is a private parameter, do not use it. It is used to indicate
809
if format probing has already be done.
810
"""
811
raise NotImplementedError(self.open)
812
813
@classmethod
814
def register_format(klass, format):
815
klass._formats[format.get_format_string()] = format
816
817
@classmethod
818
def set_default_format(klass, format):
819
klass._default_format = format
820
821
@classmethod
822
def unregister_format(klass, format):
823
assert klass._formats[format.get_format_string()] is format
824
del klass._formats[format.get_format_string()]
825
826
def __str__(self):
827
return self.get_format_string().rstrip()
828
829
def supports_tags(self):
830
"""True if this format supports tags stored in the branch"""
831
return False # by default
832
833
# XXX: Probably doesn't really belong here -- mbp 20070212
834
def _initialize_control_files(self, a_bzrdir, utf8_files, lock_filename,
835
lock_class):
836
branch_transport = a_bzrdir.get_branch_transport(self)
837
control_files = lockable_files.LockableFiles(branch_transport,
838
lock_filename, lock_class)
839
control_files.create_lock()
840
control_files.lock_write()
841
try:
842
for filename, content in utf8_files:
843
control_files.put_utf8(filename, content)
844
finally:
845
control_files.unlock()
846
847
848
class BranchHooks(dict):
849
"""A dictionary mapping hook name to a list of callables for branch hooks.
850
851
e.g. ['set_rh'] Is the list of items to be called when the
852
set_revision_history function is invoked.
853
"""
854
855
def __init__(self):
856
"""Create the default hooks.
857
858
These are all empty initially, because by default nothing should get
859
notified.
860
"""
861
dict.__init__(self)
862
# Introduced in 0.15:
863
# invoked whenever the revision history has been set
864
# with set_revision_history. The api signature is
865
# (branch, revision_history), and the branch will
866
# be write-locked.
867
self['set_rh'] = []
868
# invoked after a push operation completes.
869
# the api signature is
870
# (push_result)
871
# containing the members
872
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
873
# where local is the local branch or None, master is the target
874
# master branch, and the rest should be self explanatory. The source
875
# is read locked and the target branches write locked. Source will
876
# be the local low-latency branch.
877
self['post_push'] = []
878
# invoked after a pull operation completes.
879
# the api signature is
880
# (pull_result)
881
# containing the members
882
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
883
# where local is the local branch or None, master is the target
884
# master branch, and the rest should be self explanatory. The source
885
# is read locked and the target branches write locked. The local
886
# branch is the low-latency branch.
887
self['post_pull'] = []
888
# invoked after a commit operation completes.
889
# the api signature is
890
# (local, master, old_revno, old_revid, new_revno, new_revid)
891
# old_revid is NULL_REVISION for the first commit to a branch.
892
self['post_commit'] = []
893
# invoked after a uncommit operation completes.
894
# the api signature is
895
# (local, master, old_revno, old_revid, new_revno, new_revid) where
896
# local is the local branch or None, master is the target branch,
897
# and an empty branch recieves new_revno of 0, new_revid of None.
898
self['post_uncommit'] = []
899
900
def install_hook(self, hook_name, a_callable):
901
"""Install a_callable in to the hook hook_name.
902
903
:param hook_name: A hook name. See the __init__ method of BranchHooks
904
for the complete list of hooks.
905
:param a_callable: The callable to be invoked when the hook triggers.
906
The exact signature will depend on the hook - see the __init__
907
method of BranchHooks for details on each hook.
908
"""
909
try:
910
self[hook_name].append(a_callable)
911
except KeyError:
912
raise errors.UnknownHook('branch', hook_name)
913
914
915
# install the default hooks into the Branch class.
916
Branch.hooks = BranchHooks()
917
918
919
class BzrBranchFormat4(BranchFormat):
920
"""Bzr branch format 4.
921
922
This format has:
923
- a revision-history file.
924
- a branch-lock lock file [ to be shared with the bzrdir ]
925
"""
926
927
def get_format_description(self):
928
"""See BranchFormat.get_format_description()."""
929
return "Branch format 4"
930
931
def initialize(self, a_bzrdir):
932
"""Create a branch of this format in a_bzrdir."""
933
utf8_files = [('revision-history', ''),
934
('branch-name', ''),
935
]
936
return self._initialize_helper(a_bzrdir, utf8_files,
937
lock_type='branch4', set_format=False)
938
939
def __init__(self):
940
super(BzrBranchFormat4, self).__init__()
941
self._matchingbzrdir = bzrdir.BzrDirFormat6()
942
943
def open(self, a_bzrdir, _found=False):
944
"""Return the branch object for a_bzrdir
945
946
_found is a private parameter, do not use it. It is used to indicate
947
if format probing has already be done.
948
"""
949
if not _found:
950
# we are being called directly and must probe.
951
raise NotImplementedError
952
return BzrBranch(_format=self,
953
_control_files=a_bzrdir._control_files,
954
a_bzrdir=a_bzrdir,
955
_repository=a_bzrdir.open_repository())
956
957
def __str__(self):
958
return "Bazaar-NG branch format 4"
959
960
961
class BzrBranchFormat5(BranchFormat):
962
"""Bzr branch format 5.
963
964
This format has:
965
- a revision-history file.
966
- a format string
967
- a lock dir guarding the branch itself
968
- all of this stored in a branch/ subdirectory
969
- works with shared repositories.
970
971
This format is new in bzr 0.8.
972
"""
973
974
def get_format_string(self):
975
"""See BranchFormat.get_format_string()."""
976
return "Bazaar-NG branch format 5\n"
977
978
def get_format_description(self):
979
"""See BranchFormat.get_format_description()."""
980
return "Branch format 5"
981
982
def initialize(self, a_bzrdir):
983
"""Create a branch of this format in a_bzrdir."""
984
utf8_files = [('revision-history', ''),
985
('branch-name', ''),
986
]
987
return self._initialize_helper(a_bzrdir, utf8_files)
988
989
def __init__(self):
990
super(BzrBranchFormat5, self).__init__()
991
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
992
993
def open(self, a_bzrdir, _found=False):
994
"""Return the branch object for a_bzrdir
995
996
_found is a private parameter, do not use it. It is used to indicate
997
if format probing has already be done.
998
"""
999
if not _found:
1000
format = BranchFormat.find_format(a_bzrdir)
1001
assert format.__class__ == self.__class__
1002
transport = a_bzrdir.get_branch_transport(None)
1003
control_files = lockable_files.LockableFiles(transport, 'lock',
1004
lockdir.LockDir)
1005
return BzrBranch5(_format=self,
1006
_control_files=control_files,
1007
a_bzrdir=a_bzrdir,
1008
_repository=a_bzrdir.find_repository())
1009
1010
1011
class BzrBranchFormat6(BzrBranchFormat5):
1012
"""Branch format with last-revision
1013
1014
Unlike previous formats, this has no explicit revision history. Instead,
1015
this just stores the last-revision, and the left-hand history leading
1016
up to there is the history.
1017
1018
This format was introduced in bzr 0.15
1019
"""
1020
1021
def get_format_string(self):
1022
"""See BranchFormat.get_format_string()."""
1023
return "Bazaar-NG branch format 6\n"
1024
1025
def get_format_description(self):
1026
"""See BranchFormat.get_format_description()."""
1027
return "Branch format 6"
1028
1029
def initialize(self, a_bzrdir):
1030
"""Create a branch of this format in a_bzrdir."""
1031
utf8_files = [('last-revision', '0 null:\n'),
1032
('branch-name', ''),
1033
('branch.conf', ''),
1034
('tags', ''),
1035
]
1036
return self._initialize_helper(a_bzrdir, utf8_files)
1037
1038
def open(self, a_bzrdir, _found=False):
1039
"""Return the branch object for a_bzrdir
1040
1041
_found is a private parameter, do not use it. It is used to indicate
1042
if format probing has already be done.
1043
"""
1044
if not _found:
1045
format = BranchFormat.find_format(a_bzrdir)
1046
assert format.__class__ == self.__class__
1047
transport = a_bzrdir.get_branch_transport(None)
1048
control_files = lockable_files.LockableFiles(transport, 'lock',
1049
lockdir.LockDir)
1050
return BzrBranch6(_format=self,
1051
_control_files=control_files,
1052
a_bzrdir=a_bzrdir,
1053
_repository=a_bzrdir.find_repository())
1054
1055
def supports_tags(self):
1056
return True
1057
1058
1059
class BranchReferenceFormat(BranchFormat):
1060
"""Bzr branch reference format.
1061
1062
Branch references are used in implementing checkouts, they
1063
act as an alias to the real branch which is at some other url.
1064
1065
This format has:
1066
- A location file
1067
- a format string
1068
"""
1069
1070
def get_format_string(self):
1071
"""See BranchFormat.get_format_string()."""
1072
return "Bazaar-NG Branch Reference Format 1\n"
1073
1074
def get_format_description(self):
1075
"""See BranchFormat.get_format_description()."""
1076
return "Checkout reference format 1"
1077
1078
def initialize(self, a_bzrdir, target_branch=None):
1079
"""Create a branch of this format in a_bzrdir."""
1080
if target_branch is None:
1081
# this format does not implement branch itself, thus the implicit
1082
# creation contract must see it as uninitializable
1083
raise errors.UninitializableFormat(self)
1084
mutter('creating branch reference in %s', a_bzrdir.transport.base)
1085
branch_transport = a_bzrdir.get_branch_transport(self)
1086
branch_transport.put_bytes('location',
1087
target_branch.bzrdir.root_transport.base)
1088
branch_transport.put_bytes('format', self.get_format_string())
1089
return self.open(a_bzrdir, _found=True)
1090
1091
def __init__(self):
1092
super(BranchReferenceFormat, self).__init__()
1093
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1094
1095
def _make_reference_clone_function(format, a_branch):
1096
"""Create a clone() routine for a branch dynamically."""
1097
def clone(to_bzrdir, revision_id=None):
1098
"""See Branch.clone()."""
1099
return format.initialize(to_bzrdir, a_branch)
1100
# cannot obey revision_id limits when cloning a reference ...
1101
# FIXME RBC 20060210 either nuke revision_id for clone, or
1102
# emit some sort of warning/error to the caller ?!
1103
return clone
1104
1105
def open(self, a_bzrdir, _found=False):
1106
"""Return the branch that the branch reference in a_bzrdir points at.
1107
1108
_found is a private parameter, do not use it. It is used to indicate
1109
if format probing has already be done.
1110
"""
1111
if not _found:
1112
format = BranchFormat.find_format(a_bzrdir)
1113
assert format.__class__ == self.__class__
1114
transport = a_bzrdir.get_branch_transport(None)
1115
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
1116
result = real_bzrdir.open_branch()
1117
# this changes the behaviour of result.clone to create a new reference
1118
# rather than a copy of the content of the branch.
1119
# I did not use a proxy object because that needs much more extensive
1120
# testing, and we are only changing one behaviour at the moment.
1121
# If we decide to alter more behaviours - i.e. the implicit nickname
1122
# then this should be refactored to introduce a tested proxy branch
1123
# and a subclass of that for use in overriding clone() and ....
1124
# - RBC 20060210
1125
result.clone = self._make_reference_clone_function(result)
1126
return result
1127
1128
1129
# formats which have no format string are not discoverable
1130
# and not independently creatable, so are not registered.
1131
__default_format = BzrBranchFormat5()
1132
BranchFormat.register_format(__default_format)
1133
BranchFormat.register_format(BranchReferenceFormat())
1134
BranchFormat.register_format(BzrBranchFormat6())
1135
BranchFormat.set_default_format(__default_format)
1136
_legacy_formats = [BzrBranchFormat4(),
1137
]
1138
1139
class BzrBranch(Branch):
1140
"""A branch stored in the actual filesystem.
1141
1142
Note that it's "local" in the context of the filesystem; it doesn't
1143
really matter if it's on an nfs/smb/afs/coda/... share, as long as
1144
it's writable, and can be accessed via the normal filesystem API.
1145
"""
1146
1147
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
1148
relax_version_check=DEPRECATED_PARAMETER, _format=None,
1149
_control_files=None, a_bzrdir=None, _repository=None):
1150
"""Create new branch object at a particular location.
1151
1152
transport -- A Transport object, defining how to access files.
1153
1154
init -- If True, create new control files in a previously
1155
unversioned directory. If False, the branch must already
1156
be versioned.
1157
1158
relax_version_check -- If true, the usual check for the branch
1159
version is not applied. This is intended only for
1160
upgrade/recovery type use; it's not guaranteed that
1161
all operations will work on old format branches.
1162
"""
1163
Branch.__init__(self)
1164
if a_bzrdir is None:
1165
self.bzrdir = bzrdir.BzrDir.open(transport.base)
1166
else:
1167
self.bzrdir = a_bzrdir
1168
# self._transport used to point to the directory containing the
1169
# control directory, but was not used - now it's just the transport
1170
# for the branch control files. mbp 20070212
1171
self._base = self.bzrdir.transport.clone('..').base
1172
self._format = _format
1173
if _control_files is None:
1174
raise ValueError('BzrBranch _control_files is None')
1175
self.control_files = _control_files
1176
self._transport = _control_files._transport
1177
if deprecated_passed(init):
1178
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
1179
"deprecated as of bzr 0.8. Please use Branch.create().",
1180
DeprecationWarning,
1181
stacklevel=2)
1182
if init:
1183
# this is slower than before deprecation, oh well never mind.
1184
# -> its deprecated.
1185
self._initialize(transport.base)
1186
self._check_format(_format)
1187
if deprecated_passed(relax_version_check):
1188
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
1189
"relax_version_check parameter is deprecated as of bzr 0.8. "
1190
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
1191
"open() method.",
1192
DeprecationWarning,
1193
stacklevel=2)
1194
if (not relax_version_check
1195
and not self._format.is_supported()):
1196
raise errors.UnsupportedFormatError(format=fmt)
1197
if deprecated_passed(transport):
1198
warn("BzrBranch.__init__(transport=XXX...): The transport "
1199
"parameter is deprecated as of bzr 0.8. "
1200
"Please use Branch.open, or bzrdir.open_branch().",
1201
DeprecationWarning,
1202
stacklevel=2)
1203
self.repository = _repository
1204
1205
def __str__(self):
1206
return '%s(%r)' % (self.__class__.__name__, self.base)
1207
1208
__repr__ = __str__
1209
1210
def _get_base(self):
1211
"""Returns the directory containing the control directory."""
1212
return self._base
1213
1214
base = property(_get_base, doc="The URL for the root of this branch.")
1215
1216
def _finish_transaction(self):
1217
"""Exit the current transaction."""
1218
return self.control_files._finish_transaction()
1219
1220
def get_transaction(self):
1221
"""Return the current active transaction.
1222
1223
If no transaction is active, this returns a passthrough object
1224
for which all data is immediately flushed and no caching happens.
1225
"""
1226
# this is an explicit function so that we can do tricky stuff
1227
# when the storage in rev_storage is elsewhere.
1228
# we probably need to hook the two 'lock a location' and
1229
# 'have a transaction' together more delicately, so that
1230
# we can have two locks (branch and storage) and one transaction
1231
# ... and finishing the transaction unlocks both, but unlocking
1232
# does not. - RBC 20051121
1233
return self.control_files.get_transaction()
1234
1235
def _set_transaction(self, transaction):
1236
"""Set a new active transaction."""
1237
return self.control_files._set_transaction(transaction)
1238
1239
def abspath(self, name):
1240
"""See Branch.abspath."""
1241
return self.control_files._transport.abspath(name)
1242
1243
def _check_format(self, format):
1244
"""Identify the branch format if needed.
1245
1246
The format is stored as a reference to the format object in
1247
self._format for code that needs to check it later.
1248
1249
The format parameter is either None or the branch format class
1250
used to open this branch.
1251
1252
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
1253
"""
1254
if format is None:
1255
format = BranchFormat.find_format(self.bzrdir)
1256
self._format = format
1257
mutter("got branch format %s", self._format)
1258
1259
@needs_read_lock
1260
def get_root_id(self):
1261
"""See Branch.get_root_id."""
1262
tree = self.repository.revision_tree(self.last_revision())
1263
return tree.inventory.root.file_id
1264
1265
def is_locked(self):
1266
return self.control_files.is_locked()
1267
1268
def lock_write(self):
1269
self.repository.lock_write()
1270
try:
1271
self.control_files.lock_write()
1272
except:
1273
self.repository.unlock()
1274
raise
1275
1276
def lock_read(self):
1277
self.repository.lock_read()
1278
try:
1279
self.control_files.lock_read()
1280
except:
1281
self.repository.unlock()
1282
raise
1283
1284
def unlock(self):
1285
# TODO: test for failed two phase locks. This is known broken.
1286
try:
1287
self.control_files.unlock()
1288
finally:
1289
self.repository.unlock()
1290
1291
def peek_lock_mode(self):
1292
if self.control_files._lock_count == 0:
1293
return None
1294
else:
1295
return self.control_files._lock_mode
1296
1297
def get_physical_lock_status(self):
1298
return self.control_files.get_physical_lock_status()
1299
1300
@needs_read_lock
1301
def print_file(self, file, revision_id):
1302
"""See Branch.print_file."""
1303
return self.repository.print_file(file, revision_id)
1304
1305
@needs_write_lock
1306
def append_revision(self, *revision_ids):
1307
"""See Branch.append_revision."""
1308
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1309
for revision_id in revision_ids:
1310
_mod_revision.check_not_reserved_id(revision_id)
1311
mutter("add {%s} to revision-history" % revision_id)
1312
rev_history = self.revision_history()
1313
rev_history.extend(revision_ids)
1314
self.set_revision_history(rev_history)
1315
1316
def _write_revision_history(self, history):
1317
"""Factored out of set_revision_history.
1318
1319
This performs the actual writing to disk.
1320
It is intended to be called by BzrBranch5.set_revision_history."""
1321
self.control_files.put_bytes(
1322
'revision-history', '\n'.join(history))
1323
1324
@needs_write_lock
1325
def set_revision_history(self, rev_history):
1326
"""See Branch.set_revision_history."""
1327
rev_history = [osutils.safe_revision_id(r) for r in rev_history]
1328
self._write_revision_history(rev_history)
1329
transaction = self.get_transaction()
1330
history = transaction.map.find_revision_history()
1331
if history is not None:
1332
# update the revision history in the identity map.
1333
history[:] = list(rev_history)
1334
# this call is disabled because revision_history is
1335
# not really an object yet, and the transaction is for objects.
1336
# transaction.register_dirty(history)
1337
else:
1338
transaction.map.add_revision_history(rev_history)
1339
# this call is disabled because revision_history is
1340
# not really an object yet, and the transaction is for objects.
1341
# transaction.register_clean(history)
1342
for hook in Branch.hooks['set_rh']:
1343
hook(self, rev_history)
1344
1345
@needs_write_lock
1346
def set_last_revision_info(self, revno, revision_id):
1347
revision_id = osutils.safe_revision_id(revision_id)
1348
history = self._lefthand_history(revision_id)
1349
assert len(history) == revno, '%d != %d' % (len(history), revno)
1350
self.set_revision_history(history)
1351
1352
def _gen_revision_history(self):
1353
history = [l.rstrip('\r\n') for l in
1354
self.control_files.get('revision-history').readlines()]
1355
return history
1356
1357
@needs_read_lock
1358
def revision_history(self):
1359
"""See Branch.revision_history."""
1360
transaction = self.get_transaction()
1361
history = transaction.map.find_revision_history()
1362
if history is not None:
1363
# mutter("cache hit for revision-history in %s", self)
1364
return list(history)
1365
history = self._gen_revision_history()
1366
transaction.map.add_revision_history(history)
1367
# this call is disabled because revision_history is
1368
# not really an object yet, and the transaction is for objects.
1369
# transaction.register_clean(history, precious=True)
1370
return list(history)
1371
1372
def _lefthand_history(self, revision_id, last_rev=None,
1373
other_branch=None):
1374
# stop_revision must be a descendant of last_revision
1375
stop_graph = self.repository.get_revision_graph(revision_id)
1376
if last_rev is not None and last_rev not in stop_graph:
1377
# our previous tip is not merged into stop_revision
1378
raise errors.DivergedBranches(self, other_branch)
1379
# make a new revision history from the graph
1380
current_rev_id = revision_id
1381
new_history = []
1382
while current_rev_id not in (None, _mod_revision.NULL_REVISION):
1383
new_history.append(current_rev_id)
1384
current_rev_id_parents = stop_graph[current_rev_id]
1385
try:
1386
current_rev_id = current_rev_id_parents[0]
1387
except IndexError:
1388
current_rev_id = None
1389
new_history.reverse()
1390
return new_history
1391
1392
@needs_write_lock
1393
def generate_revision_history(self, revision_id, last_rev=None,
1394
other_branch=None):
1395
"""Create a new revision history that will finish with revision_id.
1396
1397
:param revision_id: the new tip to use.
1398
:param last_rev: The previous last_revision. If not None, then this
1399
must be a ancestory of revision_id, or DivergedBranches is raised.
1400
:param other_branch: The other branch that DivergedBranches should
1401
raise with respect to.
1402
"""
1403
revision_id = osutils.safe_revision_id(revision_id)
1404
self.set_revision_history(self._lefthand_history(revision_id,
1405
last_rev, other_branch))
1406
1407
@needs_write_lock
1408
def update_revisions(self, other, stop_revision=None):
1409
"""See Branch.update_revisions."""
1410
other.lock_read()
1411
try:
1412
if stop_revision is None:
1413
stop_revision = other.last_revision()
1414
if stop_revision is None:
1415
# if there are no commits, we're done.
1416
return
1417
else:
1418
stop_revision = osutils.safe_revision_id(stop_revision)
1419
# whats the current last revision, before we fetch [and change it
1420
# possibly]
1421
last_rev = self.last_revision()
1422
# we fetch here regardless of whether we need to so that we pickup
1423
# filled in ghosts.
1424
self.fetch(other, stop_revision)
1425
my_ancestry = self.repository.get_ancestry(last_rev)
1426
if stop_revision in my_ancestry:
1427
# last_revision is a descendant of stop_revision
1428
return
1429
self.generate_revision_history(stop_revision, last_rev=last_rev,
1430
other_branch=other)
1431
finally:
1432
other.unlock()
1433
1434
def basis_tree(self):
1435
"""See Branch.basis_tree."""
1436
return self.repository.revision_tree(self.last_revision())
1437
1438
@deprecated_method(zero_eight)
1439
def working_tree(self):
1440
"""Create a Working tree object for this branch."""
1441
1442
from bzrlib.transport.local import LocalTransport
1443
if (self.base.find('://') != -1 or
1444
not isinstance(self._transport, LocalTransport)):
1445
raise NoWorkingTree(self.base)
1446
return self.bzrdir.open_workingtree()
1447
1448
@needs_write_lock
1449
def pull(self, source, overwrite=False, stop_revision=None,
1450
_hook_master=None, _run_hooks=True):
1451
"""See Branch.pull.
1452
1453
:param _hook_master: Private parameter - set the branch to
1454
be supplied as the master to push hooks.
1455
:param _run_hooks: Private parameter - allow disabling of
1456
hooks, used when pushing to a master branch.
1457
"""
1458
result = PullResult()
1459
result.source_branch = source
1460
result.target_branch = self
1461
source.lock_read()
1462
try:
1463
result.old_revno, result.old_revid = self.last_revision_info()
1464
try:
1465
self.update_revisions(source, stop_revision)
1466
except DivergedBranches:
1467
if not overwrite:
1468
raise
1469
if overwrite:
1470
if stop_revision is None:
1471
stop_revision = source.last_revision()
1472
self.generate_revision_history(stop_revision)
1473
result.tag_conflicts = source.tags.merge_to(self.tags)
1474
result.new_revno, result.new_revid = self.last_revision_info()
1475
if _hook_master:
1476
result.master_branch = _hook_master
1477
result.local_branch = self
1478
else:
1479
result.master_branch = self
1480
result.local_branch = None
1481
if _run_hooks:
1482
for hook in Branch.hooks['post_pull']:
1483
hook(result)
1484
finally:
1485
source.unlock()
1486
return result
1487
1488
def _get_parent_location(self):
1489
_locs = ['parent', 'pull', 'x-pull']
1490
for l in _locs:
1491
try:
1492
return self.control_files.get(l).read().strip('\n')
1493
except NoSuchFile:
1494
pass
1495
return None
1496
1497
@needs_read_lock
1498
def push(self, target, overwrite=False, stop_revision=None,
1499
_hook_master=None, _run_hooks=True):
1500
"""See Branch.push.
1501
1502
:param _hook_master: Private parameter - set the branch to
1503
be supplied as the master to push hooks.
1504
:param _run_hooks: Private parameter - allow disabling of
1505
hooks, used when pushing to a master branch.
1506
"""
1507
result = PushResult()
1508
result.source_branch = self
1509
result.target_branch = target
1510
target.lock_write()
1511
try:
1512
result.old_revno, result.old_revid = target.last_revision_info()
1513
try:
1514
target.update_revisions(self, stop_revision)
1515
except DivergedBranches:
1516
if not overwrite:
1517
raise
1518
if overwrite:
1519
target.set_revision_history(self.revision_history())
1520
result.tag_conflicts = self.tags.merge_to(target.tags)
1521
result.new_revno, result.new_revid = target.last_revision_info()
1522
if _hook_master:
1523
result.master_branch = _hook_master
1524
result.local_branch = target
1525
else:
1526
result.master_branch = target
1527
result.local_branch = None
1528
if _run_hooks:
1529
for hook in Branch.hooks['post_push']:
1530
hook(result)
1531
finally:
1532
target.unlock()
1533
return result
1534
1535
def get_parent(self):
1536
"""See Branch.get_parent."""
1537
1538
assert self.base[-1] == '/'
1539
parent = self._get_parent_location()
1540
if parent is None:
1541
return parent
1542
# This is an old-format absolute path to a local branch
1543
# turn it into a url
1544
if parent.startswith('/'):
1545
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1546
try:
1547
return urlutils.join(self.base[:-1], parent)
1548
except errors.InvalidURLJoin, e:
1549
raise errors.InaccessibleParent(parent, self.base)
1550
1551
def get_push_location(self):
1552
"""See Branch.get_push_location."""
1553
push_loc = self.get_config().get_user_option('push_location')
1554
return push_loc
1555
1556
def set_push_location(self, location):
1557
"""See Branch.set_push_location."""
1558
self.get_config().set_user_option(
1559
'push_location', location,
1560
store=_mod_config.STORE_LOCATION_NORECURSE)
1561
1562
@needs_write_lock
1563
def set_parent(self, url):
1564
"""See Branch.set_parent."""
1565
# TODO: Maybe delete old location files?
1566
# URLs should never be unicode, even on the local fs,
1567
# FIXUP this and get_parent in a future branch format bump:
1568
# read and rewrite the file, and have the new format code read
1569
# using .get not .get_utf8. RBC 20060125
1570
if url is not None:
1571
if isinstance(url, unicode):
1572
try:
1573
url = url.encode('ascii')
1574
except UnicodeEncodeError:
1575
raise bzrlib.errors.InvalidURL(url,
1576
"Urls must be 7-bit ascii, "
1577
"use bzrlib.urlutils.escape")
1578
url = urlutils.relative_url(self.base, url)
1579
self._set_parent_location(url)
1580
1581
def _set_parent_location(self, url):
1582
if url is None:
1583
self.control_files._transport.delete('parent')
1584
else:
1585
assert isinstance(url, str)
1586
self.control_files.put_bytes('parent', url + '\n')
1587
1588
@deprecated_function(zero_nine)
1589
def tree_config(self):
1590
"""DEPRECATED; call get_config instead.
1591
TreeConfig has become part of BranchConfig."""
1592
return TreeConfig(self)
1593
1594
1595
class BzrBranch5(BzrBranch):
1596
"""A format 5 branch. This supports new features over plan branches.
1597
1598
It has support for a master_branch which is the data for bound branches.
1599
"""
1600
1601
def __init__(self,
1602
_format,
1603
_control_files,
1604
a_bzrdir,
1605
_repository):
1606
super(BzrBranch5, self).__init__(_format=_format,
1607
_control_files=_control_files,
1608
a_bzrdir=a_bzrdir,
1609
_repository=_repository)
1610
1611
@needs_write_lock
1612
def pull(self, source, overwrite=False, stop_revision=None,
1613
_run_hooks=True):
1614
"""Extends branch.pull to be bound branch aware.
1615
1616
:param _run_hooks: Private parameter used to force hook running
1617
off during bound branch double-pushing.
1618
"""
1619
bound_location = self.get_bound_location()
1620
master_branch = None
1621
if bound_location and source.base != bound_location:
1622
# not pulling from master, so we need to update master.
1623
master_branch = self.get_master_branch()
1624
master_branch.lock_write()
1625
try:
1626
if master_branch:
1627
# pull from source into master.
1628
master_branch.pull(source, overwrite, stop_revision,
1629
_run_hooks=False)
1630
return super(BzrBranch5, self).pull(source, overwrite,
1631
stop_revision, _hook_master=master_branch,
1632
_run_hooks=_run_hooks)
1633
finally:
1634
if master_branch:
1635
master_branch.unlock()
1636
1637
@needs_read_lock
1638
def push(self, target, overwrite=False, stop_revision=None):
1639
"""Updates branch.push to be bound branch aware."""
1640
bound_location = target.get_bound_location()
1641
master_branch = None
1642
if bound_location and target.base != bound_location:
1643
# not pushing to master, so we need to update master.
1644
master_branch = target.get_master_branch()
1645
master_branch.lock_write()
1646
try:
1647
if master_branch:
1648
# push into the master from this branch.
1649
super(BzrBranch5, self).push(master_branch, overwrite,
1650
stop_revision, _run_hooks=False)
1651
# and push into the target branch from this. Note that we push from
1652
# this branch again, because its considered the highest bandwidth
1653
# repository.
1654
return super(BzrBranch5, self).push(target, overwrite,
1655
stop_revision, _hook_master=master_branch)
1656
finally:
1657
if master_branch:
1658
master_branch.unlock()
1659
1660
def get_bound_location(self):
1661
try:
1662
return self.control_files.get_utf8('bound').read()[:-1]
1663
except errors.NoSuchFile:
1664
return None
1665
1666
@needs_read_lock
1667
def get_master_branch(self):
1668
"""Return the branch we are bound to.
1669
1670
:return: Either a Branch, or None
1671
1672
This could memoise the branch, but if thats done
1673
it must be revalidated on each new lock.
1674
So for now we just don't memoise it.
1675
# RBC 20060304 review this decision.
1676
"""
1677
bound_loc = self.get_bound_location()
1678
if not bound_loc:
1679
return None
1680
try:
1681
return Branch.open(bound_loc)
1682
except (errors.NotBranchError, errors.ConnectionError), e:
1683
raise errors.BoundBranchConnectionFailure(
1684
self, bound_loc, e)
1685
1686
@needs_write_lock
1687
def set_bound_location(self, location):
1688
"""Set the target where this branch is bound to.
1689
1690
:param location: URL to the target branch
1691
"""
1692
if location:
1693
self.control_files.put_utf8('bound', location+'\n')
1694
else:
1695
try:
1696
self.control_files._transport.delete('bound')
1697
except NoSuchFile:
1698
return False
1020
1699
return True
1021
if filename == head:
1022
break
1023
filename = head
1024
return False
1025
1026
1027
1028
def _gen_revision_id(when):
1029
"""Return new revision-id."""
1030
s = '%s-%s-' % (user_email(), compact_date(when))
1031
s += hexlify(rand_bytes(8))
1032
return s
1033
1034
1035
def gen_file_id(name):
1036
"""Return new file id.
1037
1038
This should probably generate proper UUIDs, but for the moment we
1039
cope with just randomness because running uuidgen every time is
1040
slow."""
1041
idx = name.rfind('/')
1042
if idx != -1:
1043
name = name[idx+1 : ]
1044
idx = name.rfind('\\')
1045
if idx != -1:
1046
name = name[idx+1 : ]
1047
1048
name = name.lstrip('.')
1049
1050
s = hexlify(rand_bytes(8))
1051
return '-'.join((name, compact_date(time.time()), s))
1700
1701
@needs_write_lock
1702
def bind(self, other):
1703
"""Bind this branch to the branch other.
1704
1705
This does not push or pull data between the branches, though it does
1706
check for divergence to raise an error when the branches are not
1707
either the same, or one a prefix of the other. That behaviour may not
1708
be useful, so that check may be removed in future.
1709
1710
:param other: The branch to bind to
1711
:type other: Branch
1712
"""
1713
# TODO: jam 20051230 Consider checking if the target is bound
1714
# It is debatable whether you should be able to bind to
1715
# a branch which is itself bound.
1716
# Committing is obviously forbidden,
1717
# but binding itself may not be.
1718
# Since we *have* to check at commit time, we don't
1719
# *need* to check here
1720
1721
# we want to raise diverged if:
1722
# last_rev is not in the other_last_rev history, AND
1723
# other_last_rev is not in our history, and do it without pulling
1724
# history around
1725
last_rev = self.last_revision()
1726
if last_rev is not None:
1727
other.lock_read()
1728
try:
1729
other_last_rev = other.last_revision()
1730
if other_last_rev is not None:
1731
# neither branch is new, we have to do some work to
1732
# ascertain diversion.
1733
remote_graph = other.repository.get_revision_graph(
1734
other_last_rev)
1735
local_graph = self.repository.get_revision_graph(last_rev)
1736
if (last_rev not in remote_graph and
1737
other_last_rev not in local_graph):
1738
raise errors.DivergedBranches(self, other)
1739
finally:
1740
other.unlock()
1741
self.set_bound_location(other.base)
1742
1743
@needs_write_lock
1744
def unbind(self):
1745
"""If bound, unbind"""
1746
return self.set_bound_location(None)
1747
1748
@needs_write_lock
1749
def update(self):
1750
"""Synchronise this branch with the master branch if any.
1751
1752
:return: None or the last_revision that was pivoted out during the
1753
update.
1754
"""
1755
master = self.get_master_branch()
1756
if master is not None:
1757
old_tip = self.last_revision()
1758
self.pull(master, overwrite=True)
1759
if old_tip in self.repository.get_ancestry(self.last_revision()):
1760
return None
1761
return old_tip
1762
return None
1763
1764
1765
class BzrBranchExperimental(BzrBranch5):
1766
"""Bzr experimental branch format
1767
1768
This format has:
1769
- a revision-history file.
1770
- a format string
1771
- a lock dir guarding the branch itself
1772
- all of this stored in a branch/ subdirectory
1773
- works with shared repositories.
1774
- a tag dictionary in the branch
1775
1776
This format is new in bzr 0.15, but shouldn't be used for real data,
1777
only for testing.
1778
1779
This class acts as it's own BranchFormat.
1780
"""
1781
1782
_matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1783
1784
@classmethod
1785
def get_format_string(cls):
1786
"""See BranchFormat.get_format_string()."""
1787
return "Bazaar-NG branch format experimental\n"
1788
1789
@classmethod
1790
def get_format_description(cls):
1791
"""See BranchFormat.get_format_description()."""
1792
return "Experimental branch format"
1793
1794
@classmethod
1795
def _initialize_control_files(cls, a_bzrdir, utf8_files, lock_filename,
1796
lock_class):
1797
branch_transport = a_bzrdir.get_branch_transport(cls)
1798
control_files = lockable_files.LockableFiles(branch_transport,
1799
lock_filename, lock_class)
1800
control_files.create_lock()
1801
control_files.lock_write()
1802
try:
1803
for filename, content in utf8_files:
1804
control_files.put_utf8(filename, content)
1805
finally:
1806
control_files.unlock()
1807
1808
@classmethod
1809
def initialize(cls, a_bzrdir):
1810
"""Create a branch of this format in a_bzrdir."""
1811
utf8_files = [('format', cls.get_format_string()),
1812
('revision-history', ''),
1813
('branch-name', ''),
1814
('tags', ''),
1815
]
1816
cls._initialize_control_files(a_bzrdir, utf8_files,
1817
'lock', lockdir.LockDir)
1818
return cls.open(a_bzrdir, _found=True)
1819
1820
@classmethod
1821
def open(cls, a_bzrdir, _found=False):
1822
"""Return the branch object for a_bzrdir
1823
1824
_found is a private parameter, do not use it. It is used to indicate
1825
if format probing has already be done.
1826
"""
1827
if not _found:
1828
format = BranchFormat.find_format(a_bzrdir)
1829
assert format.__class__ == cls
1830
transport = a_bzrdir.get_branch_transport(None)
1831
control_files = lockable_files.LockableFiles(transport, 'lock',
1832
lockdir.LockDir)
1833
return cls(_format=cls,
1834
_control_files=control_files,
1835
a_bzrdir=a_bzrdir,
1836
_repository=a_bzrdir.find_repository())
1837
1838
@classmethod
1839
def is_supported(cls):
1840
return True
1841
1842
def _make_tags(self):
1843
return BasicTags(self)
1844
1845
@classmethod
1846
def supports_tags(cls):
1847
return True
1848
1849
1850
BranchFormat.register_format(BzrBranchExperimental)
1851
1852
1853
class BzrBranch6(BzrBranch5):
1854
1855
@needs_read_lock
1856
def last_revision_info(self):
1857
revision_string = self.control_files.get('last-revision').read()
1858
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
1859
revision_id = cache_utf8.get_cached_utf8(revision_id)
1860
revno = int(revno)
1861
return revno, revision_id
1862
1863
def last_revision(self):
1864
"""Return last revision id, or None"""
1865
revision_id = self.last_revision_info()[1]
1866
if revision_id == _mod_revision.NULL_REVISION:
1867
revision_id = None
1868
return revision_id
1869
1870
def _write_last_revision_info(self, revno, revision_id):
1871
"""Simply write out the revision id, with no checks.
1872
1873
Use set_last_revision_info to perform this safely.
1874
1875
Does not update the revision_history cache.
1876
Intended to be called by set_last_revision_info and
1877
_write_revision_history.
1878
"""
1879
if revision_id is None:
1880
revision_id = 'null:'
1881
out_string = '%d %s\n' % (revno, revision_id)
1882
self.control_files.put_bytes('last-revision', out_string)
1883
1884
@needs_write_lock
1885
def set_last_revision_info(self, revno, revision_id):
1886
revision_id = osutils.safe_revision_id(revision_id)
1887
if self._get_append_revisions_only():
1888
self._check_history_violation(revision_id)
1889
self._write_last_revision_info(revno, revision_id)
1890
transaction = self.get_transaction()
1891
cached_history = transaction.map.find_revision_history()
1892
if cached_history is not None:
1893
transaction.map.remove_object(cached_history)
1894
1895
def _check_history_violation(self, revision_id):
1896
last_revision = self.last_revision()
1897
if last_revision is None:
1898
return
1899
if last_revision not in self._lefthand_history(revision_id):
1900
raise errors.AppendRevisionsOnlyViolation(self.base)
1901
1902
def _gen_revision_history(self):
1903
"""Generate the revision history from last revision
1904
"""
1905
history = list(self.repository.iter_reverse_revision_history(
1906
self.last_revision()))
1907
history.reverse()
1908
return history
1909
1910
def _write_revision_history(self, history):
1911
"""Factored out of set_revision_history.
1912
1913
This performs the actual writing to disk, with format-specific checks.
1914
It is intended to be called by BzrBranch5.set_revision_history.
1915
"""
1916
if len(history) == 0:
1917
last_revision = 'null:'
1918
else:
1919
if history != self._lefthand_history(history[-1]):
1920
raise errors.NotLefthandHistory(history)
1921
last_revision = history[-1]
1922
if self._get_append_revisions_only():
1923
self._check_history_violation(last_revision)
1924
self._write_last_revision_info(len(history), last_revision)
1925
1926
@needs_write_lock
1927
def append_revision(self, *revision_ids):
1928
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1929
if len(revision_ids) == 0:
1930
return
1931
prev_revno, prev_revision = self.last_revision_info()
1932
for revision in self.repository.get_revisions(revision_ids):
1933
if prev_revision == _mod_revision.NULL_REVISION:
1934
if revision.parent_ids != []:
1935
raise errors.NotLeftParentDescendant(self, prev_revision,
1936
revision.revision_id)
1937
else:
1938
if revision.parent_ids[0] != prev_revision:
1939
raise errors.NotLeftParentDescendant(self, prev_revision,
1940
revision.revision_id)
1941
prev_revision = revision.revision_id
1942
self.set_last_revision_info(prev_revno + len(revision_ids),
1943
revision_ids[-1])
1944
1945
def _set_config_location(self, name, url, config=None,
1946
make_relative=False):
1947
if config is None:
1948
config = self.get_config()
1949
if url is None:
1950
url = ''
1951
elif make_relative:
1952
url = urlutils.relative_url(self.base, url)
1953
config.set_user_option(name, url)
1954
1955
1956
def _get_config_location(self, name, config=None):
1957
if config is None:
1958
config = self.get_config()
1959
location = config.get_user_option(name)
1960
if location == '':
1961
location = None
1962
return location
1963
1964
@needs_write_lock
1965
def _set_parent_location(self, url):
1966
"""Set the parent branch"""
1967
self._set_config_location('parent_location', url, make_relative=True)
1968
1969
@needs_read_lock
1970
def _get_parent_location(self):
1971
"""Set the parent branch"""
1972
return self._get_config_location('parent_location')
1973
1974
def set_push_location(self, location):
1975
"""See Branch.set_push_location."""
1976
self._set_config_location('push_location', location)
1977
1978
def set_bound_location(self, location):
1979
"""See Branch.set_push_location."""
1980
result = None
1981
config = self.get_config()
1982
if location is None:
1983
if config.get_user_option('bound') != 'True':
1984
return False
1985
else:
1986
config.set_user_option('bound', 'False')
1987
return True
1988
else:
1989
self._set_config_location('bound_location', location,
1990
config=config)
1991
config.set_user_option('bound', 'True')
1992
return True
1993
1994
def _get_bound_location(self, bound):
1995
"""Return the bound location in the config file.
1996
1997
Return None if the bound parameter does not match"""
1998
config = self.get_config()
1999
config_bound = (config.get_user_option('bound') == 'True')
2000
if config_bound != bound:
2001
return None
2002
return self._get_config_location('bound_location', config=config)
2003
2004
def get_bound_location(self):
2005
"""See Branch.set_push_location."""
2006
return self._get_bound_location(True)
2007
2008
def get_old_bound_location(self):
2009
"""See Branch.get_old_bound_location"""
2010
return self._get_bound_location(False)
2011
2012
def set_append_revisions_only(self, enabled):
2013
if enabled:
2014
value = 'True'
2015
else:
2016
value = 'False'
2017
self.get_config().set_user_option('append_revisions_only', value)
2018
2019
def _get_append_revisions_only(self):
2020
value = self.get_config().get_user_option('append_revisions_only')
2021
return value == 'True'
2022
2023
def _synchronize_history(self, destination, revision_id):
2024
"""Synchronize last revision and revision history between branches.
2025
2026
This version is most efficient when the destination is also a
2027
BzrBranch6, but works for BzrBranch5, as long as the destination's
2028
repository contains all the lefthand ancestors of the intended
2029
last_revision. If not, set_last_revision_info will fail.
2030
2031
:param destination: The branch to copy the history into
2032
:param revision_id: The revision-id to truncate history at. May
2033
be None to copy complete history.
2034
"""
2035
if revision_id is None:
2036
revno, revision_id = self.last_revision_info()
2037
else:
2038
revno = self.revision_id_to_revno(revision_id)
2039
destination.set_last_revision_info(revno, revision_id)
2040
2041
def _make_tags(self):
2042
return BasicTags(self)
2043
2044
2045
class BranchTestProviderAdapter(object):
2046
"""A tool to generate a suite testing multiple branch formats at once.
2047
2048
This is done by copying the test once for each transport and injecting
2049
the transport_server, transport_readonly_server, and branch_format
2050
classes into each copy. Each copy is also given a new id() to make it
2051
easy to identify.
2052
"""
2053
2054
def __init__(self, transport_server, transport_readonly_server, formats):
2055
self._transport_server = transport_server
2056
self._transport_readonly_server = transport_readonly_server
2057
self._formats = formats
2058
2059
def adapt(self, test):
2060
result = TestSuite()
2061
for branch_format, bzrdir_format in self._formats:
2062
new_test = deepcopy(test)
2063
new_test.transport_server = self._transport_server
2064
new_test.transport_readonly_server = self._transport_readonly_server
2065
new_test.bzrdir_format = bzrdir_format
2066
new_test.branch_format = branch_format
2067
def make_new_test_id():
2068
# the format can be either a class or an instance
2069
name = getattr(branch_format, '__name__',
2070
branch_format.__class__.__name__)
2071
new_id = "%s(%s)" % (new_test.id(), name)
2072
return lambda: new_id
2073
new_test.id = make_new_test_id()
2074
result.addTest(new_test)
2075
return result
2076
2077
2078
######################################################################
2079
# results of operations
2080
2081
2082
class _Result(object):
2083
2084
def _show_tag_conficts(self, to_file):
2085
if not getattr(self, 'tag_conflicts', None):
2086
return
2087
to_file.write('Conflicting tags:\n')
2088
for name, value1, value2 in self.tag_conflicts:
2089
to_file.write(' %s\n' % (name, ))
2090
2091
2092
class PullResult(_Result):
2093
"""Result of a Branch.pull operation.
2094
2095
:ivar old_revno: Revision number before pull.
2096
:ivar new_revno: Revision number after pull.
2097
:ivar old_revid: Tip revision id before pull.
2098
:ivar new_revid: Tip revision id after pull.
2099
:ivar source_branch: Source (local) branch object.
2100
:ivar master_branch: Master branch of the target, or None.
2101
:ivar target_branch: Target/destination branch object.
2102
"""
2103
2104
def __int__(self):
2105
# DEPRECATED: pull used to return the change in revno
2106
return self.new_revno - self.old_revno
2107
2108
def report(self, to_file):
2109
if self.old_revid == self.new_revid:
2110
to_file.write('No revisions to pull.\n')
2111
else:
2112
to_file.write('Now on revision %d.\n' % self.new_revno)
2113
self._show_tag_conficts(to_file)
2114
2115
2116
class PushResult(_Result):
2117
"""Result of a Branch.push operation.
2118
2119
:ivar old_revno: Revision number before push.
2120
:ivar new_revno: Revision number after push.
2121
:ivar old_revid: Tip revision id before push.
2122
:ivar new_revid: Tip revision id after push.
2123
:ivar source_branch: Source branch object.
2124
:ivar master_branch: Master branch of the target, or None.
2125
:ivar target_branch: Target/destination branch object.
2126
"""
2127
2128
def __int__(self):
2129
# DEPRECATED: push used to return the change in revno
2130
return self.new_revno - self.old_revno
2131
2132
def report(self, to_file):
2133
"""Write a human-readable description of the result."""
2134
if self.old_revid == self.new_revid:
2135
to_file.write('No new revisions to push.\n')
2136
else:
2137
to_file.write('Pushed up to revision %d.\n' % self.new_revno)
2138
self._show_tag_conficts(to_file)
2139
2140
2141
class BranchCheckResult(object):
2142
"""Results of checking branch consistency.
2143
2144
:see: Branch.check
2145
"""
2146
2147
def __init__(self, branch):
2148
self.branch = branch
2149
2150
def report_results(self, verbose):
2151
"""Report the check results via trace.note.
2152
2153
:param verbose: Requests more detailed display of what was checked,
2154
if any.
2155
"""
2156
note('checked branch %s format %s',
2157
self.branch.base,
2158
self.branch._format)
2159
2160
2161
class Converter5to6(object):
2162
"""Perform an in-place upgrade of format 5 to format 6"""
2163
2164
def convert(self, branch):
2165
# Data for 5 and 6 can peacefully coexist.
2166
format = BzrBranchFormat6()
2167
new_branch = format.open(branch.bzrdir, _found=True)
2168
2169
# Copy source data into target
2170
new_branch.set_last_revision_info(*branch.last_revision_info())
2171
new_branch.set_parent(branch.get_parent())
2172
new_branch.set_bound_location(branch.get_bound_location())
2173
new_branch.set_push_location(branch.get_push_location())
2174
2175
# New branch has no tags by default
2176
new_branch.tags._set_tag_dict({})
2177
2178
# Copying done; now update target format
2179
new_branch.control_files.put_utf8('format',
2180
format.get_format_string())
2181
2182
# Clean up old files
2183
new_branch.control_files._transport.delete('revision-history')
2184
try:
2185
branch.set_parent(None)
2186
except NoSuchFile:
2187
pass
2188
branch.set_bound_location(None)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1