« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1393.1.21
- compare with another revision
- download diff
- download tarball
- view history from revision 1393.1.21
- Committer: Martin Pool
- Date: 2005-09-30 06:39:42 UTC
- mfrom: (1185.10.11)
- mto: (1185.14.2)
- mto: This revision was merged to the branch mainline in revision 1396.
- Revision ID: mbp@sourcefrog.net-20050930063942-3eab86500bffba49
- merge merge and export fixes from aaron
aaron.bentley@utoronto.ca-20050930040234-71c1a151f795e806
aaron.bentley@utoronto.ca-20050930040234-71c1a151f795e806
- 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/export
- bzrlib/plugins/launchpad
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests/blackbox
- 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
- bzrlib/ui
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- tools/doc_generate
- files renamed:
- tools/doc_generate/autodoc_man.py => bzr-man.py
- bzrlib/bundle/__init__.py => bzrlib/changeset.py
- bzrlib/tests/ => bzrlib/selftest/
- bzrlib/tests/blackbox/test_too_much.py => bzrlib/selftest/blackbox.py
- bzrlib/tests/test_plugins.py => bzrlib/selftest/plugins.py
- bzrlib/tests/branch_implementations/test_parent.py => bzrlib/selftest/test_parent.py
- bzrlib/tests/blackbox/test_revision_info.py => bzrlib/selftest/test_revision_info.py
- bzrlib/tests/branch_implementations/test_branch.py => bzrlib/selftest/testbranch.py
- bzrlib/tests/test_diff.py => bzrlib/selftest/testdiff.py
- bzrlib/tests/test_fetch.py => bzrlib/selftest/testfetch.py
- bzrlib/tests/test_graph.py => bzrlib/selftest/testgraph.py
- bzrlib/tests/test_hashcache.py => bzrlib/selftest/testhashcache.py
- bzrlib/tests/test_inv.py => bzrlib/selftest/testinv.py
- bzrlib/tests/test_log.py => bzrlib/selftest/testlog.py
- bzrlib/tests/test_merge.py => bzrlib/selftest/testmerge.py
- bzrlib/tests/test_merge3.py => bzrlib/selftest/testmerge3.py
- bzrlib/tests/test_revision.py => bzrlib/selftest/testrevision.py
- bzrlib/tests/test_revisionnamespaces.py => bzrlib/selftest/testrevisionnamespaces.py
- bzrlib/tests/blackbox/test_status.py => bzrlib/selftest/teststatus.py
- bzrlib/tests/test_store.py => bzrlib/selftest/teststore.py
- bzrlib/tests/test_transport.py => bzrlib/selftest/testtransport.py
- bzrlib/tests/blackbox/test_versioning.py => bzrlib/selftest/versioning.py
- bzrlib/tests/test_whitebox.py => bzrlib/selftest/whitebox.py
- bzrlib/store/versioned/__init__.py => bzrlib/store/weave.py
- bzrlib/transport/http/__init__.py => bzrlib/transport/http.py
- bzrlib/ui/__init__.py => bzrlib/ui.py
- bzrlib/xml_serializer.py => bzrlib/xml.py
- doc/tutorial.txt => tutorial.txt
- files modified:
- .bzrignore
- bzr *
- setup.py *
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 sys
19
import os
20
import errno
21
from warnings import warn
19
22
from cStringIO import StringIO
20
from unittest import TestSuite
21
from warnings import warn
23
22
24
23
25
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
30
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
26
from bzrlib.trace import mutter, note
27
from bzrlib.osutils import (isdir, quotefn, compact_date, rand_bytes,
28
rename, splitpath, sha_file, appendpath,
29
file_kind)
30
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
31
NoSuchRevision, HistoryMissing, NotBranchError,
32
DivergedBranches, LockError, UnlistableStore,
33
UnlistableBranch, NoSuchFile)
34
from bzrlib.textui import show_status
35
from bzrlib.revision import Revision, validate_revision_id, is_ancestor
36
from bzrlib.delta import compare_trees
37
from bzrlib.tree import EmptyTree, RevisionTree
38
from bzrlib.inventory import Inventory
39
from bzrlib.store import copy_all
40
from bzrlib.store.compressed_text import CompressedTextStore
41
from bzrlib.store.text import TextStore
42
from bzrlib.store.weave import WeaveStore
43
from bzrlib.transport import Transport, get_transport
44
import bzrlib.xml5
45
import bzrlib.ui
46
46
47
47
48
48
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
49
49
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
50
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
51
52
53
# TODO: Maybe include checks for common corruption of newlines, etc?
50
## TODO: Maybe include checks for common corruption of newlines, etc?
51
54
52
55
53
# TODO: Some operations like log might retrieve the same revisions
56
54
# repeatedly to calculate deltas. We could perhaps have a weakref
57
55
# 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
56
# cached in memory between lock and unlock operations.
57
58
def find_branch(*ignored, **ignored_too):
59
# XXX: leave this here for about one release, then remove it
60
raise NotImplementedError('find_branch() is not supported anymore, '
61
'please use one of the new branch constructors')
62
def _relpath(base, path):
63
"""Return path relative to base, or raise exception.
64
65
The path may be either an absolute path or a path relative to the
66
current working directory.
67
68
Lifted out of Branch.relpath for ease of testing.
69
70
os.path.commonprefix (python2.4) has a bad bug that it works just
71
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
72
avoids that problem."""
73
rp = os.path.abspath(path)
74
75
s = []
76
head = rp
77
while len(head) >= len(base):
78
if head == base:
79
break
80
head, tail = os.path.split(head)
81
if tail:
82
s.insert(0, tail)
83
else:
84
raise NotBranchError("path %r is not within branch %r" % (rp, base))
85
86
return os.sep.join(s)
87
88
89
def find_branch_root(t):
90
"""Find the branch root enclosing the transport's base.
91
92
t is a Transport object.
93
94
It is not necessary that the base of t exists.
95
96
Basically we keep looking up until we find the control directory or
97
run into the root. If there isn't one, raises NotBranchError.
98
"""
99
orig_base = t.base
100
while True:
101
if t.has(bzrlib.BZRDIR):
102
return t
103
new_t = t.clone('..')
104
if new_t.base == t.base:
105
# reached the root, whatever that may be
106
raise NotBranchError('%s is not in a branch' % orig_base)
107
t = new_t
60
108
61
109
62
110
######################################################################
68
116
base
69
117
Base directory/url of the branch.
70
118
"""
71
# this is really an instance variable - FIXME move it there
72
# - RBC 20060112
73
119
base = None
74
120
75
121
def __init__(self, *ignored, **ignored_too):
76
122
raise NotImplementedError('The Branch class is abstract')
77
123
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
124
@staticmethod
93
@deprecated_method(zero_eight)
94
125
def open_downlevel(base):
95
"""Open a branch which may be of an old format."""
96
return Branch.open(base, _unsupported=True)
126
"""Open a branch which may be of an old format.
127
128
Only local branches are supported."""
129
return _Branch(get_transport(base), relax_version_check=True)
97
130
98
131
@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)
132
def open(base):
133
"""Open an existing branch, rooted at 'base' (url)"""
134
t = get_transport(base)
135
return _Branch(t)
107
136
108
137
@staticmethod
109
138
def open_containing(url):
110
139
"""Open an existing branch which contains url.
111
140
112
141
This probes for a branch at url, and searches upwards from there.
113
114
Basically we keep looking up until we find the control directory or
115
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
If there is one, it is returned, along with the unused portion of url.
119
142
"""
120
control, relpath = bzrdir.BzrDir.open_containing(url)
121
return control.open_branch(), relpath
143
t = get_transport(url)
144
t = find_branch_root(t)
145
return _Branch(t)
122
146
123
147
@staticmethod
124
@deprecated_function(zero_eight)
125
148
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
149
"""Create a new branch, rooted at 'base' (url)"""
150
t = get_transport(base)
151
return _Branch(t, init=True)
132
152
133
153
def setup_caching(self, cache_root):
134
154
"""Subclasses that care about caching should override this, and set
135
155
up cached stores located under cache_root.
136
156
"""
137
# seems to be unused, 2006-01-13 mbp
138
warn('%s is deprecated' % self.setup_caching)
139
self.cache_root = cache_root
140
141
def get_config(self):
142
return bzrlib.config.BranchConfig(self)
143
144
def _get_nick(self):
145
return self.get_config().get_nickname()
146
147
def _set_nick(self, nick):
148
self.get_config().set_user_option('nickname', nick)
149
150
nick = property(_get_nick, _set_nick)
151
152
def is_locked(self):
153
raise NotImplementedError('is_locked is abstract')
157
158
159
class _Branch(Branch):
160
"""A branch stored in the actual filesystem.
161
162
Note that it's "local" in the context of the filesystem; it doesn't
163
really matter if it's on an nfs/smb/afs/coda/... share, as long as
164
it's writable, and can be accessed via the normal filesystem API.
165
166
_lock_mode
167
None, or 'r' or 'w'
168
169
_lock_count
170
If _lock_mode is true, a positive count of the number of times the
171
lock has been taken.
172
173
_lock
174
Lock object from bzrlib.lock.
175
"""
176
# We actually expect this class to be somewhat short-lived; part of its
177
# purpose is to try to isolate what bits of the branch logic are tied to
178
# filesystem access, so that in a later step, we can extricate them to
179
# a separarte ("storage") class.
180
_lock_mode = None
181
_lock_count = None
182
_lock = None
183
_inventory_weave = None
184
185
# Map some sort of prefix into a namespace
186
# stuff like "revno:10", "revid:", etc.
187
# This should match a prefix with a function which accepts
188
REVISION_NAMESPACES = {}
189
190
def push_stores(self, branch_to):
191
"""Copy the content of this branches store to branch_to."""
192
if (self._branch_format != branch_to._branch_format
193
or self._branch_format != 4):
194
from bzrlib.fetch import greedy_fetch
195
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
196
self, self._branch_format, branch_to, branch_to._branch_format)
197
greedy_fetch(to_branch=branch_to, from_branch=self,
198
revision=self.last_revision())
199
return
200
201
store_pairs = ((self.text_store, branch_to.text_store),
202
(self.inventory_store, branch_to.inventory_store),
203
(self.revision_store, branch_to.revision_store))
204
try:
205
for from_store, to_store in store_pairs:
206
copy_all(from_store, to_store)
207
except UnlistableStore:
208
raise UnlistableBranch(from_store)
209
210
def __init__(self, transport, init=False,
211
relax_version_check=False):
212
"""Create new branch object at a particular location.
213
214
transport -- A Transport object, defining how to access files.
215
(If a string, transport.transport() will be used to
216
create a Transport object)
217
218
init -- If True, create new control files in a previously
219
unversioned directory. If False, the branch must already
220
be versioned.
221
222
relax_version_check -- If true, the usual check for the branch
223
version is not applied. This is intended only for
224
upgrade/recovery type use; it's not guaranteed that
225
all operations will work on old format branches.
226
227
In the test suite, creation of new trees is tested using the
228
`ScratchBranch` class.
229
"""
230
assert isinstance(transport, Transport), \
231
"%r is not a Transport" % transport
232
self._transport = transport
233
if init:
234
self._make_control()
235
self._check_format(relax_version_check)
236
237
def get_store(name, compressed=True):
238
relpath = self._rel_controlfilename(name)
239
if compressed:
240
store = CompressedTextStore(self._transport.clone(relpath))
241
else:
242
store = TextStore(self._transport.clone(relpath))
243
if self._transport.should_cache():
244
from meta_store import CachedStore
245
cache_path = os.path.join(self.cache_root, name)
246
os.mkdir(cache_path)
247
store = CachedStore(store, cache_path)
248
return store
249
def get_weave(name):
250
relpath = self._rel_controlfilename(name)
251
ws = WeaveStore(self._transport.clone(relpath))
252
if self._transport.should_cache():
253
ws.enable_cache = True
254
return ws
255
256
if self._branch_format == 4:
257
self.inventory_store = get_store('inventory-store')
258
self.text_store = get_store('text-store')
259
self.revision_store = get_store('revision-store')
260
elif self._branch_format == 5:
261
self.control_weaves = get_weave([])
262
self.weave_store = get_weave('weaves')
263
self.revision_store = get_store('revision-store', compressed=False)
264
265
def __str__(self):
266
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
267
268
269
__repr__ = __str__
270
271
272
def __del__(self):
273
if self._lock_mode or self._lock:
274
# XXX: This should show something every time, and be suitable for
275
# headless operation and embedding
276
warn("branch %r was not explicitly unlocked" % self)
277
self._lock.unlock()
278
279
# TODO: It might be best to do this somewhere else,
280
# but it is nice for a Branch object to automatically
281
# cache it's information.
282
# Alternatively, we could have the Transport objects cache requests
283
# See the earlier discussion about how major objects (like Branch)
284
# should never expect their __del__ function to run.
285
if hasattr(self, 'cache_root') and self.cache_root is not None:
286
try:
287
import shutil
288
shutil.rmtree(self.cache_root)
289
except:
290
pass
291
self.cache_root = None
292
293
def _get_base(self):
294
if self._transport:
295
return self._transport.base
296
return None
297
298
base = property(_get_base)
299
154
300
155
301
def lock_write(self):
156
raise NotImplementedError('lock_write is abstract')
302
# TODO: Upgrade locking to support using a Transport,
303
# and potentially a remote locking protocol
304
if self._lock_mode:
305
if self._lock_mode != 'w':
306
raise LockError("can't upgrade to a write lock from %r" %
307
self._lock_mode)
308
self._lock_count += 1
309
else:
310
self._lock = self._transport.lock_write(
311
self._rel_controlfilename('branch-lock'))
312
self._lock_mode = 'w'
313
self._lock_count = 1
314
157
315
158
316
def lock_read(self):
159
raise NotImplementedError('lock_read is abstract')
160
317
if self._lock_mode:
318
assert self._lock_mode in ('r', 'w'), \
319
"invalid lock mode %r" % self._lock_mode
320
self._lock_count += 1
321
else:
322
self._lock = self._transport.lock_read(
323
self._rel_controlfilename('branch-lock'))
324
self._lock_mode = 'r'
325
self._lock_count = 1
326
161
327
def unlock(self):
162
raise NotImplementedError('unlock is abstract')
163
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')
328
if not self._lock_mode:
329
raise LockError('branch %r is not locked' % (self))
330
331
if self._lock_count > 1:
332
self._lock_count -= 1
333
else:
334
self._lock.unlock()
335
self._lock = None
336
self._lock_mode = self._lock_count = None
170
337
171
338
def abspath(self, name):
172
"""Return absolute filename for something in the branch
173
174
XXX: Robert Collins 20051017 what is this used for? why is it a branch
175
method and not a tree method.
176
"""
177
raise NotImplementedError('abspath is abstract')
178
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
339
"""Return absolute filename for something in the branch"""
340
return self._transport.abspath(name)
341
342
def relpath(self, path):
343
"""Return path relative to this branch of something inside it.
344
345
Raises an error if path is not in this branch."""
346
return self._transport.relpath(path)
347
348
349
def _rel_controlfilename(self, file_or_path):
350
if isinstance(file_or_path, basestring):
351
file_or_path = [file_or_path]
352
return [bzrlib.BZRDIR] + file_or_path
353
354
def controlfilename(self, file_or_path):
355
"""Return location relative to branch."""
356
return self._transport.abspath(self._rel_controlfilename(file_or_path))
357
358
359
def controlfile(self, file_or_path, mode='r'):
360
"""Open a control file for this branch.
361
362
There are two classes of file in the control directory: text
363
and binary. binary files are untranslated byte streams. Text
364
control files are stored with Unix newlines and in UTF-8, even
365
if the platform or locale defaults are different.
366
367
Controlfiles should almost never be opened in write mode but
368
rather should be atomically copied and replaced using atomicfile.
369
"""
370
import codecs
371
372
relpath = self._rel_controlfilename(file_or_path)
373
#TODO: codecs.open() buffers linewise, so it was overloaded with
374
# a much larger buffer, do we need to do the same for getreader/getwriter?
375
if mode == 'rb':
376
return self._transport.get(relpath)
377
elif mode == 'wb':
378
raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
379
elif mode == 'r':
380
return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
381
elif mode == 'w':
382
raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
204
383
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]
384
raise BzrError("invalid controlfile mode %r" % mode)
385
386
def put_controlfile(self, path, f, encode=True):
387
"""Write an entry as a controlfile.
388
389
:param path: The path to put the file, relative to the .bzr control
390
directory
391
:param f: A file-like or string object whose contents should be copied.
392
:param encode: If true, encode the contents as utf-8
393
"""
394
self.put_controlfiles([(path, f)], encode=encode)
395
396
def put_controlfiles(self, files, encode=True):
397
"""Write several entries as controlfiles.
398
399
:param files: A list of [(path, file)] pairs, where the path is the directory
400
underneath the bzr control directory
401
:param encode: If true, encode the contents as utf-8
402
"""
403
import codecs
404
ctrl_files = []
405
for path, f in files:
406
if encode:
407
if isinstance(f, basestring):
408
f = f.encode('utf-8', 'replace')
214
409
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
410
f = codecs.getwriter('utf-8')(f, errors='replace')
411
path = self._rel_controlfilename(path)
412
ctrl_files.append((path, f))
413
self._transport.put_multi(ctrl_files)
414
415
def _make_control(self):
416
from bzrlib.inventory import Inventory
417
from bzrlib.weavefile import write_weave_v5
418
from bzrlib.weave import Weave
419
420
# Create an empty inventory
421
sio = StringIO()
422
# if we want per-tree root ids then this is the place to set
423
# them; they're not needed for now and so ommitted for
424
# simplicity.
425
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
426
empty_inv = sio.getvalue()
427
sio = StringIO()
428
bzrlib.weavefile.write_weave_v5(Weave(), sio)
429
empty_weave = sio.getvalue()
430
431
dirs = [[], 'revision-store', 'weaves']
432
files = [('README',
433
"This is a Bazaar-NG control directory.\n"
434
"Do not change any files in this directory.\n"),
435
('branch-format', BZR_BRANCH_FORMAT_5),
436
('revision-history', ''),
437
('branch-name', ''),
438
('branch-lock', ''),
439
('pending-merges', ''),
440
('inventory', empty_inv),
441
('inventory.weave', empty_weave),
442
('ancestry.weave', empty_weave)
443
]
444
cfn = self._rel_controlfilename
445
self._transport.mkdir_multi([cfn(d) for d in dirs])
446
self.put_controlfiles(files)
447
mutter('created control directory in ' + self._transport.base)
448
449
def _check_format(self, relax_version_check):
450
"""Check this branch format is supported.
451
452
The format level is stored, as an integer, in
453
self._branch_format for code that needs to check it later.
454
455
In the future, we might need different in-memory Branch
456
classes to support downlevel branches. But not yet.
457
"""
458
try:
459
fmt = self.controlfile('branch-format', 'r').read()
460
except NoSuchFile:
461
raise NotBranchError(self.base)
462
463
if fmt == BZR_BRANCH_FORMAT_5:
464
self._branch_format = 5
465
elif fmt == BZR_BRANCH_FORMAT_4:
466
self._branch_format = 4
467
468
if (not relax_version_check
469
and self._branch_format != 5):
470
raise BzrError('sorry, branch format %r not supported' % fmt,
471
['use a different bzr version',
472
'or remove the .bzr directory'
473
' and "bzr init" again'])
474
475
def get_root_id(self):
476
"""Return the id of this branches root"""
477
inv = self.read_working_inventory()
478
return inv.root.file_id
479
480
def set_root_id(self, file_id):
481
inv = self.read_working_inventory()
482
orig_root_id = inv.root.file_id
483
del inv._byid[inv.root.file_id]
484
inv.root.file_id = file_id
485
inv._byid[inv.root.file_id] = inv.root
486
for fid in inv:
487
entry = inv[fid]
488
if entry.parent_id in (None, orig_root_id):
489
entry.parent_id = inv.root.file_id
490
self._write_inventory(inv)
491
492
def read_working_inventory(self):
493
"""Read the working inventory."""
494
self.lock_read()
495
try:
496
# ElementTree does its own conversion from UTF-8, so open in
497
# binary.
498
f = self.controlfile('inventory', 'rb')
499
return bzrlib.xml5.serializer_v5.read_inventory(f)
500
finally:
501
self.unlock()
502
503
504
def _write_inventory(self, inv):
505
"""Update the working inventory.
506
507
That is to say, the inventory describing changes underway, that
508
will be committed to the next revision.
509
"""
510
from cStringIO import StringIO
511
self.lock_write()
512
try:
513
sio = StringIO()
514
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
515
sio.seek(0)
516
# Transport handles atomicity
517
self.put_controlfile('inventory', sio)
518
finally:
519
self.unlock()
520
521
mutter('wrote working inventory')
522
523
524
inventory = property(read_working_inventory, _write_inventory, None,
525
"""Inventory for the working copy.""")
526
527
528
def add(self, files, ids=None):
529
"""Make files versioned.
530
531
Note that the command line normally calls smart_add instead,
532
which can automatically recurse.
533
534
This puts the files in the Added state, so that they will be
535
recorded by the next commit.
536
537
files
538
List of paths to add, relative to the base of the tree.
539
540
ids
541
If set, use these instead of automatically generated ids.
542
Must be the same length as the list of files, but may
543
contain None for ids that are to be autogenerated.
544
545
TODO: Perhaps have an option to add the ids even if the files do
546
not (yet) exist.
547
548
TODO: Perhaps yield the ids and paths as they're added.
549
"""
550
# TODO: Re-adding a file that is removed in the working copy
551
# should probably put it back with the previous ID.
552
if isinstance(files, basestring):
553
assert(ids is None or isinstance(ids, basestring))
554
files = [files]
555
if ids is not None:
556
ids = [ids]
557
558
if ids is None:
559
ids = [None] * len(files)
560
else:
561
assert(len(ids) == len(files))
562
563
self.lock_write()
564
try:
565
inv = self.read_working_inventory()
566
for f,file_id in zip(files, ids):
567
if is_control_file(f):
568
raise BzrError("cannot add control file %s" % quotefn(f))
569
570
fp = splitpath(f)
571
572
if len(fp) == 0:
573
raise BzrError("cannot add top-level %r" % f)
574
575
fullpath = os.path.normpath(self.abspath(f))
576
577
try:
578
kind = file_kind(fullpath)
579
except OSError:
580
# maybe something better?
581
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
582
583
if kind != 'file' and kind != 'directory':
584
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
585
586
if file_id is None:
587
file_id = gen_file_id(f)
588
inv.add_path(f, kind=kind, file_id=file_id)
589
590
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
591
592
self._write_inventory(inv)
593
finally:
594
self.unlock()
595
596
597
def print_file(self, file, revno):
598
"""Print `file` to stdout."""
599
self.lock_read()
600
try:
601
tree = self.revision_tree(self.get_rev_id(revno))
602
# use inventory as it was in that revision
603
file_id = tree.inventory.path2id(file)
604
if not file_id:
605
raise BzrError("%r is not present in revision %s" % (file, revno))
606
tree.print_file(file_id)
607
finally:
608
self.unlock()
609
610
611
def remove(self, files, verbose=False):
612
"""Mark nominated files for removal from the inventory.
613
614
This does not remove their text. This does not run on
615
616
TODO: Refuse to remove modified files unless --force is given?
617
618
TODO: Do something useful with directories.
619
620
TODO: Should this remove the text or not? Tough call; not
621
removing may be useful and the user can just use use rm, and
622
is the opposite of add. Removing it is consistent with most
623
other tools. Maybe an option.
624
"""
625
## TODO: Normalize names
626
## TODO: Remove nested loops; better scalability
627
if isinstance(files, basestring):
628
files = [files]
629
630
self.lock_write()
631
632
try:
633
tree = self.working_tree()
634
inv = tree.inventory
635
636
# do this before any modifications
637
for f in files:
638
fid = inv.path2id(f)
639
if not fid:
640
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
641
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
642
if verbose:
643
# having remove it, it must be either ignored or unknown
644
if tree.is_ignored(f):
645
new_status = 'I'
646
else:
647
new_status = '?'
648
show_status(new_status, inv[fid].kind, quotefn(f))
649
del inv[fid]
650
651
self._write_inventory(inv)
652
finally:
653
self.unlock()
654
655
656
# FIXME: this doesn't need to be a branch method
657
def set_inventory(self, new_inventory_list):
658
from bzrlib.inventory import Inventory, InventoryEntry
659
inv = Inventory(self.get_root_id())
660
for path, file_id, parent, kind in new_inventory_list:
661
name = os.path.basename(path)
662
if name == "":
663
continue
664
inv.add(InventoryEntry(file_id, name, kind, parent))
665
self._write_inventory(inv)
666
667
668
def unknowns(self):
669
"""Return all unknown files.
670
671
These are files in the working directory that are not versioned or
672
control files or ignored.
673
674
>>> b = ScratchBranch(files=['foo', 'foo~'])
675
>>> list(b.unknowns())
676
['foo']
677
>>> b.add('foo')
678
>>> list(b.unknowns())
679
[]
680
>>> b.remove('foo')
681
>>> list(b.unknowns())
682
['foo']
683
"""
684
return self.working_tree().unknowns()
685
686
687
def append_revision(self, *revision_ids):
688
for revision_id in revision_ids:
689
mutter("add {%s} to revision-history" % revision_id)
690
691
rev_history = self.revision_history()
692
rev_history.extend(revision_ids)
693
694
self.lock_write()
695
try:
696
self.put_controlfile('revision-history', '\n'.join(rev_history))
697
finally:
698
self.unlock()
699
700
701
def has_revision(self, revision_id):
702
"""True if this branch has a copy of the revision.
703
704
This does not necessarily imply the revision is merge
705
or on the mainline."""
706
return (revision_id is None
707
or revision_id in self.revision_store)
708
709
710
def get_revision_xml_file(self, revision_id):
711
"""Return XML file object for revision object."""
712
if not revision_id or not isinstance(revision_id, basestring):
713
raise InvalidRevisionId(revision_id)
714
715
self.lock_read()
716
try:
717
try:
718
return self.revision_store[revision_id]
719
except (IndexError, KeyError):
720
raise bzrlib.errors.NoSuchRevision(self, revision_id)
721
finally:
722
self.unlock()
723
724
725
def get_revision_xml(self, revision_id):
726
return self.get_revision_xml_file(revision_id).read()
727
728
729
def get_revision(self, revision_id):
730
"""Return the Revision object for a named revision"""
731
xml_file = self.get_revision_xml_file(revision_id)
732
733
try:
734
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
735
except SyntaxError, e:
736
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
737
[revision_id,
738
str(e)])
739
740
assert r.revision_id == revision_id
741
return r
742
259
743
260
744
def get_revision_delta(self, revno):
261
745
"""Return the delta for one revision.
267
751
rh = self.revision_history()
268
752
if not (1 <= revno <= len(rh)):
269
753
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')
754
755
# revno is 1-based; list is 0-based
756
757
new_tree = self.revision_tree(rh[revno-1])
758
if revno == 1:
759
old_tree = EmptyTree()
760
else:
761
old_tree = self.revision_tree(rh[revno-2])
762
763
return compare_trees(old_tree, new_tree)
764
765
def get_revision_sha1(self, revision_id):
766
"""Hash the stored value of a revision, and return it."""
767
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
768
769
770
def _get_ancestry_weave(self):
771
return self.control_weaves.get_weave('ancestry')
772
773
774
def get_ancestry(self, revision_id):
775
"""Return a list of revision-ids integrated by a revision.
776
"""
777
# strip newlines
778
if revision_id is None:
779
return [None]
780
w = self._get_ancestry_weave()
781
return [None] + [l[:-1] for l in w.get_iter(w.lookup(revision_id))]
782
783
784
def get_inventory_weave(self):
785
return self.control_weaves.get_weave('inventory')
786
787
788
def get_inventory(self, revision_id):
789
"""Get Inventory object by hash."""
790
xml = self.get_inventory_xml(revision_id)
791
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
792
793
794
def get_inventory_xml(self, revision_id):
795
"""Get inventory XML as a file object."""
796
try:
797
assert isinstance(revision_id, basestring), type(revision_id)
798
iw = self.get_inventory_weave()
799
return iw.get_text(iw.lookup(revision_id))
800
except IndexError:
801
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
802
803
804
def get_inventory_sha1(self, revision_id):
805
"""Return the sha1 hash of the inventory entry
806
"""
807
return self.get_revision(revision_id).inventory_sha1
808
809
810
def get_revision_inventory(self, revision_id):
811
"""Return inventory of a past revision."""
812
# TODO: Unify this with get_inventory()
813
# bzr 0.0.6 and later imposes the constraint that the inventory_id
814
# must be the same as its revision, so this is trivial.
815
if revision_id == None:
816
return Inventory(self.get_root_id())
817
else:
818
return self.get_inventory(revision_id)
819
285
820
286
821
def revision_history(self):
287
822
"""Return sequence of revision hashes on to this branch."""
288
raise NotImplementedError('revision_history is abstract')
823
self.lock_read()
824
try:
825
return [l.rstrip('\r\n') for l in
826
self.controlfile('revision-history', 'r').readlines()]
827
finally:
828
self.unlock()
829
830
831
def common_ancestor(self, other, self_revno=None, other_revno=None):
832
"""
833
>>> from bzrlib.commit import commit
834
>>> sb = ScratchBranch(files=['foo', 'foo~'])
835
>>> sb.common_ancestor(sb) == (None, None)
836
True
837
>>> commit(sb, "Committing first revision", verbose=False)
838
>>> sb.common_ancestor(sb)[0]
839
1
840
>>> clone = sb.clone()
841
>>> commit(sb, "Committing second revision", verbose=False)
842
>>> sb.common_ancestor(sb)[0]
843
2
844
>>> sb.common_ancestor(clone)[0]
845
1
846
>>> commit(clone, "Committing divergent second revision",
847
... verbose=False)
848
>>> sb.common_ancestor(clone)[0]
849
1
850
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
851
True
852
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
853
True
854
>>> clone2 = sb.clone()
855
>>> sb.common_ancestor(clone2)[0]
856
2
857
>>> sb.common_ancestor(clone2, self_revno=1)[0]
858
1
859
>>> sb.common_ancestor(clone2, other_revno=1)[0]
860
1
861
"""
862
my_history = self.revision_history()
863
other_history = other.revision_history()
864
if self_revno is None:
865
self_revno = len(my_history)
866
if other_revno is None:
867
other_revno = len(other_history)
868
indices = range(min((self_revno, other_revno)))
869
indices.reverse()
870
for r in indices:
871
if my_history[r] == other_history[r]:
872
return r+1, my_history[r]
873
return None, None
874
289
875
290
876
def revno(self):
291
877
"""Return current revision number for this branch.
295
881
"""
296
882
return len(self.revision_history())
297
883
298
def unbind(self):
299
"""Older format branches cannot bind or unbind."""
300
raise errors.UpgradeRequired(self.base)
301
884
302
885
def last_revision(self):
303
"""Return last patch hash, or None if no history."""
886
"""Return last patch hash, or None if no history.
887
"""
304
888
ph = self.revision_history()
305
889
if ph:
306
890
return ph[-1]
307
891
else:
308
892
return None
309
893
310
def missing_revisions(self, other, stop_revision=None):
894
895
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
311
896
"""Return a list of new revisions that would perfectly fit.
312
897
313
898
If self and other have not diverged, return a list of the revisions
314
899
present in other, but missing from self.
900
901
>>> from bzrlib.commit import commit
902
>>> bzrlib.trace.silent = True
903
>>> br1 = ScratchBranch()
904
>>> br2 = ScratchBranch()
905
>>> br1.missing_revisions(br2)
906
[]
907
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
908
>>> br1.missing_revisions(br2)
909
[u'REVISION-ID-1']
910
>>> br2.missing_revisions(br1)
911
[]
912
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
913
>>> br1.missing_revisions(br2)
914
[]
915
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
916
>>> br1.missing_revisions(br2)
917
[u'REVISION-ID-2A']
918
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
919
>>> br1.missing_revisions(br2)
920
Traceback (most recent call last):
921
DivergedBranches: These branches have diverged.
315
922
"""
923
# FIXME: If the branches have diverged, but the latest
924
# revision in this branch is completely merged into the other,
925
# then we should still be able to pull.
316
926
self_history = self.revision_history()
317
927
self_len = len(self_history)
318
928
other_history = other.revision_history()
327
937
else:
328
938
assert isinstance(stop_revision, int)
329
939
if stop_revision > other_len:
330
raise errors.NoSuchRevision(self, stop_revision)
940
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
331
941
return other_history[self_len:stop_revision]
332
942
333
943
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
"""
340
raise NotImplementedError('update_revisions is abstract')
341
944
"""Pull in new perfect-fit revisions."""
945
from bzrlib.fetch import greedy_fetch
946
from bzrlib.revision import get_intervening_revisions
947
if stop_revision is None:
948
stop_revision = other.last_revision()
949
greedy_fetch(to_branch=self, from_branch=other,
950
revision=stop_revision)
951
pullable_revs = self.missing_revisions(
952
other, other.revision_id_to_revno(stop_revision))
953
if pullable_revs:
954
greedy_fetch(to_branch=self,
955
from_branch=other,
956
revision=pullable_revs[-1])
957
self.append_revision(*pullable_revs)
958
959
960
def commit(self, *args, **kw):
961
from bzrlib.commit import Commit
962
Commit().commit(self, *args, **kw)
963
342
964
def revision_id_to_revno(self, revision_id):
343
965
"""Given a revision id, return its revno"""
344
966
if revision_id is None:
359
981
raise bzrlib.errors.NoSuchRevision(self, revno)
360
982
return history[revno - 1]
361
983
362
def pull(self, source, overwrite=False, stop_revision=None):
363
raise NotImplementedError('pull is abstract')
984
def revision_tree(self, revision_id):
985
"""Return Tree for a revision on this branch.
986
987
`revision_id` may be None for the null revision, in which case
988
an `EmptyTree` is returned."""
989
# TODO: refactor this to use an existing revision object
990
# so we don't need to read it in twice.
991
if revision_id == None:
992
return EmptyTree()
993
else:
994
inv = self.get_revision_inventory(revision_id)
995
return RevisionTree(self.weave_store, inv, revision_id)
996
997
998
def working_tree(self):
999
"""Return a `Tree` for the working copy."""
1000
from bzrlib.workingtree import WorkingTree
1001
# TODO: In the future, WorkingTree should utilize Transport
1002
return WorkingTree(self._transport.base, self.read_working_inventory())
1003
364
1004
365
1005
def basis_tree(self):
366
1006
"""Return `Tree` object for last revision.
367
1007
368
1008
If there are no revisions yet, return an `EmptyTree`.
369
1009
"""
370
return self.repository.revision_tree(self.last_revision())
1010
return self.revision_tree(self.last_revision())
1011
371
1012
372
1013
def rename_one(self, from_rel, to_rel):
373
1014
"""Rename one file.
374
1015
375
1016
This can change the directory or the filename or both.
376
1017
"""
377
raise NotImplementedError('rename_one is abstract')
1018
self.lock_write()
1019
try:
1020
tree = self.working_tree()
1021
inv = tree.inventory
1022
if not tree.has_filename(from_rel):
1023
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1024
if tree.has_filename(to_rel):
1025
raise BzrError("can't rename: new working file %r already exists" % to_rel)
1026
1027
file_id = inv.path2id(from_rel)
1028
if file_id == None:
1029
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1030
1031
if inv.path2id(to_rel):
1032
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1033
1034
to_dir, to_tail = os.path.split(to_rel)
1035
to_dir_id = inv.path2id(to_dir)
1036
if to_dir_id == None and to_dir != '':
1037
raise BzrError("can't determine destination directory id for %r" % to_dir)
1038
1039
mutter("rename_one:")
1040
mutter(" file_id {%s}" % file_id)
1041
mutter(" from_rel %r" % from_rel)
1042
mutter(" to_rel %r" % to_rel)
1043
mutter(" to_dir %r" % to_dir)
1044
mutter(" to_dir_id {%s}" % to_dir_id)
1045
1046
inv.rename(file_id, to_dir_id, to_tail)
1047
1048
from_abs = self.abspath(from_rel)
1049
to_abs = self.abspath(to_rel)
1050
try:
1051
rename(from_abs, to_abs)
1052
except OSError, e:
1053
raise BzrError("failed to rename %r to %r: %s"
1054
% (from_abs, to_abs, e[1]),
1055
["rename rolled back"])
1056
1057
self._write_inventory(inv)
1058
finally:
1059
self.unlock()
1060
378
1061
379
1062
def move(self, from_paths, to_name):
380
1063
"""Rename files.
390
1073
This returns a list of (from_path, to_path) pairs for each
391
1074
entry that is moved.
392
1075
"""
393
raise NotImplementedError('move is abstract')
1076
result = []
1077
self.lock_write()
1078
try:
1079
## TODO: Option to move IDs only
1080
assert not isinstance(from_paths, basestring)
1081
tree = self.working_tree()
1082
inv = tree.inventory
1083
to_abs = self.abspath(to_name)
1084
if not isdir(to_abs):
1085
raise BzrError("destination %r is not a directory" % to_abs)
1086
if not tree.has_filename(to_name):
1087
raise BzrError("destination %r not in working directory" % to_abs)
1088
to_dir_id = inv.path2id(to_name)
1089
if to_dir_id == None and to_name != '':
1090
raise BzrError("destination %r is not a versioned directory" % to_name)
1091
to_dir_ie = inv[to_dir_id]
1092
if to_dir_ie.kind not in ('directory', 'root_directory'):
1093
raise BzrError("destination %r is not a directory" % to_abs)
1094
1095
to_idpath = inv.get_idpath(to_dir_id)
1096
1097
for f in from_paths:
1098
if not tree.has_filename(f):
1099
raise BzrError("%r does not exist in working tree" % f)
1100
f_id = inv.path2id(f)
1101
if f_id == None:
1102
raise BzrError("%r is not versioned" % f)
1103
name_tail = splitpath(f)[-1]
1104
dest_path = appendpath(to_name, name_tail)
1105
if tree.has_filename(dest_path):
1106
raise BzrError("destination %r already exists" % dest_path)
1107
if f_id in to_idpath:
1108
raise BzrError("can't move %r to a subdirectory of itself" % f)
1109
1110
# OK, so there's a race here, it's possible that someone will
1111
# create a file in this interval and then the rename might be
1112
# left half-done. But we should have caught most problems.
1113
1114
for f in from_paths:
1115
name_tail = splitpath(f)[-1]
1116
dest_path = appendpath(to_name, name_tail)
1117
result.append((f, dest_path))
1118
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1119
try:
1120
rename(self.abspath(f), self.abspath(dest_path))
1121
except OSError, e:
1122
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1123
["rename rolled back"])
1124
1125
self._write_inventory(inv)
1126
finally:
1127
self.unlock()
1128
1129
return result
1130
1131
1132
def revert(self, filenames, old_tree=None, backups=True):
1133
"""Restore selected files to the versions from a previous tree.
1134
1135
backups
1136
If true (default) backups are made of files before
1137
they're renamed.
1138
"""
1139
from bzrlib.errors import NotVersionedError, BzrError
1140
from bzrlib.atomicfile import AtomicFile
1141
from bzrlib.osutils import backup_file
1142
1143
inv = self.read_working_inventory()
1144
if old_tree is None:
1145
old_tree = self.basis_tree()
1146
old_inv = old_tree.inventory
1147
1148
nids = []
1149
for fn in filenames:
1150
file_id = inv.path2id(fn)
1151
if not file_id:
1152
raise NotVersionedError("not a versioned file", fn)
1153
if not old_inv.has_id(file_id):
1154
raise BzrError("file not present in old tree", fn, file_id)
1155
nids.append((fn, file_id))
1156
1157
# TODO: Rename back if it was previously at a different location
1158
1159
# TODO: If given a directory, restore the entire contents from
1160
# the previous version.
1161
1162
# TODO: Make a backup to a temporary file.
1163
1164
# TODO: If the file previously didn't exist, delete it?
1165
for fn, file_id in nids:
1166
backup_file(fn)
1167
1168
f = AtomicFile(fn, 'wb')
1169
try:
1170
f.write(old_tree.get_file(file_id).read())
1171
f.commit()
1172
finally:
1173
f.close()
1174
1175
1176
def pending_merges(self):
1177
"""Return a list of pending merges.
1178
1179
These are revisions that have been merged into the working
1180
directory but not yet committed.
1181
"""
1182
cfn = self._rel_controlfilename('pending-merges')
1183
if not self._transport.has(cfn):
1184
return []
1185
p = []
1186
for l in self.controlfile('pending-merges', 'r').readlines():
1187
p.append(l.rstrip('\n'))
1188
return p
1189
1190
1191
def add_pending_merge(self, *revision_ids):
1192
# TODO: Perhaps should check at this point that the
1193
# history of the revision is actually present?
1194
for rev_id in revision_ids:
1195
validate_revision_id(rev_id)
1196
1197
p = self.pending_merges()
1198
updated = False
1199
for rev_id in revision_ids:
1200
if rev_id in p:
1201
continue
1202
p.append(rev_id)
1203
updated = True
1204
if updated:
1205
self.set_pending_merges(p)
1206
1207
def set_pending_merges(self, rev_list):
1208
self.lock_write()
1209
try:
1210
self.put_controlfile('pending-merges', '\n'.join(rev_list))
1211
finally:
1212
self.unlock()
1213
394
1214
395
1215
def get_parent(self):
396
1216
"""Return the parent location of the branch.
399
1219
pattern is that the user can override it by specifying a
400
1220
location.
401
1221
"""
402
raise NotImplementedError('get_parent is abstract')
403
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
def get_push_location(self):
423
"""Return the None or the location to push this branch to."""
424
raise NotImplementedError('get_push_location is abstract')
425
426
def set_push_location(self, location):
427
"""Set a new push location for this branch."""
428
raise NotImplementedError('set_push_location is abstract')
1222
import errno
1223
_locs = ['parent', 'pull', 'x-pull']
1224
for l in _locs:
1225
try:
1226
return self.controlfile(l, 'r').read().strip('\n')
1227
except IOError, e:
1228
if e.errno != errno.ENOENT:
1229
raise
1230
return None
1231
429
1232
430
1233
def set_parent(self, url):
431
raise NotImplementedError('set_parent is abstract')
432
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
1234
# TODO: Maybe delete old location files?
1235
from bzrlib.atomicfile import AtomicFile
1236
self.lock_write()
1237
try:
1238
f = AtomicFile(self.controlfilename('parent'))
1239
try:
1240
f.write(url + '\n')
1241
f.commit()
1242
finally:
1243
f.close()
1244
finally:
1245
self.unlock()
440
1246
441
1247
def check_revno(self, revno):
442
1248
"""\
453
1259
"""
454
1260
if revno < 1 or revno > self.revno():
455
1261
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
]
855
856
class BzrBranch(Branch):
857
"""A branch stored in the actual filesystem.
858
859
Note that it's "local" in the context of the filesystem; it doesn't
860
really matter if it's on an nfs/smb/afs/coda/... share, as long as
861
it's writable, and can be accessed via the normal filesystem API.
862
"""
1262
1263
1264
1265
1266
1267
class ScratchBranch(_Branch):
1268
"""Special test class: a branch that cleans up after itself.
1269
1270
>>> b = ScratchBranch()
1271
>>> isdir(b.base)
1272
True
1273
>>> bd = b.base
1274
>>> b.destroy()
1275
>>> isdir(bd)
1276
False
1277
"""
1278
def __init__(self, files=[], dirs=[], base=None):
1279
"""Make a test branch.
1280
1281
This creates a temporary directory and runs init-tree in it.
1282
1283
If any files are listed, they are created in the working copy.
1284
"""
1285
from tempfile import mkdtemp
1286
init = False
1287
if base is None:
1288
base = mkdtemp()
1289
init = True
1290
if isinstance(base, basestring):
1291
base = get_transport(base)
1292
_Branch.__init__(self, base, init=init)
1293
for d in dirs:
1294
self._transport.mkdir(d)
1295
1296
for f in files:
1297
self._transport.put(f, 'content of %s' % f)
1298
1299
1300
def clone(self):
1301
"""
1302
>>> orig = ScratchBranch(files=["file1", "file2"])
1303
>>> clone = orig.clone()
1304
>>> if os.name != 'nt':
1305
... os.path.samefile(orig.base, clone.base)
1306
... else:
1307
... orig.base == clone.base
1308
...
1309
False
1310
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1311
True
1312
"""
1313
from shutil import copytree
1314
from tempfile import mkdtemp
1315
base = mkdtemp()
1316
os.rmdir(base)
1317
copytree(self.base, base, symlinks=True)
1318
return ScratchBranch(base=base)
1319
1320
1321
1322
def __del__(self):
1323
self.destroy()
1324
1325
def destroy(self):
1326
"""Destroy the test branch, removing the scratch directory."""
1327
from shutil import rmtree
1328
try:
1329
if self.base:
1330
mutter("delete ScratchBranch %s" % self.base)
1331
rmtree(self.base)
1332
except OSError, e:
1333
# Work around for shutil.rmtree failing on Windows when
1334
# readonly files are encountered
1335
mutter("hit exception in destroying ScratchBranch: %s" % e)
1336
for root, dirs, files in os.walk(self.base, topdown=False):
1337
for name in files:
1338
os.chmod(os.path.join(root, name), 0700)
1339
rmtree(self.base)
1340
self._transport = None
1341
863
1342
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):
867
"""Create new branch object at a particular location.
868
869
transport -- A Transport object, defining how to access files.
870
871
init -- If True, create new control files in a previously
872
unversioned directory. If False, the branch must already
873
be versioned.
874
875
relax_version_check -- If true, the usual check for the branch
876
version is not applied. This is intended only for
877
upgrade/recovery type use; it's not guaranteed that
878
all operations will work on old format branches.
879
"""
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
917
918
def __str__(self):
919
return '%s(%r)' % (self.__class__.__name__, self.base)
920
921
__repr__ = __str__
922
923
def __del__(self):
924
# TODO: It might be best to do this somewhere else,
925
# but it is nice for a Branch object to automatically
926
# cache it's information.
927
# Alternatively, we could have the Transport objects cache requests
928
# See the earlier discussion about how major objects (like Branch)
929
# should never expect their __del__ function to run.
930
# XXX: cache_root seems to be unused, 2006-01-13 mbp
931
if hasattr(self, 'cache_root') and self.cache_root is not None:
932
try:
933
osutils.rmtree(self.cache_root)
934
except:
935
pass
936
self.cache_root = None
937
938
def _get_base(self):
939
return self._base
940
941
base = property(_get_base, doc="The URL for the root of this branch.")
942
943
def _finish_transaction(self):
944
"""Exit the current transaction."""
945
return self.control_files._finish_transaction()
946
947
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):
963
"""Set a new active transaction."""
964
return self.control_files._set_transaction(transaction)
965
966
def abspath(self, name):
967
"""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.
980
"""
981
if format is None:
982
format = BranchFormat.find_format(self.bzrdir)
983
self._format = format
984
mutter("got branch format %s", self._format)
985
986
@needs_read_lock
987
def get_root_id(self):
988
"""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
# TODO: test for failed two phase locks. This is known broken.
997
self.control_files.lock_write()
998
self.repository.lock_write()
999
1000
def lock_read(self):
1001
# TODO: test for failed two phase locks. This is known broken.
1002
self.control_files.lock_read()
1003
self.repository.lock_read()
1004
1005
def unlock(self):
1006
# TODO: test for failed two phase locks. This is known broken.
1007
try:
1008
self.repository.unlock()
1009
finally:
1010
self.control_files.unlock()
1011
1012
def peek_lock_mode(self):
1013
if self.control_files._lock_count == 0:
1014
return None
1015
else:
1016
return self.control_files._lock_mode
1017
1018
def get_physical_lock_status(self):
1019
return self.control_files.get_physical_lock_status()
1020
1021
@needs_read_lock
1022
def print_file(self, file, revision_id):
1023
"""See Branch.print_file."""
1024
return self.repository.print_file(file, revision_id)
1025
1026
@needs_write_lock
1027
def append_revision(self, *revision_ids):
1028
"""See Branch.append_revision."""
1029
for revision_id in revision_ids:
1030
mutter("add {%s} to revision-history" % revision_id)
1031
rev_history = self.revision_history()
1032
rev_history.extend(revision_ids)
1033
self.set_revision_history(rev_history)
1034
1035
@needs_write_lock
1036
def set_revision_history(self, rev_history):
1037
"""See Branch.set_revision_history."""
1038
self.control_files.put_utf8(
1039
'revision-history', '\n'.join(rev_history))
1040
transaction = self.get_transaction()
1041
history = transaction.map.find_revision_history()
1042
if history is not None:
1043
# update the revision history in the identity map.
1044
history[:] = list(rev_history)
1045
# this call is disabled because revision_history is
1046
# not really an object yet, and the transaction is for objects.
1047
# transaction.register_dirty(history)
1048
else:
1049
transaction.map.add_revision_history(rev_history)
1050
# this call is disabled because revision_history is
1051
# not really an object yet, and the transaction is for objects.
1052
# transaction.register_clean(history)
1053
1054
@needs_read_lock
1055
def revision_history(self):
1056
"""See Branch.revision_history."""
1057
transaction = self.get_transaction()
1058
history = transaction.map.find_revision_history()
1059
if history is not None:
1060
mutter("cache hit for revision-history in %s", self)
1061
return list(history)
1062
history = [l.rstrip('\r\n') for l in
1063
self.control_files.get_utf8('revision-history').readlines()]
1064
transaction.map.add_revision_history(history)
1065
# this call is disabled because revision_history is
1066
# not really an object yet, and the transaction is for objects.
1067
# transaction.register_clean(history, precious=True)
1068
return list(history)
1069
1070
@needs_write_lock
1071
def generate_revision_history(self, revision_id, last_rev=None,
1072
other_branch=None):
1073
"""Create a new revision history that will finish with revision_id.
1074
1075
:param revision_id: the new tip to use.
1076
:param last_rev: The previous last_revision. If not None, then this
1077
must be a ancestory of revision_id, or DivergedBranches is raised.
1078
:param other_branch: The other branch that DivergedBranches should
1079
raise with respect to.
1080
"""
1081
# stop_revision must be a descendant of last_revision
1082
stop_graph = self.repository.get_revision_graph(revision_id)
1083
if last_rev is not None and last_rev not in stop_graph:
1084
# our previous tip is not merged into stop_revision
1085
raise errors.DivergedBranches(self, other_branch)
1086
# make a new revision history from the graph
1087
current_rev_id = revision_id
1088
new_history = []
1089
while current_rev_id not in (None, revision.NULL_REVISION):
1090
new_history.append(current_rev_id)
1091
current_rev_id_parents = stop_graph[current_rev_id]
1092
try:
1093
current_rev_id = current_rev_id_parents[0]
1094
except IndexError:
1095
current_rev_id = None
1096
new_history.reverse()
1097
self.set_revision_history(new_history)
1098
1099
@needs_write_lock
1100
def update_revisions(self, other, stop_revision=None):
1101
"""See Branch.update_revisions."""
1102
other.lock_read()
1103
try:
1104
if stop_revision is None:
1105
stop_revision = other.last_revision()
1106
if stop_revision is None:
1107
# if there are no commits, we're done.
1108
return
1109
# whats the current last revision, before we fetch [and change it
1110
# possibly]
1111
last_rev = self.last_revision()
1112
# we fetch here regardless of whether we need to so that we pickup
1113
# filled in ghosts.
1114
self.fetch(other, stop_revision)
1115
my_ancestry = self.repository.get_ancestry(last_rev)
1116
if stop_revision in my_ancestry:
1117
# last_revision is a descendant of stop_revision
1118
return
1119
self.generate_revision_history(stop_revision, last_rev=last_rev,
1120
other_branch=other)
1121
finally:
1122
other.unlock()
1123
1124
def basis_tree(self):
1125
"""See Branch.basis_tree."""
1126
return self.repository.revision_tree(self.last_revision())
1127
1128
@deprecated_method(zero_eight)
1129
def working_tree(self):
1130
"""Create a Working tree object for this branch."""
1131
1132
from bzrlib.transport.local import LocalTransport
1133
if (self.base.find('://') != -1 or
1134
not isinstance(self._transport, LocalTransport)):
1135
raise NoWorkingTree(self.base)
1136
return self.bzrdir.open_workingtree()
1137
1138
@needs_write_lock
1139
def pull(self, source, overwrite=False, stop_revision=None):
1140
"""See Branch.pull."""
1141
source.lock_read()
1142
try:
1143
old_count = len(self.revision_history())
1144
try:
1145
self.update_revisions(source,stop_revision)
1146
except DivergedBranches:
1147
if not overwrite:
1148
raise
1149
if overwrite:
1150
self.set_revision_history(source.revision_history())
1151
new_count = len(self.revision_history())
1152
return new_count - old_count
1153
finally:
1154
source.unlock()
1155
1156
def get_parent(self):
1157
"""See Branch.get_parent."""
1158
1159
_locs = ['parent', 'pull', 'x-pull']
1160
assert self.base[-1] == '/'
1161
for l in _locs:
1162
try:
1163
parent = self.control_files.get(l).read().strip('\n')
1164
except NoSuchFile:
1165
continue
1166
# This is an old-format absolute path to a local branch
1167
# turn it into a url
1168
if parent.startswith('/'):
1169
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1170
return urlutils.join(self.base[:-1], parent)
1171
return None
1172
1173
def get_push_location(self):
1174
"""See Branch.get_push_location."""
1175
push_loc = self.get_config().get_user_option('push_location')
1176
return push_loc
1177
1178
def set_push_location(self, location):
1179
"""See Branch.set_push_location."""
1180
self.get_config().set_user_option('push_location', location,
1181
local=True)
1182
1183
@needs_write_lock
1184
def set_parent(self, url):
1185
"""See Branch.set_parent."""
1186
# TODO: Maybe delete old location files?
1187
# URLs should never be unicode, even on the local fs,
1188
# FIXUP this and get_parent in a future branch format bump:
1189
# read and rewrite the file, and have the new format code read
1190
# using .get not .get_utf8. RBC 20060125
1191
if url is None:
1192
self.control_files._transport.delete('parent')
1193
else:
1194
if isinstance(url, unicode):
1195
try:
1196
url = url.encode('ascii')
1197
except UnicodeEncodeError:
1198
raise bzrlib.errors.InvalidURL(url,
1199
"Urls must be 7-bit ascii, "
1200
"use bzrlib.urlutils.escape")
1201
1202
url = urlutils.relative_url(self.base, url)
1203
self.control_files.put('parent', url + '\n')
1204
1205
@deprecated_function(zero_nine)
1206
def tree_config(self):
1207
"""DEPRECATED; call get_config instead.
1208
TreeConfig has become part of BranchConfig."""
1209
return TreeConfig(self)
1210
1211
1212
class BzrBranch5(BzrBranch):
1213
"""A format 5 branch. This supports new features over plan branches.
1214
1215
It has support for a master_branch which is the data for bound branches.
1216
"""
1217
1218
def __init__(self,
1219
_format,
1220
_control_files,
1221
a_bzrdir,
1222
_repository):
1223
super(BzrBranch5, self).__init__(_format=_format,
1224
_control_files=_control_files,
1225
a_bzrdir=a_bzrdir,
1226
_repository=_repository)
1227
1228
@needs_write_lock
1229
def pull(self, source, overwrite=False, stop_revision=None):
1230
"""Updates branch.pull to be bound branch aware."""
1231
bound_location = self.get_bound_location()
1232
if source.base != bound_location:
1233
# not pulling from master, so we need to update master.
1234
master_branch = self.get_master_branch()
1235
if master_branch:
1236
master_branch.pull(source)
1237
source = master_branch
1238
return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1239
1240
def get_bound_location(self):
1241
try:
1242
return self.control_files.get_utf8('bound').read()[:-1]
1243
except errors.NoSuchFile:
1244
return None
1245
1246
@needs_read_lock
1247
def get_master_branch(self):
1248
"""Return the branch we are bound to.
1249
1250
:return: Either a Branch, or None
1251
1252
This could memoise the branch, but if thats done
1253
it must be revalidated on each new lock.
1254
So for now we just don't memoise it.
1255
# RBC 20060304 review this decision.
1256
"""
1257
bound_loc = self.get_bound_location()
1258
if not bound_loc:
1259
return None
1260
try:
1261
return Branch.open(bound_loc)
1262
except (errors.NotBranchError, errors.ConnectionError), e:
1263
raise errors.BoundBranchConnectionFailure(
1264
self, bound_loc, e)
1265
1266
@needs_write_lock
1267
def set_bound_location(self, location):
1268
"""Set the target where this branch is bound to.
1269
1270
:param location: URL to the target branch
1271
"""
1272
if location:
1273
self.control_files.put_utf8('bound', location+'\n')
1274
else:
1275
try:
1276
self.control_files._transport.delete('bound')
1277
except NoSuchFile:
1278
return False
1343
1344
######################################################################
1345
# predicates
1346
1347
1348
def is_control_file(filename):
1349
## FIXME: better check
1350
filename = os.path.normpath(filename)
1351
while filename != '':
1352
head, tail = os.path.split(filename)
1353
## mutter('check %r for control file' % ((head, tail), ))
1354
if tail == bzrlib.BZRDIR:
1279
1355
return True
1280
1281
@needs_write_lock
1282
def bind(self, other):
1283
"""Bind the local branch the other branch.
1284
1285
:param other: The branch to bind to
1286
:type other: Branch
1287
"""
1288
# TODO: jam 20051230 Consider checking if the target is bound
1289
# It is debatable whether you should be able to bind to
1290
# a branch which is itself bound.
1291
# Committing is obviously forbidden,
1292
# but binding itself may not be.
1293
# Since we *have* to check at commit time, we don't
1294
# *need* to check here
1295
self.pull(other)
1296
1297
# we are now equal to or a suffix of other.
1298
1299
# Since we have 'pulled' from the remote location,
1300
# now we should try to pull in the opposite direction
1301
# in case the local tree has more revisions than the
1302
# remote one.
1303
# There may be a different check you could do here
1304
# rather than actually trying to install revisions remotely.
1305
# TODO: capture an exception which indicates the remote branch
1306
# is not writable.
1307
# If it is up-to-date, this probably should not be a failure
1308
1309
# lock other for write so the revision-history syncing cannot race
1310
other.lock_write()
1311
try:
1312
other.pull(self)
1313
# if this does not error, other now has the same last rev we do
1314
# it can only error if the pull from other was concurrent with
1315
# a commit to other from someone else.
1316
1317
# until we ditch revision-history, we need to sync them up:
1318
self.set_revision_history(other.revision_history())
1319
# now other and self are up to date with each other and have the
1320
# same revision-history.
1321
finally:
1322
other.unlock()
1323
1324
self.set_bound_location(other.base)
1325
1326
@needs_write_lock
1327
def unbind(self):
1328
"""If bound, unbind"""
1329
return self.set_bound_location(None)
1330
1331
@needs_write_lock
1332
def update(self):
1333
"""Synchronise this branch with the master branch if any.
1334
1335
:return: None or the last_revision that was pivoted out during the
1336
update.
1337
"""
1338
master = self.get_master_branch()
1339
if master is not None:
1340
old_tip = self.last_revision()
1341
self.pull(master, overwrite=True)
1342
if old_tip in self.repository.get_ancestry(self.last_revision()):
1343
return None
1344
return old_tip
1345
return None
1346
1347
1348
class BranchTestProviderAdapter(object):
1349
"""A tool to generate a suite testing multiple branch formats at once.
1350
1351
This is done by copying the test once for each transport and injecting
1352
the transport_server, transport_readonly_server, and branch_format
1353
classes into each copy. Each copy is also given a new id() to make it
1354
easy to identify.
1355
"""
1356
1357
def __init__(self, transport_server, transport_readonly_server, formats):
1358
self._transport_server = transport_server
1359
self._transport_readonly_server = transport_readonly_server
1360
self._formats = formats
1361
1362
def adapt(self, test):
1363
result = TestSuite()
1364
for branch_format, bzrdir_format in self._formats:
1365
new_test = deepcopy(test)
1366
new_test.transport_server = self._transport_server
1367
new_test.transport_readonly_server = self._transport_readonly_server
1368
new_test.bzrdir_format = bzrdir_format
1369
new_test.branch_format = branch_format
1370
def make_new_test_id():
1371
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1372
return lambda: new_id
1373
new_test.id = make_new_test_id()
1374
result.addTest(new_test)
1375
return result
1376
1377
1378
class BranchCheckResult(object):
1379
"""Results of checking branch consistency.
1380
1381
:see: Branch.check
1382
"""
1383
1384
def __init__(self, branch):
1385
self.branch = branch
1386
1387
def report_results(self, verbose):
1388
"""Report the check results via trace.note.
1389
1390
:param verbose: Requests more detailed display of what was checked,
1391
if any.
1392
"""
1393
note('checked branch %s format %s',
1394
self.branch.base,
1395
self.branch._format)
1396
1397
1398
######################################################################
1399
# predicates
1400
1401
1402
@deprecated_function(zero_eight)
1403
def is_control_file(*args, **kwargs):
1404
"""See bzrlib.workingtree.is_control_file."""
1405
return bzrlib.workingtree.is_control_file(*args, **kwargs)
1356
if filename == head:
1357
break
1358
filename = head
1359
return False
1360
1361
1362
1363
def gen_file_id(name):
1364
"""Return new file id.
1365
1366
This should probably generate proper UUIDs, but for the moment we
1367
cope with just randomness because running uuidgen every time is
1368
slow."""
1369
import re
1370
from binascii import hexlify
1371
from time import time
1372
1373
# get last component
1374
idx = name.rfind('/')
1375
if idx != -1:
1376
name = name[idx+1 : ]
1377
idx = name.rfind('\\')
1378
if idx != -1:
1379
name = name[idx+1 : ]
1380
1381
# make it not a hidden file
1382
name = name.lstrip('.')
1383
1384
# remove any wierd characters; we don't escape them but rather
1385
# just pull them out
1386
name = re.sub(r'[^\w.]', '', name)
1387
1388
s = hexlify(rand_bytes(8))
1389
return '-'.join((name, compact_date(time()), s))
1390
1391
1392
def gen_root_id():
1393
"""Return a new tree-root file id."""
1394
return gen_file_id('TREE_ROOT')
1395
1396
Loggerhead is a web-based interface for Breezy
Version: 2.0.1