« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1185.49.21
- compare with another revision
- download diff
- download tarball
- view history from revision 1185.49.21
- Committer: John Arbash Meinel
- Date: 2005-11-30 15:43:57 UTC
- mto: (1185.50.1 jam-integration)
- mto: This revision was merged to the branch mainline in revision 1518.
- Revision ID: john@arbash-meinel.com-20051130154357-614206b3a7b83cd0
Refactored bzrlib/ui.py into a module with the possibility for multiple ui forms.
- files added:
- bzrlib/clone.py
- notes
- patches
- files removed:
- BRANCH.TODO
- bzrlib/benchmarks
- bzrlib/bundle
- bzrlib/bundle/old
- bzrlib/bundle/serializer
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/plugins/launchpad
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/test_patches_data
- bzrlib/tests/workingtree_implementations
- bzrlib/transport/http
- tools/doc_generate
- files renamed:
- tools/doc_generate/autodoc_man.py => bzr_man.py
- bzrlib/bundle/__init__.py => bzrlib/changeset.py
- bzrlib/store/versioned/__init__.py => bzrlib/store/weave.py
- bzrlib/tests/blackbox/test_annotate.py => bzrlib/tests/test_annotate.py
- bzrlib/tests/branch_implementations/test_branch.py => bzrlib/tests/test_branch.py
- bzrlib/tests/branch_implementations/test_parent.py => bzrlib/tests/test_parent.py
- bzrlib/tests/blackbox/test_revision_info.py => bzrlib/tests/test_revision_info.py
- bzrlib/tests/test_sftp_transport.py => bzrlib/tests/test_sftp.py
- bzrlib/tests/blackbox/test_status.py => bzrlib/tests/test_status.py
- bzrlib/tests/blackbox/test_uncommit.py => bzrlib/tests/test_uncommit.py
- bzrlib/transport/http/__init__.py => bzrlib/transport/http.py
- bzrlib/xml_serializer.py => bzrlib/xml.py
- doc/tutorial.txt => tutorial.txt
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
#
1
# Copyright (C) 2005 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 copy import deepcopy
18
import shutil
19
import sys
20
import os
21
import errno
22
from warnings import warn
19
23
from cStringIO import StringIO
20
from unittest import TestSuite
21
from warnings import warn
24
22
25
23
26
import bzrlib
24
from bzrlib import bzrdir, errors, lockdir, osutils, revision, \
25
tree, \
26
ui, \
27
urlutils
28
from bzrlib.config import TreeConfig
29
from bzrlib.decorators import needs_read_lock, needs_write_lock
27
import bzrlib.inventory as inventory
28
from bzrlib.trace import mutter, note
29
from bzrlib.osutils import (isdir, quotefn,
30
rename, splitpath, sha_file, appendpath,
31
file_kind, abspath)
30
32
import bzrlib.errors as errors
31
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
32
HistoryMissing, InvalidRevisionId,
33
InvalidRevisionNumber, LockError, NoSuchFile,
34
NoSuchRevision, NoWorkingTree, NotVersionedError,
35
NotBranchError, UninitializableFormat,
36
UnlistableStore, UnlistableBranch,
37
)
38
from bzrlib.lockable_files import LockableFiles, TransportLock
39
from bzrlib.symbol_versioning import (deprecated_function,
40
deprecated_method,
41
DEPRECATED_PARAMETER,
42
deprecated_passed,
43
zero_eight, zero_nine,
44
)
45
from bzrlib.trace import mutter, note
33
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
34
NoSuchRevision, HistoryMissing, NotBranchError,
35
DivergedBranches, LockError, UnlistableStore,
36
UnlistableBranch, NoSuchFile, NotVersionedError,
37
NoWorkingTree)
38
from bzrlib.textui import show_status
39
from bzrlib.revision import (Revision, is_ancestor, get_intervening_revisions,
40
NULL_REVISION)
41
42
from bzrlib.delta import compare_trees
43
from bzrlib.tree import EmptyTree, RevisionTree
44
from bzrlib.inventory import Inventory
45
from bzrlib.store import copy_all
46
from bzrlib.store.text import TextStore
47
from bzrlib.store.weave import WeaveStore
48
from bzrlib.testament import Testament
49
import bzrlib.transactions as transactions
50
from bzrlib.transport import Transport, get_transport
51
import bzrlib.xml5
52
import bzrlib.ui
53
from config import TreeConfig
46
54
47
55
48
56
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
49
57
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
50
58
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
51
52
53
# TODO: Maybe include checks for common corruption of newlines, etc?
59
## TODO: Maybe include checks for common corruption of newlines, etc?
60
54
61
55
62
# TODO: Some operations like log might retrieve the same revisions
56
63
# repeatedly to calculate deltas. We could perhaps have a weakref
57
64
# cache in memory to make this faster. In general anything can be
58
# cached in memory between lock and unlock operations. .. nb thats
59
# what the transaction identity map provides
60
65
# cached in memory between lock and unlock operations.
66
67
def find_branch(*ignored, **ignored_too):
68
# XXX: leave this here for about one release, then remove it
69
raise NotImplementedError('find_branch() is not supported anymore, '
70
'please use one of the new branch constructors')
71
72
73
def needs_read_lock(unbound):
74
"""Decorate unbound to take out and release a read lock."""
75
def decorated(self, *args, **kwargs):
76
self.lock_read()
77
try:
78
return unbound(self, *args, **kwargs)
79
finally:
80
self.unlock()
81
return decorated
82
83
84
def needs_write_lock(unbound):
85
"""Decorate unbound to take out and release a write lock."""
86
def decorated(self, *args, **kwargs):
87
self.lock_write()
88
try:
89
return unbound(self, *args, **kwargs)
90
finally:
91
self.unlock()
92
return decorated
61
93
62
94
######################################################################
63
95
# branch objects
68
100
base
69
101
Base directory/url of the branch.
70
102
"""
71
# this is really an instance variable - FIXME move it there
72
# - RBC 20060112
73
103
base = None
74
104
75
105
def __init__(self, *ignored, **ignored_too):
76
106
raise NotImplementedError('The Branch class is abstract')
77
107
78
def break_lock(self):
79
"""Break a lock if one is present from another instance.
80
81
Uses the ui factory to ask for confirmation if the lock may be from
82
an active process.
83
84
This will probe the repository for its lock as well.
85
"""
86
self.control_files.break_lock()
87
self.repository.break_lock()
88
master = self.get_master_branch()
89
if master is not None:
90
master.break_lock()
91
92
108
@staticmethod
93
@deprecated_method(zero_eight)
94
109
def open_downlevel(base):
95
"""Open a branch which may be of an old format."""
96
return Branch.open(base, _unsupported=True)
110
"""Open a branch which may be of an old format.
111
112
Only local branches are supported."""
113
return BzrBranch(get_transport(base), relax_version_check=True)
97
114
98
115
@staticmethod
99
def open(base, _unsupported=False):
100
"""Open the branch rooted at base.
101
102
For instance, if the branch is at URL/.bzr/branch,
103
Branch.open(URL) -> a Branch instance.
104
"""
105
control = bzrdir.BzrDir.open(base, _unsupported)
106
return control.open_branch(_unsupported)
116
def open(base):
117
"""Open an existing branch, rooted at 'base' (url)"""
118
t = get_transport(base)
119
mutter("trying to open %r with transport %r", base, t)
120
return BzrBranch(t)
107
121
108
122
@staticmethod
109
123
def open_containing(url):
113
127
114
128
Basically we keep looking up until we find the control directory or
115
129
run into the root. If there isn't one, raises NotBranchError.
116
If there is one and it is either an unrecognised format or an unsupported
117
format, UnknownFormatError or UnsupportedFormatError are raised.
118
130
If there is one, it is returned, along with the unused portion of url.
119
131
"""
120
control, relpath = bzrdir.BzrDir.open_containing(url)
121
return control.open_branch(), relpath
132
t = get_transport(url)
133
while True:
134
try:
135
return BzrBranch(t), t.relpath(url)
136
except NotBranchError:
137
pass
138
new_t = t.clone('..')
139
if new_t.base == t.base:
140
# reached the root, whatever that may be
141
raise NotBranchError(path=url)
142
t = new_t
122
143
123
144
@staticmethod
124
@deprecated_function(zero_eight)
125
145
def initialize(base):
126
"""Create a new working tree and branch, rooted at 'base' (url)
127
128
NOTE: This will soon be deprecated in favour of creation
129
through a BzrDir.
130
"""
131
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
146
"""Create a new branch, rooted at 'base' (url)"""
147
t = get_transport(base)
148
return BzrBranch(t, init=True)
132
149
133
150
def setup_caching(self, cache_root):
134
151
"""Subclasses that care about caching should override this, and set
135
152
up cached stores located under cache_root.
136
153
"""
137
# seems to be unused, 2006-01-13 mbp
138
warn('%s is deprecated' % self.setup_caching)
139
154
self.cache_root = cache_root
140
155
141
def get_config(self):
142
return bzrlib.config.BranchConfig(self)
143
144
156
def _get_nick(self):
145
return self.get_config().get_nickname()
157
cfg = self.tree_config()
158
return cfg.get_option(u"nickname", default=self.base.split('/')[-1])
146
159
147
160
def _set_nick(self, nick):
148
self.get_config().set_user_option('nickname', nick)
161
cfg = self.tree_config()
162
cfg.set_option(nick, "nickname")
163
assert cfg.get_option("nickname") == nick
149
164
150
165
nick = property(_get_nick, _set_nick)
151
152
def is_locked(self):
153
raise NotImplementedError('is_locked is abstract')
166
167
def push_stores(self, branch_to):
168
"""Copy the content of this branches store to branch_to."""
169
raise NotImplementedError('push_stores is abstract')
170
171
def get_transaction(self):
172
"""Return the current active transaction.
173
174
If no transaction is active, this returns a passthrough object
175
for which all data is immediately flushed and no caching happens.
176
"""
177
raise NotImplementedError('get_transaction is abstract')
154
178
155
179
def lock_write(self):
156
180
raise NotImplementedError('lock_write is abstract')
157
181
158
182
def lock_read(self):
159
183
raise NotImplementedError('lock_read is abstract')
160
184
161
185
def unlock(self):
162
186
raise NotImplementedError('unlock is abstract')
163
187
164
def peek_lock_mode(self):
165
"""Return lock mode for the Branch: 'r', 'w' or None"""
166
raise NotImplementedError(self.peek_lock_mode)
167
168
def get_physical_lock_status(self):
169
raise NotImplementedError('get_physical_lock_status is abstract')
170
171
188
def abspath(self, name):
172
189
"""Return absolute filename for something in the branch
173
190
176
193
"""
177
194
raise NotImplementedError('abspath is abstract')
178
195
179
def bind(self, other):
180
"""Bind the local branch the other branch.
181
182
:param other: The branch to bind to
183
:type other: Branch
184
"""
185
raise errors.UpgradeRequired(self.base)
186
187
@needs_write_lock
188
def fetch(self, from_branch, last_revision=None, pb=None):
189
"""Copy revisions from from_branch into this branch.
190
191
:param from_branch: Where to copy from.
192
:param last_revision: What revision to stop at (None for at the end
193
of the branch.
194
:param pb: An optional progress bar to use.
195
196
Returns the copied revision count and the failed revisions in a tuple:
197
(copied, failures).
198
"""
199
if self.base == from_branch.base:
200
return (0, [])
201
if pb is None:
202
nested_pb = ui.ui_factory.nested_progress_bar()
203
pb = nested_pb
204
else:
205
nested_pb = None
206
207
from_branch.lock_read()
208
try:
209
if last_revision is None:
210
pb.update('get source history')
211
from_history = from_branch.revision_history()
212
if from_history:
213
last_revision = from_history[-1]
214
else:
215
# no history in the source branch
216
last_revision = revision.NULL_REVISION
217
return self.repository.fetch(from_branch.repository,
218
revision_id=last_revision,
219
pb=nested_pb)
220
finally:
221
if nested_pb is not None:
222
nested_pb.finished()
223
from_branch.unlock()
224
225
def get_bound_location(self):
226
"""Return the URL of the branch we are bound to.
227
228
Older format branches cannot bind, please be sure to use a metadir
229
branch.
230
"""
231
return None
232
233
def get_commit_builder(self, parents, config=None, timestamp=None,
234
timezone=None, committer=None, revprops=None,
235
revision_id=None):
236
"""Obtain a CommitBuilder for this branch.
237
238
:param parents: Revision ids of the parents of the new revision.
239
:param config: Optional configuration to use.
240
:param timestamp: Optional timestamp recorded for commit.
241
:param timezone: Optional timezone for timestamp.
242
:param committer: Optional committer to set for commit.
243
:param revprops: Optional dictionary of revision properties.
244
:param revision_id: Optional revision id.
245
"""
246
247
if config is None:
248
config = self.get_config()
249
250
return self.repository.get_commit_builder(self, parents, config,
251
timestamp, timezone, committer, revprops, revision_id)
252
253
def get_master_branch(self):
254
"""Return the branch we are bound to.
255
256
:return: Either a Branch, or None
257
"""
258
return None
196
def controlfilename(self, file_or_path):
197
"""Return location relative to branch."""
198
raise NotImplementedError('controlfilename is abstract')
199
200
def controlfile(self, file_or_path, mode='r'):
201
"""Open a control file for this branch.
202
203
There are two classes of file in the control directory: text
204
and binary. binary files are untranslated byte streams. Text
205
control files are stored with Unix newlines and in UTF-8, even
206
if the platform or locale defaults are different.
207
208
Controlfiles should almost never be opened in write mode but
209
rather should be atomically copied and replaced using atomicfile.
210
"""
211
raise NotImplementedError('controlfile is abstract')
212
213
def put_controlfile(self, path, f, encode=True):
214
"""Write an entry as a controlfile.
215
216
:param path: The path to put the file, relative to the .bzr control
217
directory
218
:param f: A file-like or string object whose contents should be copied.
219
:param encode: If true, encode the contents as utf-8
220
"""
221
raise NotImplementedError('put_controlfile is abstract')
222
223
def put_controlfiles(self, files, encode=True):
224
"""Write several entries as controlfiles.
225
226
:param files: A list of [(path, file)] pairs, where the path is the directory
227
underneath the bzr control directory
228
:param encode: If true, encode the contents as utf-8
229
"""
230
raise NotImplementedError('put_controlfiles is abstract')
231
232
def get_root_id(self):
233
"""Return the id of this branches root"""
234
raise NotImplementedError('get_root_id is abstract')
235
236
def set_root_id(self, file_id):
237
raise NotImplementedError('set_root_id is abstract')
238
239
def print_file(self, file, revno):
240
"""Print `file` to stdout."""
241
raise NotImplementedError('print_file is abstract')
242
243
def append_revision(self, *revision_ids):
244
raise NotImplementedError('append_revision is abstract')
245
246
def set_revision_history(self, rev_history):
247
raise NotImplementedError('set_revision_history is abstract')
248
249
def has_revision(self, revision_id):
250
"""True if this branch has a copy of the revision.
251
252
This does not necessarily imply the revision is merge
253
or on the mainline."""
254
raise NotImplementedError('has_revision is abstract')
255
256
def get_revision_xml(self, revision_id):
257
raise NotImplementedError('get_revision_xml is abstract')
258
259
def get_revision(self, revision_id):
260
"""Return the Revision object for a named revision"""
261
raise NotImplementedError('get_revision is abstract')
259
262
260
263
def get_revision_delta(self, revno):
261
264
"""Return the delta for one revision.
267
270
rh = self.revision_history()
268
271
if not (1 <= revno <= len(rh)):
269
272
raise InvalidRevisionNumber(revno)
270
return self.repository.get_revision_delta(rh[revno-1])
271
272
def get_root_id(self):
273
"""Return the id of this branches root"""
274
raise NotImplementedError('get_root_id is abstract')
275
276
def print_file(self, file, revision_id):
277
"""Print `file` to stdout."""
278
raise NotImplementedError('print_file is abstract')
279
280
def append_revision(self, *revision_ids):
281
raise NotImplementedError('append_revision is abstract')
282
283
def set_revision_history(self, rev_history):
284
raise NotImplementedError('set_revision_history is abstract')
273
274
# revno is 1-based; list is 0-based
275
276
new_tree = self.revision_tree(rh[revno-1])
277
if revno == 1:
278
old_tree = EmptyTree()
279
else:
280
old_tree = self.revision_tree(rh[revno-2])
281
282
return compare_trees(old_tree, new_tree)
283
284
def get_revision_sha1(self, revision_id):
285
"""Hash the stored value of a revision, and return it."""
286
raise NotImplementedError('get_revision_sha1 is abstract')
287
288
def get_ancestry(self, revision_id):
289
"""Return a list of revision-ids integrated by a revision.
290
291
This currently returns a list, but the ordering is not guaranteed:
292
treat it as a set.
293
"""
294
raise NotImplementedError('get_ancestry is abstract')
295
296
def get_inventory(self, revision_id):
297
"""Get Inventory object by hash."""
298
raise NotImplementedError('get_inventory is abstract')
299
300
def get_inventory_xml(self, revision_id):
301
"""Get inventory XML as a file object."""
302
raise NotImplementedError('get_inventory_xml is abstract')
303
304
def get_inventory_sha1(self, revision_id):
305
"""Return the sha1 hash of the inventory entry."""
306
raise NotImplementedError('get_inventory_sha1 is abstract')
307
308
def get_revision_inventory(self, revision_id):
309
"""Return inventory of a past revision."""
310
raise NotImplementedError('get_revision_inventory is abstract')
285
311
286
312
def revision_history(self):
287
313
"""Return sequence of revision hashes on to this branch."""
295
321
"""
296
322
return len(self.revision_history())
297
323
298
def unbind(self):
299
"""Older format branches cannot bind or unbind."""
300
raise errors.UpgradeRequired(self.base)
301
302
324
def last_revision(self):
303
325
"""Return last patch hash, or None if no history."""
304
326
ph = self.revision_history()
307
329
else:
308
330
return None
309
331
310
def missing_revisions(self, other, stop_revision=None):
332
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
311
333
"""Return a list of new revisions that would perfectly fit.
312
334
313
335
If self and other have not diverged, return a list of the revisions
314
336
present in other, but missing from self.
337
338
>>> from bzrlib.commit import commit
339
>>> bzrlib.trace.silent = True
340
>>> br1 = ScratchBranch()
341
>>> br2 = ScratchBranch()
342
>>> br1.missing_revisions(br2)
343
[]
344
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
345
>>> br1.missing_revisions(br2)
346
[u'REVISION-ID-1']
347
>>> br2.missing_revisions(br1)
348
[]
349
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
350
>>> br1.missing_revisions(br2)
351
[]
352
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
353
>>> br1.missing_revisions(br2)
354
[u'REVISION-ID-2A']
355
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
356
>>> br1.missing_revisions(br2)
357
Traceback (most recent call last):
358
DivergedBranches: These branches have diverged.
315
359
"""
316
360
self_history = self.revision_history()
317
361
self_len = len(self_history)
327
371
else:
328
372
assert isinstance(stop_revision, int)
329
373
if stop_revision > other_len:
330
raise errors.NoSuchRevision(self, stop_revision)
374
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
331
375
return other_history[self_len:stop_revision]
332
376
333
377
def update_revisions(self, other, stop_revision=None):
334
"""Pull in new perfect-fit revisions.
335
336
:param other: Another Branch to pull from
337
:param stop_revision: Updated until the given revision
338
:return: None
339
"""
378
"""Pull in new perfect-fit revisions."""
340
379
raise NotImplementedError('update_revisions is abstract')
341
380
381
def pullable_revisions(self, other, stop_revision):
382
raise NotImplementedError('pullable_revisions is abstract')
383
342
384
def revision_id_to_revno(self, revision_id):
343
385
"""Given a revision id, return its revno"""
344
386
if revision_id is None:
359
401
raise bzrlib.errors.NoSuchRevision(self, revno)
360
402
return history[revno - 1]
361
403
362
def pull(self, source, overwrite=False, stop_revision=None):
404
def revision_tree(self, revision_id):
405
"""Return Tree for a revision on this branch.
406
407
`revision_id` may be None for the null revision, in which case
408
an `EmptyTree` is returned."""
409
raise NotImplementedError('revision_tree is abstract')
410
411
def working_tree(self):
412
"""Return a `Tree` for the working copy if this is a local branch."""
413
raise NotImplementedError('working_tree is abstract')
414
415
def pull(self, source, overwrite=False):
363
416
raise NotImplementedError('pull is abstract')
364
417
365
418
def basis_tree(self):
367
420
368
421
If there are no revisions yet, return an `EmptyTree`.
369
422
"""
370
return self.repository.revision_tree(self.last_revision())
423
return self.revision_tree(self.last_revision())
371
424
372
425
def rename_one(self, from_rel, to_rel):
373
426
"""Rename one file.
401
454
"""
402
455
raise NotImplementedError('get_parent is abstract')
403
456
404
def get_submit_branch(self):
405
"""Return the submit location of the branch.
406
407
This is the default location for bundle. The usual
408
pattern is that the user can override it by specifying a
409
location.
410
"""
411
return self.get_config().get_user_option('submit_branch')
412
413
def set_submit_branch(self, location):
414
"""Return the submit location of the branch.
415
416
This is the default location for bundle. The usual
417
pattern is that the user can override it by specifying a
418
location.
419
"""
420
self.get_config().set_user_option('submit_branch', location)
421
422
457
def get_push_location(self):
423
458
"""Return the None or the location to push this branch to."""
424
459
raise NotImplementedError('get_push_location is abstract')
430
465
def set_parent(self, url):
431
466
raise NotImplementedError('set_parent is abstract')
432
467
433
@needs_write_lock
434
def update(self):
435
"""Synchronise this branch with the master branch if any.
436
437
:return: None or the last_revision pivoted out during the update.
438
"""
439
return None
440
441
468
def check_revno(self, revno):
442
469
"""\
443
470
Check whether a revno corresponds to any revision.
453
480
"""
454
481
if revno < 1 or revno > self.revno():
455
482
raise InvalidRevisionNumber(revno)
456
457
@needs_read_lock
458
def clone(self, *args, **kwargs):
459
"""Clone this branch into to_bzrdir preserving all semantic values.
460
461
revision_id: if not None, the revision history in the new branch will
462
be truncated to end with revision_id.
463
"""
464
# for API compatibility, until 0.8 releases we provide the old api:
465
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
466
# after 0.8 releases, the *args and **kwargs should be changed:
467
# def clone(self, to_bzrdir, revision_id=None):
468
if (kwargs.get('to_location', None) or
469
kwargs.get('revision', None) or
470
kwargs.get('basis_branch', None) or
471
(len(args) and isinstance(args[0], basestring))):
472
# backwards compatibility api:
473
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
474
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
475
# get basis_branch
476
if len(args) > 2:
477
basis_branch = args[2]
478
else:
479
basis_branch = kwargs.get('basis_branch', None)
480
if basis_branch:
481
basis = basis_branch.bzrdir
482
else:
483
basis = None
484
# get revision
485
if len(args) > 1:
486
revision_id = args[1]
487
else:
488
revision_id = kwargs.get('revision', None)
489
# get location
490
if len(args):
491
url = args[0]
492
else:
493
# no default to raise if not provided.
494
url = kwargs.get('to_location')
495
return self.bzrdir.clone(url,
496
revision_id=revision_id,
497
basis=basis).open_branch()
498
# new cleaner api.
499
# generate args by hand
500
if len(args) > 1:
501
revision_id = args[1]
502
else:
503
revision_id = kwargs.get('revision_id', None)
504
if len(args):
505
to_bzrdir = args[0]
506
else:
507
# no default to raise if not provided.
508
to_bzrdir = kwargs.get('to_bzrdir')
509
result = self._format.initialize(to_bzrdir)
510
self.copy_content_into(result, revision_id=revision_id)
511
return result
512
513
@needs_read_lock
514
def sprout(self, to_bzrdir, revision_id=None):
515
"""Create a new line of development from the branch, into to_bzrdir.
516
517
revision_id: if not None, the revision history in the new branch will
518
be truncated to end with revision_id.
519
"""
520
result = self._format.initialize(to_bzrdir)
521
self.copy_content_into(result, revision_id=revision_id)
522
result.set_parent(self.bzrdir.root_transport.base)
523
return result
524
525
@needs_read_lock
526
def copy_content_into(self, destination, revision_id=None):
527
"""Copy the content of self into destination.
528
529
revision_id: if not None, the revision history in the new branch will
530
be truncated to end with revision_id.
531
"""
532
new_history = self.revision_history()
533
if revision_id is not None:
534
try:
535
new_history = new_history[:new_history.index(revision_id) + 1]
536
except ValueError:
537
rev = self.repository.get_revision(revision_id)
538
new_history = rev.get_history(self.repository)[1:]
539
destination.set_revision_history(new_history)
540
parent = self.get_parent()
541
if parent:
542
destination.set_parent(parent)
543
544
@needs_read_lock
545
def check(self):
546
"""Check consistency of the branch.
547
548
In particular this checks that revisions given in the revision-history
549
do actually match up in the revision graph, and that they're all
550
present in the repository.
551
552
Callers will typically also want to check the repository.
553
554
:return: A BranchCheckResult.
555
"""
556
mainline_parent_id = None
557
for revision_id in self.revision_history():
558
try:
559
revision = self.repository.get_revision(revision_id)
560
except errors.NoSuchRevision, e:
561
raise errors.BzrCheckError("mainline revision {%s} not in repository"
562
% revision_id)
563
# In general the first entry on the revision history has no parents.
564
# But it's not illegal for it to have parents listed; this can happen
565
# in imports from Arch when the parents weren't reachable.
566
if mainline_parent_id is not None:
567
if mainline_parent_id not in revision.parent_ids:
568
raise errors.BzrCheckError("previous revision {%s} not listed among "
569
"parents of {%s}"
570
% (mainline_parent_id, revision_id))
571
mainline_parent_id = revision_id
572
return BranchCheckResult(self)
573
574
575
class BranchFormat(object):
576
"""An encapsulation of the initialization and open routines for a format.
577
578
Formats provide three things:
579
* An initialization routine,
580
* a format string,
581
* an open routine.
582
583
Formats are placed in an dict by their format string for reference
584
during branch opening. Its not required that these be instances, they
585
can be classes themselves with class methods - it simply depends on
586
whether state is needed for a given format or not.
587
588
Once a format is deprecated, just deprecate the initialize and open
589
methods on the format class. Do not deprecate the object, as the
590
object will be created every time regardless.
591
"""
592
593
_default_format = None
594
"""The default format used for new branches."""
595
596
_formats = {}
597
"""The known formats."""
598
599
@classmethod
600
def find_format(klass, a_bzrdir):
601
"""Return the format for the branch object in a_bzrdir."""
602
try:
603
transport = a_bzrdir.get_branch_transport(None)
604
format_string = transport.get("format").read()
605
return klass._formats[format_string]
606
except NoSuchFile:
607
raise NotBranchError(path=transport.base)
608
except KeyError:
609
raise errors.UnknownFormatError(format=format_string)
610
611
@classmethod
612
def get_default_format(klass):
613
"""Return the current default format."""
614
return klass._default_format
615
616
def get_format_string(self):
617
"""Return the ASCII format string that identifies this format."""
618
raise NotImplementedError(self.get_format_string)
619
620
def get_format_description(self):
621
"""Return the short format description for this format."""
622
raise NotImplementedError(self.get_format_string)
623
624
def initialize(self, a_bzrdir):
625
"""Create a branch of this format in a_bzrdir."""
626
raise NotImplementedError(self.initialize)
627
628
def is_supported(self):
629
"""Is this format supported?
630
631
Supported formats can be initialized and opened.
632
Unsupported formats may not support initialization or committing or
633
some other features depending on the reason for not being supported.
634
"""
635
return True
636
637
def open(self, a_bzrdir, _found=False):
638
"""Return the branch object for a_bzrdir
639
640
_found is a private parameter, do not use it. It is used to indicate
641
if format probing has already be done.
642
"""
643
raise NotImplementedError(self.open)
644
645
@classmethod
646
def register_format(klass, format):
647
klass._formats[format.get_format_string()] = format
648
649
@classmethod
650
def set_default_format(klass, format):
651
klass._default_format = format
652
653
@classmethod
654
def unregister_format(klass, format):
655
assert klass._formats[format.get_format_string()] is format
656
del klass._formats[format.get_format_string()]
657
658
def __str__(self):
659
return self.get_format_string().rstrip()
660
661
662
class BzrBranchFormat4(BranchFormat):
663
"""Bzr branch format 4.
664
665
This format has:
666
- a revision-history file.
667
- a branch-lock lock file [ to be shared with the bzrdir ]
668
"""
669
670
def get_format_description(self):
671
"""See BranchFormat.get_format_description()."""
672
return "Branch format 4"
673
674
def initialize(self, a_bzrdir):
675
"""Create a branch of this format in a_bzrdir."""
676
mutter('creating branch in %s', a_bzrdir.transport.base)
677
branch_transport = a_bzrdir.get_branch_transport(self)
678
utf8_files = [('revision-history', ''),
679
('branch-name', ''),
680
]
681
control_files = LockableFiles(branch_transport, 'branch-lock',
682
TransportLock)
683
control_files.create_lock()
684
control_files.lock_write()
685
try:
686
for file, content in utf8_files:
687
control_files.put_utf8(file, content)
688
finally:
689
control_files.unlock()
690
return self.open(a_bzrdir, _found=True)
691
692
def __init__(self):
693
super(BzrBranchFormat4, self).__init__()
694
self._matchingbzrdir = bzrdir.BzrDirFormat6()
695
696
def open(self, a_bzrdir, _found=False):
697
"""Return the branch object for a_bzrdir
698
699
_found is a private parameter, do not use it. It is used to indicate
700
if format probing has already be done.
701
"""
702
if not _found:
703
# we are being called directly and must probe.
704
raise NotImplementedError
705
return BzrBranch(_format=self,
706
_control_files=a_bzrdir._control_files,
707
a_bzrdir=a_bzrdir,
708
_repository=a_bzrdir.open_repository())
709
710
def __str__(self):
711
return "Bazaar-NG branch format 4"
712
713
714
class BzrBranchFormat5(BranchFormat):
715
"""Bzr branch format 5.
716
717
This format has:
718
- a revision-history file.
719
- a format string
720
- a lock dir guarding the branch itself
721
- all of this stored in a branch/ subdirectory
722
- works with shared repositories.
723
724
This format is new in bzr 0.8.
725
"""
726
727
def get_format_string(self):
728
"""See BranchFormat.get_format_string()."""
729
return "Bazaar-NG branch format 5\n"
730
731
def get_format_description(self):
732
"""See BranchFormat.get_format_description()."""
733
return "Branch format 5"
734
735
def initialize(self, a_bzrdir):
736
"""Create a branch of this format in a_bzrdir."""
737
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
738
branch_transport = a_bzrdir.get_branch_transport(self)
739
utf8_files = [('revision-history', ''),
740
('branch-name', ''),
741
]
742
control_files = LockableFiles(branch_transport, 'lock', lockdir.LockDir)
743
control_files.create_lock()
744
control_files.lock_write()
745
control_files.put_utf8('format', self.get_format_string())
746
try:
747
for file, content in utf8_files:
748
control_files.put_utf8(file, content)
749
finally:
750
control_files.unlock()
751
return self.open(a_bzrdir, _found=True, )
752
753
def __init__(self):
754
super(BzrBranchFormat5, self).__init__()
755
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
756
757
def open(self, a_bzrdir, _found=False):
758
"""Return the branch object for a_bzrdir
759
760
_found is a private parameter, do not use it. It is used to indicate
761
if format probing has already be done.
762
"""
763
if not _found:
764
format = BranchFormat.find_format(a_bzrdir)
765
assert format.__class__ == self.__class__
766
transport = a_bzrdir.get_branch_transport(None)
767
control_files = LockableFiles(transport, 'lock', lockdir.LockDir)
768
return BzrBranch5(_format=self,
769
_control_files=control_files,
770
a_bzrdir=a_bzrdir,
771
_repository=a_bzrdir.find_repository())
772
773
def __str__(self):
774
return "Bazaar-NG Metadir branch format 5"
775
776
777
class BranchReferenceFormat(BranchFormat):
778
"""Bzr branch reference format.
779
780
Branch references are used in implementing checkouts, they
781
act as an alias to the real branch which is at some other url.
782
783
This format has:
784
- A location file
785
- a format string
786
"""
787
788
def get_format_string(self):
789
"""See BranchFormat.get_format_string()."""
790
return "Bazaar-NG Branch Reference Format 1\n"
791
792
def get_format_description(self):
793
"""See BranchFormat.get_format_description()."""
794
return "Checkout reference format 1"
795
796
def initialize(self, a_bzrdir, target_branch=None):
797
"""Create a branch of this format in a_bzrdir."""
798
if target_branch is None:
799
# this format does not implement branch itself, thus the implicit
800
# creation contract must see it as uninitializable
801
raise errors.UninitializableFormat(self)
802
mutter('creating branch reference in %s', a_bzrdir.transport.base)
803
branch_transport = a_bzrdir.get_branch_transport(self)
804
# FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
805
branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
806
branch_transport.put('format', StringIO(self.get_format_string()))
807
return self.open(a_bzrdir, _found=True)
808
809
def __init__(self):
810
super(BranchReferenceFormat, self).__init__()
811
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
812
813
def _make_reference_clone_function(format, a_branch):
814
"""Create a clone() routine for a branch dynamically."""
815
def clone(to_bzrdir, revision_id=None):
816
"""See Branch.clone()."""
817
return format.initialize(to_bzrdir, a_branch)
818
# cannot obey revision_id limits when cloning a reference ...
819
# FIXME RBC 20060210 either nuke revision_id for clone, or
820
# emit some sort of warning/error to the caller ?!
821
return clone
822
823
def open(self, a_bzrdir, _found=False):
824
"""Return the branch that the branch reference in a_bzrdir points at.
825
826
_found is a private parameter, do not use it. It is used to indicate
827
if format probing has already be done.
828
"""
829
if not _found:
830
format = BranchFormat.find_format(a_bzrdir)
831
assert format.__class__ == self.__class__
832
transport = a_bzrdir.get_branch_transport(None)
833
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
834
result = real_bzrdir.open_branch()
835
# this changes the behaviour of result.clone to create a new reference
836
# rather than a copy of the content of the branch.
837
# I did not use a proxy object because that needs much more extensive
838
# testing, and we are only changing one behaviour at the moment.
839
# If we decide to alter more behaviours - i.e. the implicit nickname
840
# then this should be refactored to introduce a tested proxy branch
841
# and a subclass of that for use in overriding clone() and ....
842
# - RBC 20060210
843
result.clone = self._make_reference_clone_function(result)
844
return result
845
846
847
# formats which have no format string are not discoverable
848
# and not independently creatable, so are not registered.
849
__default_format = BzrBranchFormat5()
850
BranchFormat.register_format(__default_format)
851
BranchFormat.register_format(BranchReferenceFormat())
852
BranchFormat.set_default_format(__default_format)
853
_legacy_formats = [BzrBranchFormat4(),
854
]
483
484
def sign_revision(self, revision_id, gpg_strategy):
485
raise NotImplementedError('sign_revision is abstract')
486
487
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
488
raise NotImplementedError('store_revision_signature is abstract')
855
489
856
490
class BzrBranch(Branch):
857
491
"""A branch stored in the actual filesystem.
859
493
Note that it's "local" in the context of the filesystem; it doesn't
860
494
really matter if it's on an nfs/smb/afs/coda/... share, as long as
861
495
it's writable, and can be accessed via the normal filesystem API.
496
497
_lock_mode
498
None, or 'r' or 'w'
499
500
_lock_count
501
If _lock_mode is true, a positive count of the number of times the
502
lock has been taken.
503
504
_lock
505
Lock object from bzrlib.lock.
862
506
"""
507
# We actually expect this class to be somewhat short-lived; part of its
508
# purpose is to try to isolate what bits of the branch logic are tied to
509
# filesystem access, so that in a later step, we can extricate them to
510
# a separarte ("storage") class.
511
_lock_mode = None
512
_lock_count = None
513
_lock = None
514
_inventory_weave = None
863
515
864
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
865
relax_version_check=DEPRECATED_PARAMETER, _format=None,
866
_control_files=None, a_bzrdir=None, _repository=None):
516
# Map some sort of prefix into a namespace
517
# stuff like "revno:10", "revid:", etc.
518
# This should match a prefix with a function which accepts
519
REVISION_NAMESPACES = {}
520
521
def push_stores(self, branch_to):
522
"""See Branch.push_stores."""
523
if (self._branch_format != branch_to._branch_format
524
or self._branch_format != 4):
525
from bzrlib.fetch import greedy_fetch
526
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
527
self, self._branch_format, branch_to, branch_to._branch_format)
528
greedy_fetch(to_branch=branch_to, from_branch=self,
529
revision=self.last_revision())
530
return
531
532
store_pairs = ((self.text_store, branch_to.text_store),
533
(self.inventory_store, branch_to.inventory_store),
534
(self.revision_store, branch_to.revision_store))
535
try:
536
for from_store, to_store in store_pairs:
537
copy_all(from_store, to_store)
538
except UnlistableStore:
539
raise UnlistableBranch(from_store)
540
541
def __init__(self, transport, init=False,
542
relax_version_check=False):
867
543
"""Create new branch object at a particular location.
868
544
869
545
transport -- A Transport object, defining how to access files.
876
552
version is not applied. This is intended only for
877
553
upgrade/recovery type use; it's not guaranteed that
878
554
all operations will work on old format branches.
555
556
In the test suite, creation of new trees is tested using the
557
`ScratchBranch` class.
879
558
"""
880
if a_bzrdir is None:
881
self.bzrdir = bzrdir.BzrDir.open(transport.base)
882
else:
883
self.bzrdir = a_bzrdir
884
self._transport = self.bzrdir.transport.clone('..')
885
self._base = self._transport.base
886
self._format = _format
887
if _control_files is None:
888
raise ValueError('BzrBranch _control_files is None')
889
self.control_files = _control_files
890
if deprecated_passed(init):
891
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
892
"deprecated as of bzr 0.8. Please use Branch.create().",
893
DeprecationWarning,
894
stacklevel=2)
895
if init:
896
# this is slower than before deprecation, oh well never mind.
897
# -> its deprecated.
898
self._initialize(transport.base)
899
self._check_format(_format)
900
if deprecated_passed(relax_version_check):
901
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
902
"relax_version_check parameter is deprecated as of bzr 0.8. "
903
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
904
"open() method.",
905
DeprecationWarning,
906
stacklevel=2)
907
if (not relax_version_check
908
and not self._format.is_supported()):
909
raise errors.UnsupportedFormatError(format=fmt)
910
if deprecated_passed(transport):
911
warn("BzrBranch.__init__(transport=XXX...): The transport "
912
"parameter is deprecated as of bzr 0.8. "
913
"Please use Branch.open, or bzrdir.open_branch().",
914
DeprecationWarning,
915
stacklevel=2)
916
self.repository = _repository
559
assert isinstance(transport, Transport), \
560
"%r is not a Transport" % transport
561
self._transport = transport
562
if init:
563
self._make_control()
564
self._check_format(relax_version_check)
565
566
def get_store(name, compressed=True, prefixed=False):
567
# FIXME: This approach of assuming stores are all entirely compressed
568
# or entirely uncompressed is tidy, but breaks upgrade from
569
# some existing branches where there's a mixture; we probably
570
# still want the option to look for both.
571
relpath = self._rel_controlfilename(name)
572
store = TextStore(self._transport.clone(relpath),
573
prefixed=prefixed,
574
compressed=compressed)
575
#if self._transport.should_cache():
576
# cache_path = os.path.join(self.cache_root, name)
577
# os.mkdir(cache_path)
578
# store = bzrlib.store.CachedStore(store, cache_path)
579
return store
580
def get_weave(name, prefixed=False):
581
relpath = self._rel_controlfilename(name)
582
ws = WeaveStore(self._transport.clone(relpath), prefixed=prefixed)
583
if self._transport.should_cache():
584
ws.enable_cache = True
585
return ws
586
587
if self._branch_format == 4:
588
self.inventory_store = get_store(u'inventory-store')
589
self.text_store = get_store(u'text-store')
590
self.revision_store = get_store(u'revision-store')
591
elif self._branch_format == 5:
592
self.control_weaves = get_weave(u'')
593
self.weave_store = get_weave(u'weaves')
594
self.revision_store = get_store(u'revision-store', compressed=False)
595
elif self._branch_format == 6:
596
self.control_weaves = get_weave(u'')
597
self.weave_store = get_weave(u'weaves', prefixed=True)
598
self.revision_store = get_store(u'revision-store', compressed=False,
599
prefixed=True)
600
self.revision_store.register_suffix('sig')
601
self._transaction = None
917
602
918
603
def __str__(self):
919
return '%s(%r)' % (self.__class__.__name__, self.base)
604
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
920
605
921
606
__repr__ = __str__
922
607
923
608
def __del__(self):
609
if self._lock_mode or self._lock:
610
# XXX: This should show something every time, and be suitable for
611
# headless operation and embedding
612
warn("branch %r was not explicitly unlocked" % self)
613
self._lock.unlock()
614
924
615
# TODO: It might be best to do this somewhere else,
925
616
# but it is nice for a Branch object to automatically
926
617
# cache it's information.
927
618
# Alternatively, we could have the Transport objects cache requests
928
619
# See the earlier discussion about how major objects (like Branch)
929
620
# should never expect their __del__ function to run.
930
# XXX: cache_root seems to be unused, 2006-01-13 mbp
931
621
if hasattr(self, 'cache_root') and self.cache_root is not None:
932
622
try:
933
osutils.rmtree(self.cache_root)
623
shutil.rmtree(self.cache_root)
934
624
except:
935
625
pass
936
626
self.cache_root = None
937
627
938
628
def _get_base(self):
939
return self._base
629
if self._transport:
630
return self._transport.base
631
return None
940
632
941
633
base = property(_get_base, doc="The URL for the root of this branch.")
942
634
943
635
def _finish_transaction(self):
944
636
"""Exit the current transaction."""
945
return self.control_files._finish_transaction()
637
if self._transaction is None:
638
raise errors.LockError('Branch %s is not in a transaction' %
639
self)
640
transaction = self._transaction
641
self._transaction = None
642
transaction.finish()
946
643
947
644
def get_transaction(self):
948
"""Return the current active transaction.
949
950
If no transaction is active, this returns a passthrough object
951
for which all data is immediately flushed and no caching happens.
952
"""
953
# this is an explicit function so that we can do tricky stuff
954
# when the storage in rev_storage is elsewhere.
955
# we probably need to hook the two 'lock a location' and
956
# 'have a transaction' together more delicately, so that
957
# we can have two locks (branch and storage) and one transaction
958
# ... and finishing the transaction unlocks both, but unlocking
959
# does not. - RBC 20051121
960
return self.control_files.get_transaction()
961
962
def _set_transaction(self, transaction):
645
"""See Branch.get_transaction."""
646
if self._transaction is None:
647
return transactions.PassThroughTransaction()
648
else:
649
return self._transaction
650
651
def _set_transaction(self, new_transaction):
963
652
"""Set a new active transaction."""
964
return self.control_files._set_transaction(transaction)
653
if self._transaction is not None:
654
raise errors.LockError('Branch %s is in a transaction already.' %
655
self)
656
self._transaction = new_transaction
657
658
def lock_write(self):
659
mutter("lock write: %s (%s)", self, self._lock_count)
660
# TODO: Upgrade locking to support using a Transport,
661
# and potentially a remote locking protocol
662
if self._lock_mode:
663
if self._lock_mode != 'w':
664
raise LockError("can't upgrade to a write lock from %r" %
665
self._lock_mode)
666
self._lock_count += 1
667
else:
668
self._lock = self._transport.lock_write(
669
self._rel_controlfilename('branch-lock'))
670
self._lock_mode = 'w'
671
self._lock_count = 1
672
self._set_transaction(transactions.PassThroughTransaction())
673
674
def lock_read(self):
675
mutter("lock read: %s (%s)", self, self._lock_count)
676
if self._lock_mode:
677
assert self._lock_mode in ('r', 'w'), \
678
"invalid lock mode %r" % self._lock_mode
679
self._lock_count += 1
680
else:
681
self._lock = self._transport.lock_read(
682
self._rel_controlfilename('branch-lock'))
683
self._lock_mode = 'r'
684
self._lock_count = 1
685
self._set_transaction(transactions.ReadOnlyTransaction())
686
# 5K may be excessive, but hey, its a knob.
687
self.get_transaction().set_cache_size(5000)
688
689
def unlock(self):
690
mutter("unlock: %s (%s)", self, self._lock_count)
691
if not self._lock_mode:
692
raise LockError('branch %r is not locked' % (self))
693
694
if self._lock_count > 1:
695
self._lock_count -= 1
696
else:
697
self._finish_transaction()
698
self._lock.unlock()
699
self._lock = None
700
self._lock_mode = self._lock_count = None
965
701
966
702
def abspath(self, name):
967
703
"""See Branch.abspath."""
968
return self.control_files._transport.abspath(name)
969
970
def _check_format(self, format):
971
"""Identify the branch format if needed.
972
973
The format is stored as a reference to the format object in
974
self._format for code that needs to check it later.
975
976
The format parameter is either None or the branch format class
977
used to open this branch.
978
979
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
704
return self._transport.abspath(name)
705
706
def _rel_controlfilename(self, file_or_path):
707
if not isinstance(file_or_path, basestring):
708
file_or_path = u'/'.join(file_or_path)
709
if file_or_path == '':
710
return bzrlib.BZRDIR
711
return bzrlib.transport.urlescape(bzrlib.BZRDIR + u'/' + file_or_path)
712
713
def controlfilename(self, file_or_path):
714
"""See Branch.controlfilename."""
715
return self._transport.abspath(self._rel_controlfilename(file_or_path))
716
717
def controlfile(self, file_or_path, mode='r'):
718
"""See Branch.controlfile."""
719
import codecs
720
721
relpath = self._rel_controlfilename(file_or_path)
722
#TODO: codecs.open() buffers linewise, so it was overloaded with
723
# a much larger buffer, do we need to do the same for getreader/getwriter?
724
if mode == 'rb':
725
return self._transport.get(relpath)
726
elif mode == 'wb':
727
raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
728
elif mode == 'r':
729
# XXX: Do we really want errors='replace'? Perhaps it should be
730
# an error, or at least reported, if there's incorrectly-encoded
731
# data inside a file.
732
# <https://launchpad.net/products/bzr/+bug/3823>
733
return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
734
elif mode == 'w':
735
raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
736
else:
737
raise BzrError("invalid controlfile mode %r" % mode)
738
739
def put_controlfile(self, path, f, encode=True):
740
"""See Branch.put_controlfile."""
741
self.put_controlfiles([(path, f)], encode=encode)
742
743
def put_controlfiles(self, files, encode=True):
744
"""See Branch.put_controlfiles."""
745
import codecs
746
ctrl_files = []
747
for path, f in files:
748
if encode:
749
if isinstance(f, basestring):
750
f = f.encode('utf-8', 'replace')
751
else:
752
f = codecs.getwriter('utf-8')(f, errors='replace')
753
path = self._rel_controlfilename(path)
754
ctrl_files.append((path, f))
755
self._transport.put_multi(ctrl_files)
756
757
def _make_control(self):
758
from bzrlib.inventory import Inventory
759
from bzrlib.weavefile import write_weave_v5
760
from bzrlib.weave import Weave
761
762
# Create an empty inventory
763
sio = StringIO()
764
# if we want per-tree root ids then this is the place to set
765
# them; they're not needed for now and so ommitted for
766
# simplicity.
767
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
768
empty_inv = sio.getvalue()
769
sio = StringIO()
770
bzrlib.weavefile.write_weave_v5(Weave(), sio)
771
empty_weave = sio.getvalue()
772
773
dirs = [[], 'revision-store', 'weaves']
774
files = [('README',
775
"This is a Bazaar-NG control directory.\n"
776
"Do not change any files in this directory.\n"),
777
('branch-format', BZR_BRANCH_FORMAT_6),
778
('revision-history', ''),
779
('branch-name', ''),
780
('branch-lock', ''),
781
('pending-merges', ''),
782
('inventory', empty_inv),
783
('inventory.weave', empty_weave),
784
('ancestry.weave', empty_weave)
785
]
786
cfn = self._rel_controlfilename
787
self._transport.mkdir_multi([cfn(d) for d in dirs])
788
self.put_controlfiles(files)
789
mutter('created control directory in ' + self._transport.base)
790
791
def _check_format(self, relax_version_check):
792
"""Check this branch format is supported.
793
794
The format level is stored, as an integer, in
795
self._branch_format for code that needs to check it later.
796
797
In the future, we might need different in-memory Branch
798
classes to support downlevel branches. But not yet.
980
799
"""
981
if format is None:
982
format = BranchFormat.find_format(self.bzrdir)
983
self._format = format
984
mutter("got branch format %s", self._format)
800
try:
801
fmt = self.controlfile('branch-format', 'r').read()
802
except NoSuchFile:
803
raise NotBranchError(path=self.base)
804
mutter("got branch format %r", fmt)
805
if fmt == BZR_BRANCH_FORMAT_6:
806
self._branch_format = 6
807
elif fmt == BZR_BRANCH_FORMAT_5:
808
self._branch_format = 5
809
elif fmt == BZR_BRANCH_FORMAT_4:
810
self._branch_format = 4
811
812
if (not relax_version_check
813
and self._branch_format not in (5, 6)):
814
raise errors.UnsupportedFormatError(
815
'sorry, branch format %r not supported' % fmt,
816
['use a different bzr version',
817
'or remove the .bzr directory'
818
' and "bzr init" again'])
985
819
986
820
@needs_read_lock
987
821
def get_root_id(self):
988
822
"""See Branch.get_root_id."""
989
tree = self.repository.revision_tree(self.last_revision())
990
return tree.inventory.root.file_id
991
992
def is_locked(self):
993
return self.control_files.is_locked()
994
995
def lock_write(self):
996
self.repository.lock_write()
997
try:
998
self.control_files.lock_write()
999
except:
1000
self.repository.unlock()
1001
raise
1002
1003
def lock_read(self):
1004
self.repository.lock_read()
1005
try:
1006
self.control_files.lock_read()
1007
except:
1008
self.repository.unlock()
1009
raise
1010
1011
def unlock(self):
1012
# TODO: test for failed two phase locks. This is known broken.
1013
try:
1014
self.control_files.unlock()
1015
finally:
1016
self.repository.unlock()
1017
1018
def peek_lock_mode(self):
1019
if self.control_files._lock_count == 0:
1020
return None
1021
else:
1022
return self.control_files._lock_mode
1023
1024
def get_physical_lock_status(self):
1025
return self.control_files.get_physical_lock_status()
823
inv = self.get_inventory(self.last_revision())
824
return inv.root.file_id
1026
825
1027
826
@needs_read_lock
1028
def print_file(self, file, revision_id):
827
def print_file(self, file, revno):
1029
828
"""See Branch.print_file."""
1030
return self.repository.print_file(file, revision_id)
829
tree = self.revision_tree(self.get_rev_id(revno))
830
# use inventory as it was in that revision
831
file_id = tree.inventory.path2id(file)
832
if not file_id:
833
raise BzrError("%r is not present in revision %s" % (file, revno))
834
tree.print_file(file_id)
1031
835
1032
836
@needs_write_lock
1033
837
def append_revision(self, *revision_ids):
1041
845
@needs_write_lock
1042
846
def set_revision_history(self, rev_history):
1043
847
"""See Branch.set_revision_history."""
1044
self.control_files.put_utf8(
1045
'revision-history', '\n'.join(rev_history))
1046
transaction = self.get_transaction()
1047
history = transaction.map.find_revision_history()
1048
if history is not None:
1049
# update the revision history in the identity map.
1050
history[:] = list(rev_history)
1051
# this call is disabled because revision_history is
1052
# not really an object yet, and the transaction is for objects.
1053
# transaction.register_dirty(history)
848
old_revision = self.last_revision()
849
new_revision = rev_history[-1]
850
self.put_controlfile('revision-history', '\n'.join(rev_history))
851
self.working_tree().set_last_revision(new_revision, old_revision)
852
853
def has_revision(self, revision_id):
854
"""See Branch.has_revision."""
855
return (revision_id is None
856
or self.revision_store.has_id(revision_id))
857
858
@needs_read_lock
859
def _get_revision_xml_file(self, revision_id):
860
if not revision_id or not isinstance(revision_id, basestring):
861
raise InvalidRevisionId(revision_id=revision_id, branch=self)
862
try:
863
return self.revision_store.get(revision_id)
864
except (IndexError, KeyError):
865
raise bzrlib.errors.NoSuchRevision(self, revision_id)
866
867
def get_revision_xml(self, revision_id):
868
"""See Branch.get_revision_xml."""
869
return self._get_revision_xml_file(revision_id).read()
870
871
def get_revision(self, revision_id):
872
"""See Branch.get_revision."""
873
xml_file = self._get_revision_xml_file(revision_id)
874
875
try:
876
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
877
except SyntaxError, e:
878
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
879
[revision_id,
880
str(e)])
881
882
assert r.revision_id == revision_id
883
return r
884
885
def get_revision_sha1(self, revision_id):
886
"""See Branch.get_revision_sha1."""
887
# In the future, revision entries will be signed. At that
888
# point, it is probably best *not* to include the signature
889
# in the revision hash. Because that lets you re-sign
890
# the revision, (add signatures/remove signatures) and still
891
# have all hash pointers stay consistent.
892
# But for now, just hash the contents.
893
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
894
895
def get_ancestry(self, revision_id):
896
"""See Branch.get_ancestry."""
897
if revision_id is None:
898
return [None]
899
w = self._get_inventory_weave()
900
return [None] + map(w.idx_to_name,
901
w.inclusions([w.lookup(revision_id)]))
902
903
def _get_inventory_weave(self):
904
return self.control_weaves.get_weave('inventory',
905
self.get_transaction())
906
907
def get_inventory(self, revision_id):
908
"""See Branch.get_inventory."""
909
xml = self.get_inventory_xml(revision_id)
910
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
911
912
def get_inventory_xml(self, revision_id):
913
"""See Branch.get_inventory_xml."""
914
try:
915
assert isinstance(revision_id, basestring), type(revision_id)
916
iw = self._get_inventory_weave()
917
return iw.get_text(iw.lookup(revision_id))
918
except IndexError:
919
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
920
921
def get_inventory_sha1(self, revision_id):
922
"""See Branch.get_inventory_sha1."""
923
return self.get_revision(revision_id).inventory_sha1
924
925
def get_revision_inventory(self, revision_id):
926
"""See Branch.get_revision_inventory."""
927
# TODO: Unify this with get_inventory()
928
# bzr 0.0.6 and later imposes the constraint that the inventory_id
929
# must be the same as its revision, so this is trivial.
930
if revision_id == None:
931
# This does not make sense: if there is no revision,
932
# then it is the current tree inventory surely ?!
933
# and thus get_root_id() is something that looks at the last
934
# commit on the branch, and the get_root_id is an inventory check.
935
raise NotImplementedError
936
# return Inventory(self.get_root_id())
1054
937
else:
1055
transaction.map.add_revision_history(rev_history)
1056
# this call is disabled because revision_history is
1057
# not really an object yet, and the transaction is for objects.
1058
# transaction.register_clean(history)
938
return self.get_inventory(revision_id)
1059
939
1060
940
@needs_read_lock
1061
941
def revision_history(self):
1066
946
mutter("cache hit for revision-history in %s", self)
1067
947
return list(history)
1068
948
history = [l.rstrip('\r\n') for l in
1069
self.control_files.get_utf8('revision-history').readlines()]
949
self.controlfile('revision-history', 'r').readlines()]
1070
950
transaction.map.add_revision_history(history)
1071
951
# this call is disabled because revision_history is
1072
952
# not really an object yet, and the transaction is for objects.
1073
953
# transaction.register_clean(history, precious=True)
1074
954
return list(history)
1075
955
1076
@needs_write_lock
1077
def generate_revision_history(self, revision_id, last_rev=None,
1078
other_branch=None):
1079
"""Create a new revision history that will finish with revision_id.
1080
1081
:param revision_id: the new tip to use.
1082
:param last_rev: The previous last_revision. If not None, then this
1083
must be a ancestory of revision_id, or DivergedBranches is raised.
1084
:param other_branch: The other branch that DivergedBranches should
1085
raise with respect to.
1086
"""
1087
# stop_revision must be a descendant of last_revision
1088
stop_graph = self.repository.get_revision_graph(revision_id)
1089
if last_rev is not None and last_rev not in stop_graph:
1090
# our previous tip is not merged into stop_revision
1091
raise errors.DivergedBranches(self, other_branch)
1092
# make a new revision history from the graph
1093
current_rev_id = revision_id
1094
new_history = []
1095
while current_rev_id not in (None, revision.NULL_REVISION):
1096
new_history.append(current_rev_id)
1097
current_rev_id_parents = stop_graph[current_rev_id]
1098
try:
1099
current_rev_id = current_rev_id_parents[0]
1100
except IndexError:
1101
current_rev_id = None
1102
new_history.reverse()
1103
self.set_revision_history(new_history)
1104
1105
@needs_write_lock
1106
956
def update_revisions(self, other, stop_revision=None):
1107
957
"""See Branch.update_revisions."""
1108
other.lock_read()
958
from bzrlib.fetch import greedy_fetch
959
if stop_revision is None:
960
stop_revision = other.last_revision()
961
### Should this be checking is_ancestor instead of revision_history?
962
if (stop_revision is not None and
963
stop_revision in self.revision_history()):
964
return
965
greedy_fetch(to_branch=self, from_branch=other,
966
revision=stop_revision)
967
pullable_revs = self.pullable_revisions(other, stop_revision)
968
if len(pullable_revs) > 0:
969
self.append_revision(*pullable_revs)
970
971
def pullable_revisions(self, other, stop_revision):
972
"""See Branch.pullable_revisions."""
973
other_revno = other.revision_id_to_revno(stop_revision)
1109
974
try:
1110
if stop_revision is None:
1111
stop_revision = other.last_revision()
1112
if stop_revision is None:
1113
# if there are no commits, we're done.
1114
return
1115
# whats the current last revision, before we fetch [and change it
1116
# possibly]
1117
last_rev = self.last_revision()
1118
# we fetch here regardless of whether we need to so that we pickup
1119
# filled in ghosts.
1120
self.fetch(other, stop_revision)
1121
my_ancestry = self.repository.get_ancestry(last_rev)
1122
if stop_revision in my_ancestry:
1123
# last_revision is a descendant of stop_revision
1124
return
1125
self.generate_revision_history(stop_revision, last_rev=last_rev,
1126
other_branch=other)
1127
finally:
1128
other.unlock()
975
return self.missing_revisions(other, other_revno)
976
except DivergedBranches, e:
977
try:
978
pullable_revs = get_intervening_revisions(self.last_revision(),
979
stop_revision, self)
980
assert self.last_revision() not in pullable_revs
981
return pullable_revs
982
except bzrlib.errors.NotAncestor:
983
if is_ancestor(self.last_revision(), stop_revision, self):
984
return []
985
else:
986
raise e
987
988
def revision_tree(self, revision_id):
989
"""See Branch.revision_tree."""
990
# TODO: refactor this to use an existing revision object
991
# so we don't need to read it in twice.
992
if revision_id == None or revision_id == NULL_REVISION:
993
return EmptyTree()
994
else:
995
inv = self.get_revision_inventory(revision_id)
996
return RevisionTree(self.weave_store, inv, revision_id)
1129
997
1130
998
def basis_tree(self):
1131
999
"""See Branch.basis_tree."""
1132
return self.repository.revision_tree(self.last_revision())
1000
try:
1001
revision_id = self.revision_history()[-1]
1002
xml = self.working_tree().read_basis_inventory(revision_id)
1003
inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
1004
return RevisionTree(self.weave_store, inv, revision_id)
1005
except (IndexError, NoSuchFile), e:
1006
return self.revision_tree(self.last_revision())
1133
1007
1134
@deprecated_method(zero_eight)
1135
1008
def working_tree(self):
1136
"""Create a Working tree object for this branch."""
1137
1138
from bzrlib.transport.local import LocalTransport
1139
if (self.base.find('://') != -1 or
1140
not isinstance(self._transport, LocalTransport)):
1009
"""See Branch.working_tree."""
1010
from bzrlib.workingtree import WorkingTree
1011
if self._transport.base.find('://') != -1:
1141
1012
raise NoWorkingTree(self.base)
1142
return self.bzrdir.open_workingtree()
1013
return WorkingTree(self.base, branch=self)
1143
1014
1144
1015
@needs_write_lock
1145
def pull(self, source, overwrite=False, stop_revision=None):
1016
def pull(self, source, overwrite=False):
1146
1017
"""See Branch.pull."""
1147
1018
source.lock_read()
1148
1019
try:
1149
1020
old_count = len(self.revision_history())
1150
1021
try:
1151
self.update_revisions(source,stop_revision)
1022
self.update_revisions(source)
1152
1023
except DivergedBranches:
1153
1024
if not overwrite:
1154
1025
raise
1155
if overwrite:
1156
1026
self.set_revision_history(source.revision_history())
1157
1027
new_count = len(self.revision_history())
1158
1028
return new_count - old_count
1161
1031
1162
1032
def get_parent(self):
1163
1033
"""See Branch.get_parent."""
1164
1034
import errno
1165
1035
_locs = ['parent', 'pull', 'x-pull']
1166
assert self.base[-1] == '/'
1167
1036
for l in _locs:
1168
1037
try:
1169
parent = self.control_files.get(l).read().strip('\n')
1170
except NoSuchFile:
1171
continue
1172
# This is an old-format absolute path to a local branch
1173
# turn it into a url
1174
if parent.startswith('/'):
1175
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1176
return urlutils.join(self.base[:-1], parent)
1038
return self.controlfile(l, 'r').read().strip('\n')
1039
except IOError, e:
1040
if e.errno != errno.ENOENT:
1041
raise
1177
1042
return None
1178
1043
1179
1044
def get_push_location(self):
1180
1045
"""See Branch.get_push_location."""
1181
push_loc = self.get_config().get_user_option('push_location')
1046
config = bzrlib.config.BranchConfig(self)
1047
push_loc = config.get_user_option('push_location')
1182
1048
return push_loc
1183
1049
1184
1050
def set_push_location(self, location):
1185
1051
"""See Branch.set_push_location."""
1186
self.get_config().set_user_option('push_location', location,
1187
local=True)
1052
config = bzrlib.config.LocationConfig(self.base)
1053
config.set_user_option('push_location', location)
1188
1054
1189
1055
@needs_write_lock
1190
1056
def set_parent(self, url):
1191
1057
"""See Branch.set_parent."""
1192
1058
# TODO: Maybe delete old location files?
1193
# URLs should never be unicode, even on the local fs,
1194
# FIXUP this and get_parent in a future branch format bump:
1195
# read and rewrite the file, and have the new format code read
1196
# using .get not .get_utf8. RBC 20060125
1197
if url is None:
1198
self.control_files._transport.delete('parent')
1199
else:
1200
if isinstance(url, unicode):
1201
try:
1202
url = url.encode('ascii')
1203
except UnicodeEncodeError:
1204
raise bzrlib.errors.InvalidURL(url,
1205
"Urls must be 7-bit ascii, "
1206
"use bzrlib.urlutils.escape")
1207
1208
url = urlutils.relative_url(self.base, url)
1209
self.control_files.put('parent', url + '\n')
1059
from bzrlib.atomicfile import AtomicFile
1060
f = AtomicFile(self.controlfilename('parent'))
1061
try:
1062
f.write(url + '\n')
1063
f.commit()
1064
finally:
1065
f.close()
1210
1066
1211
@deprecated_function(zero_nine)
1212
1067
def tree_config(self):
1213
"""DEPRECATED; call get_config instead.
1214
TreeConfig has become part of BranchConfig."""
1215
1068
return TreeConfig(self)
1216
1069
1217
1218
class BzrBranch5(BzrBranch):
1219
"""A format 5 branch. This supports new features over plan branches.
1220
1221
It has support for a master_branch which is the data for bound branches.
1070
def sign_revision(self, revision_id, gpg_strategy):
1071
"""See Branch.sign_revision."""
1072
plaintext = Testament.from_revision(self, revision_id).as_short_text()
1073
self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1074
1075
@needs_write_lock
1076
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1077
"""See Branch.store_revision_signature."""
1078
self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)),
1079
revision_id, "sig")
1080
1081
1082
class ScratchBranch(BzrBranch):
1083
"""Special test class: a branch that cleans up after itself.
1084
1085
>>> b = ScratchBranch()
1086
>>> isdir(b.base)
1087
True
1088
>>> bd = b.base
1089
>>> b._transport.__del__()
1090
>>> isdir(bd)
1091
False
1222
1092
"""
1223
1093
1224
def __init__(self,
1225
_format,
1226
_control_files,
1227
a_bzrdir,
1228
_repository):
1229
super(BzrBranch5, self).__init__(_format=_format,
1230
_control_files=_control_files,
1231
a_bzrdir=a_bzrdir,
1232
_repository=_repository)
1233
1234
@needs_write_lock
1235
def pull(self, source, overwrite=False, stop_revision=None):
1236
"""Updates branch.pull to be bound branch aware."""
1237
bound_location = self.get_bound_location()
1238
if source.base != bound_location:
1239
# not pulling from master, so we need to update master.
1240
master_branch = self.get_master_branch()
1241
if master_branch:
1242
master_branch.pull(source)
1243
source = master_branch
1244
return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1245
1246
def get_bound_location(self):
1247
try:
1248
return self.control_files.get_utf8('bound').read()[:-1]
1249
except errors.NoSuchFile:
1250
return None
1251
1252
@needs_read_lock
1253
def get_master_branch(self):
1254
"""Return the branch we are bound to.
1255
1256
:return: Either a Branch, or None
1257
1258
This could memoise the branch, but if thats done
1259
it must be revalidated on each new lock.
1260
So for now we just don't memoise it.
1261
# RBC 20060304 review this decision.
1262
"""
1263
bound_loc = self.get_bound_location()
1264
if not bound_loc:
1265
return None
1266
try:
1267
return Branch.open(bound_loc)
1268
except (errors.NotBranchError, errors.ConnectionError), e:
1269
raise errors.BoundBranchConnectionFailure(
1270
self, bound_loc, e)
1271
1272
@needs_write_lock
1273
def set_bound_location(self, location):
1274
"""Set the target where this branch is bound to.
1275
1276
:param location: URL to the target branch
1277
"""
1278
if location:
1279
self.control_files.put_utf8('bound', location+'\n')
1094
def __init__(self, files=[], dirs=[], transport=None):
1095
"""Make a test branch.
1096
1097
This creates a temporary directory and runs init-tree in it.
1098
1099
If any files are listed, they are created in the working copy.
1100
"""
1101
if transport is None:
1102
transport = bzrlib.transport.local.ScratchTransport()
1103
super(ScratchBranch, self).__init__(transport, init=True)
1280
1104
else:
1281
try:
1282
self.control_files._transport.delete('bound')
1283
except NoSuchFile:
1284
return False
1105
super(ScratchBranch, self).__init__(transport)
1106
1107
for d in dirs:
1108
self._transport.mkdir(d)
1109
1110
for f in files:
1111
self._transport.put(f, 'content of %s' % f)
1112
1113
1114
def clone(self):
1115
"""
1116
>>> orig = ScratchBranch(files=["file1", "file2"])
1117
>>> clone = orig.clone()
1118
>>> if os.name != 'nt':
1119
... os.path.samefile(orig.base, clone.base)
1120
... else:
1121
... orig.base == clone.base
1122
...
1123
False
1124
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1125
True
1126
"""
1127
from shutil import copytree
1128
from tempfile import mkdtemp
1129
base = mkdtemp()
1130
os.rmdir(base)
1131
copytree(self.base, base, symlinks=True)
1132
return ScratchBranch(
1133
transport=bzrlib.transport.local.ScratchTransport(base))
1134
1135
1136
######################################################################
1137
# predicates
1138
1139
1140
def is_control_file(filename):
1141
## FIXME: better check
1142
filename = os.path.normpath(filename)
1143
while filename != '':
1144
head, tail = os.path.split(filename)
1145
## mutter('check %r for control file' % ((head, tail), ))
1146
if tail == bzrlib.BZRDIR:
1285
1147
return True
1286
1287
@needs_write_lock
1288
def bind(self, other):
1289
"""Bind the local branch the other branch.
1290
1291
:param other: The branch to bind to
1292
:type other: Branch
1293
"""
1294
# TODO: jam 20051230 Consider checking if the target is bound
1295
# It is debatable whether you should be able to bind to
1296
# a branch which is itself bound.
1297
# Committing is obviously forbidden,
1298
# but binding itself may not be.
1299
# Since we *have* to check at commit time, we don't
1300
# *need* to check here
1301
self.pull(other)
1302
1303
# we are now equal to or a suffix of other.
1304
1305
# Since we have 'pulled' from the remote location,
1306
# now we should try to pull in the opposite direction
1307
# in case the local tree has more revisions than the
1308
# remote one.
1309
# There may be a different check you could do here
1310
# rather than actually trying to install revisions remotely.
1311
# TODO: capture an exception which indicates the remote branch
1312
# is not writable.
1313
# If it is up-to-date, this probably should not be a failure
1314
1315
# lock other for write so the revision-history syncing cannot race
1316
other.lock_write()
1317
try:
1318
other.pull(self)
1319
# if this does not error, other now has the same last rev we do
1320
# it can only error if the pull from other was concurrent with
1321
# a commit to other from someone else.
1322
1323
# until we ditch revision-history, we need to sync them up:
1324
self.set_revision_history(other.revision_history())
1325
# now other and self are up to date with each other and have the
1326
# same revision-history.
1327
finally:
1328
other.unlock()
1329
1330
self.set_bound_location(other.base)
1331
1332
@needs_write_lock
1333
def unbind(self):
1334
"""If bound, unbind"""
1335
return self.set_bound_location(None)
1336
1337
@needs_write_lock
1338
def update(self):
1339
"""Synchronise this branch with the master branch if any.
1340
1341
:return: None or the last_revision that was pivoted out during the
1342
update.
1343
"""
1344
master = self.get_master_branch()
1345
if master is not None:
1346
old_tip = self.last_revision()
1347
self.pull(master, overwrite=True)
1348
if old_tip in self.repository.get_ancestry(self.last_revision()):
1349
return None
1350
return old_tip
1351
return None
1352
1353
1354
class BranchTestProviderAdapter(object):
1355
"""A tool to generate a suite testing multiple branch formats at once.
1356
1357
This is done by copying the test once for each transport and injecting
1358
the transport_server, transport_readonly_server, and branch_format
1359
classes into each copy. Each copy is also given a new id() to make it
1360
easy to identify.
1361
"""
1362
1363
def __init__(self, transport_server, transport_readonly_server, formats):
1364
self._transport_server = transport_server
1365
self._transport_readonly_server = transport_readonly_server
1366
self._formats = formats
1367
1368
def adapt(self, test):
1369
result = TestSuite()
1370
for branch_format, bzrdir_format in self._formats:
1371
new_test = deepcopy(test)
1372
new_test.transport_server = self._transport_server
1373
new_test.transport_readonly_server = self._transport_readonly_server
1374
new_test.bzrdir_format = bzrdir_format
1375
new_test.branch_format = branch_format
1376
def make_new_test_id():
1377
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1378
return lambda: new_id
1379
new_test.id = make_new_test_id()
1380
result.addTest(new_test)
1381
return result
1382
1383
1384
class BranchCheckResult(object):
1385
"""Results of checking branch consistency.
1386
1387
:see: Branch.check
1388
"""
1389
1390
def __init__(self, branch):
1391
self.branch = branch
1392
1393
def report_results(self, verbose):
1394
"""Report the check results via trace.note.
1395
1396
:param verbose: Requests more detailed display of what was checked,
1397
if any.
1398
"""
1399
note('checked branch %s format %s',
1400
self.branch.base,
1401
self.branch._format)
1402
1403
1404
######################################################################
1405
# predicates
1406
1407
1408
@deprecated_function(zero_eight)
1409
def is_control_file(*args, **kwargs):
1410
"""See bzrlib.workingtree.is_control_file."""
1411
return bzrlib.workingtree.is_control_file(*args, **kwargs)
1148
if filename == head:
1149
break
1150
filename = head
1151
return False
Loggerhead is a web-based interface for Breezy
Version: 2.0.1