« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1185.13.1
- compare with another revision
- compare with revision 6170
- download diff
- download tarball
- view history from revision 1185.13.1
- Committer: Robert Collins
- Date: 2005-10-06 12:34:22 UTC
- mfrom: (1418)
- mto: (1417.1.4) (1185.41.1 bzr.sftp) (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)
- mto: This revision was merged to the branch mainline in revision 1419.
- Revision ID: robertc@robertcollins.net-20051006123422-cd10b1c9ea79a299
Merge in format-5 work - release bzr 0.1rc1.
- files added:
- NEWS.developers
- bzrlib/store
- bzrlib/transport
- files removed:
- bzrlib/meta_store.py
- files renamed:
- tools/testweave.py => bzrlib/selftest/test_weave.py
- bzrlib/store.py => bzrlib/store/__init__.py
- tools/history2weaves.py => bzrlib/upgrade.py
- bzrlib/newinventory.py => contrib/newinventory.py
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
17
17
18
18
import sys
19
19
import os
20
import errno
21
from warnings import warn
22
from cStringIO import StringIO
23
20
24
21
25
import bzrlib
26
from bzrlib.inventory import InventoryEntry
27
import bzrlib.inventory as inventory
22
28
from bzrlib.trace import mutter, note
23
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
24
splitpath, \
25
sha_file, appendpath, file_kind
26
27
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId, \
28
DivergedBranches, NotBranchError
29
from bzrlib.osutils import (isdir, quotefn, compact_date, rand_bytes,
30
rename, splitpath, sha_file, appendpath,
31
file_kind)
32
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
33
NoSuchRevision, HistoryMissing, NotBranchError,
34
DivergedBranches, LockError, UnlistableStore,
35
UnlistableBranch, NoSuchFile)
29
36
from bzrlib.textui import show_status
30
37
from bzrlib.revision import Revision
31
38
from bzrlib.delta import compare_trees
32
39
from bzrlib.tree import EmptyTree, RevisionTree
33
import bzrlib.xml
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
34
47
import bzrlib.ui
35
48
36
49
37
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
50
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
51
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
39
52
## TODO: Maybe include checks for common corruption of newlines, etc?
40
53
41
54
42
55
# TODO: Some operations like log might retrieve the same revisions
43
56
# repeatedly to calculate deltas. We could perhaps have a weakref
44
# cache in memory to make this faster.
57
# cache in memory to make this faster. In general anything can be
58
# cached in memory between lock and unlock operations.
45
59
46
60
def find_branch(*ignored, **ignored_too):
47
61
# XXX: leave this here for about one release, then remove it
48
62
raise NotImplementedError('find_branch() is not supported anymore, '
49
63
'please use one of the new branch constructors')
50
51
64
def _relpath(base, path):
52
65
"""Return path relative to base, or raise exception.
53
66
75
88
return os.sep.join(s)
76
89
77
90
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.
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.
84
97
85
98
Basically we keep looking up until we find the control directory or
86
99
run into the root. If there isn't one, raises NotBranchError.
87
100
"""
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
101
orig_base = t.base
100
102
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:
103
if t.has(bzrlib.BZRDIR):
104
return t
105
new_t = t.clone('..')
106
if new_t.base == t.base:
105
107
# reached the root, whatever that may be
106
raise NotBranchError('%s is not in a branch' % orig_f)
107
f = head
108
109
108
raise NotBranchError('%s is not in a branch' % orig_base)
109
t = new_t
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
127
134
def open(base):
128
135
"""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)
136
t = get_transport(base)
137
mutter("trying to open %r with transport %r", base, t)
138
return _Branch(t)
134
139
135
140
@staticmethod
136
141
def open_containing(url):
137
"""Open an existing branch, containing url (search upwards for the root)
142
"""Open an existing branch which contains url.
143
144
This probes for a branch at url, and searches upwards from there.
138
145
"""
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)
146
t = get_transport(url)
147
t = find_branch_root(t)
148
return _Branch(t)
144
149
145
150
@staticmethod
146
151
def initialize(base):
147
152
"""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)
153
t = get_transport(base)
154
return _Branch(t, init=True)
153
155
154
156
def setup_caching(self, cache_root):
155
157
"""Subclasses that care about caching should override this, and set
156
158
up cached stores located under cache_root.
157
159
"""
158
159
160
class LocalBranch(Branch):
160
self.cache_root = cache_root
161
162
163
class _Branch(Branch):
161
164
"""A branch stored in the actual filesystem.
162
165
163
166
Note that it's "local" in the context of the filesystem; it doesn't
181
184
_lock_mode = None
182
185
_lock_count = None
183
186
_lock = None
184
185
def __init__(self, base, init=False, find_root=True):
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):
186
216
"""Create new branch object at a particular location.
187
217
188
base -- Base directory for the branch. May be a file:// url.
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)
189
221
190
222
init -- If True, create new control files in a previously
191
223
unversioned directory. If False, the branch must already
192
224
be versioned.
193
225
194
find_root -- If true and init is false, find the root of the
195
existing branch containing base.
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.
196
230
197
231
In the test suite, creation of new trees is tested using the
198
232
`ScratchBranch` class.
199
233
"""
200
from bzrlib.store import ImmutableStore
234
assert isinstance(transport, Transport), \
235
"%r is not a Transport" % transport
236
self._transport = transport
201
237
if init:
202
self.base = os.path.realpath(base)
203
238
self._make_control()
204
elif find_root:
205
self.base = find_branch_root(base)
206
else:
207
if base.startswith("file://"):
208
base = base[7:]
209
self.base = os.path.realpath(base)
210
if not isdir(self.controlfilename('.')):
211
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
212
['use "bzr init" to initialize a new working tree',
213
'current bzr can only operate from top-of-tree'])
214
self._check_format()
215
216
self.text_store = ImmutableStore(self.controlfilename('text-store'))
217
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
218
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
219
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)
220
271
221
272
def __str__(self):
222
return '%s(%r)' % (self.__class__.__name__, self.base)
273
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
223
274
224
275
225
276
__repr__ = __str__
227
278
228
279
def __del__(self):
229
280
if self._lock_mode or self._lock:
230
from bzrlib.warnings import warn
281
# XXX: This should show something every time, and be suitable for
282
# headless operation and embedding
231
283
warn("branch %r was not explicitly unlocked" % self)
232
284
self._lock.unlock()
233
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
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
234
308
def lock_write(self):
309
# TODO: Upgrade locking to support using a Transport,
310
# and potentially a remote locking protocol
235
311
if self._lock_mode:
236
312
if self._lock_mode != 'w':
237
from bzrlib.errors import LockError
238
313
raise LockError("can't upgrade to a write lock from %r" %
239
314
self._lock_mode)
240
315
self._lock_count += 1
241
316
else:
242
from bzrlib.lock import WriteLock
243
244
self._lock = WriteLock(self.controlfilename('branch-lock'))
317
self._lock = self._transport.lock_write(
318
self._rel_controlfilename('branch-lock'))
245
319
self._lock_mode = 'w'
246
320
self._lock_count = 1
247
321
252
326
"invalid lock mode %r" % self._lock_mode
253
327
self._lock_count += 1
254
328
else:
255
from bzrlib.lock import ReadLock
256
257
self._lock = ReadLock(self.controlfilename('branch-lock'))
329
self._lock = self._transport.lock_read(
330
self._rel_controlfilename('branch-lock'))
258
331
self._lock_mode = 'r'
259
332
self._lock_count = 1
260
333
261
334
def unlock(self):
262
335
if not self._lock_mode:
263
from bzrlib.errors import LockError
264
336
raise LockError('branch %r is not locked' % (self))
265
337
266
338
if self._lock_count > 1:
272
344
273
345
def abspath(self, name):
274
346
"""Return absolute filename for something in the branch"""
275
return os.path.join(self.base, name)
347
return self._transport.abspath(name)
276
348
277
349
def relpath(self, path):
278
350
"""Return path relative to this branch of something inside it.
279
351
280
352
Raises an error if path is not in this branch."""
281
return _relpath(self.base, path)
353
return self._transport.relpath(path)
354
355
356
def _rel_controlfilename(self, file_or_path):
357
if isinstance(file_or_path, basestring):
358
file_or_path = [file_or_path]
359
return [bzrlib.BZRDIR] + file_or_path
282
360
283
361
def controlfilename(self, file_or_path):
284
362
"""Return location relative to branch."""
285
if isinstance(file_or_path, basestring):
286
file_or_path = [file_or_path]
287
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
363
return self._transport.abspath(self._rel_controlfilename(file_or_path))
288
364
289
365
290
366
def controlfile(self, file_or_path, mode='r'):
298
374
Controlfiles should almost never be opened in write mode but
299
375
rather should be atomically copied and replaced using atomicfile.
300
376
"""
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)
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")
312
390
else:
313
391
raise BzrError("invalid controlfile mode %r" % mode)
314
392
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
315
422
def _make_control(self):
316
423
from bzrlib.inventory import Inventory
424
from bzrlib.weavefile import write_weave_v5
425
from bzrlib.weave import Weave
317
426
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
427
# Create an empty inventory
428
sio = StringIO()
332
429
# if we want per-tree root ids then this is the place to set
333
430
# them; they're not needed for now and so ommitted for
334
431
# simplicity.
335
f = self.controlfile('inventory','w')
336
bzrlib.xml.serializer_v4.write_inventory(Inventory(), f)
337
338
339
def _check_format(self):
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):
340
457
"""Check this branch format is supported.
341
458
342
The current tool only supports the current unstable format.
459
The format level is stored, as an integer, in
460
self._branch_format for code that needs to check it later.
343
461
344
462
In the future, we might need different in-memory Branch
345
463
classes to support downlevel branches. But not yet.
346
464
"""
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:
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):
353
477
raise BzrError('sorry, branch format %r not supported' % fmt,
354
478
['use a different bzr version',
355
'or remove the .bzr directory and "bzr init" again'])
479
'or remove the .bzr directory'
480
' and "bzr init" again'])
356
481
357
482
def get_root_id(self):
358
483
"""Return the id of this branches root"""
373
498
374
499
def read_working_inventory(self):
375
500
"""Read the working inventory."""
376
from bzrlib.inventory import Inventory
377
501
self.lock_read()
378
502
try:
379
503
# ElementTree does its own conversion from UTF-8, so open in
380
504
# binary.
381
505
f = self.controlfile('inventory', 'rb')
382
return bzrlib.xml.serializer_v4.read_inventory(f)
506
return bzrlib.xml5.serializer_v5.read_inventory(f)
383
507
finally:
384
508
self.unlock()
385
509
390
514
That is to say, the inventory describing changes underway, that
391
515
will be committed to the next revision.
392
516
"""
393
from bzrlib.atomicfile import AtomicFile
394
517
from cStringIO import StringIO
395
518
self.lock_write()
396
519
try:
397
f = AtomicFile(self.controlfilename('inventory'), 'wb')
398
try:
399
bzrlib.xml.serializer_v4.write_inventory(inv, f)
400
f.commit()
401
finally:
402
f.close()
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)
403
525
finally:
404
526
self.unlock()
405
527
406
528
mutter('wrote working inventory')
407
529
408
409
530
inventory = property(read_working_inventory, _write_inventory, None,
410
531
"""Inventory for the working copy.""")
411
532
412
413
533
def add(self, files, ids=None):
414
534
"""Make files versioned.
415
535
463
583
kind = file_kind(fullpath)
464
584
except OSError:
465
585
# maybe something better?
466
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
586
raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
467
587
468
if kind != 'file' and kind != 'directory':
469
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
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))
470
591
471
592
if file_id is None:
472
593
file_id = gen_file_id(f)
537
658
finally:
538
659
self.unlock()
539
660
540
541
661
# FIXME: this doesn't need to be a branch method
542
662
def set_inventory(self, new_inventory_list):
543
663
from bzrlib.inventory import Inventory, InventoryEntry
546
666
name = os.path.basename(path)
547
667
if name == "":
548
668
continue
549
inv.add(InventoryEntry(file_id, name, kind, parent))
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)
550
678
self._write_inventory(inv)
551
679
552
553
680
def unknowns(self):
554
681
"""Return all unknown files.
555
682
570
697
571
698
572
699
def append_revision(self, *revision_ids):
573
from bzrlib.atomicfile import AtomicFile
574
575
700
for revision_id in revision_ids:
576
701
mutter("add {%s} to revision-history" % revision_id)
577
578
rev_history = self.revision_history()
579
rev_history.extend(revision_ids)
580
581
f = AtomicFile(self.controlfilename('revision-history'))
702
self.lock_write()
582
703
try:
583
for rev_id in rev_history:
584
print >>f, rev_id
585
f.commit()
704
rev_history = self.revision_history()
705
rev_history.extend(revision_ids)
706
self.put_controlfile('revision-history', '\n'.join(rev_history))
586
707
finally:
587
f.close()
588
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)
589
717
590
718
def get_revision_xml_file(self, revision_id):
591
719
"""Return XML file object for revision object."""
601
729
finally:
602
730
self.unlock()
603
731
604
605
732
#deprecated
606
733
get_revision_xml = get_revision_xml_file
607
734
735
def get_revision_xml(self, revision_id):
736
return self.get_revision_xml_file(revision_id).read()
737
608
738
609
739
def get_revision(self, revision_id):
610
740
"""Return the Revision object for a named revision"""
611
741
xml_file = self.get_revision_xml_file(revision_id)
612
742
613
743
try:
614
r = bzrlib.xml.serializer_v4.read_revision(xml_file)
744
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
615
745
except SyntaxError, e:
616
746
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
617
747
[revision_id,
620
750
assert r.revision_id == revision_id
621
751
return r
622
752
623
624
753
def get_revision_delta(self, revno):
625
754
"""Return the delta for one revision.
626
755
642
771
643
772
return compare_trees(old_tree, new_tree)
644
773
645
646
647
774
def get_revision_sha1(self, revision_id):
648
775
"""Hash the stored value of a revision, and return it."""
649
776
# In the future, revision entries will be signed. At that
652
779
# the revision, (add signatures/remove signatures) and still
653
780
# have all hash pointers stay consistent.
654
781
# But for now, just hash the contents.
655
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
656
657
658
def get_inventory(self, inventory_id):
659
"""Get Inventory object by hash.
660
661
TODO: Perhaps for this and similar methods, take a revision
662
parameter which can be either an integer revno or a
663
string hash."""
664
from bzrlib.inventory import Inventory
665
666
f = self.get_inventory_xml_file(inventory_id)
667
return bzrlib.xml.serializer_v4.read_inventory(f)
668
669
670
def get_inventory_xml(self, inventory_id):
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):
671
805
"""Get inventory XML as a file object."""
672
return self.inventory_store[inventory_id]
673
674
get_inventory_xml_file = get_inventory_xml
675
676
677
def get_inventory_sha1(self, inventory_id):
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):
678
814
"""Return the sha1 hash of the inventory entry
679
815
"""
680
return sha_file(self.get_inventory_xml(inventory_id))
681
816
return self.get_revision(revision_id).inventory_sha1
682
817
683
818
def get_revision_inventory(self, revision_id):
684
819
"""Return inventory of a past revision."""
685
# bzr 0.0.6 imposes the constraint that the inventory_id
820
# TODO: Unify this with get_inventory()
821
# bzr 0.0.6 and later imposes the constraint that the inventory_id
686
822
# must be the same as its revision, so this is trivial.
687
823
if revision_id == None:
688
from bzrlib.inventory import Inventory
689
824
return Inventory(self.get_root_id())
690
825
else:
691
826
return self.get_inventory(revision_id)
692
827
693
694
828
def revision_history(self):
695
"""Return sequence of revision hashes on to this branch.
696
697
>>> ScratchBranch().revision_history()
698
[]
699
"""
829
"""Return sequence of revision hashes on to this branch."""
700
830
self.lock_read()
701
831
try:
702
832
return [l.rstrip('\r\n') for l in
704
834
finally:
705
835
self.unlock()
706
836
707
708
837
def common_ancestor(self, other, self_revno=None, other_revno=None):
709
838
"""
710
839
>>> from bzrlib.commit import commit
759
888
return len(self.revision_history())
760
889
761
890
762
def last_patch(self):
891
def last_revision(self):
763
892
"""Return last patch hash, or None if no history.
764
893
"""
765
894
ph = self.revision_history()
770
899
771
900
772
901
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
773
"""
902
"""Return a list of new revisions that would perfectly fit.
903
774
904
If self and other have not diverged, return a list of the revisions
775
905
present in other, but missing from self.
776
906
796
926
Traceback (most recent call last):
797
927
DivergedBranches: These branches have diverged.
798
928
"""
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.
799
932
self_history = self.revision_history()
800
933
self_len = len(self_history)
801
934
other_history = other.revision_history()
807
940
808
941
if stop_revision is None:
809
942
stop_revision = other_len
810
elif stop_revision > other_len:
811
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
812
943
else:
944
assert isinstance(stop_revision, int)
945
if stop_revision > other_len:
946
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
813
947
return other_history[self_len:stop_revision]
814
948
815
816
949
def update_revisions(self, other, stop_revision=None):
817
"""Pull in all new revisions from other branch.
818
"""
950
"""Pull in new perfect-fit revisions."""
819
951
from bzrlib.fetch import greedy_fetch
820
952
from bzrlib.revision import get_intervening_revisions
821
822
pb = bzrlib.ui.ui_factory.progress_bar()
823
pb.update('comparing histories')
824
953
if stop_revision is None:
825
other_revision = other.last_patch()
826
else:
827
other_revision = other.get_rev_id(stop_revision)
828
count = greedy_fetch(self, other, other_revision, pb)[0]
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
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
896
965
897
966
def commit(self, *args, **kw):
898
from bzrlib.commit import commit
899
commit(self, *args, **kw)
900
967
from bzrlib.commit import Commit
968
Commit().commit(self, *args, **kw)
969
901
970
def revision_id_to_revno(self, revision_id):
902
971
"""Given a revision id, return its revno"""
972
if revision_id is None:
973
return 0
903
974
history = self.revision_history()
904
975
try:
905
976
return history.index(revision_id) + 1
916
987
raise bzrlib.errors.NoSuchRevision(self, revno)
917
988
return history[revno - 1]
918
989
919
920
990
def revision_tree(self, revision_id):
921
991
"""Return Tree for a revision on this branch.
922
992
928
998
return EmptyTree()
929
999
else:
930
1000
inv = self.get_revision_inventory(revision_id)
931
return RevisionTree(self.text_store, inv)
1001
return RevisionTree(self.weave_store, inv, revision_id)
932
1002
933
1003
934
1004
def working_tree(self):
935
1005
"""Return a `Tree` for the working copy."""
936
1006
from bzrlib.workingtree import WorkingTree
937
return WorkingTree(self.base, self.read_working_inventory())
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())
938
1013
939
1014
940
1015
def basis_tree(self):
942
1017
943
1018
If there are no revisions yet, return an `EmptyTree`.
944
1019
"""
945
r = self.last_patch()
946
if r == None:
947
return EmptyTree()
948
else:
949
return RevisionTree(self.text_store, self.get_revision_inventory(r))
950
1020
return self.revision_tree(self.last_revision())
951
1021
952
1022
953
1023
def rename_one(self, from_rel, to_rel):
988
1058
from_abs = self.abspath(from_rel)
989
1059
to_abs = self.abspath(to_rel)
990
1060
try:
991
os.rename(from_abs, to_abs)
1061
rename(from_abs, to_abs)
992
1062
except OSError, e:
993
1063
raise BzrError("failed to rename %r to %r: %s"
994
1064
% (from_abs, to_abs, e[1]),
1057
1127
result.append((f, dest_path))
1058
1128
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1059
1129
try:
1060
os.rename(self.abspath(f), self.abspath(dest_path))
1130
rename(self.abspath(f), self.abspath(dest_path))
1061
1131
except OSError, e:
1062
1132
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1063
1133
["rename rolled back"])
1119
1189
These are revisions that have been merged into the working
1120
1190
directory but not yet committed.
1121
1191
"""
1122
cfn = self.controlfilename('pending-merges')
1123
if not os.path.exists(cfn):
1192
cfn = self._rel_controlfilename('pending-merges')
1193
if not self._transport.has(cfn):
1124
1194
return []
1125
1195
p = []
1126
1196
for l in self.controlfile('pending-merges', 'r').readlines():
1128
1198
return p
1129
1199
1130
1200
1131
def add_pending_merge(self, revision_id):
1132
from bzrlib.revision import validate_revision_id
1133
1134
validate_revision_id(revision_id)
1135
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?
1136
1204
p = self.pending_merges()
1137
if revision_id in p:
1138
return
1139
p.append(revision_id)
1140
self.set_pending_merges(p)
1141
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)
1142
1213
1143
1214
def set_pending_merges(self, rev_list):
1144
from bzrlib.atomicfile import AtomicFile
1145
1215
self.lock_write()
1146
1216
try:
1147
f = AtomicFile(self.controlfilename('pending-merges'))
1148
try:
1149
for l in rev_list:
1150
print >>f, l
1151
f.commit()
1152
finally:
1153
f.close()
1217
self.put_controlfile('pending-merges', '\n'.join(rev_list))
1154
1218
finally:
1155
1219
self.unlock()
1156
1220
1207
1271
1208
1272
1209
1273
1210
class ScratchBranch(LocalBranch):
1274
class ScratchBranch(_Branch):
1211
1275
"""Special test class: a branch that cleans up after itself.
1212
1276
1213
1277
>>> b = ScratchBranch()
1230
1294
if base is None:
1231
1295
base = mkdtemp()
1232
1296
init = True
1233
LocalBranch.__init__(self, base, init=init)
1297
if isinstance(base, basestring):
1298
base = get_transport(base)
1299
_Branch.__init__(self, base, init=init)
1234
1300
for d in dirs:
1235
os.mkdir(self.abspath(d))
1301
self._transport.mkdir(d)
1236
1302
1237
1303
for f in files:
1238
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1304
self._transport.put(f, 'content of %s' % f)
1239
1305
1240
1306
1241
1307
def clone(self):
1242
1308
"""
1243
1309
>>> orig = ScratchBranch(files=["file1", "file2"])
1244
1310
>>> clone = orig.clone()
1245
>>> os.path.samefile(orig.base, clone.base)
1311
>>> if os.name != 'nt':
1312
... os.path.samefile(orig.base, clone.base)
1313
... else:
1314
... orig.base == clone.base
1315
...
1246
1316
False
1247
1317
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1248
1318
True
1254
1324
copytree(self.base, base, symlinks=True)
1255
1325
return ScratchBranch(base=base)
1256
1326
1257
1258
1259
1327
def __del__(self):
1260
1328
self.destroy()
1261
1329
1274
1342
for name in files:
1275
1343
os.chmod(os.path.join(root, name), 0700)
1276
1344
rmtree(self.base)
1277
self.base = None
1345
self._transport = None
1278
1346
1279
1347
1280
1348
1331
1399
return gen_file_id('TREE_ROOT')
1332
1400
1333
1401
1334
def copy_branch(branch_from, to_location, revno=None):
1335
"""Copy branch_from into the existing directory to_location.
1336
1337
revision
1338
If not None, only revisions up to this point will be copied.
1339
The head of the new branch will be that revision.
1340
1341
to_location
1342
The name of a local directory that exists but is empty.
1343
"""
1344
from bzrlib.merge import merge
1345
1346
assert isinstance(branch_from, Branch)
1347
assert isinstance(to_location, basestring)
1348
1349
br_to = Branch.initialize(to_location)
1350
br_to.set_root_id(branch_from.get_root_id())
1351
if revno is None:
1352
revno = branch_from.revno()
1353
br_to.update_revisions(branch_from, stop_revision=revno)
1354
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1355
check_clean=False, ignore_zero=True)
1356
br_to.set_parent(branch_from.base)
1357
return br_to
Loggerhead is a web-based interface for Breezy
Version: 2.0.1