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