15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
21
import traceback, socket, fnmatch, difflib, time
22
from binascii import hexlify
22
from bzrlib.trace import mutter, note
23
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
25
sha_file, appendpath, file_kind
27
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
29
from bzrlib.textui import show_status
30
from bzrlib.revision import Revision
31
from bzrlib.delta import compare_trees
32
from bzrlib.tree import EmptyTree, RevisionTree
33
from bzrlib.inventory import Inventory
34
from bzrlib.weavestore import WeaveStore
40
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
41
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
25
from inventory import Inventory
26
from trace import mutter, note
27
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
28
from inventory import InventoryEntry, Inventory
29
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
30
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
31
joinpath, sha_string, file_kind, local_time_offset, appendpath
32
from store import ImmutableStore
33
from revision import Revision
34
from errors import bailout, BzrError
35
from textui import show_status
36
from diff import diff_trees
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
42
39
## TODO: Maybe include checks for common corruption of newlines, etc?
45
# TODO: Some operations like log might retrieve the same revisions
46
# repeatedly to calculate deltas. We could perhaps have a weakref
47
# cache in memory to make this faster.
49
# TODO: please move the revision-string syntax stuff out of the branch
50
# object; it's clutter
53
43
def find_branch(f, **args):
54
if f and (f.startswith('http://') or f.startswith('https://')):
44
if f.startswith('http://') or f.startswith('https://'):
55
45
import remotebranch
56
46
return remotebranch.RemoteBranch(f, **args)
58
48
return Branch(f, **args)
61
def find_cached_branch(f, cache_root, **args):
62
from remotebranch import RemoteBranch
63
br = find_branch(f, **args)
64
def cacheify(br, store_name):
65
from meta_store import CachedStore
66
cache_path = os.path.join(cache_root, store_name)
68
new_store = CachedStore(getattr(br, store_name), cache_path)
69
setattr(br, store_name, new_store)
71
if isinstance(br, RemoteBranch):
72
cacheify(br, 'inventory_store')
73
cacheify(br, 'text_store')
74
cacheify(br, 'revision_store')
78
def _relpath(base, path):
79
"""Return path relative to base, or raise exception.
81
The path may be either an absolute path or a path relative to the
82
current working directory.
84
Lifted out of Branch.relpath for ease of testing.
86
os.path.commonprefix (python2.4) has a bad bug that it works just
87
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
88
avoids that problem."""
89
rp = os.path.abspath(path)
93
while len(head) >= len(base):
96
head, tail = os.path.split(head)
100
from errors import NotBranchError
101
raise NotBranchError("path %r is not within branch %r" % (rp, base))
103
return os.sep.join(s)
106
51
def find_branch_root(f=None):
215
129
__repr__ = __str__
219
if self._lock_mode or self._lock:
220
from warnings import warn
221
warn("branch %r was not explicitly unlocked" % self)
225
def lock_write(self):
227
if self._lock_mode != 'w':
228
from errors import LockError
229
raise LockError("can't upgrade to a write lock from %r" %
231
self._lock_count += 1
233
from bzrlib.lock import WriteLock
235
self._lock = WriteLock(self.controlfilename('branch-lock'))
236
self._lock_mode = 'w'
242
assert self._lock_mode in ('r', 'w'), \
243
"invalid lock mode %r" % self._lock_mode
244
self._lock_count += 1
246
from bzrlib.lock import ReadLock
248
self._lock = ReadLock(self.controlfilename('branch-lock'))
249
self._lock_mode = 'r'
253
if not self._lock_mode:
254
from errors import LockError
255
raise LockError('branch %r is not locked' % (self))
257
if self._lock_count > 1:
258
self._lock_count -= 1
262
self._lock_mode = self._lock_count = None
133
def lock(self, mode='w'):
134
"""Lock the on-disk branch, excluding other processes."""
140
om = os.O_WRONLY | os.O_CREAT
145
raise BzrError("invalid locking mode %r" % mode)
148
lockfile = os.open(self.controlfilename('branch-lock'), om)
150
if e.errno == errno.ENOENT:
151
# might not exist on branches from <0.0.4
152
self.controlfile('branch-lock', 'w').close()
153
lockfile = os.open(self.controlfilename('branch-lock'), om)
157
fcntl.lockf(lockfile, lm)
159
fcntl.lockf(lockfile, fcntl.LOCK_UN)
161
self._lockmode = None
163
self._lockmode = mode
165
warning("please write a locking method for platform %r" % sys.platform)
167
self._lockmode = None
169
self._lockmode = mode
172
def _need_readlock(self):
173
if self._lockmode not in ['r', 'w']:
174
raise BzrError('need read lock on branch, only have %r' % self._lockmode)
176
def _need_writelock(self):
177
if self._lockmode not in ['w']:
178
raise BzrError('need write lock on branch, only have %r' % self._lockmode)
264
181
def abspath(self, name):
265
182
"""Return absolute filename for something in the branch"""
266
183
return os.path.join(self.base, name)
268
186
def relpath(self, path):
269
187
"""Return path relative to this branch of something inside it.
271
189
Raises an error if path is not in this branch."""
272
return _relpath(self.base, path)
190
rp = os.path.realpath(path)
192
if not rp.startswith(self.base):
193
bailout("path %r is not within branch %r" % (rp, self.base))
194
rp = rp[len(self.base):]
195
rp = rp.lstrip(os.sep)
274
199
def controlfilename(self, file_or_path):
275
200
"""Return location relative to branch."""
276
if isinstance(file_or_path, basestring):
201
if isinstance(file_or_path, types.StringTypes):
277
202
file_or_path = [file_or_path]
278
203
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
304
226
raise BzrError("invalid controlfile mode %r" % mode)
306
230
def _make_control(self):
307
231
os.mkdir(self.controlfilename([]))
308
232
self.controlfile('README', 'w').write(
309
233
"This is a Bazaar-NG control directory.\n"
310
"Do not change any files in this directory.\n")
311
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT_5)
312
for d in ('text-store', 'inventory-store', 'revision-store',
234
"Do not change any files in this directory.")
235
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
236
for d in ('text-store', 'inventory-store', 'revision-store'):
314
237
os.mkdir(self.controlfilename(d))
315
238
for f in ('revision-history', 'merged-patches',
316
239
'pending-merged-patches', 'branch-name',
319
241
self.controlfile(f, 'w').write('')
320
242
mutter('created control directory in ' + self.base)
322
# if we want per-tree root ids then this is the place to set
323
# them; they're not needed for now and so ommitted for
325
f = self.controlfile('inventory','w')
326
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), f)
243
Inventory().write_xml(self.controlfile('inventory','w'))
329
246
def _check_format(self):
330
247
"""Check this branch format is supported.
332
The format level is stored, as an integer, in
333
self._branch_format for code that needs to check it later.
249
The current tool only supports the current unstable format.
335
251
In the future, we might need different in-memory Branch
336
252
classes to support downlevel branches. But not yet.
254
# This ignores newlines so that we can open branches created
255
# on Windows from Linux and so on. I think it might be better
256
# to always make all internal files in unix format.
338
257
fmt = self.controlfile('branch-format', 'r').read()
339
if fmt == BZR_BRANCH_FORMAT_5:
340
self._branch_format = 5
342
raise BzrError('sorry, branch format "%s" not supported; '
343
'use a different bzr version, '
344
'or run "bzr upgrade", '
345
'or remove the .bzr directory and "bzr init" again'
346
% fmt.rstrip('\n\r'))
348
def get_root_id(self):
349
"""Return the id of this branches root"""
350
inv = self.read_working_inventory()
351
return inv.root.file_id
353
def set_root_id(self, file_id):
354
inv = self.read_working_inventory()
355
orig_root_id = inv.root.file_id
356
del inv._byid[inv.root.file_id]
357
inv.root.file_id = file_id
358
inv._byid[inv.root.file_id] = inv.root
361
if entry.parent_id in (None, orig_root_id):
362
entry.parent_id = inv.root.file_id
363
self._write_inventory(inv)
258
fmt.replace('\r\n', '')
259
if fmt != BZR_BRANCH_FORMAT:
260
bailout('sorry, branch format %r not supported' % fmt,
261
['use a different bzr version',
262
'or remove the .bzr directory and "bzr init" again'])
365
265
def read_working_inventory(self):
366
266
"""Read the working inventory."""
369
# ElementTree does its own conversion from UTF-8, so open in
371
f = self.controlfile('inventory', 'rb')
372
return bzrlib.xml5.serializer_v5.read_inventory(f)
267
self._need_readlock()
269
# ElementTree does its own conversion from UTF-8, so open in
271
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
272
mutter("loaded inventory of %d items in %f"
273
% (len(inv), time.time() - before))
377
277
def _write_inventory(self, inv):
378
278
"""Update the working inventory.
380
280
That is to say, the inventory describing changes underway, that
381
281
will be committed to the next revision.
383
from bzrlib.atomicfile import AtomicFile
387
f = AtomicFile(self.controlfilename('inventory'), 'wb')
389
bzrlib.xml5.serializer_v5.write_inventory(inv, f)
283
self._need_writelock()
284
## TODO: factor out to atomicfile? is rename safe on windows?
285
## TODO: Maybe some kind of clean/dirty marker on inventory?
286
tmpfname = self.controlfilename('inventory.tmp')
287
tmpf = file(tmpfname, 'wb')
290
inv_fname = self.controlfilename('inventory')
291
if sys.platform == 'win32':
293
os.rename(tmpfname, inv_fname)
396
294
mutter('wrote working inventory')
399
297
inventory = property(read_working_inventory, _write_inventory, None,
400
298
"""Inventory for the working copy.""")
403
def add(self, files, ids=None):
301
def add(self, files, verbose=False):
404
302
"""Make files versioned.
406
Note that the command line normally calls smart_add instead,
407
which can automatically recurse.
304
Note that the command line normally calls smart_add instead.
409
306
This puts the files in the Added state, so that they will be
410
307
recorded by the next commit.
413
List of paths to add, relative to the base of the tree.
416
If set, use these instead of automatically generated ids.
417
Must be the same length as the list of files, but may
418
contain None for ids that are to be autogenerated.
420
309
TODO: Perhaps have an option to add the ids even if the files do
423
TODO: Perhaps yield the ids and paths as they're added.
312
TODO: Perhaps return the ids of the files? But then again it
313
is easy to retrieve them if they're needed.
315
TODO: Option to specify file id.
317
TODO: Adding a directory should optionally recurse down and
318
add all non-ignored children. Perhaps do that in a
321
>>> b = ScratchBranch(files=['foo'])
322
>>> 'foo' in b.unknowns()
327
>>> 'foo' in b.unknowns()
329
>>> bool(b.inventory.path2id('foo'))
335
Traceback (most recent call last):
337
BzrError: ('foo is already versioned', [])
339
>>> b.add(['nothere'])
340
Traceback (most recent call last):
341
BzrError: ('cannot add: not a regular file or directory: nothere', [])
343
self._need_writelock()
425
345
# TODO: Re-adding a file that is removed in the working copy
426
346
# should probably put it back with the previous ID.
427
if isinstance(files, basestring):
428
assert(ids is None or isinstance(ids, basestring))
347
if isinstance(files, types.StringTypes):
434
ids = [None] * len(files)
436
assert(len(ids) == len(files))
440
inv = self.read_working_inventory()
441
for f,file_id in zip(files, ids):
442
if is_control_file(f):
443
raise BzrError("cannot add control file %s" % quotefn(f))
448
raise BzrError("cannot add top-level %r" % f)
450
fullpath = os.path.normpath(self.abspath(f))
453
kind = file_kind(fullpath)
455
# maybe something better?
456
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
458
if kind != 'file' and kind != 'directory':
459
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
462
file_id = gen_file_id(f)
463
inv.add_path(f, kind=kind, file_id=file_id)
465
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
467
self._write_inventory(inv)
350
inv = self.read_working_inventory()
352
if is_control_file(f):
353
bailout("cannot add control file %s" % quotefn(f))
358
bailout("cannot add top-level %r" % f)
360
fullpath = os.path.normpath(self.abspath(f))
363
kind = file_kind(fullpath)
365
# maybe something better?
366
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
368
if kind != 'file' and kind != 'directory':
369
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
371
file_id = gen_file_id(f)
372
inv.add_path(f, kind=kind, file_id=file_id)
375
show_status('A', kind, quotefn(f))
377
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
379
self._write_inventory(inv)
472
382
def print_file(self, file, revno):
473
383
"""Print `file` to stdout."""
476
tree = self.revision_tree(self.lookup_revision(revno))
477
# use inventory as it was in that revision
478
file_id = tree.inventory.path2id(file)
480
raise BzrError("%r is not present in revision %s" % (file, revno))
481
tree.print_file(file_id)
384
self._need_readlock()
385
tree = self.revision_tree(self.lookup_revision(revno))
386
# use inventory as it was in that revision
387
file_id = tree.inventory.path2id(file)
389
bailout("%r is not present in revision %d" % (file, revno))
390
tree.print_file(file_id)
486
393
def remove(self, files, verbose=False):
487
394
"""Mark nominated files for removal from the inventory.
559
473
return self.working_tree().unknowns()
562
def append_revision(self, *revision_ids):
563
from bzrlib.atomicfile import AtomicFile
565
for revision_id in revision_ids:
566
mutter("add {%s} to revision-history" % revision_id)
476
def commit(self, message, timestamp=None, timezone=None,
479
"""Commit working copy as a new revision.
481
The basic approach is to add all the file texts into the
482
store, then the inventory, then make a new revision pointing
483
to that inventory and store that.
485
This is not quite safe if the working copy changes during the
486
commit; for the moment that is simply not allowed. A better
487
approach is to make a temporary copy of the files before
488
computing their hashes, and then add those hashes in turn to
489
the inventory. This should mean at least that there are no
490
broken hash pointers. There is no way we can get a snapshot
491
of the whole directory at an instant. This would also have to
492
be robust against files disappearing, moving, etc. So the
493
whole thing is a bit hard.
495
timestamp -- if not None, seconds-since-epoch for a
496
postdated/predated commit.
498
self._need_writelock()
500
## TODO: Show branch names
502
# TODO: Don't commit if there are no changes, unless forced?
504
# First walk over the working inventory; and both update that
505
# and also build a new revision inventory. The revision
506
# inventory needs to hold the text-id, sha1 and size of the
507
# actual file versions committed in the revision. (These are
508
# not present in the working inventory.) We also need to
509
# detect missing/deleted files, and remove them from the
512
work_inv = self.read_working_inventory()
514
basis = self.basis_tree()
515
basis_inv = basis.inventory
517
for path, entry in work_inv.iter_entries():
518
## TODO: Cope with files that have gone missing.
520
## TODO: Check that the file kind has not changed from the previous
521
## revision of this file (if any).
525
p = self.abspath(path)
526
file_id = entry.file_id
527
mutter('commit prep file %s, id %r ' % (p, file_id))
529
if not os.path.exists(p):
530
mutter(" file is missing, removing from inventory")
532
show_status('D', entry.kind, quotefn(path))
533
missing_ids.append(file_id)
536
# TODO: Handle files that have been deleted
538
# TODO: Maybe a special case for empty files? Seems a
539
# waste to store them many times.
543
if basis_inv.has_id(file_id):
544
old_kind = basis_inv[file_id].kind
545
if old_kind != entry.kind:
546
bailout("entry %r changed kind from %r to %r"
547
% (file_id, old_kind, entry.kind))
549
if entry.kind == 'directory':
551
bailout("%s is entered as directory but not a directory" % quotefn(p))
552
elif entry.kind == 'file':
554
bailout("%s is entered as file but is not a file" % quotefn(p))
556
content = file(p, 'rb').read()
558
entry.text_sha1 = sha_string(content)
559
entry.text_size = len(content)
561
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
563
and (old_ie.text_size == entry.text_size)
564
and (old_ie.text_sha1 == entry.text_sha1)):
565
## assert content == basis.get_file(file_id).read()
566
entry.text_id = basis_inv[file_id].text_id
567
mutter(' unchanged from previous text_id {%s}' %
571
entry.text_id = gen_file_id(entry.name)
572
self.text_store.add(content, entry.text_id)
573
mutter(' stored with text_id {%s}' % entry.text_id)
577
elif (old_ie.name == entry.name
578
and old_ie.parent_id == entry.parent_id):
583
show_status(state, entry.kind, quotefn(path))
585
for file_id in missing_ids:
586
# have to do this later so we don't mess up the iterator.
587
# since parents may be removed before their children we
590
# FIXME: There's probably a better way to do this; perhaps
591
# the workingtree should know how to filter itself.
592
if work_inv.has_id(file_id):
593
del work_inv[file_id]
596
inv_id = rev_id = _gen_revision_id(time.time())
598
inv_tmp = tempfile.TemporaryFile()
599
inv.write_xml(inv_tmp)
601
self.inventory_store.add(inv_tmp, inv_id)
602
mutter('new inventory_id is {%s}' % inv_id)
604
self._write_inventory(work_inv)
606
if timestamp == None:
607
timestamp = time.time()
609
if committer == None:
610
committer = username()
613
timezone = local_time_offset()
615
mutter("building commit log message")
616
rev = Revision(timestamp=timestamp,
619
precursor = self.last_patch(),
624
rev_tmp = tempfile.TemporaryFile()
625
rev.write_xml(rev_tmp)
627
self.revision_store.add(rev_tmp, rev_id)
628
mutter("new revision_id is {%s}" % rev_id)
630
## XXX: Everything up to here can simply be orphaned if we abort
631
## the commit; it will leave junk files behind but that doesn't
634
## TODO: Read back the just-generated changeset, and make sure it
635
## applies and recreates the right state.
637
## TODO: Also calculate and store the inventory SHA1
638
mutter("committing patch r%d" % (self.revno() + 1))
641
self.append_revision(rev_id)
644
note("commited r%d" % self.revno())
647
def append_revision(self, revision_id):
648
mutter("add {%s} to revision-history" % revision_id)
568
649
rev_history = self.revision_history()
569
rev_history.extend(revision_ids)
571
f = AtomicFile(self.controlfilename('revision-history'))
573
for rev_id in rev_history:
580
def get_revision_xml_file(self, revision_id):
581
"""Return XML file object for revision object."""
582
if not revision_id or not isinstance(revision_id, basestring):
583
raise InvalidRevisionId(revision_id)
588
return self.revision_store[revision_id]
590
raise bzrlib.errors.NoSuchRevision(self, revision_id)
596
get_revision_xml = get_revision_xml_file
651
tmprhname = self.controlfilename('revision-history.tmp')
652
rhname = self.controlfilename('revision-history')
654
f = file(tmprhname, 'wt')
655
rev_history.append(revision_id)
656
f.write('\n'.join(rev_history))
660
if sys.platform == 'win32':
662
os.rename(tmprhname, rhname)
599
666
def get_revision(self, revision_id):
600
667
"""Return the Revision object for a named revision"""
601
xml_file = self.get_revision_xml_file(revision_id)
604
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
605
except SyntaxError, e:
606
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
668
self._need_readlock()
669
r = Revision.read_xml(self.revision_store[revision_id])
610
670
assert r.revision_id == revision_id
614
def get_revision_delta(self, revno):
615
"""Return the delta for one revision.
617
The delta is relative to its mainline predecessor, or the
618
empty tree for revision 1.
620
assert isinstance(revno, int)
621
rh = self.revision_history()
622
if not (1 <= revno <= len(rh)):
623
raise InvalidRevisionNumber(revno)
625
# revno is 1-based; list is 0-based
627
new_tree = self.revision_tree(rh[revno-1])
629
old_tree = EmptyTree()
631
old_tree = self.revision_tree(rh[revno-2])
633
return compare_trees(old_tree, new_tree)
637
def get_revision_sha1(self, revision_id):
638
"""Hash the stored value of a revision, and return it."""
639
# In the future, revision entries will be signed. At that
640
# point, it is probably best *not* to include the signature
641
# in the revision hash. Because that lets you re-sign
642
# the revision, (add signatures/remove signatures) and still
643
# have all hash pointers stay consistent.
644
# But for now, just hash the contents.
645
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
648
def get_inventory(self, revision_id):
674
def get_inventory(self, inventory_id):
649
675
"""Get Inventory object by hash.
651
677
TODO: Perhaps for this and similar methods, take a revision
652
678
parameter which can be either an integer revno or a
654
f = self.get_inventory_xml_file(revision_id)
655
return bzrlib.xml5.serializer_v5.read_inventory(f)
658
def get_inventory_xml(self, revision_id):
659
"""Get inventory XML as a file object."""
661
assert isinstance(revision_id, basestring), type(revision_id)
662
return self.inventory_store[revision_id]
664
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
666
get_inventory_xml_file = get_inventory_xml
669
def get_inventory_sha1(self, revision_id):
670
"""Return the sha1 hash of the inventory entry
672
return sha_file(self.get_inventory_xml_file(revision_id))
680
self._need_readlock()
681
i = Inventory.read_xml(self.inventory_store[inventory_id])
675
685
def get_revision_inventory(self, revision_id):
676
686
"""Return inventory of a past revision."""
677
# bzr 0.0.6 imposes the constraint that the inventory_id
678
# must be the same as its revision, so this is trivial.
687
self._need_readlock()
679
688
if revision_id == None:
680
return Inventory(self.get_root_id())
682
return self.get_inventory(revision_id)
691
return self.get_inventory(self.get_revision(revision_id).inventory_id)
685
694
def revision_history(self):
747
729
That is equivalent to the number of revisions committed to
732
>>> b = ScratchBranch()
735
>>> b.commit('no foo')
750
739
return len(self.revision_history())
753
742
def last_patch(self):
754
743
"""Return last patch hash, or None if no history.
745
>>> ScratchBranch().last_patch() == None
756
748
ph = self.revision_history()
763
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
765
If self and other have not diverged, return a list of the revisions
766
present in other, but missing from self.
768
>>> from bzrlib.commit import commit
769
>>> bzrlib.trace.silent = True
770
>>> br1 = ScratchBranch()
771
>>> br2 = ScratchBranch()
772
>>> br1.missing_revisions(br2)
774
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
775
>>> br1.missing_revisions(br2)
777
>>> br2.missing_revisions(br1)
779
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
780
>>> br1.missing_revisions(br2)
782
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
783
>>> br1.missing_revisions(br2)
785
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
786
>>> br1.missing_revisions(br2)
787
Traceback (most recent call last):
788
DivergedBranches: These branches have diverged.
790
self_history = self.revision_history()
791
self_len = len(self_history)
792
other_history = other.revision_history()
793
other_len = len(other_history)
794
common_index = min(self_len, other_len) -1
795
if common_index >= 0 and \
796
self_history[common_index] != other_history[common_index]:
797
raise DivergedBranches(self, other)
799
if stop_revision is None:
800
stop_revision = other_len
801
elif stop_revision > other_len:
802
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
804
return other_history[self_len:stop_revision]
807
def update_revisions(self, other, stop_revision=None):
808
"""Pull in all new revisions from other branch.
810
from bzrlib.fetch import greedy_fetch
812
pb = bzrlib.ui.ui_factory.progress_bar()
813
pb.update('comparing histories')
815
revision_ids = self.missing_revisions(other, stop_revision)
817
if len(revision_ids) > 0:
818
count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
821
self.append_revision(*revision_ids)
822
## note("Added %d revisions." % count)
825
def install_revisions(self, other, revision_ids, pb):
826
if hasattr(other.revision_store, "prefetch"):
827
other.revision_store.prefetch(revision_ids)
828
if hasattr(other.inventory_store, "prefetch"):
829
inventory_ids = [other.get_revision(r).inventory_id
830
for r in revision_ids]
831
other.inventory_store.prefetch(inventory_ids)
834
pb = bzrlib.ui.ui_factory.progress_bar()
841
for i, rev_id in enumerate(revision_ids):
842
pb.update('fetching revision', i+1, len(revision_ids))
844
rev = other.get_revision(rev_id)
845
except bzrlib.errors.NoSuchRevision:
849
revisions.append(rev)
850
inv = other.get_inventory(str(rev.inventory_id))
851
for key, entry in inv.iter_entries():
852
if entry.text_id is None:
854
if entry.text_id not in self.text_store:
855
needed_texts.add(entry.text_id)
859
count, cp_fail = self.text_store.copy_multi(other.text_store,
861
#print "Added %d texts." % count
862
inventory_ids = [ f.inventory_id for f in revisions ]
863
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
865
#print "Added %d inventories." % count
866
revision_ids = [ f.revision_id for f in revisions]
868
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
871
assert len(cp_fail) == 0
872
return count, failures
875
def commit(self, *args, **kw):
876
from bzrlib.commit import Commit
877
Commit().commit(self, *args, **kw)
880
def lookup_revision(self, revision):
881
"""Return the revision identifier for a given revision information."""
882
revno, info = self._get_revision_info(revision)
886
def revision_id_to_revno(self, revision_id):
887
"""Given a revision id, return its revno"""
888
history = self.revision_history()
890
return history.index(revision_id) + 1
892
raise bzrlib.errors.NoSuchRevision(self, revision_id)
895
def get_revision_info(self, revision):
896
"""Return (revno, revision id) for revision identifier.
898
revision can be an integer, in which case it is assumed to be revno (though
899
this will translate negative values into positive ones)
900
revision can also be a string, in which case it is parsed for something like
901
'date:' or 'revid:' etc.
903
revno, rev_id = self._get_revision_info(revision)
905
raise bzrlib.errors.NoSuchRevision(self, revision)
908
def get_rev_id(self, revno, history=None):
909
"""Find the revision id of the specified revno."""
755
def lookup_revision(self, revno):
756
"""Return revision hash for revision number."""
913
history = self.revision_history()
914
elif revno <= 0 or revno > len(history):
915
raise bzrlib.errors.NoSuchRevision(self, revno)
916
return history[revno - 1]
918
def _get_revision_info(self, revision):
919
"""Return (revno, revision id) for revision specifier.
921
revision can be an integer, in which case it is assumed to be revno
922
(though this will translate negative values into positive ones)
923
revision can also be a string, in which case it is parsed for something
924
like 'date:' or 'revid:' etc.
926
A revid is always returned. If it is None, the specifier referred to
927
the null revision. If the revid does not occur in the revision
928
history, revno will be None.
934
try:# Convert to int if possible
935
revision = int(revision)
938
revs = self.revision_history()
939
if isinstance(revision, int):
941
revno = len(revs) + revision + 1
944
rev_id = self.get_rev_id(revno, revs)
945
elif isinstance(revision, basestring):
946
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
947
if revision.startswith(prefix):
948
result = func(self, revs, revision)
950
revno, rev_id = result
953
rev_id = self.get_rev_id(revno, revs)
956
raise BzrError('No namespace registered for string: %r' %
959
raise TypeError('Unhandled revision type %s' % revision)
963
raise bzrlib.errors.NoSuchRevision(self, revision)
966
def _namespace_revno(self, revs, revision):
967
"""Lookup a revision by revision number"""
968
assert revision.startswith('revno:')
970
return (int(revision[6:]),)
973
REVISION_NAMESPACES['revno:'] = _namespace_revno
975
def _namespace_revid(self, revs, revision):
976
assert revision.startswith('revid:')
977
rev_id = revision[len('revid:'):]
979
return revs.index(rev_id) + 1, rev_id
982
REVISION_NAMESPACES['revid:'] = _namespace_revid
984
def _namespace_last(self, revs, revision):
985
assert revision.startswith('last:')
987
offset = int(revision[5:])
992
raise BzrError('You must supply a positive value for --revision last:XXX')
993
return (len(revs) - offset + 1,)
994
REVISION_NAMESPACES['last:'] = _namespace_last
996
def _namespace_tag(self, revs, revision):
997
assert revision.startswith('tag:')
998
raise BzrError('tag: namespace registered, but not implemented.')
999
REVISION_NAMESPACES['tag:'] = _namespace_tag
1001
def _namespace_date(self, revs, revision):
1002
assert revision.startswith('date:')
1004
# Spec for date revisions:
1006
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
1007
# it can also start with a '+/-/='. '+' says match the first
1008
# entry after the given date. '-' is match the first entry before the date
1009
# '=' is match the first entry after, but still on the given date.
1011
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
1012
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
1013
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
1014
# May 13th, 2005 at 0:00
1016
# So the proper way of saying 'give me all entries for today' is:
1017
# -r {date:+today}:{date:-tomorrow}
1018
# The default is '=' when not supplied
1021
if val[:1] in ('+', '-', '='):
1022
match_style = val[:1]
1025
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
1026
if val.lower() == 'yesterday':
1027
dt = today - datetime.timedelta(days=1)
1028
elif val.lower() == 'today':
1030
elif val.lower() == 'tomorrow':
1031
dt = today + datetime.timedelta(days=1)
1034
# This should be done outside the function to avoid recompiling it.
1035
_date_re = re.compile(
1036
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
1038
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
1040
m = _date_re.match(val)
1041
if not m or (not m.group('date') and not m.group('time')):
1042
raise BzrError('Invalid revision date %r' % revision)
1045
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1047
year, month, day = today.year, today.month, today.day
1049
hour = int(m.group('hour'))
1050
minute = int(m.group('minute'))
1051
if m.group('second'):
1052
second = int(m.group('second'))
1056
hour, minute, second = 0,0,0
1058
dt = datetime.datetime(year=year, month=month, day=day,
1059
hour=hour, minute=minute, second=second)
1063
if match_style == '-':
1065
elif match_style == '=':
1066
last = dt + datetime.timedelta(days=1)
1069
for i in range(len(revs)-1, -1, -1):
1070
r = self.get_revision(revs[i])
1071
# TODO: Handle timezone.
1072
dt = datetime.datetime.fromtimestamp(r.timestamp)
1073
if first >= dt and (last is None or dt >= last):
1076
for i in range(len(revs)):
1077
r = self.get_revision(revs[i])
1078
# TODO: Handle timezone.
1079
dt = datetime.datetime.fromtimestamp(r.timestamp)
1080
if first <= dt and (last is None or dt <= last):
1082
REVISION_NAMESPACES['date:'] = _namespace_date
761
# list is 0-based; revisions are 1-based
762
return self.revision_history()[revno-1]
764
raise BzrError("no such revision %s" % revno)
1084
767
def revision_tree(self, revision_id):
1085
768
"""Return Tree for a revision on this branch.
1087
770
`revision_id` may be None for the null revision, in which case
1088
771
an `EmptyTree` is returned."""
1089
# TODO: refactor this to use an existing revision object
1090
# so we don't need to read it in twice.
772
self._need_readlock()
1091
773
if revision_id == None:
1092
774
return EmptyTree()
1094
776
inv = self.get_revision_inventory(revision_id)
1095
return RevisionTree(self.weave_store, inv, revision_id)
777
return RevisionTree(self.text_store, inv)
1098
780
def working_tree(self):
1099
781
"""Return a `Tree` for the working copy."""
1100
from workingtree import WorkingTree
1101
782
return WorkingTree(self.base, self.read_working_inventory())
1115
811
This can change the directory or the filename or both.
813
self._need_writelock()
814
tree = self.working_tree()
816
if not tree.has_filename(from_rel):
817
bailout("can't rename: old working file %r does not exist" % from_rel)
818
if tree.has_filename(to_rel):
819
bailout("can't rename: new working file %r already exists" % to_rel)
821
file_id = inv.path2id(from_rel)
823
bailout("can't rename: old name %r is not versioned" % from_rel)
825
if inv.path2id(to_rel):
826
bailout("can't rename: new name %r is already versioned" % to_rel)
828
to_dir, to_tail = os.path.split(to_rel)
829
to_dir_id = inv.path2id(to_dir)
830
if to_dir_id == None and to_dir != '':
831
bailout("can't determine destination directory id for %r" % to_dir)
833
mutter("rename_one:")
834
mutter(" file_id {%s}" % file_id)
835
mutter(" from_rel %r" % from_rel)
836
mutter(" to_rel %r" % to_rel)
837
mutter(" to_dir %r" % to_dir)
838
mutter(" to_dir_id {%s}" % to_dir_id)
840
inv.rename(file_id, to_dir_id, to_tail)
842
print "%s => %s" % (from_rel, to_rel)
844
from_abs = self.abspath(from_rel)
845
to_abs = self.abspath(to_rel)
1119
tree = self.working_tree()
1120
inv = tree.inventory
1121
if not tree.has_filename(from_rel):
1122
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1123
if tree.has_filename(to_rel):
1124
raise BzrError("can't rename: new working file %r already exists" % to_rel)
1126
file_id = inv.path2id(from_rel)
1128
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1130
if inv.path2id(to_rel):
1131
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1133
to_dir, to_tail = os.path.split(to_rel)
1134
to_dir_id = inv.path2id(to_dir)
1135
if to_dir_id == None and to_dir != '':
1136
raise BzrError("can't determine destination directory id for %r" % to_dir)
1138
mutter("rename_one:")
1139
mutter(" file_id {%s}" % file_id)
1140
mutter(" from_rel %r" % from_rel)
1141
mutter(" to_rel %r" % to_rel)
1142
mutter(" to_dir %r" % to_dir)
1143
mutter(" to_dir_id {%s}" % to_dir_id)
1145
inv.rename(file_id, to_dir_id, to_tail)
1147
from_abs = self.abspath(from_rel)
1148
to_abs = self.abspath(to_rel)
1150
os.rename(from_abs, to_abs)
1152
raise BzrError("failed to rename %r to %r: %s"
1153
% (from_abs, to_abs, e[1]),
1154
["rename rolled back"])
1156
self._write_inventory(inv)
847
os.rename(from_abs, to_abs)
849
bailout("failed to rename %r to %r: %s"
850
% (from_abs, to_abs, e[1]),
851
["rename rolled back"])
853
self._write_inventory(inv)
1161
857
def move(self, from_paths, to_name):
1169
865
Note that to_name is only the last component of the new name;
1170
866
this doesn't change the directory.
1172
This returns a list of (from_path, to_path) pairs for each
1173
entry that is moved.
1178
## TODO: Option to move IDs only
1179
assert not isinstance(from_paths, basestring)
1180
tree = self.working_tree()
1181
inv = tree.inventory
1182
to_abs = self.abspath(to_name)
1183
if not isdir(to_abs):
1184
raise BzrError("destination %r is not a directory" % to_abs)
1185
if not tree.has_filename(to_name):
1186
raise BzrError("destination %r not in working directory" % to_abs)
1187
to_dir_id = inv.path2id(to_name)
1188
if to_dir_id == None and to_name != '':
1189
raise BzrError("destination %r is not a versioned directory" % to_name)
1190
to_dir_ie = inv[to_dir_id]
1191
if to_dir_ie.kind not in ('directory', 'root_directory'):
1192
raise BzrError("destination %r is not a directory" % to_abs)
1194
to_idpath = inv.get_idpath(to_dir_id)
1196
for f in from_paths:
1197
if not tree.has_filename(f):
1198
raise BzrError("%r does not exist in working tree" % f)
1199
f_id = inv.path2id(f)
1201
raise BzrError("%r is not versioned" % f)
1202
name_tail = splitpath(f)[-1]
1203
dest_path = appendpath(to_name, name_tail)
1204
if tree.has_filename(dest_path):
1205
raise BzrError("destination %r already exists" % dest_path)
1206
if f_id in to_idpath:
1207
raise BzrError("can't move %r to a subdirectory of itself" % f)
1209
# OK, so there's a race here, it's possible that someone will
1210
# create a file in this interval and then the rename might be
1211
# left half-done. But we should have caught most problems.
1213
for f in from_paths:
1214
name_tail = splitpath(f)[-1]
1215
dest_path = appendpath(to_name, name_tail)
1216
result.append((f, dest_path))
1217
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1219
os.rename(self.abspath(f), self.abspath(dest_path))
1221
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1222
["rename rolled back"])
1224
self._write_inventory(inv)
1231
def revert(self, filenames, old_tree=None, backups=True):
1232
"""Restore selected files to the versions from a previous tree.
1235
If true (default) backups are made of files before
1238
from bzrlib.errors import NotVersionedError, BzrError
1239
from bzrlib.atomicfile import AtomicFile
1240
from bzrlib.osutils import backup_file
1242
inv = self.read_working_inventory()
1243
if old_tree is None:
1244
old_tree = self.basis_tree()
1245
old_inv = old_tree.inventory
1248
for fn in filenames:
1249
file_id = inv.path2id(fn)
1251
raise NotVersionedError("not a versioned file", fn)
1252
if not old_inv.has_id(file_id):
1253
raise BzrError("file not present in old tree", fn, file_id)
1254
nids.append((fn, file_id))
1256
# TODO: Rename back if it was previously at a different location
1258
# TODO: If given a directory, restore the entire contents from
1259
# the previous version.
1261
# TODO: Make a backup to a temporary file.
1263
# TODO: If the file previously didn't exist, delete it?
1264
for fn, file_id in nids:
1267
f = AtomicFile(fn, 'wb')
1269
f.write(old_tree.get_file(file_id).read())
1275
def pending_merges(self):
1276
"""Return a list of pending merges.
1278
These are revisions that have been merged into the working
1279
directory but not yet committed.
1281
cfn = self.controlfilename('pending-merges')
1282
if not os.path.exists(cfn):
1285
for l in self.controlfile('pending-merges', 'r').readlines():
1286
p.append(l.rstrip('\n'))
1290
def add_pending_merge(self, revision_id):
1291
from bzrlib.revision import validate_revision_id
1293
validate_revision_id(revision_id)
1295
p = self.pending_merges()
1296
if revision_id in p:
1298
p.append(revision_id)
1299
self.set_pending_merges(p)
1302
def set_pending_merges(self, rev_list):
1303
from bzrlib.atomicfile import AtomicFile
1306
f = AtomicFile(self.controlfilename('pending-merges'))
1317
def get_parent(self):
1318
"""Return the parent location of the branch.
1320
This is the default location for push/pull/missing. The usual
1321
pattern is that the user can override it by specifying a
1325
_locs = ['parent', 'pull', 'x-pull']
1328
return self.controlfile(l, 'r').read().strip('\n')
1330
if e.errno != errno.ENOENT:
1335
def set_parent(self, url):
1336
# TODO: Maybe delete old location files?
1337
from bzrlib.atomicfile import AtomicFile
1340
f = AtomicFile(self.controlfilename('parent'))
1349
def check_revno(self, revno):
1351
Check whether a revno corresponds to any revision.
1352
Zero (the NULL revision) is considered valid.
1355
self.check_real_revno(revno)
1357
def check_real_revno(self, revno):
1359
Check whether a revno corresponds to a real revision.
1360
Zero (the NULL revision) is considered invalid
1362
if revno < 1 or revno > self.revno():
1363
raise InvalidRevisionNumber(revno)
868
self._need_writelock()
869
## TODO: Option to move IDs only
870
assert not isinstance(from_paths, basestring)
871
tree = self.working_tree()
873
to_abs = self.abspath(to_name)
874
if not isdir(to_abs):
875
bailout("destination %r is not a directory" % to_abs)
876
if not tree.has_filename(to_name):
877
bailout("destination %r not in working directory" % to_abs)
878
to_dir_id = inv.path2id(to_name)
879
if to_dir_id == None and to_name != '':
880
bailout("destination %r is not a versioned directory" % to_name)
881
to_dir_ie = inv[to_dir_id]
882
if to_dir_ie.kind not in ('directory', 'root_directory'):
883
bailout("destination %r is not a directory" % to_abs)
885
to_idpath = Set(inv.get_idpath(to_dir_id))
888
if not tree.has_filename(f):
889
bailout("%r does not exist in working tree" % f)
890
f_id = inv.path2id(f)
892
bailout("%r is not versioned" % f)
893
name_tail = splitpath(f)[-1]
894
dest_path = appendpath(to_name, name_tail)
895
if tree.has_filename(dest_path):
896
bailout("destination %r already exists" % dest_path)
897
if f_id in to_idpath:
898
bailout("can't move %r to a subdirectory of itself" % f)
900
# OK, so there's a race here, it's possible that someone will
901
# create a file in this interval and then the rename might be
902
# left half-done. But we should have caught most problems.
905
name_tail = splitpath(f)[-1]
906
dest_path = appendpath(to_name, name_tail)
907
print "%s => %s" % (f, dest_path)
908
inv.rename(inv.path2id(f), to_dir_id, name_tail)
910
os.rename(self.abspath(f), self.abspath(dest_path))
912
bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
913
["rename rolled back"])
915
self._write_inventory(inv)
919
def show_status(self, show_all=False, file_list=None):
920
"""Display single-line status for non-ignored working files.
922
The list is show sorted in order by file name.
924
>>> b = ScratchBranch(files=['foo', 'foo~'])
930
>>> b.commit("add foo")
932
>>> os.unlink(b.abspath('foo'))
936
self._need_readlock()
938
# We have to build everything into a list first so that it can
939
# sorted by name, incorporating all the different sources.
941
# FIXME: Rather than getting things in random order and then sorting,
942
# just step through in order.
944
# Interesting case: the old ID for a file has been removed,
945
# but a new file has been created under that name.
947
old = self.basis_tree()
948
new = self.working_tree()
950
items = diff_trees(old, new)
951
# We want to filter out only if any file was provided in the file_list.
952
if isinstance(file_list, list) and len(file_list):
953
items = [item for item in items if item[3] in file_list]
955
for fs, fid, oldname, newname, kind in items:
957
show_status(fs, kind,
958
oldname + ' => ' + newname)
959
elif fs == 'A' or fs == 'M':
960
show_status(fs, kind, newname)
962
show_status(fs, kind, oldname)
965
show_status(fs, kind, newname)
968
show_status(fs, kind, newname)
970
show_status(fs, kind, newname)
972
bailout("weird file state %r" % ((fs, fid),))
1368
976
class ScratchBranch(Branch):