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