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