« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1185.12.68
- compare with another revision
- download diff
- download tarball
- view history from revision 1185.12.68
- Committer: Aaron Bentley
- Date: 2005-10-20 02:57:55 UTC
- mto: (1185.25.1)
- mto: This revision was merged to the branch mainline in revision 1474.
- Revision ID: aaron.bentley@utoronto.ca-20051020025755-e03df41c52aa3156
tweaked spacing
- files added:
- INSTALL
- bzrlib/store
- bzrlib/transport
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- files removed:
- bzrlib/meta_store.py
- files renamed:
- tools/testweave.py => bzrlib/selftest/test_weave.py
- bzrlib/store.py => bzrlib/store/__init__.py
- tools/history2weaves.py => bzrlib/upgrade.py
- bzrlib/newinventory.py => contrib/newinventory.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
20
24
21
25
import bzrlib
26
from bzrlib.inventory import InventoryEntry
27
import bzrlib.inventory as inventory
22
28
from bzrlib.trace import mutter, note
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
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)
29
37
from bzrlib.textui import show_status
30
from bzrlib.revision import Revision
38
from bzrlib.revision import Revision, is_ancestor, get_intervening_revisions
39
31
40
from bzrlib.delta import compare_trees
32
41
from bzrlib.tree import EmptyTree, RevisionTree
33
import bzrlib.xml
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
34
51
import bzrlib.ui
35
52
36
53
37
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
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"
39
57
## TODO: Maybe include checks for common corruption of newlines, etc?
40
58
41
59
42
60
# TODO: Some operations like log might retrieve the same revisions
43
61
# repeatedly to calculate deltas. We could perhaps have a weakref
44
# cache in memory to make this faster.
62
# cache in memory to make this faster. In general anything can be
63
# cached in memory between lock and unlock operations.
45
64
46
65
def find_branch(*ignored, **ignored_too):
47
66
# XXX: leave this here for about one release, then remove it
48
67
raise NotImplementedError('find_branch() is not supported anymore, '
49
68
'please use one of the new branch constructors')
50
69
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
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
111
91
112
92
######################################################################
113
93
# branch objects
124
104
raise NotImplementedError('The Branch class is abstract')
125
105
126
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
127
114
def open(base):
128
115
"""Open an existing branch, rooted at 'base' (url)"""
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)
116
t = get_transport(base)
117
mutter("trying to open %r with transport %r", base, t)
118
return _Branch(t)
134
119
135
120
@staticmethod
136
121
def open_containing(url):
137
"""Open an existing branch, containing url (search upwards for the root)
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.
138
129
"""
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)
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
144
141
145
142
@staticmethod
146
143
def initialize(base):
147
144
"""Create a new branch, rooted at 'base' (url)"""
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)
145
t = get_transport(base)
146
return _Branch(t, init=True)
153
147
154
148
def setup_caching(self, cache_root):
155
149
"""Subclasses that care about caching should override this, and set
156
150
up cached stores located under cache_root.
157
151
"""
158
159
160
class LocalBranch(Branch):
152
self.cache_root = cache_root
153
154
155
class _Branch(Branch):
161
156
"""A branch stored in the actual filesystem.
162
157
163
158
Note that it's "local" in the context of the filesystem; it doesn't
181
176
_lock_mode = None
182
177
_lock_count = None
183
178
_lock = None
184
185
def __init__(self, base, init=False, find_root=True):
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):
186
208
"""Create new branch object at a particular location.
187
209
188
base -- Base directory for the branch. May be a file:// url.
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)
189
213
190
214
init -- If True, create new control files in a previously
191
215
unversioned directory. If False, the branch must already
192
216
be versioned.
193
217
194
find_root -- If true and init is false, find the root of the
195
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.
196
222
197
223
In the test suite, creation of new trees is tested using the
198
224
`ScratchBranch` class.
199
225
"""
200
from bzrlib.store import ImmutableStore
226
assert isinstance(transport, Transport), \
227
"%r is not a Transport" % transport
228
self._transport = transport
201
229
if init:
202
self.base = os.path.realpath(base)
203
230
self._make_control()
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
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
220
272
221
273
def __str__(self):
222
return '%s(%r)' % (self.__class__.__name__, self.base)
274
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
223
275
224
276
225
277
__repr__ = __str__
227
279
228
280
def __del__(self):
229
281
if self._lock_mode or self._lock:
230
from bzrlib.warnings import warn
282
# XXX: This should show something every time, and be suitable for
283
# headless operation and embedding
231
284
warn("branch %r was not explicitly unlocked" % self)
232
285
self._lock.unlock()
233
286
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
234
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
235
339
if self._lock_mode:
236
340
if self._lock_mode != 'w':
237
from bzrlib.errors import LockError
238
341
raise LockError("can't upgrade to a write lock from %r" %
239
342
self._lock_mode)
240
343
self._lock_count += 1
241
344
else:
242
from bzrlib.lock import WriteLock
243
244
self._lock = WriteLock(self.controlfilename('branch-lock'))
345
self._lock = self._transport.lock_write(
346
self._rel_controlfilename('branch-lock'))
245
347
self._lock_mode = 'w'
246
348
self._lock_count = 1
247
349
self._set_transaction(transactions.PassThroughTransaction())
248
350
249
351
def lock_read(self):
352
mutter("lock read: %s (%s)", self, self._lock_count)
250
353
if self._lock_mode:
251
354
assert self._lock_mode in ('r', 'w'), \
252
355
"invalid lock mode %r" % self._lock_mode
253
356
self._lock_count += 1
254
357
else:
255
from bzrlib.lock import ReadLock
256
257
self._lock = ReadLock(self.controlfilename('branch-lock'))
358
self._lock = self._transport.lock_read(
359
self._rel_controlfilename('branch-lock'))
258
360
self._lock_mode = 'r'
259
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)
260
365
261
366
def unlock(self):
367
mutter("unlock: %s (%s)", self, self._lock_count)
262
368
if not self._lock_mode:
263
from bzrlib.errors import LockError
264
369
raise LockError('branch %r is not locked' % (self))
265
370
266
371
if self._lock_count > 1:
267
372
self._lock_count -= 1
268
373
else:
374
self._finish_transaction()
269
375
self._lock.unlock()
270
376
self._lock = None
271
377
self._lock_mode = self._lock_count = None
272
378
273
379
def abspath(self, name):
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)
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)
282
393
283
394
def controlfilename(self, file_or_path):
284
395
"""Return location relative to branch."""
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)
396
return self._transport.abspath(self._rel_controlfilename(file_or_path))
288
397
289
398
290
399
def controlfile(self, file_or_path, mode='r'):
298
407
Controlfiles should almost never be opened in write mode but
299
408
rather should be atomically copied and replaced using atomicfile.
300
409
"""
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)
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")
312
423
else:
313
424
raise BzrError("invalid controlfile mode %r" % mode)
314
425
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
315
455
def _make_control(self):
316
456
from bzrlib.inventory import Inventory
457
from bzrlib.weavefile import write_weave_v5
458
from bzrlib.weave import Weave
317
459
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
460
# Create an empty inventory
461
sio = StringIO()
332
462
# if we want per-tree root ids then this is the place to set
333
463
# them; they're not needed for now and so ommitted for
334
464
# simplicity.
335
f = self.controlfile('inventory','w')
336
bzrlib.xml.serializer_v4.write_inventory(Inventory(), f)
337
338
339
def _check_format(self):
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):
340
490
"""Check this branch format is supported.
341
491
342
The current tool only supports the current unstable format.
492
The format level is stored, as an integer, in
493
self._branch_format for code that needs to check it later.
343
494
344
495
In the future, we might need different in-memory Branch
345
496
classes to support downlevel branches. But not yet.
346
497
"""
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,
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,
354
514
['use a different bzr version',
355
'or remove the .bzr directory and "bzr init" again'])
515
'or remove the .bzr directory'
516
' and "bzr init" again'])
356
517
357
518
def get_root_id(self):
358
519
"""Return the id of this branches root"""
371
532
entry.parent_id = inv.root.file_id
372
533
self._write_inventory(inv)
373
534
535
@needs_read_lock
374
536
def read_working_inventory(self):
375
537
"""Read the working inventory."""
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
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)
386
542
543
@needs_write_lock
387
544
def _write_inventory(self, inv):
388
545
"""Update the working inventory.
389
546
390
547
That is to say, the inventory describing changes underway, that
391
548
will be committed to the next revision.
392
549
"""
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()
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)
405
556
406
557
mutter('wrote working inventory')
407
558
408
409
559
inventory = property(read_working_inventory, _write_inventory, None,
410
560
"""Inventory for the working copy.""")
411
561
412
562
@needs_write_lock
413
563
def add(self, files, ids=None):
414
564
"""Make files versioned.
415
565
445
595
else:
446
596
assert(len(ids) == len(files))
447
597
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
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
482
629
def print_file(self, file, revno):
483
630
"""Print `file` to stdout."""
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
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)
540
637
541
638
# FIXME: this doesn't need to be a branch method
542
639
def set_inventory(self, new_inventory_list):
546
643
name = os.path.basename(path)
547
644
if name == "":
548
645
continue
549
inv.add(InventoryEntry(file_id, name, kind, parent))
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)
550
655
self._write_inventory(inv)
551
656
552
553
657
def unknowns(self):
554
658
"""Return all unknown files.
555
659
556
660
These are files in the working directory that are not versioned or
557
661
control files or ignored.
558
662
663
>>> from bzrlib.workingtree import WorkingTree
559
664
>>> b = ScratchBranch(files=['foo', 'foo~'])
560
>>> list(b.unknowns())
665
>>> map(str, b.unknowns())
561
666
['foo']
562
667
>>> b.add('foo')
563
668
>>> list(b.unknowns())
564
669
[]
565
>>> b.remove('foo')
670
>>> WorkingTree(b.base, b).remove('foo')
566
671
>>> list(b.unknowns())
567
['foo']
672
[u'foo']
568
673
"""
569
674
return self.working_tree().unknowns()
570
675
571
676
@needs_write_lock
572
677
def append_revision(self, *revision_ids):
573
from bzrlib.atomicfile import AtomicFile
574
575
678
for revision_id in revision_ids:
576
679
mutter("add {%s} to revision-history" % revision_id)
577
578
680
rev_history = self.revision_history()
579
681
rev_history.extend(revision_ids)
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
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
590
697
def get_revision_xml_file(self, revision_id):
591
698
"""Return XML file object for revision object."""
592
699
if not revision_id or not isinstance(revision_id, basestring):
593
700
raise InvalidRevisionId(revision_id)
594
595
self.lock_read()
596
701
try:
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
702
return self.revision_store.get(revision_id)
703
except (IndexError, KeyError):
704
raise bzrlib.errors.NoSuchRevision(self, revision_id)
604
705
605
706
#deprecated
606
707
get_revision_xml = get_revision_xml_file
607
708
709
def get_revision_xml(self, revision_id):
710
return self.get_revision_xml_file(revision_id).read()
711
608
712
609
713
def get_revision(self, revision_id):
610
714
"""Return the Revision object for a named revision"""
611
715
xml_file = self.get_revision_xml_file(revision_id)
612
716
613
717
try:
614
r = bzrlib.xml.serializer_v4.read_revision(xml_file)
718
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
615
719
except SyntaxError, e:
616
720
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
617
721
[revision_id,
620
724
assert r.revision_id == revision_id
621
725
return r
622
726
623
624
727
def get_revision_delta(self, revno):
625
728
"""Return the delta for one revision.
626
729
642
745
643
746
return compare_trees(old_tree, new_tree)
644
747
645
646
647
748
def get_revision_sha1(self, revision_id):
648
749
"""Hash the stored value of a revision, and return it."""
649
750
# In the future, revision entries will be signed. At that
652
753
# the revision, (add signatures/remove signatures) and still
653
754
# have all hash pointers stay consistent.
654
755
# But for now, just hash the contents.
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):
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):
671
780
"""Get inventory XML as a file object."""
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):
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):
678
789
"""Return the sha1 hash of the inventory entry
679
790
"""
680
return sha_file(self.get_inventory_xml(inventory_id))
681
791
return self.get_revision(revision_id).inventory_sha1
682
792
683
793
def get_revision_inventory(self, revision_id):
684
794
"""Return inventory of a past revision."""
685
# bzr 0.0.6 imposes the constraint that the inventory_id
795
# TODO: Unify this with get_inventory()
796
# bzr 0.0.6 and later imposes the constraint that the inventory_id
686
797
# must be the same as its revision, so this is trivial.
687
798
if revision_id == None:
688
from bzrlib.inventory import Inventory
689
799
return Inventory(self.get_root_id())
690
800
else:
691
801
return self.get_inventory(revision_id)
692
802
693
803
@needs_read_lock
694
804
def revision_history(self):
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
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)
752
818
753
819
def revno(self):
754
820
"""Return current revision number for this branch.
758
824
"""
759
825
return len(self.revision_history())
760
826
761
762
def last_patch(self):
827
def last_revision(self):
763
828
"""Return last patch hash, or None if no history.
764
829
"""
765
830
ph = self.revision_history()
768
833
else:
769
834
return None
770
835
771
772
836
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
773
"""
837
"""Return a list of new revisions that would perfectly fit.
838
774
839
If self and other have not diverged, return a list of the revisions
775
840
present in other, but missing from self.
776
841
807
872
808
873
if stop_revision is None:
809
874
stop_revision = other_len
810
elif stop_revision > other_len:
811
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
812
875
else:
876
assert isinstance(stop_revision, int)
877
if stop_revision > other_len:
878
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
813
879
return other_history[self_len:stop_revision]
814
880
815
816
881
def update_revisions(self, other, stop_revision=None):
817
"""Pull in all new revisions from other branch.
818
"""
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.
819
886
from bzrlib.fetch import greedy_fetch
820
from bzrlib.revision import get_intervening_revisions
887
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)
821
898
822
pb = bzrlib.ui.ui_factory.progress_bar()
823
pb.update('comparing histories')
824
if stop_revision is None:
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]
899
def pullable_revisions(self, other, stop_revision):
900
other_revno = other.revision_id_to_revno(stop_revision)
829
901
try:
830
revision_ids = self.missing_revisions(other, stop_revision)
902
return self.missing_revisions(other, other_revno)
831
903
except DivergedBranches, e:
832
904
try:
833
revision_ids = get_intervening_revisions(self.last_patch(),
834
other_revision, self)
835
assert self.last_patch() not in revision_ids
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
836
909
except bzrlib.errors.NotAncestor:
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
910
if is_ancestor(self.last_revision(), stop_revision, self):
911
return []
912
else:
913
raise e
914
897
915
def commit(self, *args, **kw):
898
from bzrlib.commit import commit
899
commit(self, *args, **kw)
900
916
from bzrlib.commit import Commit
917
Commit().commit(self, *args, **kw)
918
901
919
def revision_id_to_revno(self, revision_id):
902
920
"""Given a revision id, return its revno"""
921
if revision_id is None:
922
return 0
903
923
history = self.revision_history()
904
924
try:
905
925
return history.index(revision_id) + 1
916
936
raise bzrlib.errors.NoSuchRevision(self, revno)
917
937
return history[revno - 1]
918
938
919
920
939
def revision_tree(self, revision_id):
921
940
"""Return Tree for a revision on this branch.
922
941
928
947
return EmptyTree()
929
948
else:
930
949
inv = self.get_revision_inventory(revision_id)
931
return RevisionTree(self.text_store, inv)
932
950
return RevisionTree(self.weave_store, inv, revision_id)
933
951
934
952
def working_tree(self):
935
953
"""Return a `Tree` for the working copy."""
936
954
from bzrlib.workingtree import WorkingTree
937
return WorkingTree(self.base, self.read_working_inventory())
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)
938
961
939
962
940
963
def basis_tree(self):
942
965
943
966
If there are no revisions yet, return an `EmptyTree`.
944
967
"""
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
968
return self.revision_tree(self.last_revision())
969
970
@needs_write_lock
953
971
def rename_one(self, from_rel, to_rel):
954
972
"""Rename one file.
955
973
956
974
This can change the directory or the filename or both.
957
975
"""
958
self.lock_write()
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)
959
1006
try:
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
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
1002
1016
def move(self, from_paths, to_name):
1003
1017
"""Rename files.
1004
1018
1014
1028
entry that is moved.
1015
1029
"""
1016
1030
result = []
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
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)
1069
1078
return result
1070
1079
1071
1080
1076
1085
If true (default) backups are made of files before
1077
1086
they're renamed.
1078
1087
"""
1079
from bzrlib.errors import NotVersionedError, BzrError
1080
1088
from bzrlib.atomicfile import AtomicFile
1081
1089
from bzrlib.osutils import backup_file
1082
1090
1089
1097
for fn in filenames:
1090
1098
file_id = inv.path2id(fn)
1091
1099
if not file_id:
1092
raise NotVersionedError("not a versioned file", fn)
1100
raise NotVersionedError(path=fn)
1093
1101
if not old_inv.has_id(file_id):
1094
1102
raise BzrError("file not present in old tree", fn, file_id)
1095
1103
nids.append((fn, file_id))
1119
1127
These are revisions that have been merged into the working
1120
1128
directory but not yet committed.
1121
1129
"""
1122
cfn = self.controlfilename('pending-merges')
1123
if not os.path.exists(cfn):
1130
cfn = self._rel_controlfilename('pending-merges')
1131
if not self._transport.has(cfn):
1124
1132
return []
1125
1133
p = []
1126
1134
for l in self.controlfile('pending-merges', 'r').readlines():
1128
1136
return p
1129
1137
1130
1138
1131
def add_pending_merge(self, revision_id):
1132
from bzrlib.revision import validate_revision_id
1133
1134
validate_revision_id(revision_id)
1135
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?
1136
1142
p = self.pending_merges()
1137
if revision_id in p:
1138
return
1139
p.append(revision_id)
1140
self.set_pending_merges(p)
1141
1142
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
1143
1153
def set_pending_merges(self, 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
1154
self.put_controlfile('pending-merges', '\n'.join(rev_list))
1157
1155
1158
1156
def get_parent(self):
1159
1157
"""Return the parent location of the branch.
1172
1170
raise
1173
1171
return None
1174
1172
1175
1173
@needs_write_lock
1176
1174
def set_parent(self, url):
1177
1175
# TODO: Maybe delete old location files?
1178
1176
from bzrlib.atomicfile import AtomicFile
1179
self.lock_write()
1177
f = AtomicFile(self.controlfilename('parent'))
1180
1178
try:
1181
f = AtomicFile(self.controlfilename('parent'))
1182
try:
1183
f.write(url + '\n')
1184
f.commit()
1185
finally:
1186
f.close()
1179
f.write(url + '\n')
1180
f.commit()
1187
1181
finally:
1188
self.unlock()
1182
f.close()
1189
1183
1190
1184
def check_revno(self, revno):
1191
1185
"""\
1203
1197
if revno < 1 or revno > self.revno():
1204
1198
raise InvalidRevisionNumber(revno)
1205
1199
1206
1207
1208
1209
1210
class ScratchBranch(LocalBranch):
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):
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.destroy()
1217
>>> b._transport.__del__()
1218
1218
>>> isdir(bd)
1219
1219
False
1220
1220
"""
1221
def __init__(self, files=[], dirs=[], base=None):
1221
1222
def __init__(self, files=[], dirs=[], transport=None):
1222
1223
"""Make a test branch.
1223
1224
1224
1225
This creates a temporary directory and runs init-tree in it.
1225
1226
1226
1227
If any files are listed, they are created in the working copy.
1227
1228
"""
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)
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
1234
1235
for d in dirs:
1235
os.mkdir(self.abspath(d))
1236
self._transport.mkdir(d)
1236
1237
1237
1238
for f in files:
1238
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1239
self._transport.put(f, 'content of %s' % f)
1239
1240
1240
1241
1241
1242
def clone(self):
1242
1243
"""
1243
1244
>>> orig = ScratchBranch(files=["file1", "file2"])
1244
1245
>>> clone = orig.clone()
1245
>>> os.path.samefile(orig.base, clone.base)
1246
>>> if os.name != 'nt':
1247
... os.path.samefile(orig.base, clone.base)
1248
... else:
1249
... orig.base == clone.base
1250
...
1246
1251
False
1247
1252
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1248
1253
True
1252
1257
base = mkdtemp()
1253
1258
os.rmdir(base)
1254
1259
copytree(self.base, base, symlinks=True)
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
1260
return ScratchBranch(
1261
transport=bzrlib.transport.local.ScratchTransport(base))
1279
1262
1280
1263
1281
1264
######################################################################
1331
1314
return gen_file_id('TREE_ROOT')
1332
1315
1333
1316
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