« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1185.1.23
- compare with another revision
- download diff
- download tarball
- view history from revision 1185.1.23
- Committer: Robert Collins
- Date: 2005-09-15 17:59:53 UTC
- mto: (1185.41.1 bzr.sftp) (1092.3.4) (1417.1.4) (1464.1.1) (1534.1.1 integration) (1495.1.4) (1505.1.16 bzr-bound-branch) (1508.1.15) (1526.1.3 run_tests_twice_for_i18n) (1540.1.3 bzr.dev (Main development branch)) (1685.1.1 bzr-encoding) (1553.5.1 bzr.dev (Main development branch)) (1608.2.1 bzr.mbp.escape-stores) (1393.1.21)
- mto: This revision was merged to the branch mainline in revision 1390.
- Revision ID: robertc@robertcollins.net-20050915175953-a16fdc627ce7c541
Harald Meland's xml escaping on commit patch
- files added:
- bzrlib/meta_store.py
- files removed:
- NEWS.developers
- bzrlib/store
- bzrlib/transport
- files renamed:
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/upgrade.py => tools/history2weaves.py
- bzrlib/selftest/test_weave.py => tools/testweave.py
- files modified:
- .bzrignore
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)
32
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
33
NoSuchRevision, HistoryMissing, NotBranchError,
34
DivergedBranches, LockError, UnlistableStore,
35
UnlistableBranch, NoSuchFile)
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
36
29
from bzrlib.textui import show_status
37
30
from bzrlib.revision import Revision
38
31
from bzrlib.delta import compare_trees
39
32
from bzrlib.tree import EmptyTree, RevisionTree
40
from bzrlib.inventory import Inventory
41
from bzrlib.store import copy_all
42
from bzrlib.store.compressed_text import CompressedTextStore
43
from bzrlib.store.text import TextStore
44
from bzrlib.store.weave import WeaveStore
45
from bzrlib.transport import Transport, get_transport
46
import bzrlib.xml5
33
import bzrlib.xml
47
34
import bzrlib.ui
48
35
49
36
50
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
51
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
37
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
52
39
## TODO: Maybe include checks for common corruption of newlines, etc?
53
40
54
41
55
42
# TODO: Some operations like log might retrieve the same revisions
56
43
# repeatedly to calculate deltas. We could perhaps have a weakref
57
# cache in memory to make this faster. In general anything can be
58
# cached in memory between lock and unlock operations.
44
# cache in memory to make this faster.
59
45
60
46
def find_branch(*ignored, **ignored_too):
61
47
# XXX: leave this here for about one release, then remove it
62
48
raise NotImplementedError('find_branch() is not supported anymore, '
63
49
'please use one of the new branch constructors')
50
64
51
def _relpath(base, path):
65
52
"""Return path relative to base, or raise exception.
66
53
88
75
return os.sep.join(s)
89
76
90
77
91
def find_branch_root(t):
92
"""Find the branch root enclosing the transport's base.
93
94
t is a Transport object.
95
96
It is not necessary that the base of t exists.
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.
97
84
98
85
Basically we keep looking up until we find the control directory or
99
86
run into the root. If there isn't one, raises NotBranchError.
100
87
"""
101
orig_base = t.base
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
102
100
while True:
103
if t.has(bzrlib.BZRDIR):
104
return t
105
new_t = t.clone('..')
106
if new_t.base == t.base:
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:
107
105
# reached the root, whatever that may be
108
raise NotBranchError('%s is not in a branch' % orig_base)
109
t = new_t
106
raise NotBranchError('%s is not in a branch' % orig_f)
107
f = head
108
109
110
110
111
111
112
112
######################################################################
124
124
raise NotImplementedError('The Branch class is abstract')
125
125
126
126
@staticmethod
127
def open_downlevel(base):
128
"""Open a branch which may be of an old format.
129
130
Only local branches are supported."""
131
return _Branch(get_transport(base), relax_version_check=True)
132
133
@staticmethod
134
127
def open(base):
135
128
"""Open an existing branch, rooted at 'base' (url)"""
136
t = get_transport(base)
137
mutter("trying to open %r with transport %r", base, t)
138
return _Branch(t)
129
if base and (base.startswith('http://') or base.startswith('https://')):
130
from bzrlib.remotebranch import RemoteBranch
131
return RemoteBranch(base, find_root=False)
132
else:
133
return LocalBranch(base, find_root=False)
139
134
140
135
@staticmethod
141
136
def open_containing(url):
142
"""Open an existing branch which contains url.
143
144
This probes for a branch at url, and searches upwards from there.
137
"""Open an existing branch, containing url (search upwards for the root)
145
138
"""
146
t = get_transport(url)
147
t = find_branch_root(t)
148
return _Branch(t)
139
if url and (url.startswith('http://') or url.startswith('https://')):
140
from bzrlib.remotebranch import RemoteBranch
141
return RemoteBranch(url)
142
else:
143
return LocalBranch(url)
149
144
150
145
@staticmethod
151
146
def initialize(base):
152
147
"""Create a new branch, rooted at 'base' (url)"""
153
t = get_transport(base)
154
return _Branch(t, init=True)
148
if base and (base.startswith('http://') or base.startswith('https://')):
149
from bzrlib.remotebranch import RemoteBranch
150
return RemoteBranch(base, init=True)
151
else:
152
return LocalBranch(base, init=True)
155
153
156
154
def setup_caching(self, cache_root):
157
155
"""Subclasses that care about caching should override this, and set
158
156
up cached stores located under cache_root.
159
157
"""
160
self.cache_root = cache_root
161
162
163
class _Branch(Branch):
158
159
160
class LocalBranch(Branch):
164
161
"""A branch stored in the actual filesystem.
165
162
166
163
Note that it's "local" in the context of the filesystem; it doesn't
184
181
_lock_mode = None
185
182
_lock_count = None
186
183
_lock = None
187
_inventory_weave = None
188
189
# Map some sort of prefix into a namespace
190
# stuff like "revno:10", "revid:", etc.
191
# This should match a prefix with a function which accepts
192
REVISION_NAMESPACES = {}
193
194
def push_stores(self, branch_to):
195
"""Copy the content of this branches store to branch_to."""
196
if (self._branch_format != branch_to._branch_format
197
or self._branch_format != 4):
198
from bzrlib.fetch import greedy_fetch
199
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
200
self, self._branch_format, branch_to, branch_to._branch_format)
201
greedy_fetch(to_branch=branch_to, from_branch=self,
202
revision=self.last_revision())
203
return
204
205
store_pairs = ((self.text_store, branch_to.text_store),
206
(self.inventory_store, branch_to.inventory_store),
207
(self.revision_store, branch_to.revision_store))
208
try:
209
for from_store, to_store in store_pairs:
210
copy_all(from_store, to_store)
211
except UnlistableStore:
212
raise UnlistableBranch(from_store)
213
214
def __init__(self, transport, init=False,
215
relax_version_check=False):
184
185
def __init__(self, base, init=False, find_root=True):
216
186
"""Create new branch object at a particular location.
217
187
218
transport -- A Transport object, defining how to access files.
219
(If a string, transport.transport() will be used to
220
create a Transport object)
188
base -- Base directory for the branch. May be a file:// url.
221
189
222
190
init -- If True, create new control files in a previously
223
191
unversioned directory. If False, the branch must already
224
192
be versioned.
225
193
226
relax_version_check -- If true, the usual check for the branch
227
version is not applied. This is intended only for
228
upgrade/recovery type use; it's not guaranteed that
229
all operations will work on old format branches.
194
find_root -- If true and init is false, find the root of the
195
existing branch containing base.
230
196
231
197
In the test suite, creation of new trees is tested using the
232
198
`ScratchBranch` class.
233
199
"""
234
assert isinstance(transport, Transport), \
235
"%r is not a Transport" % transport
236
self._transport = transport
200
from bzrlib.store import ImmutableStore
237
201
if init:
202
self.base = os.path.realpath(base)
238
203
self._make_control()
239
self._check_format(relax_version_check)
240
241
def get_store(name, compressed=True):
242
# FIXME: This approach of assuming stores are all entirely compressed
243
# or entirely uncompressed is tidy, but breaks upgrade from
244
# some existing branches where there's a mixture; we probably
245
# still want the option to look for both.
246
relpath = self._rel_controlfilename(name)
247
if compressed:
248
store = CompressedTextStore(self._transport.clone(relpath))
249
else:
250
store = TextStore(self._transport.clone(relpath))
251
#if self._transport.should_cache():
252
# cache_path = os.path.join(self.cache_root, name)
253
# os.mkdir(cache_path)
254
# store = bzrlib.store.CachedStore(store, cache_path)
255
return store
256
def get_weave(name):
257
relpath = self._rel_controlfilename(name)
258
ws = WeaveStore(self._transport.clone(relpath))
259
if self._transport.should_cache():
260
ws.enable_cache = True
261
return ws
262
263
if self._branch_format == 4:
264
self.inventory_store = get_store('inventory-store')
265
self.text_store = get_store('text-store')
266
self.revision_store = get_store('revision-store')
267
elif self._branch_format == 5:
268
self.control_weaves = get_weave([])
269
self.weave_store = get_weave('weaves')
270
self.revision_store = get_store('revision-store', compressed=False)
204
elif find_root:
205
self.base = find_branch_root(base)
206
else:
207
if base.startswith("file://"):
208
base = base[7:]
209
self.base = os.path.realpath(base)
210
if not isdir(self.controlfilename('.')):
211
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
212
['use "bzr init" to initialize a new working tree',
213
'current bzr can only operate from top-of-tree'])
214
self._check_format()
215
216
self.text_store = ImmutableStore(self.controlfilename('text-store'))
217
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
218
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
219
271
220
272
221
def __str__(self):
273
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
222
return '%s(%r)' % (self.__class__.__name__, self.base)
274
223
275
224
276
225
__repr__ = __str__
278
227
279
228
def __del__(self):
280
229
if self._lock_mode or self._lock:
281
# XXX: This should show something every time, and be suitable for
282
# headless operation and embedding
230
from bzrlib.warnings import warn
283
231
warn("branch %r was not explicitly unlocked" % self)
284
232
self._lock.unlock()
285
233
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
import shutil
295
shutil.rmtree(self.cache_root)
296
except:
297
pass
298
self.cache_root = None
299
300
def _get_base(self):
301
if self._transport:
302
return self._transport.base
303
return None
304
305
base = property(_get_base)
306
307
308
234
def lock_write(self):
309
# TODO: Upgrade locking to support using a Transport,
310
# and potentially a remote locking protocol
311
235
if self._lock_mode:
312
236
if self._lock_mode != 'w':
237
from bzrlib.errors import LockError
313
238
raise LockError("can't upgrade to a write lock from %r" %
314
239
self._lock_mode)
315
240
self._lock_count += 1
316
241
else:
317
self._lock = self._transport.lock_write(
318
self._rel_controlfilename('branch-lock'))
242
from bzrlib.lock import WriteLock
243
244
self._lock = WriteLock(self.controlfilename('branch-lock'))
319
245
self._lock_mode = 'w'
320
246
self._lock_count = 1
321
247
326
252
"invalid lock mode %r" % self._lock_mode
327
253
self._lock_count += 1
328
254
else:
329
self._lock = self._transport.lock_read(
330
self._rel_controlfilename('branch-lock'))
255
from bzrlib.lock import ReadLock
256
257
self._lock = ReadLock(self.controlfilename('branch-lock'))
331
258
self._lock_mode = 'r'
332
259
self._lock_count = 1
333
260
334
261
def unlock(self):
335
262
if not self._lock_mode:
263
from bzrlib.errors import LockError
336
264
raise LockError('branch %r is not locked' % (self))
337
265
338
266
if self._lock_count > 1:
344
272
345
273
def abspath(self, name):
346
274
"""Return absolute filename for something in the branch"""
347
return self._transport.abspath(name)
275
return os.path.join(self.base, name)
348
276
349
277
def relpath(self, path):
350
278
"""Return path relative to this branch of something inside it.
351
279
352
280
Raises an error if path is not in this branch."""
353
return self._transport.relpath(path)
354
355
356
def _rel_controlfilename(self, file_or_path):
281
return _relpath(self.base, path)
282
283
def controlfilename(self, file_or_path):
284
"""Return location relative to branch."""
357
285
if isinstance(file_or_path, basestring):
358
286
file_or_path = [file_or_path]
359
return [bzrlib.BZRDIR] + file_or_path
360
361
def controlfilename(self, file_or_path):
362
"""Return location relative to branch."""
363
return self._transport.abspath(self._rel_controlfilename(file_or_path))
287
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
364
288
365
289
366
290
def controlfile(self, file_or_path, mode='r'):
374
298
Controlfiles should almost never be opened in write mode but
375
299
rather should be atomically copied and replaced using atomicfile.
376
300
"""
377
import codecs
378
379
relpath = self._rel_controlfilename(file_or_path)
380
#TODO: codecs.open() buffers linewise, so it was overloaded with
381
# a much larger buffer, do we need to do the same for getreader/getwriter?
382
if mode == 'rb':
383
return self._transport.get(relpath)
384
elif mode == 'wb':
385
raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
386
elif mode == 'r':
387
return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
388
elif mode == 'w':
389
raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
301
302
fn = self.controlfilename(file_or_path)
303
304
if mode == 'rb' or mode == 'wb':
305
return file(fn, mode)
306
elif mode == 'r' or mode == 'w':
307
# open in binary mode anyhow so there's no newline translation;
308
# codecs uses line buffering by default; don't want that.
309
import codecs
310
return codecs.open(fn, mode + 'b', 'utf-8',
311
buffering=60000)
390
312
else:
391
313
raise BzrError("invalid controlfile mode %r" % mode)
392
314
393
def put_controlfile(self, path, f, encode=True):
394
"""Write an entry as a controlfile.
395
396
:param path: The path to put the file, relative to the .bzr control
397
directory
398
:param f: A file-like or string object whose contents should be copied.
399
:param encode: If true, encode the contents as utf-8
400
"""
401
self.put_controlfiles([(path, f)], encode=encode)
402
403
def put_controlfiles(self, files, encode=True):
404
"""Write several entries as controlfiles.
405
406
:param files: A list of [(path, file)] pairs, where the path is the directory
407
underneath the bzr control directory
408
:param encode: If true, encode the contents as utf-8
409
"""
410
import codecs
411
ctrl_files = []
412
for path, f in files:
413
if encode:
414
if isinstance(f, basestring):
415
f = f.encode('utf-8', 'replace')
416
else:
417
f = codecs.getwriter('utf-8')(f, errors='replace')
418
path = self._rel_controlfilename(path)
419
ctrl_files.append((path, f))
420
self._transport.put_multi(ctrl_files)
421
422
315
def _make_control(self):
423
316
from bzrlib.inventory import Inventory
424
from bzrlib.weavefile import write_weave_v5
425
from bzrlib.weave import Weave
426
317
427
# Create an empty inventory
428
sio = StringIO()
318
os.mkdir(self.controlfilename([]))
319
self.controlfile('README', 'w').write(
320
"This is a Bazaar-NG control directory.\n"
321
"Do not change any files in this directory.\n")
322
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
323
for d in ('text-store', 'inventory-store', 'revision-store'):
324
os.mkdir(self.controlfilename(d))
325
for f in ('revision-history', 'merged-patches',
326
'pending-merged-patches', 'branch-name',
327
'branch-lock',
328
'pending-merges'):
329
self.controlfile(f, 'w').write('')
330
mutter('created control directory in ' + self.base)
331
429
332
# if we want per-tree root ids then this is the place to set
430
333
# them; they're not needed for now and so ommitted for
431
334
# simplicity.
432
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
433
empty_inv = sio.getvalue()
434
sio = StringIO()
435
bzrlib.weavefile.write_weave_v5(Weave(), sio)
436
empty_weave = sio.getvalue()
437
438
dirs = [[], 'revision-store', 'weaves']
439
files = [('README',
440
"This is a Bazaar-NG control directory.\n"
441
"Do not change any files in this directory.\n"),
442
('branch-format', BZR_BRANCH_FORMAT_5),
443
('revision-history', ''),
444
('branch-name', ''),
445
('branch-lock', ''),
446
('pending-merges', ''),
447
('inventory', empty_inv),
448
('inventory.weave', empty_weave),
449
('ancestry.weave', empty_weave)
450
]
451
cfn = self._rel_controlfilename
452
self._transport.mkdir_multi([cfn(d) for d in dirs])
453
self.put_controlfiles(files)
454
mutter('created control directory in ' + self._transport.base)
455
456
def _check_format(self, relax_version_check):
335
f = self.controlfile('inventory','w')
336
bzrlib.xml.serializer_v4.write_inventory(Inventory(), f)
337
338
339
def _check_format(self):
457
340
"""Check this branch format is supported.
458
341
459
The format level is stored, as an integer, in
460
self._branch_format for code that needs to check it later.
342
The current tool only supports the current unstable format.
461
343
462
344
In the future, we might need different in-memory Branch
463
345
classes to support downlevel branches. But not yet.
464
346
"""
465
try:
466
fmt = self.controlfile('branch-format', 'r').read()
467
except NoSuchFile:
468
raise NotBranchError(self.base)
469
mutter("got branch format %r", fmt)
470
if fmt == BZR_BRANCH_FORMAT_5:
471
self._branch_format = 5
472
elif fmt == BZR_BRANCH_FORMAT_4:
473
self._branch_format = 4
474
475
if (not relax_version_check
476
and self._branch_format != 5):
347
# This ignores newlines so that we can open branches created
348
# on Windows from Linux and so on. I think it might be better
349
# to always make all internal files in unix format.
350
fmt = self.controlfile('branch-format', 'r').read()
351
fmt = fmt.replace('\r\n', '\n')
352
if fmt != BZR_BRANCH_FORMAT:
477
353
raise BzrError('sorry, branch format %r not supported' % fmt,
478
354
['use a different bzr version',
479
'or remove the .bzr directory'
480
' and "bzr init" again'])
355
'or remove the .bzr directory and "bzr init" again'])
481
356
482
357
def get_root_id(self):
483
358
"""Return the id of this branches root"""
498
373
499
374
def read_working_inventory(self):
500
375
"""Read the working inventory."""
376
from bzrlib.inventory import Inventory
501
377
self.lock_read()
502
378
try:
503
379
# ElementTree does its own conversion from UTF-8, so open in
504
380
# binary.
505
381
f = self.controlfile('inventory', 'rb')
506
return bzrlib.xml5.serializer_v5.read_inventory(f)
382
return bzrlib.xml.serializer_v4.read_inventory(f)
507
383
finally:
508
384
self.unlock()
509
385
514
390
That is to say, the inventory describing changes underway, that
515
391
will be committed to the next revision.
516
392
"""
517
from cStringIO import StringIO
393
from bzrlib.atomicfile import AtomicFile
394
518
395
self.lock_write()
519
396
try:
520
sio = StringIO()
521
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
522
sio.seek(0)
523
# Transport handles atomicity
524
self.put_controlfile('inventory', sio)
397
f = AtomicFile(self.controlfilename('inventory'), 'wb')
398
try:
399
bzrlib.xml.serializer_v4.write_inventory(inv, f)
400
f.commit()
401
finally:
402
f.close()
525
403
finally:
526
404
self.unlock()
527
405
528
406
mutter('wrote working inventory')
529
407
408
530
409
inventory = property(read_working_inventory, _write_inventory, None,
531
410
"""Inventory for the working copy.""")
532
411
412
533
413
def add(self, files, ids=None):
534
414
"""Make files versioned.
535
415
583
463
kind = file_kind(fullpath)
584
464
except OSError:
585
465
# maybe something better?
586
raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
466
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
587
467
588
if not InventoryEntry.versionable_kind(kind):
589
raise BzrError('cannot add: not a versionable file ('
590
'i.e. regular file, symlink or directory): %s' % quotefn(f))
468
if kind != 'file' and kind != 'directory':
469
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
591
470
592
471
if file_id is None:
593
472
file_id = gen_file_id(f)
658
537
finally:
659
538
self.unlock()
660
539
540
661
541
# FIXME: this doesn't need to be a branch method
662
542
def set_inventory(self, new_inventory_list):
663
543
from bzrlib.inventory import Inventory, InventoryEntry
666
546
name = os.path.basename(path)
667
547
if name == "":
668
548
continue
669
# fixme, there should be a factory function inv,add_??
670
if kind == 'directory':
671
inv.add(inventory.InventoryDirectory(file_id, name, parent))
672
elif kind == 'file':
673
inv.add(inventory.InventoryFile(file_id, name, parent))
674
elif kind == 'symlink':
675
inv.add(inventory.InventoryLink(file_id, name, parent))
676
else:
677
raise BzrError("unknown kind %r" % kind)
549
inv.add(InventoryEntry(file_id, name, kind, parent))
678
550
self._write_inventory(inv)
679
551
552
680
553
def unknowns(self):
681
554
"""Return all unknown files.
682
555
697
570
698
571
699
572
def append_revision(self, *revision_ids):
573
from bzrlib.atomicfile import AtomicFile
574
700
575
for revision_id in revision_ids:
701
576
mutter("add {%s} to revision-history" % revision_id)
702
self.lock_write()
577
578
rev_history = self.revision_history()
579
rev_history.extend(revision_ids)
580
581
f = AtomicFile(self.controlfilename('revision-history'))
703
582
try:
704
rev_history = self.revision_history()
705
rev_history.extend(revision_ids)
706
self.put_controlfile('revision-history', '\n'.join(rev_history))
583
for rev_id in rev_history:
584
print >>f, rev_id
585
f.commit()
707
586
finally:
708
self.unlock()
709
710
def has_revision(self, revision_id):
711
"""True if this branch has a copy of the revision.
712
713
This does not necessarily imply the revision is merge
714
or on the mainline."""
715
return (revision_id is None
716
or revision_id in self.revision_store)
587
f.close()
588
717
589
718
590
def get_revision_xml_file(self, revision_id):
719
591
"""Return XML file object for revision object."""
729
601
finally:
730
602
self.unlock()
731
603
604
732
605
#deprecated
733
606
get_revision_xml = get_revision_xml_file
734
607
735
def get_revision_xml(self, revision_id):
736
return self.get_revision_xml_file(revision_id).read()
737
738
608
739
609
def get_revision(self, revision_id):
740
610
"""Return the Revision object for a named revision"""
741
611
xml_file = self.get_revision_xml_file(revision_id)
742
612
743
613
try:
744
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
614
r = bzrlib.xml.serializer_v4.read_revision(xml_file)
745
615
except SyntaxError, e:
746
616
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
747
617
[revision_id,
750
620
assert r.revision_id == revision_id
751
621
return r
752
622
623
753
624
def get_revision_delta(self, revno):
754
625
"""Return the delta for one revision.
755
626
771
642
772
643
return compare_trees(old_tree, new_tree)
773
644
645
646
774
647
def get_revision_sha1(self, revision_id):
775
648
"""Hash the stored value of a revision, and return it."""
776
649
# In the future, revision entries will be signed. At that
779
652
# the revision, (add signatures/remove signatures) and still
780
653
# have all hash pointers stay consistent.
781
654
# But for now, just hash the contents.
782
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
783
784
def get_ancestry(self, revision_id):
785
"""Return a list of revision-ids integrated by a revision.
786
787
This currently returns a list, but the ordering is not guaranteed:
788
treat it as a set.
789
"""
790
if revision_id is None:
791
return [None]
792
w = self.control_weaves.get_weave('inventory')
793
return [None] + map(w.idx_to_name,
794
w.inclusions([w.lookup(revision_id)]))
795
796
def get_inventory_weave(self):
797
return self.control_weaves.get_weave('inventory')
798
799
def get_inventory(self, revision_id):
800
"""Get Inventory object by hash."""
801
xml = self.get_inventory_xml(revision_id)
802
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
803
804
def get_inventory_xml(self, revision_id):
655
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
656
657
658
def get_inventory(self, inventory_id):
659
"""Get Inventory object by hash.
660
661
TODO: Perhaps for this and similar methods, take a revision
662
parameter which can be either an integer revno or a
663
string hash."""
664
from bzrlib.inventory import Inventory
665
666
f = self.get_inventory_xml_file(inventory_id)
667
return bzrlib.xml.serializer_v4.read_inventory(f)
668
669
670
def get_inventory_xml(self, inventory_id):
805
671
"""Get inventory XML as a file object."""
806
try:
807
assert isinstance(revision_id, basestring), type(revision_id)
808
iw = self.get_inventory_weave()
809
return iw.get_text(iw.lookup(revision_id))
810
except IndexError:
811
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
812
813
def get_inventory_sha1(self, revision_id):
672
return self.inventory_store[inventory_id]
673
674
get_inventory_xml_file = get_inventory_xml
675
676
677
def get_inventory_sha1(self, inventory_id):
814
678
"""Return the sha1 hash of the inventory entry
815
679
"""
816
return self.get_revision(revision_id).inventory_sha1
680
return sha_file(self.get_inventory_xml(inventory_id))
681
817
682
818
683
def get_revision_inventory(self, revision_id):
819
684
"""Return inventory of a past revision."""
820
# TODO: Unify this with get_inventory()
821
# bzr 0.0.6 and later imposes the constraint that the inventory_id
685
# bzr 0.0.6 imposes the constraint that the inventory_id
822
686
# must be the same as its revision, so this is trivial.
823
687
if revision_id == None:
688
from bzrlib.inventory import Inventory
824
689
return Inventory(self.get_root_id())
825
690
else:
826
691
return self.get_inventory(revision_id)
827
692
693
828
694
def revision_history(self):
829
"""Return sequence of revision hashes on to this branch."""
695
"""Return sequence of revision hashes on to this branch.
696
697
>>> ScratchBranch().revision_history()
698
[]
699
"""
830
700
self.lock_read()
831
701
try:
832
702
return [l.rstrip('\r\n') for l in
834
704
finally:
835
705
self.unlock()
836
706
707
837
708
def common_ancestor(self, other, self_revno=None, other_revno=None):
838
709
"""
839
710
>>> from bzrlib.commit import commit
888
759
return len(self.revision_history())
889
760
890
761
891
def last_revision(self):
762
def last_patch(self):
892
763
"""Return last patch hash, or None if no history.
893
764
"""
894
765
ph = self.revision_history()
899
770
900
771
901
772
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
902
"""Return a list of new revisions that would perfectly fit.
903
773
"""
904
774
If self and other have not diverged, return a list of the revisions
905
775
present in other, but missing from self.
906
776
926
796
Traceback (most recent call last):
927
797
DivergedBranches: These branches have diverged.
928
798
"""
929
# FIXME: If the branches have diverged, but the latest
930
# revision in this branch is completely merged into the other,
931
# then we should still be able to pull.
932
799
self_history = self.revision_history()
933
800
self_len = len(self_history)
934
801
other_history = other.revision_history()
940
807
941
808
if stop_revision is None:
942
809
stop_revision = other_len
943
else:
944
assert isinstance(stop_revision, int)
945
if stop_revision > other_len:
946
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
810
elif stop_revision > other_len:
811
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
812
947
813
return other_history[self_len:stop_revision]
948
814
815
949
816
def update_revisions(self, other, stop_revision=None):
950
"""Pull in new perfect-fit revisions."""
817
"""Pull in all new revisions from other branch.
818
"""
951
819
from bzrlib.fetch import greedy_fetch
952
820
from bzrlib.revision import get_intervening_revisions
821
822
pb = bzrlib.ui.ui_factory.progress_bar()
823
pb.update('comparing histories')
953
824
if stop_revision is None:
954
stop_revision = other.last_revision()
955
greedy_fetch(to_branch=self, from_branch=other,
956
revision=stop_revision)
957
pullable_revs = self.missing_revisions(
958
other, other.revision_id_to_revno(stop_revision))
959
if pullable_revs:
960
greedy_fetch(to_branch=self,
961
from_branch=other,
962
revision=pullable_revs[-1])
963
self.append_revision(*pullable_revs)
964
825
other_revision = other.last_patch()
826
else:
827
other_revision = other.get_rev_id(stop_revision)
828
count = greedy_fetch(self, other, other_revision, pb)[0]
829
try:
830
revision_ids = self.missing_revisions(other, stop_revision)
831
except DivergedBranches, e:
832
try:
833
revision_ids = get_intervening_revisions(self.last_patch(),
834
other_revision, self)
835
assert self.last_patch() not in revision_ids
836
except bzrlib.errors.NotAncestor:
837
raise e
838
839
self.append_revision(*revision_ids)
840
pb.clear()
841
842
def install_revisions(self, other, revision_ids, pb):
843
if hasattr(other.revision_store, "prefetch"):
844
other.revision_store.prefetch(revision_ids)
845
if hasattr(other.inventory_store, "prefetch"):
846
inventory_ids = []
847
for rev_id in revision_ids:
848
try:
849
revision = other.get_revision(rev_id).inventory_id
850
inventory_ids.append(revision)
851
except bzrlib.errors.NoSuchRevision:
852
pass
853
other.inventory_store.prefetch(inventory_ids)
854
855
if pb is None:
856
pb = bzrlib.ui.ui_factory.progress_bar()
857
858
revisions = []
859
needed_texts = set()
860
i = 0
861
862
failures = set()
863
for i, rev_id in enumerate(revision_ids):
864
pb.update('fetching revision', i+1, len(revision_ids))
865
try:
866
rev = other.get_revision(rev_id)
867
except bzrlib.errors.NoSuchRevision:
868
failures.add(rev_id)
869
continue
870
871
revisions.append(rev)
872
inv = other.get_inventory(str(rev.inventory_id))
873
for key, entry in inv.iter_entries():
874
if entry.text_id is None:
875
continue
876
if entry.text_id not in self.text_store:
877
needed_texts.add(entry.text_id)
878
879
pb.clear()
880
881
count, cp_fail = self.text_store.copy_multi(other.text_store,
882
needed_texts)
883
#print "Added %d texts." % count
884
inventory_ids = [ f.inventory_id for f in revisions ]
885
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
886
inventory_ids)
887
#print "Added %d inventories." % count
888
revision_ids = [ f.revision_id for f in revisions]
889
890
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
891
revision_ids,
892
permit_failure=True)
893
assert len(cp_fail) == 0
894
return count, failures
895
965
896
966
897
def commit(self, *args, **kw):
967
from bzrlib.commit import Commit
968
Commit().commit(self, *args, **kw)
969
898
from bzrlib.commit import commit
899
commit(self, *args, **kw)
900
901
970
902
def revision_id_to_revno(self, revision_id):
971
903
"""Given a revision id, return its revno"""
972
if revision_id is None:
973
return 0
974
904
history = self.revision_history()
975
905
try:
976
906
return history.index(revision_id) + 1
977
907
except ValueError:
978
908
raise bzrlib.errors.NoSuchRevision(self, revision_id)
979
909
910
980
911
def get_rev_id(self, revno, history=None):
981
912
"""Find the revision id of the specified revno."""
982
913
if revno == 0:
987
918
raise bzrlib.errors.NoSuchRevision(self, revno)
988
919
return history[revno - 1]
989
920
921
990
922
def revision_tree(self, revision_id):
991
923
"""Return Tree for a revision on this branch.
992
924
998
930
return EmptyTree()
999
931
else:
1000
932
inv = self.get_revision_inventory(revision_id)
1001
return RevisionTree(self.weave_store, inv, revision_id)
933
return RevisionTree(self.text_store, inv)
1002
934
1003
935
1004
936
def working_tree(self):
1005
937
"""Return a `Tree` for the working copy."""
1006
938
from bzrlib.workingtree import WorkingTree
1007
# TODO: In the future, WorkingTree should utilize Transport
1008
# RobertCollins 20051003 - I don't think it should - working trees are
1009
# much more complex to keep consistent than our careful .bzr subset.
1010
# instead, we should say that working trees are local only, and optimise
1011
# for that.
1012
return WorkingTree(self._transport.base, self.read_working_inventory())
939
return WorkingTree(self.base, self.read_working_inventory())
1013
940
1014
941
1015
942
def basis_tree(self):
1017
944
1018
945
If there are no revisions yet, return an `EmptyTree`.
1019
946
"""
1020
return self.revision_tree(self.last_revision())
947
r = self.last_patch()
948
if r == None:
949
return EmptyTree()
950
else:
951
return RevisionTree(self.text_store, self.get_revision_inventory(r))
952
1021
953
1022
954
1023
955
def rename_one(self, from_rel, to_rel):
1058
990
from_abs = self.abspath(from_rel)
1059
991
to_abs = self.abspath(to_rel)
1060
992
try:
1061
rename(from_abs, to_abs)
993
os.rename(from_abs, to_abs)
1062
994
except OSError, e:
1063
995
raise BzrError("failed to rename %r to %r: %s"
1064
996
% (from_abs, to_abs, e[1]),
1127
1059
result.append((f, dest_path))
1128
1060
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1129
1061
try:
1130
rename(self.abspath(f), self.abspath(dest_path))
1062
os.rename(self.abspath(f), self.abspath(dest_path))
1131
1063
except OSError, e:
1132
1064
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1133
1065
["rename rolled back"])
1189
1121
These are revisions that have been merged into the working
1190
1122
directory but not yet committed.
1191
1123
"""
1192
cfn = self._rel_controlfilename('pending-merges')
1193
if not self._transport.has(cfn):
1124
cfn = self.controlfilename('pending-merges')
1125
if not os.path.exists(cfn):
1194
1126
return []
1195
1127
p = []
1196
1128
for l in self.controlfile('pending-merges', 'r').readlines():
1198
1130
return p
1199
1131
1200
1132
1201
def add_pending_merge(self, *revision_ids):
1202
# TODO: Perhaps should check at this point that the
1203
# history of the revision is actually present?
1133
def add_pending_merge(self, revision_id):
1134
from bzrlib.revision import validate_revision_id
1135
1136
validate_revision_id(revision_id)
1137
1204
1138
p = self.pending_merges()
1205
updated = False
1206
for rev_id in revision_ids:
1207
if rev_id in p:
1208
continue
1209
p.append(rev_id)
1210
updated = True
1211
if updated:
1212
self.set_pending_merges(p)
1139
if revision_id in p:
1140
return
1141
p.append(revision_id)
1142
self.set_pending_merges(p)
1143
1213
1144
1214
1145
def set_pending_merges(self, rev_list):
1146
from bzrlib.atomicfile import AtomicFile
1215
1147
self.lock_write()
1216
1148
try:
1217
self.put_controlfile('pending-merges', '\n'.join(rev_list))
1149
f = AtomicFile(self.controlfilename('pending-merges'))
1150
try:
1151
for l in rev_list:
1152
print >>f, l
1153
f.commit()
1154
finally:
1155
f.close()
1218
1156
finally:
1219
1157
self.unlock()
1220
1158
1271
1209
1272
1210
1273
1211
1274
class ScratchBranch(_Branch):
1212
class ScratchBranch(LocalBranch):
1275
1213
"""Special test class: a branch that cleans up after itself.
1276
1214
1277
1215
>>> b = ScratchBranch()
1294
1232
if base is None:
1295
1233
base = mkdtemp()
1296
1234
init = True
1297
if isinstance(base, basestring):
1298
base = get_transport(base)
1299
_Branch.__init__(self, base, init=init)
1235
LocalBranch.__init__(self, base, init=init)
1300
1236
for d in dirs:
1301
self._transport.mkdir(d)
1237
os.mkdir(self.abspath(d))
1302
1238
1303
1239
for f in files:
1304
self._transport.put(f, 'content of %s' % f)
1240
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1305
1241
1306
1242
1307
1243
def clone(self):
1308
1244
"""
1309
1245
>>> orig = ScratchBranch(files=["file1", "file2"])
1310
1246
>>> clone = orig.clone()
1311
>>> if os.name != 'nt':
1312
... os.path.samefile(orig.base, clone.base)
1313
... else:
1314
... orig.base == clone.base
1315
...
1247
>>> os.path.samefile(orig.base, clone.base)
1316
1248
False
1317
1249
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1318
1250
True
1324
1256
copytree(self.base, base, symlinks=True)
1325
1257
return ScratchBranch(base=base)
1326
1258
1259
1260
1327
1261
def __del__(self):
1328
1262
self.destroy()
1329
1263
1342
1276
for name in files:
1343
1277
os.chmod(os.path.join(root, name), 0700)
1344
1278
rmtree(self.base)
1345
self._transport = None
1279
self.base = None
1346
1280
1347
1281
1348
1282
1399
1333
return gen_file_id('TREE_ROOT')
1400
1334
1401
1335
1336
def copy_branch(branch_from, to_location, revision=None):
1337
"""Copy branch_from into the existing directory to_location.
1338
1339
revision
1340
If not None, only revisions up to this point will be copied.
1341
The head of the new branch will be that revision.
1342
1343
to_location
1344
The name of a local directory that exists but is empty.
1345
"""
1346
from bzrlib.merge import merge
1347
from bzrlib.revisionspec import RevisionSpec
1348
1349
assert isinstance(branch_from, Branch)
1350
assert isinstance(to_location, basestring)
1351
1352
br_to = Branch.initialize(to_location)
1353
br_to.set_root_id(branch_from.get_root_id())
1354
if revision is None:
1355
revno = branch_from.revno()
1356
else:
1357
revno, rev_id = RevisionSpec(revision).in_history(branch_from)
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