« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1185.13.1
- compare with another revision
- 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.
45
46
# TODO: please move the revision-string syntax stuff out of the branch
47
# object; it's clutter
48
49
50
def find_branch(f, **args):
51
if f and (f.startswith('http://') or f.startswith('https://')):
52
from bzrlib.remotebranch import RemoteBranch
53
return RemoteBranch(f, **args)
54
else:
55
return LocalBranch(f, **args)
56
57
58
def find_cached_branch(f, cache_root, **args):
59
from bzrlib.remotebranch import RemoteBranch
60
br = find_branch(f, **args)
61
def cacheify(br, store_name):
62
from bzrlib.meta_store import CachedStore
63
cache_path = os.path.join(cache_root, store_name)
64
os.mkdir(cache_path)
65
new_store = CachedStore(getattr(br, store_name), cache_path)
66
setattr(br, store_name, new_store)
67
68
if isinstance(br, RemoteBranch):
69
cacheify(br, 'inventory_store')
70
cacheify(br, 'text_store')
71
cacheify(br, 'revision_store')
72
return br
73
74
57
# cache in memory to make this faster. In general anything can be
58
# cached in memory between lock and unlock operations.
59
60
def find_branch(*ignored, **ignored_too):
61
# XXX: leave this here for about one release, then remove it
62
raise NotImplementedError('find_branch() is not supported anymore, '
63
'please use one of the new branch constructors')
75
64
def _relpath(base, path):
76
65
"""Return path relative to base, or raise exception.
77
66
99
88
return os.sep.join(s)
100
89
101
90
102
def find_branch_root(f=None):
103
"""Find the branch root enclosing f, or pwd.
104
105
f may be a filename or a URL.
106
107
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.
108
97
109
98
Basically we keep looking up until we find the control directory or
110
99
run into the root. If there isn't one, raises NotBranchError.
111
100
"""
112
if f == None:
113
f = os.getcwd()
114
elif hasattr(os.path, 'realpath'):
115
f = os.path.realpath(f)
116
else:
117
f = os.path.abspath(f)
118
if not os.path.exists(f):
119
raise BzrError('%r does not exist' % f)
120
121
122
orig_f = f
123
101
orig_base = t.base
124
102
while True:
125
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
126
return f
127
head, tail = os.path.split(f)
128
if head == f:
103
if t.has(bzrlib.BZRDIR):
104
return t
105
new_t = t.clone('..')
106
if new_t.base == t.base:
129
107
# reached the root, whatever that may be
130
raise NotBranchError('%s is not in a branch' % orig_f)
131
f = head
132
133
108
raise NotBranchError('%s is not in a branch' % orig_base)
109
t = new_t
134
110
135
111
136
112
######################################################################
144
120
"""
145
121
base = None
146
122
147
def __new__(cls, *a, **kw):
148
"""this is temporary, till we get rid of all code that does
149
b = Branch()
150
"""
151
# XXX: AAARGH! MY EYES! UUUUGLY!!!
152
if cls == Branch:
153
cls = LocalBranch
154
b = object.__new__(cls)
155
return b
156
157
158
class LocalBranch(Branch):
123
def __init__(self, *ignored, **ignored_too):
124
raise NotImplementedError('The Branch class is abstract')
125
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
def open(base):
135
"""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)
139
140
@staticmethod
141
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.
145
"""
146
t = get_transport(url)
147
t = find_branch_root(t)
148
return _Branch(t)
149
150
@staticmethod
151
def initialize(base):
152
"""Create a new branch, rooted at 'base' (url)"""
153
t = get_transport(base)
154
return _Branch(t, init=True)
155
156
def setup_caching(self, cache_root):
157
"""Subclasses that care about caching should override this, and set
158
up cached stores located under cache_root.
159
"""
160
self.cache_root = cache_root
161
162
163
class _Branch(Branch):
159
164
"""A branch stored in the actual filesystem.
160
165
161
166
Note that it's "local" in the context of the filesystem; it doesn't
179
184
_lock_mode = None
180
185
_lock_count = None
181
186
_lock = None
182
183
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):
184
216
"""Create new branch object at a particular location.
185
217
186
base -- Base directory for the branch.
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)
187
221
188
222
init -- If True, create new control files in a previously
189
223
unversioned directory. If False, the branch must already
190
224
be versioned.
191
225
192
find_root -- If true and init is false, find the root of the
193
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.
194
230
195
231
In the test suite, creation of new trees is tested using the
196
232
`ScratchBranch` class.
197
233
"""
198
from bzrlib.store import ImmutableStore
234
assert isinstance(transport, Transport), \
235
"%r is not a Transport" % transport
236
self._transport = transport
199
237
if init:
200
self.base = os.path.realpath(base)
201
238
self._make_control()
202
elif find_root:
203
self.base = find_branch_root(base)
204
else:
205
self.base = os.path.realpath(base)
206
if not isdir(self.controlfilename('.')):
207
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
208
['use "bzr init" to initialize a new working tree',
209
'current bzr can only operate from top-of-tree'])
210
self._check_format()
211
212
self.text_store = ImmutableStore(self.controlfilename('text-store'))
213
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
214
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
215
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)
216
271
217
272
def __str__(self):
218
return '%s(%r)' % (self.__class__.__name__, self.base)
273
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
219
274
220
275
221
276
__repr__ = __str__
223
278
224
279
def __del__(self):
225
280
if self._lock_mode or self._lock:
226
from bzrlib.warnings import warn
281
# XXX: This should show something every time, and be suitable for
282
# headless operation and embedding
227
283
warn("branch %r was not explicitly unlocked" % self)
228
284
self._lock.unlock()
229
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
230
307
231
308
def lock_write(self):
309
# TODO: Upgrade locking to support using a Transport,
310
# and potentially a remote locking protocol
232
311
if self._lock_mode:
233
312
if self._lock_mode != 'w':
234
from bzrlib.errors import LockError
235
313
raise LockError("can't upgrade to a write lock from %r" %
236
314
self._lock_mode)
237
315
self._lock_count += 1
238
316
else:
239
from bzrlib.lock import WriteLock
240
241
self._lock = WriteLock(self.controlfilename('branch-lock'))
317
self._lock = self._transport.lock_write(
318
self._rel_controlfilename('branch-lock'))
242
319
self._lock_mode = 'w'
243
320
self._lock_count = 1
244
321
249
326
"invalid lock mode %r" % self._lock_mode
250
327
self._lock_count += 1
251
328
else:
252
from bzrlib.lock import ReadLock
253
254
self._lock = ReadLock(self.controlfilename('branch-lock'))
329
self._lock = self._transport.lock_read(
330
self._rel_controlfilename('branch-lock'))
255
331
self._lock_mode = 'r'
256
332
self._lock_count = 1
257
333
258
334
def unlock(self):
259
335
if not self._lock_mode:
260
from bzrlib.errors import LockError
261
336
raise LockError('branch %r is not locked' % (self))
262
337
263
338
if self._lock_count > 1:
269
344
270
345
def abspath(self, name):
271
346
"""Return absolute filename for something in the branch"""
272
return os.path.join(self.base, name)
347
return self._transport.abspath(name)
273
348
274
349
def relpath(self, path):
275
350
"""Return path relative to this branch of something inside it.
276
351
277
352
Raises an error if path is not in this branch."""
278
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
279
360
280
361
def controlfilename(self, file_or_path):
281
362
"""Return location relative to branch."""
282
if isinstance(file_or_path, basestring):
283
file_or_path = [file_or_path]
284
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
363
return self._transport.abspath(self._rel_controlfilename(file_or_path))
285
364
286
365
287
366
def controlfile(self, file_or_path, mode='r'):
295
374
Controlfiles should almost never be opened in write mode but
296
375
rather should be atomically copied and replaced using atomicfile.
297
376
"""
298
299
fn = self.controlfilename(file_or_path)
300
301
if mode == 'rb' or mode == 'wb':
302
return file(fn, mode)
303
elif mode == 'r' or mode == 'w':
304
# open in binary mode anyhow so there's no newline translation;
305
# codecs uses line buffering by default; don't want that.
306
import codecs
307
return codecs.open(fn, mode + 'b', 'utf-8',
308
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")
309
390
else:
310
391
raise BzrError("invalid controlfile mode %r" % mode)
311
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
312
422
def _make_control(self):
313
423
from bzrlib.inventory import Inventory
424
from bzrlib.weavefile import write_weave_v5
425
from bzrlib.weave import Weave
314
426
315
os.mkdir(self.controlfilename([]))
316
self.controlfile('README', 'w').write(
317
"This is a Bazaar-NG control directory.\n"
318
"Do not change any files in this directory.\n")
319
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
320
for d in ('text-store', 'inventory-store', 'revision-store'):
321
os.mkdir(self.controlfilename(d))
322
for f in ('revision-history', 'merged-patches',
323
'pending-merged-patches', 'branch-name',
324
'branch-lock',
325
'pending-merges'):
326
self.controlfile(f, 'w').write('')
327
mutter('created control directory in ' + self.base)
328
427
# Create an empty inventory
428
sio = StringIO()
329
429
# if we want per-tree root ids then this is the place to set
330
430
# them; they're not needed for now and so ommitted for
331
431
# simplicity.
332
f = self.controlfile('inventory','w')
333
bzrlib.xml.serializer_v4.write_inventory(Inventory(), f)
334
335
336
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):
337
457
"""Check this branch format is supported.
338
458
339
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.
340
461
341
462
In the future, we might need different in-memory Branch
342
463
classes to support downlevel branches. But not yet.
343
464
"""
344
# This ignores newlines so that we can open branches created
345
# on Windows from Linux and so on. I think it might be better
346
# to always make all internal files in unix format.
347
fmt = self.controlfile('branch-format', 'r').read()
348
fmt = fmt.replace('\r\n', '\n')
349
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):
350
477
raise BzrError('sorry, branch format %r not supported' % fmt,
351
478
['use a different bzr version',
352
'or remove the .bzr directory and "bzr init" again'])
479
'or remove the .bzr directory'
480
' and "bzr init" again'])
353
481
354
482
def get_root_id(self):
355
483
"""Return the id of this branches root"""
370
498
371
499
def read_working_inventory(self):
372
500
"""Read the working inventory."""
373
from bzrlib.inventory import Inventory
374
501
self.lock_read()
375
502
try:
376
503
# ElementTree does its own conversion from UTF-8, so open in
377
504
# binary.
378
505
f = self.controlfile('inventory', 'rb')
379
return bzrlib.xml.serializer_v4.read_inventory(f)
506
return bzrlib.xml5.serializer_v5.read_inventory(f)
380
507
finally:
381
508
self.unlock()
382
509
387
514
That is to say, the inventory describing changes underway, that
388
515
will be committed to the next revision.
389
516
"""
390
from bzrlib.atomicfile import AtomicFile
391
517
from cStringIO import StringIO
392
518
self.lock_write()
393
519
try:
394
f = AtomicFile(self.controlfilename('inventory'), 'wb')
395
try:
396
bzrlib.xml.serializer_v4.write_inventory(inv, f)
397
f.commit()
398
finally:
399
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)
400
525
finally:
401
526
self.unlock()
402
527
403
528
mutter('wrote working inventory')
404
529
405
406
530
inventory = property(read_working_inventory, _write_inventory, None,
407
531
"""Inventory for the working copy.""")
408
532
409
410
533
def add(self, files, ids=None):
411
534
"""Make files versioned.
412
535
460
583
kind = file_kind(fullpath)
461
584
except OSError:
462
585
# maybe something better?
463
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))
464
587
465
if kind != 'file' and kind != 'directory':
466
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))
467
591
468
592
if file_id is None:
469
593
file_id = gen_file_id(f)
534
658
finally:
535
659
self.unlock()
536
660
537
538
661
# FIXME: this doesn't need to be a branch method
539
662
def set_inventory(self, new_inventory_list):
540
663
from bzrlib.inventory import Inventory, InventoryEntry
543
666
name = os.path.basename(path)
544
667
if name == "":
545
668
continue
546
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)
547
678
self._write_inventory(inv)
548
679
549
550
680
def unknowns(self):
551
681
"""Return all unknown files.
552
682
567
697
568
698
569
699
def append_revision(self, *revision_ids):
570
from bzrlib.atomicfile import AtomicFile
571
572
700
for revision_id in revision_ids:
573
701
mutter("add {%s} to revision-history" % revision_id)
574
575
rev_history = self.revision_history()
576
rev_history.extend(revision_ids)
577
578
f = AtomicFile(self.controlfilename('revision-history'))
702
self.lock_write()
579
703
try:
580
for rev_id in rev_history:
581
print >>f, rev_id
582
f.commit()
704
rev_history = self.revision_history()
705
rev_history.extend(revision_ids)
706
self.put_controlfile('revision-history', '\n'.join(rev_history))
583
707
finally:
584
f.close()
585
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)
586
717
587
718
def get_revision_xml_file(self, revision_id):
588
719
"""Return XML file object for revision object."""
593
724
try:
594
725
try:
595
726
return self.revision_store[revision_id]
596
except IndexError:
727
except (IndexError, KeyError):
597
728
raise bzrlib.errors.NoSuchRevision(self, revision_id)
598
729
finally:
599
730
self.unlock()
600
731
601
602
732
#deprecated
603
733
get_revision_xml = get_revision_xml_file
604
734
735
def get_revision_xml(self, revision_id):
736
return self.get_revision_xml_file(revision_id).read()
737
605
738
606
739
def get_revision(self, revision_id):
607
740
"""Return the Revision object for a named revision"""
608
741
xml_file = self.get_revision_xml_file(revision_id)
609
742
610
743
try:
611
r = bzrlib.xml.serializer_v4.read_revision(xml_file)
744
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
612
745
except SyntaxError, e:
613
746
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
614
747
[revision_id,
617
750
assert r.revision_id == revision_id
618
751
return r
619
752
620
621
753
def get_revision_delta(self, revno):
622
754
"""Return the delta for one revision.
623
755
639
771
640
772
return compare_trees(old_tree, new_tree)
641
773
642
643
644
774
def get_revision_sha1(self, revision_id):
645
775
"""Hash the stored value of a revision, and return it."""
646
776
# In the future, revision entries will be signed. At that
649
779
# the revision, (add signatures/remove signatures) and still
650
780
# have all hash pointers stay consistent.
651
781
# But for now, just hash the contents.
652
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
653
654
655
def get_inventory(self, inventory_id):
656
"""Get Inventory object by hash.
657
658
TODO: Perhaps for this and similar methods, take a revision
659
parameter which can be either an integer revno or a
660
string hash."""
661
from bzrlib.inventory import Inventory
662
663
f = self.get_inventory_xml_file(inventory_id)
664
return bzrlib.xml.serializer_v4.read_inventory(f)
665
666
667
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):
668
805
"""Get inventory XML as a file object."""
669
return self.inventory_store[inventory_id]
670
671
get_inventory_xml_file = get_inventory_xml
672
673
674
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):
675
814
"""Return the sha1 hash of the inventory entry
676
815
"""
677
return sha_file(self.get_inventory_xml(inventory_id))
678
816
return self.get_revision(revision_id).inventory_sha1
679
817
680
818
def get_revision_inventory(self, revision_id):
681
819
"""Return inventory of a past revision."""
682
# 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
683
822
# must be the same as its revision, so this is trivial.
684
823
if revision_id == None:
685
from bzrlib.inventory import Inventory
686
824
return Inventory(self.get_root_id())
687
825
else:
688
826
return self.get_inventory(revision_id)
689
827
690
691
828
def revision_history(self):
692
"""Return sequence of revision hashes on to this branch.
693
694
>>> ScratchBranch().revision_history()
695
[]
696
"""
829
"""Return sequence of revision hashes on to this branch."""
697
830
self.lock_read()
698
831
try:
699
832
return [l.rstrip('\r\n') for l in
701
834
finally:
702
835
self.unlock()
703
836
704
705
837
def common_ancestor(self, other, self_revno=None, other_revno=None):
706
838
"""
707
839
>>> from bzrlib.commit import commit
756
888
return len(self.revision_history())
757
889
758
890
759
def last_patch(self):
891
def last_revision(self):
760
892
"""Return last patch hash, or None if no history.
761
893
"""
762
894
ph = self.revision_history()
767
899
768
900
769
901
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
770
"""
902
"""Return a list of new revisions that would perfectly fit.
903
771
904
If self and other have not diverged, return a list of the revisions
772
905
present in other, but missing from self.
773
906
793
926
Traceback (most recent call last):
794
927
DivergedBranches: These branches have diverged.
795
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.
796
932
self_history = self.revision_history()
797
933
self_len = len(self_history)
798
934
other_history = other.revision_history()
804
940
805
941
if stop_revision is None:
806
942
stop_revision = other_len
807
elif stop_revision > other_len:
808
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
809
943
else:
944
assert isinstance(stop_revision, int)
945
if stop_revision > other_len:
946
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
810
947
return other_history[self_len:stop_revision]
811
948
812
813
949
def update_revisions(self, other, stop_revision=None):
814
"""Pull in all new revisions from other branch.
815
"""
950
"""Pull in new perfect-fit revisions."""
816
951
from bzrlib.fetch import greedy_fetch
817
818
pb = bzrlib.ui.ui_factory.progress_bar()
819
pb.update('comparing histories')
820
821
revision_ids = self.missing_revisions(other, stop_revision)
822
823
if len(revision_ids) > 0:
824
count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
825
else:
826
count = 0
827
self.append_revision(*revision_ids)
828
## note("Added %d revisions." % count)
829
pb.clear()
830
831
def install_revisions(self, other, revision_ids, pb):
832
if hasattr(other.revision_store, "prefetch"):
833
other.revision_store.prefetch(revision_ids)
834
if hasattr(other.inventory_store, "prefetch"):
835
inventory_ids = [other.get_revision(r).inventory_id
836
for r in revision_ids]
837
other.inventory_store.prefetch(inventory_ids)
838
839
if pb is None:
840
pb = bzrlib.ui.ui_factory.progress_bar()
841
842
revisions = []
843
needed_texts = set()
844
i = 0
845
846
failures = set()
847
for i, rev_id in enumerate(revision_ids):
848
pb.update('fetching revision', i+1, len(revision_ids))
849
try:
850
rev = other.get_revision(rev_id)
851
except bzrlib.errors.NoSuchRevision:
852
failures.add(rev_id)
853
continue
854
855
revisions.append(rev)
856
inv = other.get_inventory(str(rev.inventory_id))
857
for key, entry in inv.iter_entries():
858
if entry.text_id is None:
859
continue
860
if entry.text_id not in self.text_store:
861
needed_texts.add(entry.text_id)
862
863
pb.clear()
864
865
count, cp_fail = self.text_store.copy_multi(other.text_store,
866
needed_texts)
867
#print "Added %d texts." % count
868
inventory_ids = [ f.inventory_id for f in revisions ]
869
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
870
inventory_ids)
871
#print "Added %d inventories." % count
872
revision_ids = [ f.revision_id for f in revisions]
873
874
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
875
revision_ids,
876
permit_failure=True)
877
assert len(cp_fail) == 0
878
return count, failures
879
952
from bzrlib.revision import get_intervening_revisions
953
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
880
965
881
966
def commit(self, *args, **kw):
882
from bzrlib.commit import commit
883
commit(self, *args, **kw)
884
885
886
def lookup_revision(self, revision):
887
"""Return the revision identifier for a given revision specifier."""
888
# XXX: I'm not sure this method belongs here; I'd rather have the
889
# revision spec stuff be an UI thing, and branch blissfully unaware
890
# of it.
891
# Also, I'm not entirely happy with this method returning None
892
# when the revision doesn't exist.
893
# But I'm keeping the contract I found, because this seems to be
894
# used in a lot of places - and when I do change these, I'd rather
895
# figure out case-by-case which ones actually want to care about
896
# revision specs (eg, they are UI-level) and which ones should trust
897
# that they have a revno/revid.
898
# -- lalo@exoweb.net, 2005-09-07
899
from bzrlib.errors import NoSuchRevision
900
from bzrlib.revisionspec import RevisionSpec
901
try:
902
spec = RevisionSpec(self, revision)
903
except NoSuchRevision:
904
return None
905
return spec.rev_id
906
907
967
from bzrlib.commit import Commit
968
Commit().commit(self, *args, **kw)
969
908
970
def revision_id_to_revno(self, revision_id):
909
971
"""Given a revision id, return its revno"""
972
if revision_id is None:
973
return 0
910
974
history = self.revision_history()
911
975
try:
912
976
return history.index(revision_id) + 1
913
977
except ValueError:
914
978
raise bzrlib.errors.NoSuchRevision(self, revision_id)
915
979
916
917
980
def get_rev_id(self, revno, history=None):
918
981
"""Find the revision id of the specified revno."""
919
982
if revno == 0:
935
998
return EmptyTree()
936
999
else:
937
1000
inv = self.get_revision_inventory(revision_id)
938
return RevisionTree(self.text_store, inv)
1001
return RevisionTree(self.weave_store, inv, revision_id)
939
1002
940
1003
941
1004
def working_tree(self):
942
1005
"""Return a `Tree` for the working copy."""
943
1006
from bzrlib.workingtree import WorkingTree
944
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())
945
1013
946
1014
947
1015
def basis_tree(self):
949
1017
950
1018
If there are no revisions yet, return an `EmptyTree`.
951
1019
"""
952
r = self.last_patch()
953
if r == None:
954
return EmptyTree()
955
else:
956
return RevisionTree(self.text_store, self.get_revision_inventory(r))
957
1020
return self.revision_tree(self.last_revision())
958
1021
959
1022
960
1023
def rename_one(self, from_rel, to_rel):
995
1058
from_abs = self.abspath(from_rel)
996
1059
to_abs = self.abspath(to_rel)
997
1060
try:
998
os.rename(from_abs, to_abs)
1061
rename(from_abs, to_abs)
999
1062
except OSError, e:
1000
1063
raise BzrError("failed to rename %r to %r: %s"
1001
1064
% (from_abs, to_abs, e[1]),
1064
1127
result.append((f, dest_path))
1065
1128
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1066
1129
try:
1067
os.rename(self.abspath(f), self.abspath(dest_path))
1130
rename(self.abspath(f), self.abspath(dest_path))
1068
1131
except OSError, e:
1069
1132
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1070
1133
["rename rolled back"])
1126
1189
These are revisions that have been merged into the working
1127
1190
directory but not yet committed.
1128
1191
"""
1129
cfn = self.controlfilename('pending-merges')
1130
if not os.path.exists(cfn):
1192
cfn = self._rel_controlfilename('pending-merges')
1193
if not self._transport.has(cfn):
1131
1194
return []
1132
1195
p = []
1133
1196
for l in self.controlfile('pending-merges', 'r').readlines():
1135
1198
return p
1136
1199
1137
1200
1138
def add_pending_merge(self, revision_id):
1139
from bzrlib.revision import validate_revision_id
1140
1141
validate_revision_id(revision_id)
1142
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?
1143
1204
p = self.pending_merges()
1144
if revision_id in p:
1145
return
1146
p.append(revision_id)
1147
self.set_pending_merges(p)
1148
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)
1149
1213
1150
1214
def set_pending_merges(self, rev_list):
1151
from bzrlib.atomicfile import AtomicFile
1152
1215
self.lock_write()
1153
1216
try:
1154
f = AtomicFile(self.controlfilename('pending-merges'))
1155
try:
1156
for l in rev_list:
1157
print >>f, l
1158
f.commit()
1159
finally:
1160
f.close()
1217
self.put_controlfile('pending-merges', '\n'.join(rev_list))
1161
1218
finally:
1162
1219
self.unlock()
1163
1220
1211
1268
raise InvalidRevisionNumber(revno)
1212
1269
1213
1270
1214
1215
1216
class ScratchBranch(LocalBranch):
1271
1272
1273
1274
class ScratchBranch(_Branch):
1217
1275
"""Special test class: a branch that cleans up after itself.
1218
1276
1219
1277
>>> b = ScratchBranch()
1236
1294
if base is None:
1237
1295
base = mkdtemp()
1238
1296
init = True
1239
LocalBranch.__init__(self, base, init=init)
1297
if isinstance(base, basestring):
1298
base = get_transport(base)
1299
_Branch.__init__(self, base, init=init)
1240
1300
for d in dirs:
1241
os.mkdir(self.abspath(d))
1301
self._transport.mkdir(d)
1242
1302
1243
1303
for f in files:
1244
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1304
self._transport.put(f, 'content of %s' % f)
1245
1305
1246
1306
1247
1307
def clone(self):
1248
1308
"""
1249
1309
>>> orig = ScratchBranch(files=["file1", "file2"])
1250
1310
>>> clone = orig.clone()
1251
>>> 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
...
1252
1316
False
1253
1317
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1254
1318
True
1260
1324
copytree(self.base, base, symlinks=True)
1261
1325
return ScratchBranch(base=base)
1262
1326
1263
1264
1265
1327
def __del__(self):
1266
1328
self.destroy()
1267
1329
1280
1342
for name in files:
1281
1343
os.chmod(os.path.join(root, name), 0700)
1282
1344
rmtree(self.base)
1283
self.base = None
1345
self._transport = None
1284
1346
1285
1347
1286
1348
1337
1399
return gen_file_id('TREE_ROOT')
1338
1400
1339
1401
1340
def copy_branch(branch_from, to_location, revision=None):
1341
"""Copy branch_from into the existing directory to_location.
1342
1343
revision
1344
If not None, only revisions up to this point will be copied.
1345
The head of the new branch will be that revision.
1346
1347
to_location
1348
The name of a local directory that exists but is empty.
1349
"""
1350
from bzrlib.merge import merge
1351
from bzrlib.revisionspec import RevisionSpec
1352
1353
assert isinstance(branch_from, Branch)
1354
assert isinstance(to_location, basestring)
1355
1356
br_to = Branch(to_location, init=True)
1357
br_to.set_root_id(branch_from.get_root_id())
1358
if revision is None:
1359
revno = branch_from.revno()
1360
else:
1361
revno, rev_id = RevisionSpec(branch_from, revision)
1362
br_to.update_revisions(branch_from, stop_revision=revno)
1363
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1364
check_clean=False, ignore_zero=True)
1365
1366
from_location = branch_from.base
1367
br_to.set_parent(branch_from.base)
1368
Loggerhead is a web-based interface for Breezy
Version: 2.0.1