« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1185.16.80
- compare with another revision
- download diff
- download tarball
- view history from revision 1185.16.80
- Committer: Martin Pool
- Date: 2005-10-19 07:04:01 UTC
- mto: (1185.41.1 bzr.sftp) (1534.1.1 integration) (1495.1.4) (1505.1.16 bzr-bound-branch) (1508.1.15) (1526.1.3 run_tests_twice_for_i18n) (1540.1.3 bzr.dev (Main development branch)) (1685.1.1 bzr-encoding) (1553.5.1 bzr.dev (Main development branch)) (1608.2.1 bzr.mbp.escape-stores)
- mto: This revision was merged to the branch mainline in revision 1473.
- Revision ID: mbp@sourcefrog.net-20051019070401-0536bd80d1282c7f
Update news and readme
- better explanation of dependencies
- better explanation of dependencies
- files added:
- HACKING
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- contrib/emacs
- files removed:
- bzrlib/meta_store.py
- plugins/changeset
- files renamed:
- plugins/ => bzrlib/plugins/
- tools/testweave.py => bzrlib/selftest/test_weave.py
- bzrlib/store.py => bzrlib/store/__init__.py
- effbot/ => bzrlib/util/effbot/
- elementtree/ => bzrlib/util/elementtree/
- urlgrabber/ => bzrlib/util/urlgrabber/
- bzrlib/newinventory.py => contrib/newinventory.py
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/branch.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
import sys, os
18
import sys
19
import os
20
import errno
21
from warnings import warn
22
from cStringIO import StringIO
23
19
24
20
25
import bzrlib
26
from bzrlib.inventory import InventoryEntry
27
import bzrlib.inventory as inventory
21
28
from bzrlib.trace import mutter, note
22
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, splitpath, \
23
sha_file, appendpath, file_kind
24
from bzrlib.errors import BzrError
25
26
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
29
from bzrlib.osutils import (isdir, quotefn, compact_date, rand_bytes,
30
rename, splitpath, sha_file, appendpath,
31
file_kind, abspath)
32
import bzrlib.errors as errors
33
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
34
NoSuchRevision, HistoryMissing, NotBranchError,
35
DivergedBranches, LockError, UnlistableStore,
36
UnlistableBranch, NoSuchFile, NotVersionedError)
37
from bzrlib.textui import show_status
38
from bzrlib.revision import Revision, is_ancestor, get_intervening_revisions
39
40
from bzrlib.delta import compare_trees
41
from bzrlib.tree import EmptyTree, RevisionTree
42
from bzrlib.inventory import Inventory
43
from bzrlib.store import copy_all
44
from bzrlib.store.compressed_text import CompressedTextStore
45
from bzrlib.store.text import TextStore
46
from bzrlib.store.weave import WeaveStore
47
from bzrlib.testament import Testament
48
import bzrlib.transactions as transactions
49
from bzrlib.transport import Transport, get_transport
50
import bzrlib.xml5
51
import bzrlib.ui
52
53
54
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
55
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
56
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
27
57
## TODO: Maybe include checks for common corruption of newlines, etc?
28
58
29
59
30
31
def find_branch(f, **args):
32
if f and (f.startswith('http://') or f.startswith('https://')):
33
import remotebranch
34
return remotebranch.RemoteBranch(f, **args)
35
else:
36
return Branch(f, **args)
37
38
39
def find_cached_branch(f, cache_root, **args):
40
from remotebranch import RemoteBranch
41
br = find_branch(f, **args)
42
def cacheify(br, store_name):
43
from meta_store import CachedStore
44
cache_path = os.path.join(cache_root, store_name)
45
os.mkdir(cache_path)
46
new_store = CachedStore(getattr(br, store_name), cache_path)
47
setattr(br, store_name, new_store)
48
49
if isinstance(br, RemoteBranch):
50
cacheify(br, 'inventory_store')
51
cacheify(br, 'text_store')
52
cacheify(br, 'revision_store')
53
return br
54
55
56
def _relpath(base, path):
57
"""Return path relative to base, or raise exception.
58
59
The path may be either an absolute path or a path relative to the
60
current working directory.
61
62
Lifted out of Branch.relpath for ease of testing.
63
64
os.path.commonprefix (python2.4) has a bad bug that it works just
65
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
66
avoids that problem."""
67
rp = os.path.abspath(path)
68
69
s = []
70
head = rp
71
while len(head) >= len(base):
72
if head == base:
73
break
74
head, tail = os.path.split(head)
75
if tail:
76
s.insert(0, tail)
77
else:
78
from errors import NotBranchError
79
raise NotBranchError("path %r is not within branch %r" % (rp, base))
80
81
return os.sep.join(s)
82
83
84
def find_branch_root(f=None):
85
"""Find the branch root enclosing f, or pwd.
86
87
f may be a filename or a URL.
88
89
It is not necessary that f exists.
90
91
Basically we keep looking up until we find the control directory or
92
run into the root."""
93
if f == None:
94
f = os.getcwd()
95
elif hasattr(os.path, 'realpath'):
96
f = os.path.realpath(f)
97
else:
98
f = os.path.abspath(f)
99
if not os.path.exists(f):
100
raise BzrError('%r does not exist' % f)
101
102
103
orig_f = f
104
105
while True:
106
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
107
return f
108
head, tail = os.path.split(f)
109
if head == f:
110
# reached the root, whatever that may be
111
raise BzrError('%r is not in a branch' % orig_f)
112
f = head
113
114
class DivergedBranches(Exception):
115
def __init__(self, branch1, branch2):
116
self.branch1 = branch1
117
self.branch2 = branch2
118
Exception.__init__(self, "These branches have diverged.")
119
120
121
class NoSuchRevision(BzrError):
122
def __init__(self, branch, revision):
123
self.branch = branch
124
self.revision = revision
125
msg = "Branch %s has no revision %d" % (branch, revision)
126
BzrError.__init__(self, msg)
127
60
# TODO: Some operations like log might retrieve the same revisions
61
# repeatedly to calculate deltas. We could perhaps have a weakref
62
# cache in memory to make this faster. In general anything can be
63
# cached in memory between lock and unlock operations.
64
65
def find_branch(*ignored, **ignored_too):
66
# XXX: leave this here for about one release, then remove it
67
raise NotImplementedError('find_branch() is not supported anymore, '
68
'please use one of the new branch constructors')
69
70
71
def needs_read_lock(unbound):
72
"""Decorate unbound to take out and release a read lock."""
73
def decorated(self, *args, **kwargs):
74
self.lock_read()
75
try:
76
return unbound(self, *args, **kwargs)
77
finally:
78
self.unlock()
79
return decorated
80
81
82
def needs_write_lock(unbound):
83
"""Decorate unbound to take out and release a write lock."""
84
def decorated(self, *args, **kwargs):
85
self.lock_write()
86
try:
87
return unbound(self, *args, **kwargs)
88
finally:
89
self.unlock()
90
return decorated
128
91
129
92
######################################################################
130
93
# branch objects
133
96
"""Branch holding a history of revisions.
134
97
135
98
base
136
Base directory of the branch.
99
Base directory/url of the branch.
100
"""
101
base = None
102
103
def __init__(self, *ignored, **ignored_too):
104
raise NotImplementedError('The Branch class is abstract')
105
106
@staticmethod
107
def open_downlevel(base):
108
"""Open a branch which may be of an old format.
109
110
Only local branches are supported."""
111
return _Branch(get_transport(base), relax_version_check=True)
112
113
@staticmethod
114
def open(base):
115
"""Open an existing branch, rooted at 'base' (url)"""
116
t = get_transport(base)
117
mutter("trying to open %r with transport %r", base, t)
118
return _Branch(t)
119
120
@staticmethod
121
def open_containing(url):
122
"""Open an existing branch which contains url.
123
124
This probes for a branch at url, and searches upwards from there.
125
126
Basically we keep looking up until we find the control directory or
127
run into the root. If there isn't one, raises NotBranchError.
128
If there is one, it is returned, along with the unused portion of url.
129
"""
130
t = get_transport(url)
131
while True:
132
try:
133
return _Branch(t), t.relpath(url)
134
except NotBranchError:
135
pass
136
new_t = t.clone('..')
137
if new_t.base == t.base:
138
# reached the root, whatever that may be
139
raise NotBranchError(path=url)
140
t = new_t
141
142
@staticmethod
143
def initialize(base):
144
"""Create a new branch, rooted at 'base' (url)"""
145
t = get_transport(base)
146
return _Branch(t, init=True)
147
148
def setup_caching(self, cache_root):
149
"""Subclasses that care about caching should override this, and set
150
up cached stores located under cache_root.
151
"""
152
self.cache_root = cache_root
153
154
155
class _Branch(Branch):
156
"""A branch stored in the actual filesystem.
157
158
Note that it's "local" in the context of the filesystem; it doesn't
159
really matter if it's on an nfs/smb/afs/coda/... share, as long as
160
it's writable, and can be accessed via the normal filesystem API.
137
161
138
162
_lock_mode
139
163
None, or 'r' or 'w'
145
169
_lock
146
170
Lock object from bzrlib.lock.
147
171
"""
148
base = None
172
# We actually expect this class to be somewhat short-lived; part of its
173
# purpose is to try to isolate what bits of the branch logic are tied to
174
# filesystem access, so that in a later step, we can extricate them to
175
# a separarte ("storage") class.
149
176
_lock_mode = None
150
177
_lock_count = None
151
178
_lock = None
179
_inventory_weave = None
152
180
153
def __init__(self, base, init=False, find_root=True):
181
# Map some sort of prefix into a namespace
182
# stuff like "revno:10", "revid:", etc.
183
# This should match a prefix with a function which accepts
184
REVISION_NAMESPACES = {}
185
186
def push_stores(self, branch_to):
187
"""Copy the content of this branches store to branch_to."""
188
if (self._branch_format != branch_to._branch_format
189
or self._branch_format != 4):
190
from bzrlib.fetch import greedy_fetch
191
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
192
self, self._branch_format, branch_to, branch_to._branch_format)
193
greedy_fetch(to_branch=branch_to, from_branch=self,
194
revision=self.last_revision())
195
return
196
197
store_pairs = ((self.text_store, branch_to.text_store),
198
(self.inventory_store, branch_to.inventory_store),
199
(self.revision_store, branch_to.revision_store))
200
try:
201
for from_store, to_store in store_pairs:
202
copy_all(from_store, to_store)
203
except UnlistableStore:
204
raise UnlistableBranch(from_store)
205
206
def __init__(self, transport, init=False,
207
relax_version_check=False):
154
208
"""Create new branch object at a particular location.
155
209
156
base -- Base directory for the branch.
210
transport -- A Transport object, defining how to access files.
211
(If a string, transport.transport() will be used to
212
create a Transport object)
157
213
158
214
init -- If True, create new control files in a previously
159
215
unversioned directory. If False, the branch must already
160
216
be versioned.
161
217
162
find_root -- If true and init is false, find the root of the
163
existing branch containing base.
218
relax_version_check -- If true, the usual check for the branch
219
version is not applied. This is intended only for
220
upgrade/recovery type use; it's not guaranteed that
221
all operations will work on old format branches.
164
222
165
223
In the test suite, creation of new trees is tested using the
166
224
`ScratchBranch` class.
167
225
"""
168
from bzrlib.store import ImmutableStore
226
assert isinstance(transport, Transport), \
227
"%r is not a Transport" % transport
228
self._transport = transport
169
229
if init:
170
self.base = os.path.realpath(base)
171
230
self._make_control()
172
elif find_root:
173
self.base = find_branch_root(base)
174
else:
175
self.base = os.path.realpath(base)
176
if not isdir(self.controlfilename('.')):
177
from errors import NotBranchError
178
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
179
['use "bzr init" to initialize a new working tree',
180
'current bzr can only operate from top-of-tree'])
181
self._check_format()
182
183
self.text_store = ImmutableStore(self.controlfilename('text-store'))
184
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
185
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
186
231
self._check_format(relax_version_check)
232
233
def get_store(name, compressed=True, prefixed=False):
234
# FIXME: This approach of assuming stores are all entirely compressed
235
# or entirely uncompressed is tidy, but breaks upgrade from
236
# some existing branches where there's a mixture; we probably
237
# still want the option to look for both.
238
relpath = self._rel_controlfilename(name)
239
if compressed:
240
store = CompressedTextStore(self._transport.clone(relpath),
241
prefixed=prefixed)
242
else:
243
store = TextStore(self._transport.clone(relpath),
244
prefixed=prefixed)
245
#if self._transport.should_cache():
246
# cache_path = os.path.join(self.cache_root, name)
247
# os.mkdir(cache_path)
248
# store = bzrlib.store.CachedStore(store, cache_path)
249
return store
250
def get_weave(name, prefixed=False):
251
relpath = self._rel_controlfilename(name)
252
ws = WeaveStore(self._transport.clone(relpath), prefixed=prefixed)
253
if self._transport.should_cache():
254
ws.enable_cache = True
255
return ws
256
257
if self._branch_format == 4:
258
self.inventory_store = get_store('inventory-store')
259
self.text_store = get_store('text-store')
260
self.revision_store = get_store('revision-store')
261
elif self._branch_format == 5:
262
self.control_weaves = get_weave([])
263
self.weave_store = get_weave('weaves')
264
self.revision_store = get_store('revision-store', compressed=False)
265
elif self._branch_format == 6:
266
self.control_weaves = get_weave([])
267
self.weave_store = get_weave('weaves', prefixed=True)
268
self.revision_store = get_store('revision-store', compressed=False,
269
prefixed=True)
270
self.revision_store.register_suffix('sig')
271
self._transaction = None
187
272
188
273
def __str__(self):
189
return '%s(%r)' % (self.__class__.__name__, self.base)
274
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
190
275
191
276
192
277
__repr__ = __str__
194
279
195
280
def __del__(self):
196
281
if self._lock_mode or self._lock:
197
from warnings import warn
282
# XXX: This should show something every time, and be suitable for
283
# headless operation and embedding
198
284
warn("branch %r was not explicitly unlocked" % self)
199
285
self._lock.unlock()
200
286
201
287
# TODO: It might be best to do this somewhere else,
288
# but it is nice for a Branch object to automatically
289
# cache it's information.
290
# Alternatively, we could have the Transport objects cache requests
291
# See the earlier discussion about how major objects (like Branch)
292
# should never expect their __del__ function to run.
293
if hasattr(self, 'cache_root') and self.cache_root is not None:
294
try:
295
import shutil
296
shutil.rmtree(self.cache_root)
297
except:
298
pass
299
self.cache_root = None
300
301
def _get_base(self):
302
if self._transport:
303
return self._transport.base
304
return None
305
306
base = property(_get_base, doc="The URL for the root of this branch.")
307
308
def _finish_transaction(self):
309
"""Exit the current transaction."""
310
if self._transaction is None:
311
raise errors.LockError('Branch %s is not in a transaction' %
312
self)
313
transaction = self._transaction
314
self._transaction = None
315
transaction.finish()
316
317
def get_transaction(self):
318
"""Return the current active transaction.
319
320
If no transaction is active, this returns a passthrough object
321
for which all data is immedaitely flushed and no caching happens.
322
"""
323
if self._transaction is None:
324
return transactions.PassThroughTransaction()
325
else:
326
return self._transaction
327
328
def _set_transaction(self, new_transaction):
329
"""Set a new active transaction."""
330
if self._transaction is not None:
331
raise errors.LockError('Branch %s is in a transaction already.' %
332
self)
333
self._transaction = new_transaction
202
334
203
335
def lock_write(self):
336
mutter("lock write: %s (%s)", self, self._lock_count)
337
# TODO: Upgrade locking to support using a Transport,
338
# and potentially a remote locking protocol
204
339
if self._lock_mode:
205
340
if self._lock_mode != 'w':
206
from errors import LockError
207
341
raise LockError("can't upgrade to a write lock from %r" %
208
342
self._lock_mode)
209
343
self._lock_count += 1
210
344
else:
211
from bzrlib.lock import WriteLock
212
213
self._lock = WriteLock(self.controlfilename('branch-lock'))
345
self._lock = self._transport.lock_write(
346
self._rel_controlfilename('branch-lock'))
214
347
self._lock_mode = 'w'
215
348
self._lock_count = 1
216
217
349
self._set_transaction(transactions.PassThroughTransaction())
218
350
219
351
def lock_read(self):
352
mutter("lock read: %s (%s)", self, self._lock_count)
220
353
if self._lock_mode:
221
354
assert self._lock_mode in ('r', 'w'), \
222
355
"invalid lock mode %r" % self._lock_mode
223
356
self._lock_count += 1
224
357
else:
225
from bzrlib.lock import ReadLock
226
227
self._lock = ReadLock(self.controlfilename('branch-lock'))
358
self._lock = self._transport.lock_read(
359
self._rel_controlfilename('branch-lock'))
228
360
self._lock_mode = 'r'
229
361
self._lock_count = 1
362
self._set_transaction(transactions.ReadOnlyTransaction())
363
# 5K may be excessive, but hey, its a knob.
364
self.get_transaction().set_cache_size(5000)
230
365
231
232
233
366
def unlock(self):
367
mutter("unlock: %s (%s)", self, self._lock_count)
234
368
if not self._lock_mode:
235
from errors import LockError
236
369
raise LockError('branch %r is not locked' % (self))
237
370
238
371
if self._lock_count > 1:
239
372
self._lock_count -= 1
240
373
else:
374
self._finish_transaction()
241
375
self._lock.unlock()
242
376
self._lock = None
243
377
self._lock_mode = self._lock_count = None
244
378
245
246
379
def abspath(self, name):
247
"""Return absolute filename for something in the branch"""
248
return os.path.join(self.base, name)
249
250
251
def relpath(self, path):
252
"""Return path relative to this branch of something inside it.
253
254
Raises an error if path is not in this branch."""
255
return _relpath(self.base, path)
256
380
"""Return absolute filename for something in the branch
381
382
XXX: Robert Collins 20051017 what is this used for? why is it a branch
383
method and not a tree method.
384
"""
385
return self._transport.abspath(name)
386
387
def _rel_controlfilename(self, file_or_path):
388
if isinstance(file_or_path, basestring):
389
file_or_path = [file_or_path]
390
return [bzrlib.BZRDIR] + file_or_path
257
391
258
392
def controlfilename(self, file_or_path):
259
393
"""Return location relative to branch."""
260
if isinstance(file_or_path, basestring):
261
file_or_path = [file_or_path]
262
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
394
return self._transport.abspath(self._rel_controlfilename(file_or_path))
263
395
264
396
265
397
def controlfile(self, file_or_path, mode='r'):
273
405
Controlfiles should almost never be opened in write mode but
274
406
rather should be atomically copied and replaced using atomicfile.
275
407
"""
276
277
fn = self.controlfilename(file_or_path)
278
279
if mode == 'rb' or mode == 'wb':
280
return file(fn, mode)
281
elif mode == 'r' or mode == 'w':
282
# open in binary mode anyhow so there's no newline translation;
283
# codecs uses line buffering by default; don't want that.
284
import codecs
285
return codecs.open(fn, mode + 'b', 'utf-8',
286
buffering=60000)
408
import codecs
409
410
relpath = self._rel_controlfilename(file_or_path)
411
#TODO: codecs.open() buffers linewise, so it was overloaded with
412
# a much larger buffer, do we need to do the same for getreader/getwriter?
413
if mode == 'rb':
414
return self._transport.get(relpath)
415
elif mode == 'wb':
416
raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
417
elif mode == 'r':
418
return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
419
elif mode == 'w':
420
raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
287
421
else:
288
422
raise BzrError("invalid controlfile mode %r" % mode)
289
423
290
424
def put_controlfile(self, path, f, encode=True):
425
"""Write an entry as a controlfile.
426
427
:param path: The path to put the file, relative to the .bzr control
428
directory
429
:param f: A file-like or string object whose contents should be copied.
430
:param encode: If true, encode the contents as utf-8
431
"""
432
self.put_controlfiles([(path, f)], encode=encode)
433
434
def put_controlfiles(self, files, encode=True):
435
"""Write several entries as controlfiles.
436
437
:param files: A list of [(path, file)] pairs, where the path is the directory
438
underneath the bzr control directory
439
:param encode: If true, encode the contents as utf-8
440
"""
441
import codecs
442
ctrl_files = []
443
for path, f in files:
444
if encode:
445
if isinstance(f, basestring):
446
f = f.encode('utf-8', 'replace')
447
else:
448
f = codecs.getwriter('utf-8')(f, errors='replace')
449
path = self._rel_controlfilename(path)
450
ctrl_files.append((path, f))
451
self._transport.put_multi(ctrl_files)
291
452
292
453
def _make_control(self):
293
454
from bzrlib.inventory import Inventory
294
from bzrlib.xml import pack_xml
455
from bzrlib.weavefile import write_weave_v5
456
from bzrlib.weave import Weave
295
457
296
os.mkdir(self.controlfilename([]))
297
self.controlfile('README', 'w').write(
458
# Create an empty inventory
459
sio = StringIO()
460
# if we want per-tree root ids then this is the place to set
461
# them; they're not needed for now and so ommitted for
462
# simplicity.
463
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
464
empty_inv = sio.getvalue()
465
sio = StringIO()
466
bzrlib.weavefile.write_weave_v5(Weave(), sio)
467
empty_weave = sio.getvalue()
468
469
dirs = [[], 'revision-store', 'weaves']
470
files = [('README',
298
471
"This is a Bazaar-NG control directory.\n"
299
"Do not change any files in this directory.\n")
300
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
301
for d in ('text-store', 'inventory-store', 'revision-store'):
302
os.mkdir(self.controlfilename(d))
303
for f in ('revision-history', 'merged-patches',
304
'pending-merged-patches', 'branch-name',
305
'branch-lock',
306
'pending-merges'):
307
self.controlfile(f, 'w').write('')
308
mutter('created control directory in ' + self.base)
309
310
pack_xml(Inventory(), self.controlfile('inventory','w'))
311
312
313
def _check_format(self):
472
"Do not change any files in this directory.\n"),
473
('branch-format', BZR_BRANCH_FORMAT_6),
474
('revision-history', ''),
475
('branch-name', ''),
476
('branch-lock', ''),
477
('pending-merges', ''),
478
('inventory', empty_inv),
479
('inventory.weave', empty_weave),
480
('ancestry.weave', empty_weave)
481
]
482
cfn = self._rel_controlfilename
483
self._transport.mkdir_multi([cfn(d) for d in dirs])
484
self.put_controlfiles(files)
485
mutter('created control directory in ' + self._transport.base)
486
487
def _check_format(self, relax_version_check):
314
488
"""Check this branch format is supported.
315
489
316
The current tool only supports the current unstable format.
490
The format level is stored, as an integer, in
491
self._branch_format for code that needs to check it later.
317
492
318
493
In the future, we might need different in-memory Branch
319
494
classes to support downlevel branches. But not yet.
320
495
"""
321
# This ignores newlines so that we can open branches created
322
# on Windows from Linux and so on. I think it might be better
323
# to always make all internal files in unix format.
324
fmt = self.controlfile('branch-format', 'r').read()
325
fmt.replace('\r\n', '')
326
if fmt != BZR_BRANCH_FORMAT:
327
raise BzrError('sorry, branch format %r not supported' % fmt,
496
try:
497
fmt = self.controlfile('branch-format', 'r').read()
498
except NoSuchFile:
499
raise NotBranchError(path=self.base)
500
mutter("got branch format %r", fmt)
501
if fmt == BZR_BRANCH_FORMAT_6:
502
self._branch_format = 6
503
elif fmt == BZR_BRANCH_FORMAT_5:
504
self._branch_format = 5
505
elif fmt == BZR_BRANCH_FORMAT_4:
506
self._branch_format = 4
507
508
if (not relax_version_check
509
and self._branch_format not in (5, 6)):
510
raise errors.UnsupportedFormatError(
511
'sorry, branch format %r not supported' % fmt,
328
512
['use a different bzr version',
329
'or remove the .bzr directory and "bzr init" again'])
330
331
332
513
'or remove the .bzr directory'
514
' and "bzr init" again'])
515
516
def get_root_id(self):
517
"""Return the id of this branches root"""
518
inv = self.read_working_inventory()
519
return inv.root.file_id
520
521
def set_root_id(self, file_id):
522
inv = self.read_working_inventory()
523
orig_root_id = inv.root.file_id
524
del inv._byid[inv.root.file_id]
525
inv.root.file_id = file_id
526
inv._byid[inv.root.file_id] = inv.root
527
for fid in inv:
528
entry = inv[fid]
529
if entry.parent_id in (None, orig_root_id):
530
entry.parent_id = inv.root.file_id
531
self._write_inventory(inv)
532
533
@needs_read_lock
333
534
def read_working_inventory(self):
334
535
"""Read the working inventory."""
335
from bzrlib.inventory import Inventory
336
from bzrlib.xml import unpack_xml
337
from time import time
338
before = time()
339
self.lock_read()
340
try:
341
# ElementTree does its own conversion from UTF-8, so open in
342
# binary.
343
inv = unpack_xml(Inventory,
344
self.controlfile('inventory', 'rb'))
345
mutter("loaded inventory of %d items in %f"
346
% (len(inv), time() - before))
347
return inv
348
finally:
349
self.unlock()
350
536
# ElementTree does its own conversion from UTF-8, so open in
537
# binary.
538
f = self.controlfile('inventory', 'rb')
539
return bzrlib.xml5.serializer_v5.read_inventory(f)
351
540
541
@needs_write_lock
352
542
def _write_inventory(self, inv):
353
543
"""Update the working inventory.
354
544
355
545
That is to say, the inventory describing changes underway, that
356
546
will be committed to the next revision.
357
547
"""
358
from bzrlib.atomicfile import AtomicFile
359
from bzrlib.xml import pack_xml
360
361
self.lock_write()
362
try:
363
f = AtomicFile(self.controlfilename('inventory'), 'wb')
364
try:
365
pack_xml(inv, f)
366
f.commit()
367
finally:
368
f.close()
369
finally:
370
self.unlock()
548
from cStringIO import StringIO
549
sio = StringIO()
550
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
551
sio.seek(0)
552
# Transport handles atomicity
553
self.put_controlfile('inventory', sio)
371
554
372
555
mutter('wrote working inventory')
373
556
374
375
557
inventory = property(read_working_inventory, _write_inventory, None,
376
558
"""Inventory for the working copy.""")
377
559
378
379
def add(self, files, verbose=False, ids=None):
560
@needs_write_lock
561
def add(self, files, ids=None):
380
562
"""Make files versioned.
381
563
382
Note that the command line normally calls smart_add instead.
564
Note that the command line normally calls smart_add instead,
565
which can automatically recurse.
383
566
384
567
This puts the files in the Added state, so that they will be
385
568
recorded by the next commit.
395
578
TODO: Perhaps have an option to add the ids even if the files do
396
579
not (yet) exist.
397
580
398
TODO: Perhaps return the ids of the files? But then again it
399
is easy to retrieve them if they're needed.
400
401
TODO: Adding a directory should optionally recurse down and
402
add all non-ignored children. Perhaps do that in a
403
higher-level method.
581
TODO: Perhaps yield the ids and paths as they're added.
404
582
"""
405
from bzrlib.textui import show_status
406
583
# TODO: Re-adding a file that is removed in the working copy
407
584
# should probably put it back with the previous ID.
408
585
if isinstance(files, basestring):
416
593
else:
417
594
assert(len(ids) == len(files))
418
595
419
self.lock_write()
420
try:
421
inv = self.read_working_inventory()
422
for f,file_id in zip(files, ids):
423
if is_control_file(f):
424
raise BzrError("cannot add control file %s" % quotefn(f))
425
426
fp = splitpath(f)
427
428
if len(fp) == 0:
429
raise BzrError("cannot add top-level %r" % f)
430
431
fullpath = os.path.normpath(self.abspath(f))
432
433
try:
434
kind = file_kind(fullpath)
435
except OSError:
436
# maybe something better?
437
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
438
439
if kind != 'file' and kind != 'directory':
440
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
441
442
if file_id is None:
443
file_id = gen_file_id(f)
444
inv.add_path(f, kind=kind, file_id=file_id)
445
446
if verbose:
447
print 'added', quotefn(f)
448
449
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
450
451
self._write_inventory(inv)
452
finally:
453
self.unlock()
454
455
596
inv = self.read_working_inventory()
597
for f,file_id in zip(files, ids):
598
if is_control_file(f):
599
raise BzrError("cannot add control file %s" % quotefn(f))
600
601
fp = splitpath(f)
602
603
if len(fp) == 0:
604
raise BzrError("cannot add top-level %r" % f)
605
606
fullpath = os.path.normpath(self.abspath(f))
607
608
try:
609
kind = file_kind(fullpath)
610
except OSError:
611
# maybe something better?
612
raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
613
614
if not InventoryEntry.versionable_kind(kind):
615
raise BzrError('cannot add: not a versionable file ('
616
'i.e. regular file, symlink or directory): %s' % quotefn(f))
617
618
if file_id is None:
619
file_id = gen_file_id(f)
620
inv.add_path(f, kind=kind, file_id=file_id)
621
622
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
623
624
self._write_inventory(inv)
625
626
@needs_read_lock
456
627
def print_file(self, file, revno):
457
628
"""Print `file` to stdout."""
458
self.lock_read()
459
try:
460
tree = self.revision_tree(self.lookup_revision(revno))
461
# use inventory as it was in that revision
462
file_id = tree.inventory.path2id(file)
463
if not file_id:
464
raise BzrError("%r is not present in revision %d" % (file, revno))
465
tree.print_file(file_id)
466
finally:
467
self.unlock()
468
469
470
def remove(self, files, verbose=False):
471
"""Mark nominated files for removal from the inventory.
472
473
This does not remove their text. This does not run on
474
475
TODO: Refuse to remove modified files unless --force is given?
476
477
TODO: Do something useful with directories.
478
479
TODO: Should this remove the text or not? Tough call; not
480
removing may be useful and the user can just use use rm, and
481
is the opposite of add. Removing it is consistent with most
482
other tools. Maybe an option.
483
"""
484
from bzrlib.textui import show_status
485
## TODO: Normalize names
486
## TODO: Remove nested loops; better scalability
487
if isinstance(files, basestring):
488
files = [files]
489
490
self.lock_write()
491
492
try:
493
tree = self.working_tree()
494
inv = tree.inventory
495
496
# do this before any modifications
497
for f in files:
498
fid = inv.path2id(f)
499
if not fid:
500
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
501
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
502
if verbose:
503
# having remove it, it must be either ignored or unknown
504
if tree.is_ignored(f):
505
new_status = 'I'
506
else:
507
new_status = '?'
508
show_status(new_status, inv[fid].kind, quotefn(f))
509
del inv[fid]
510
511
self._write_inventory(inv)
512
finally:
513
self.unlock()
514
629
tree = self.revision_tree(self.get_rev_id(revno))
630
# use inventory as it was in that revision
631
file_id = tree.inventory.path2id(file)
632
if not file_id:
633
raise BzrError("%r is not present in revision %s" % (file, revno))
634
tree.print_file(file_id)
515
635
516
636
# FIXME: this doesn't need to be a branch method
517
637
def set_inventory(self, new_inventory_list):
518
638
from bzrlib.inventory import Inventory, InventoryEntry
519
inv = Inventory()
639
inv = Inventory(self.get_root_id())
520
640
for path, file_id, parent, kind in new_inventory_list:
521
641
name = os.path.basename(path)
522
642
if name == "":
523
643
continue
524
inv.add(InventoryEntry(file_id, name, kind, parent))
644
# fixme, there should be a factory function inv,add_??
645
if kind == 'directory':
646
inv.add(inventory.InventoryDirectory(file_id, name, parent))
647
elif kind == 'file':
648
inv.add(inventory.InventoryFile(file_id, name, parent))
649
elif kind == 'symlink':
650
inv.add(inventory.InventoryLink(file_id, name, parent))
651
else:
652
raise BzrError("unknown kind %r" % kind)
525
653
self._write_inventory(inv)
526
654
527
528
655
def unknowns(self):
529
656
"""Return all unknown files.
530
657
531
658
These are files in the working directory that are not versioned or
532
659
control files or ignored.
533
660
661
>>> from bzrlib.workingtree import WorkingTree
534
662
>>> b = ScratchBranch(files=['foo', 'foo~'])
535
>>> list(b.unknowns())
663
>>> map(str, b.unknowns())
536
664
['foo']
537
665
>>> b.add('foo')
538
666
>>> list(b.unknowns())
539
667
[]
540
>>> b.remove('foo')
668
>>> WorkingTree(b.base, b).remove('foo')
541
669
>>> list(b.unknowns())
542
670
['foo']
543
671
"""
544
672
return self.working_tree().unknowns()
545
673
546
547
def append_revision(self, revision_id):
548
from bzrlib.atomicfile import AtomicFile
549
550
mutter("add {%s} to revision-history" % revision_id)
551
rev_history = self.revision_history() + [revision_id]
552
553
f = AtomicFile(self.controlfilename('revision-history'))
674
@needs_write_lock
675
def append_revision(self, *revision_ids):
676
for revision_id in revision_ids:
677
mutter("add {%s} to revision-history" % revision_id)
678
rev_history = self.revision_history()
679
rev_history.extend(revision_ids)
680
self.put_controlfile('revision-history', '\n'.join(rev_history))
681
682
def has_revision(self, revision_id):
683
"""True if this branch has a copy of the revision.
684
685
This does not necessarily imply the revision is merge
686
or on the mainline."""
687
return (revision_id is None
688
or self.revision_store.has_id(revision_id))
689
690
@needs_read_lock
691
def get_revision_xml_file(self, revision_id):
692
"""Return XML file object for revision object."""
693
if not revision_id or not isinstance(revision_id, basestring):
694
raise InvalidRevisionId(revision_id)
554
695
try:
555
for rev_id in rev_history:
556
print >>f, rev_id
557
f.commit()
558
finally:
559
f.close()
696
return self.revision_store.get(revision_id)
697
except (IndexError, KeyError):
698
raise bzrlib.errors.NoSuchRevision(self, revision_id)
699
700
#deprecated
701
get_revision_xml = get_revision_xml_file
702
703
def get_revision_xml(self, revision_id):
704
return self.get_revision_xml_file(revision_id).read()
560
705
561
706
562
707
def get_revision(self, revision_id):
563
708
"""Return the Revision object for a named revision"""
564
from bzrlib.revision import Revision
565
from bzrlib.xml import unpack_xml
709
xml_file = self.get_revision_xml_file(revision_id)
566
710
567
self.lock_read()
568
711
try:
569
if not revision_id or not isinstance(revision_id, basestring):
570
raise ValueError('invalid revision-id: %r' % revision_id)
571
r = unpack_xml(Revision, self.revision_store[revision_id])
572
finally:
573
self.unlock()
712
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
713
except SyntaxError, e:
714
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
715
[revision_id,
716
str(e)])
574
717
575
718
assert r.revision_id == revision_id
576
719
return r
577
720
721
def get_revision_delta(self, revno):
722
"""Return the delta for one revision.
723
724
The delta is relative to its mainline predecessor, or the
725
empty tree for revision 1.
726
"""
727
assert isinstance(revno, int)
728
rh = self.revision_history()
729
if not (1 <= revno <= len(rh)):
730
raise InvalidRevisionNumber(revno)
731
732
# revno is 1-based; list is 0-based
733
734
new_tree = self.revision_tree(rh[revno-1])
735
if revno == 1:
736
old_tree = EmptyTree()
737
else:
738
old_tree = self.revision_tree(rh[revno-2])
739
740
return compare_trees(old_tree, new_tree)
578
741
579
742
def get_revision_sha1(self, revision_id):
580
743
"""Hash the stored value of a revision, and return it."""
584
747
# the revision, (add signatures/remove signatures) and still
585
748
# have all hash pointers stay consistent.
586
749
# But for now, just hash the contents.
587
return sha_file(self.revision_store[revision_id])
588
589
590
def get_inventory(self, inventory_id):
591
"""Get Inventory object by hash.
592
593
TODO: Perhaps for this and similar methods, take a revision
594
parameter which can be either an integer revno or a
595
string hash."""
596
from bzrlib.inventory import Inventory
597
from bzrlib.xml import unpack_xml
598
599
return unpack_xml(Inventory, self.inventory_store[inventory_id])
600
601
602
def get_inventory_sha1(self, inventory_id):
750
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
751
752
def get_ancestry(self, revision_id):
753
"""Return a list of revision-ids integrated by a revision.
754
755
This currently returns a list, but the ordering is not guaranteed:
756
treat it as a set.
757
"""
758
if revision_id is None:
759
return [None]
760
w = self.get_inventory_weave()
761
return [None] + map(w.idx_to_name,
762
w.inclusions([w.lookup(revision_id)]))
763
764
def get_inventory_weave(self):
765
return self.control_weaves.get_weave('inventory',
766
self.get_transaction())
767
768
def get_inventory(self, revision_id):
769
"""Get Inventory object by hash."""
770
xml = self.get_inventory_xml(revision_id)
771
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
772
773
def get_inventory_xml(self, revision_id):
774
"""Get inventory XML as a file object."""
775
try:
776
assert isinstance(revision_id, basestring), type(revision_id)
777
iw = self.get_inventory_weave()
778
return iw.get_text(iw.lookup(revision_id))
779
except IndexError:
780
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
781
782
def get_inventory_sha1(self, revision_id):
603
783
"""Return the sha1 hash of the inventory entry
604
784
"""
605
return sha_file(self.inventory_store[inventory_id])
606
785
return self.get_revision(revision_id).inventory_sha1
607
786
608
787
def get_revision_inventory(self, revision_id):
609
788
"""Return inventory of a past revision."""
610
# bzr 0.0.6 imposes the constraint that the inventory_id
789
# TODO: Unify this with get_inventory()
790
# bzr 0.0.6 and later imposes the constraint that the inventory_id
611
791
# must be the same as its revision, so this is trivial.
612
792
if revision_id == None:
613
from bzrlib.inventory import Inventory
614
return Inventory()
793
return Inventory(self.get_root_id())
615
794
else:
616
795
return self.get_inventory(revision_id)
617
796
618
797
@needs_read_lock
619
798
def revision_history(self):
620
"""Return sequence of revision hashes on to this branch.
621
622
>>> ScratchBranch().revision_history()
623
[]
624
"""
625
self.lock_read()
626
try:
627
return [l.rstrip('\r\n') for l in
628
self.controlfile('revision-history', 'r').readlines()]
629
finally:
630
self.unlock()
631
632
633
def common_ancestor(self, other, self_revno=None, other_revno=None):
634
"""
635
>>> import commit
636
>>> sb = ScratchBranch(files=['foo', 'foo~'])
637
>>> sb.common_ancestor(sb) == (None, None)
638
True
639
>>> commit.commit(sb, "Committing first revision", verbose=False)
640
>>> sb.common_ancestor(sb)[0]
641
1
642
>>> clone = sb.clone()
643
>>> commit.commit(sb, "Committing second revision", verbose=False)
644
>>> sb.common_ancestor(sb)[0]
645
2
646
>>> sb.common_ancestor(clone)[0]
647
1
648
>>> commit.commit(clone, "Committing divergent second revision",
649
... verbose=False)
650
>>> sb.common_ancestor(clone)[0]
651
1
652
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
653
True
654
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
655
True
656
>>> clone2 = sb.clone()
657
>>> sb.common_ancestor(clone2)[0]
658
2
659
>>> sb.common_ancestor(clone2, self_revno=1)[0]
660
1
661
>>> sb.common_ancestor(clone2, other_revno=1)[0]
662
1
663
"""
664
my_history = self.revision_history()
665
other_history = other.revision_history()
666
if self_revno is None:
667
self_revno = len(my_history)
668
if other_revno is None:
669
other_revno = len(other_history)
670
indices = range(min((self_revno, other_revno)))
671
indices.reverse()
672
for r in indices:
673
if my_history[r] == other_history[r]:
674
return r+1, my_history[r]
675
return None, None
676
677
def enum_history(self, direction):
678
"""Return (revno, revision_id) for history of branch.
679
680
direction
681
'forward' is from earliest to latest
682
'reverse' is from latest to earliest
683
"""
684
rh = self.revision_history()
685
if direction == 'forward':
686
i = 1
687
for rid in rh:
688
yield i, rid
689
i += 1
690
elif direction == 'reverse':
691
i = len(rh)
692
while i > 0:
693
yield i, rh[i-1]
694
i -= 1
695
else:
696
raise ValueError('invalid history direction', direction)
697
799
"""Return sequence of revision hashes on to this branch."""
800
transaction = self.get_transaction()
801
history = transaction.map.find_revision_history()
802
if history is not None:
803
mutter("cache hit for revision-history in %s", self)
804
return list(history)
805
history = [l.rstrip('\r\n') for l in
806
self.controlfile('revision-history', 'r').readlines()]
807
transaction.map.add_revision_history(history)
808
# this call is disabled because revision_history is
809
# not really an object yet, and the transaction is for objects.
810
# transaction.register_clean(history, precious=True)
811
return list(history)
698
812
699
813
def revno(self):
700
814
"""Return current revision number for this branch.
704
818
"""
705
819
return len(self.revision_history())
706
820
707
708
def last_patch(self):
821
def last_revision(self):
709
822
"""Return last patch hash, or None if no history.
710
823
"""
711
824
ph = self.revision_history()
714
827
else:
715
828
return None
716
829
717
718
def missing_revisions(self, other, stop_revision=None):
719
"""
830
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
831
"""Return a list of new revisions that would perfectly fit.
832
720
833
If self and other have not diverged, return a list of the revisions
721
834
present in other, but missing from self.
722
835
753
866
754
867
if stop_revision is None:
755
868
stop_revision = other_len
756
elif stop_revision > other_len:
757
raise NoSuchRevision(self, stop_revision)
758
869
else:
870
assert isinstance(stop_revision, int)
871
if stop_revision > other_len:
872
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
759
873
return other_history[self_len:stop_revision]
760
874
761
762
875
def update_revisions(self, other, stop_revision=None):
763
"""Pull in all new revisions from other branch.
764
765
>>> from bzrlib.commit import commit
766
>>> bzrlib.trace.silent = True
767
>>> br1 = ScratchBranch(files=['foo', 'bar'])
768
>>> br1.add('foo')
769
>>> br1.add('bar')
770
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
771
>>> br2 = ScratchBranch()
772
>>> br2.update_revisions(br1)
773
Added 2 texts.
774
Added 1 inventories.
775
Added 1 revisions.
776
>>> br2.revision_history()
777
[u'REVISION-ID-1']
778
>>> br2.update_revisions(br1)
779
Added 0 texts.
780
Added 0 inventories.
781
Added 0 revisions.
782
>>> br1.text_store.total_size() == br2.text_store.total_size()
783
True
784
"""
785
from bzrlib.progress import ProgressBar
876
"""Pull in new perfect-fit revisions."""
877
# FIXME: If the branches have diverged, but the latest
878
# revision in this branch is completely merged into the other,
879
# then we should still be able to pull.
880
from bzrlib.fetch import greedy_fetch
881
if stop_revision is None:
882
stop_revision = other.last_revision()
883
### Should this be checking is_ancestor instead of revision_history?
884
if (stop_revision is not None and
885
stop_revision in self.revision_history()):
886
return
887
greedy_fetch(to_branch=self, from_branch=other,
888
revision=stop_revision)
889
pullable_revs = self.pullable_revisions(other, stop_revision)
890
if len(pullable_revs) > 0:
891
self.append_revision(*pullable_revs)
892
893
def pullable_revisions(self, other, stop_revision):
894
other_revno = other.revision_id_to_revno(stop_revision)
786
895
try:
787
set
788
except NameError:
789
from sets import Set as set
790
791
pb = ProgressBar()
792
793
pb.update('comparing histories')
794
revision_ids = self.missing_revisions(other, stop_revision)
795
796
if hasattr(other.revision_store, "prefetch"):
797
other.revision_store.prefetch(revision_ids)
798
if hasattr(other.inventory_store, "prefetch"):
799
inventory_ids = [other.get_revision(r).inventory_id
800
for r in revision_ids]
801
other.inventory_store.prefetch(inventory_ids)
802
803
revisions = []
804
needed_texts = set()
805
i = 0
806
for rev_id in revision_ids:
807
i += 1
808
pb.update('fetching revision', i, len(revision_ids))
809
rev = other.get_revision(rev_id)
810
revisions.append(rev)
811
inv = other.get_inventory(str(rev.inventory_id))
812
for key, entry in inv.iter_entries():
813
if entry.text_id is None:
814
continue
815
if entry.text_id not in self.text_store:
816
needed_texts.add(entry.text_id)
817
818
pb.clear()
819
820
count = self.text_store.copy_multi(other.text_store, needed_texts)
821
print "Added %d texts." % count
822
inventory_ids = [ f.inventory_id for f in revisions ]
823
count = self.inventory_store.copy_multi(other.inventory_store,
824
inventory_ids)
825
print "Added %d inventories." % count
826
revision_ids = [ f.revision_id for f in revisions]
827
count = self.revision_store.copy_multi(other.revision_store,
828
revision_ids)
829
for revision_id in revision_ids:
830
self.append_revision(revision_id)
831
print "Added %d revisions." % count
832
896
return self.missing_revisions(other, other_revno)
897
except DivergedBranches, e:
898
try:
899
pullable_revs = get_intervening_revisions(self.last_revision(),
900
stop_revision, self)
901
assert self.last_revision() not in pullable_revs
902
return pullable_revs
903
except bzrlib.errors.NotAncestor:
904
if is_ancestor(self.last_revision(), stop_revision, self):
905
return []
906
else:
907
raise e
833
908
834
909
def commit(self, *args, **kw):
835
from bzrlib.commit import commit
836
commit(self, *args, **kw)
837
910
from bzrlib.commit import Commit
911
Commit().commit(self, *args, **kw)
912
913
def revision_id_to_revno(self, revision_id):
914
"""Given a revision id, return its revno"""
915
if revision_id is None:
916
return 0
917
history = self.revision_history()
918
try:
919
return history.index(revision_id) + 1
920
except ValueError:
921
raise bzrlib.errors.NoSuchRevision(self, revision_id)
838
922
839
def lookup_revision(self, revno):
840
"""Return revision hash for revision number."""
923
def get_rev_id(self, revno, history=None):
924
"""Find the revision id of the specified revno."""
841
925
if revno == 0:
842
926
return None
843
844
try:
845
# list is 0-based; revisions are 1-based
846
return self.revision_history()[revno-1]
847
except IndexError:
848
raise BzrError("no such revision %s" % revno)
849
927
if history is None:
928
history = self.revision_history()
929
elif revno <= 0 or revno > len(history):
930
raise bzrlib.errors.NoSuchRevision(self, revno)
931
return history[revno - 1]
850
932
851
933
def revision_tree(self, revision_id):
852
934
"""Return Tree for a revision on this branch.
853
935
854
936
`revision_id` may be None for the null revision, in which case
855
937
an `EmptyTree` is returned."""
856
from bzrlib.tree import EmptyTree, RevisionTree
857
938
# TODO: refactor this to use an existing revision object
858
939
# so we don't need to read it in twice.
859
940
if revision_id == None:
860
941
return EmptyTree()
861
942
else:
862
943
inv = self.get_revision_inventory(revision_id)
863
return RevisionTree(self.text_store, inv)
864
944
return RevisionTree(self.weave_store, inv, revision_id)
865
945
866
946
def working_tree(self):
867
947
"""Return a `Tree` for the working copy."""
868
from workingtree import WorkingTree
869
return WorkingTree(self.base, self.read_working_inventory())
948
from bzrlib.workingtree import WorkingTree
949
# TODO: In the future, perhaps WorkingTree should utilize Transport
950
# RobertCollins 20051003 - I don't think it should - working trees are
951
# much more complex to keep consistent than our careful .bzr subset.
952
# instead, we should say that working trees are local only, and optimise
953
# for that.
954
return WorkingTree(self.base, branch=self)
870
955
871
956
872
957
def basis_tree(self):
874
959
875
960
If there are no revisions yet, return an `EmptyTree`.
876
961
"""
877
from bzrlib.tree import EmptyTree, RevisionTree
878
r = self.last_patch()
879
if r == None:
880
return EmptyTree()
881
else:
882
return RevisionTree(self.text_store, self.get_revision_inventory(r))
883
884
885
962
return self.revision_tree(self.last_revision())
963
964
@needs_write_lock
886
965
def rename_one(self, from_rel, to_rel):
887
966
"""Rename one file.
888
967
889
968
This can change the directory or the filename or both.
890
969
"""
891
self.lock_write()
970
tree = self.working_tree()
971
inv = tree.inventory
972
if not tree.has_filename(from_rel):
973
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
974
if tree.has_filename(to_rel):
975
raise BzrError("can't rename: new working file %r already exists" % to_rel)
976
977
file_id = inv.path2id(from_rel)
978
if file_id == None:
979
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
980
981
if inv.path2id(to_rel):
982
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
983
984
to_dir, to_tail = os.path.split(to_rel)
985
to_dir_id = inv.path2id(to_dir)
986
if to_dir_id == None and to_dir != '':
987
raise BzrError("can't determine destination directory id for %r" % to_dir)
988
989
mutter("rename_one:")
990
mutter(" file_id {%s}" % file_id)
991
mutter(" from_rel %r" % from_rel)
992
mutter(" to_rel %r" % to_rel)
993
mutter(" to_dir %r" % to_dir)
994
mutter(" to_dir_id {%s}" % to_dir_id)
995
996
inv.rename(file_id, to_dir_id, to_tail)
997
998
from_abs = self.abspath(from_rel)
999
to_abs = self.abspath(to_rel)
892
1000
try:
893
tree = self.working_tree()
894
inv = tree.inventory
895
if not tree.has_filename(from_rel):
896
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
897
if tree.has_filename(to_rel):
898
raise BzrError("can't rename: new working file %r already exists" % to_rel)
899
900
file_id = inv.path2id(from_rel)
901
if file_id == None:
902
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
903
904
if inv.path2id(to_rel):
905
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
906
907
to_dir, to_tail = os.path.split(to_rel)
908
to_dir_id = inv.path2id(to_dir)
909
if to_dir_id == None and to_dir != '':
910
raise BzrError("can't determine destination directory id for %r" % to_dir)
911
912
mutter("rename_one:")
913
mutter(" file_id {%s}" % file_id)
914
mutter(" from_rel %r" % from_rel)
915
mutter(" to_rel %r" % to_rel)
916
mutter(" to_dir %r" % to_dir)
917
mutter(" to_dir_id {%s}" % to_dir_id)
918
919
inv.rename(file_id, to_dir_id, to_tail)
920
921
print "%s => %s" % (from_rel, to_rel)
922
923
from_abs = self.abspath(from_rel)
924
to_abs = self.abspath(to_rel)
925
try:
926
os.rename(from_abs, to_abs)
927
except OSError, e:
928
raise BzrError("failed to rename %r to %r: %s"
929
% (from_abs, to_abs, e[1]),
930
["rename rolled back"])
931
932
self._write_inventory(inv)
933
finally:
934
self.unlock()
935
936
1001
rename(from_abs, to_abs)
1002
except OSError, e:
1003
raise BzrError("failed to rename %r to %r: %s"
1004
% (from_abs, to_abs, e[1]),
1005
["rename rolled back"])
1006
1007
self._write_inventory(inv)
1008
1009
@needs_write_lock
937
1010
def move(self, from_paths, to_name):
938
1011
"""Rename files.
939
1012
944
1017
945
1018
Note that to_name is only the last component of the new name;
946
1019
this doesn't change the directory.
1020
1021
This returns a list of (from_path, to_path) pairs for each
1022
entry that is moved.
947
1023
"""
948
self.lock_write()
949
try:
950
## TODO: Option to move IDs only
951
assert not isinstance(from_paths, basestring)
952
tree = self.working_tree()
953
inv = tree.inventory
954
to_abs = self.abspath(to_name)
955
if not isdir(to_abs):
956
raise BzrError("destination %r is not a directory" % to_abs)
957
if not tree.has_filename(to_name):
958
raise BzrError("destination %r not in working directory" % to_abs)
959
to_dir_id = inv.path2id(to_name)
960
if to_dir_id == None and to_name != '':
961
raise BzrError("destination %r is not a versioned directory" % to_name)
962
to_dir_ie = inv[to_dir_id]
963
if to_dir_ie.kind not in ('directory', 'root_directory'):
964
raise BzrError("destination %r is not a directory" % to_abs)
965
966
to_idpath = inv.get_idpath(to_dir_id)
967
968
for f in from_paths:
969
if not tree.has_filename(f):
970
raise BzrError("%r does not exist in working tree" % f)
971
f_id = inv.path2id(f)
972
if f_id == None:
973
raise BzrError("%r is not versioned" % f)
974
name_tail = splitpath(f)[-1]
975
dest_path = appendpath(to_name, name_tail)
976
if tree.has_filename(dest_path):
977
raise BzrError("destination %r already exists" % dest_path)
978
if f_id in to_idpath:
979
raise BzrError("can't move %r to a subdirectory of itself" % f)
980
981
# OK, so there's a race here, it's possible that someone will
982
# create a file in this interval and then the rename might be
983
# left half-done. But we should have caught most problems.
984
985
for f in from_paths:
986
name_tail = splitpath(f)[-1]
987
dest_path = appendpath(to_name, name_tail)
988
print "%s => %s" % (f, dest_path)
989
inv.rename(inv.path2id(f), to_dir_id, name_tail)
990
try:
991
os.rename(self.abspath(f), self.abspath(dest_path))
992
except OSError, e:
993
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
994
["rename rolled back"])
995
996
self._write_inventory(inv)
997
finally:
998
self.unlock()
1024
result = []
1025
## TODO: Option to move IDs only
1026
assert not isinstance(from_paths, basestring)
1027
tree = self.working_tree()
1028
inv = tree.inventory
1029
to_abs = self.abspath(to_name)
1030
if not isdir(to_abs):
1031
raise BzrError("destination %r is not a directory" % to_abs)
1032
if not tree.has_filename(to_name):
1033
raise BzrError("destination %r not in working directory" % to_abs)
1034
to_dir_id = inv.path2id(to_name)
1035
if to_dir_id == None and to_name != '':
1036
raise BzrError("destination %r is not a versioned directory" % to_name)
1037
to_dir_ie = inv[to_dir_id]
1038
if to_dir_ie.kind not in ('directory', 'root_directory'):
1039
raise BzrError("destination %r is not a directory" % to_abs)
1040
1041
to_idpath = inv.get_idpath(to_dir_id)
1042
1043
for f in from_paths:
1044
if not tree.has_filename(f):
1045
raise BzrError("%r does not exist in working tree" % f)
1046
f_id = inv.path2id(f)
1047
if f_id == None:
1048
raise BzrError("%r is not versioned" % f)
1049
name_tail = splitpath(f)[-1]
1050
dest_path = appendpath(to_name, name_tail)
1051
if tree.has_filename(dest_path):
1052
raise BzrError("destination %r already exists" % dest_path)
1053
if f_id in to_idpath:
1054
raise BzrError("can't move %r to a subdirectory of itself" % f)
1055
1056
# OK, so there's a race here, it's possible that someone will
1057
# create a file in this interval and then the rename might be
1058
# left half-done. But we should have caught most problems.
1059
1060
for f in from_paths:
1061
name_tail = splitpath(f)[-1]
1062
dest_path = appendpath(to_name, name_tail)
1063
result.append((f, dest_path))
1064
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1065
try:
1066
rename(self.abspath(f), self.abspath(dest_path))
1067
except OSError, e:
1068
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1069
["rename rolled back"])
1070
1071
self._write_inventory(inv)
1072
return result
999
1073
1000
1074
1001
1075
def revert(self, filenames, old_tree=None, backups=True):
1005
1079
If true (default) backups are made of files before
1006
1080
they're renamed.
1007
1081
"""
1008
from bzrlib.errors import NotVersionedError, BzrError
1009
1082
from bzrlib.atomicfile import AtomicFile
1010
1083
from bzrlib.osutils import backup_file
1011
1084
1018
1091
for fn in filenames:
1019
1092
file_id = inv.path2id(fn)
1020
1093
if not file_id:
1021
raise NotVersionedError("not a versioned file", fn)
1094
raise NotVersionedError(path=fn)
1022
1095
if not old_inv.has_id(file_id):
1023
1096
raise BzrError("file not present in old tree", fn, file_id)
1024
1097
nids.append((fn, file_id))
1048
1121
These are revisions that have been merged into the working
1049
1122
directory but not yet committed.
1050
1123
"""
1051
cfn = self.controlfilename('pending-merges')
1052
if not os.path.exists(cfn):
1124
cfn = self._rel_controlfilename('pending-merges')
1125
if not self._transport.has(cfn):
1053
1126
return []
1054
1127
p = []
1055
1128
for l in self.controlfile('pending-merges', 'r').readlines():
1057
1130
return p
1058
1131
1059
1132
1060
def add_pending_merge(self, revision_id):
1061
from bzrlib.revision import validate_revision_id
1062
1063
validate_revision_id(revision_id)
1064
1133
def add_pending_merge(self, *revision_ids):
1134
# TODO: Perhaps should check at this point that the
1135
# history of the revision is actually present?
1065
1136
p = self.pending_merges()
1066
if revision_id in p:
1067
return
1068
p.append(revision_id)
1069
self.set_pending_merges(p)
1070
1071
1137
updated = False
1138
for rev_id in revision_ids:
1139
if rev_id in p:
1140
continue
1141
p.append(rev_id)
1142
updated = True
1143
if updated:
1144
self.set_pending_merges(p)
1145
1146
@needs_write_lock
1072
1147
def set_pending_merges(self, rev_list):
1148
self.put_controlfile('pending-merges', '\n'.join(rev_list))
1149
1150
def get_parent(self):
1151
"""Return the parent location of the branch.
1152
1153
This is the default location for push/pull/missing. The usual
1154
pattern is that the user can override it by specifying a
1155
location.
1156
"""
1157
import errno
1158
_locs = ['parent', 'pull', 'x-pull']
1159
for l in _locs:
1160
try:
1161
return self.controlfile(l, 'r').read().strip('\n')
1162
except IOError, e:
1163
if e.errno != errno.ENOENT:
1164
raise
1165
return None
1166
1167
@needs_write_lock
1168
def set_parent(self, url):
1169
# TODO: Maybe delete old location files?
1073
1170
from bzrlib.atomicfile import AtomicFile
1074
self.lock_write()
1171
f = AtomicFile(self.controlfilename('parent'))
1075
1172
try:
1076
f = AtomicFile(self.controlfilename('pending-merges'))
1077
try:
1078
for l in rev_list:
1079
print >>f, l
1080
f.commit()
1081
finally:
1082
f.close()
1173
f.write(url + '\n')
1174
f.commit()
1083
1175
finally:
1084
self.unlock()
1085
1086
1087
1088
class ScratchBranch(Branch):
1176
f.close()
1177
1178
def check_revno(self, revno):
1179
"""\
1180
Check whether a revno corresponds to any revision.
1181
Zero (the NULL revision) is considered valid.
1182
"""
1183
if revno != 0:
1184
self.check_real_revno(revno)
1185
1186
def check_real_revno(self, revno):
1187
"""\
1188
Check whether a revno corresponds to a real revision.
1189
Zero (the NULL revision) is considered invalid
1190
"""
1191
if revno < 1 or revno > self.revno():
1192
raise InvalidRevisionNumber(revno)
1193
1194
def sign_revision(self, revision_id, gpg_strategy):
1195
plaintext = Testament.from_revision(self, revision_id).as_short_text()
1196
self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1197
1198
@needs_write_lock
1199
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1200
self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)),
1201
revision_id, "sig")
1202
1203
1204
class ScratchBranch(_Branch):
1089
1205
"""Special test class: a branch that cleans up after itself.
1090
1206
1091
1207
>>> b = ScratchBranch()
1092
1208
>>> isdir(b.base)
1093
1209
True
1094
1210
>>> bd = b.base
1095
>>> b.destroy()
1211
>>> b._transport.__del__()
1096
1212
>>> isdir(bd)
1097
1213
False
1098
1214
"""
1099
def __init__(self, files=[], dirs=[], base=None):
1215
1216
def __init__(self, files=[], dirs=[], transport=None):
1100
1217
"""Make a test branch.
1101
1218
1102
1219
This creates a temporary directory and runs init-tree in it.
1103
1220
1104
1221
If any files are listed, they are created in the working copy.
1105
1222
"""
1106
from tempfile import mkdtemp
1107
init = False
1108
if base is None:
1109
base = mkdtemp()
1110
init = True
1111
Branch.__init__(self, base, init=init)
1223
if transport is None:
1224
transport = bzrlib.transport.local.ScratchTransport()
1225
super(ScratchBranch, self).__init__(transport, init=True)
1226
else:
1227
super(ScratchBranch, self).__init__(transport)
1228
1112
1229
for d in dirs:
1113
os.mkdir(self.abspath(d))
1230
self._transport.mkdir(d)
1114
1231
1115
1232
for f in files:
1116
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1233
self._transport.put(f, 'content of %s' % f)
1117
1234
1118
1235
1119
1236
def clone(self):
1120
1237
"""
1121
1238
>>> orig = ScratchBranch(files=["file1", "file2"])
1122
1239
>>> clone = orig.clone()
1123
>>> os.path.samefile(orig.base, clone.base)
1240
>>> if os.name != 'nt':
1241
... os.path.samefile(orig.base, clone.base)
1242
... else:
1243
... orig.base == clone.base
1244
...
1124
1245
False
1125
1246
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1126
1247
True
1130
1251
base = mkdtemp()
1131
1252
os.rmdir(base)
1132
1253
copytree(self.base, base, symlinks=True)
1133
return ScratchBranch(base=base)
1134
1135
def __del__(self):
1136
self.destroy()
1137
1138
def destroy(self):
1139
"""Destroy the test branch, removing the scratch directory."""
1140
from shutil import rmtree
1141
try:
1142
if self.base:
1143
mutter("delete ScratchBranch %s" % self.base)
1144
rmtree(self.base)
1145
except OSError, e:
1146
# Work around for shutil.rmtree failing on Windows when
1147
# readonly files are encountered
1148
mutter("hit exception in destroying ScratchBranch: %s" % e)
1149
for root, dirs, files in os.walk(self.base, topdown=False):
1150
for name in files:
1151
os.chmod(os.path.join(root, name), 0700)
1152
rmtree(self.base)
1153
self.base = None
1154
1254
return ScratchBranch(
1255
transport=bzrlib.transport.local.ScratchTransport(base))
1155
1256
1156
1257
1157
1258
######################################################################
1200
1301
1201
1302
s = hexlify(rand_bytes(8))
1202
1303
return '-'.join((name, compact_date(time()), s))
1304
1305
1306
def gen_root_id():
1307
"""Return a new tree-root file id."""
1308
return gen_file_id('TREE_ROOT')
1309
1310
Loggerhead is a web-based interface for Breezy
Version: 2.0.1