1
# Copyright (C) 2005 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
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
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, chomp, \
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
35
from textui import show_status
36
from diff import diff_trees
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
39
## TODO: Maybe include checks for common corruption of newlines, etc?
43
def find_branch_root(f=None):
44
"""Find the branch root enclosing f, or pwd.
46
It is not necessary that f exists.
48
Basically we keep looking up until we find the control directory or
52
elif hasattr(os.path, 'realpath'):
53
f = os.path.realpath(f)
55
f = os.path.abspath(f)
61
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
63
head, tail = os.path.split(f)
65
# reached the root, whatever that may be
66
bailout('%r is not in a branch' % orig_f)
71
######################################################################
75
"""Branch holding a history of revisions.
77
:todo: Perhaps use different stores for different classes of object,
78
so that we can keep track of how much space each one uses,
79
or garbage-collect them.
81
:todo: Add a RemoteBranch subclass. For the basic case of read-only
82
HTTP access this should be very easy by,
83
just redirecting controlfile access into HTTP requests.
84
We would need a RemoteStore working similarly.
86
:todo: Keep the on-disk branch locked while the object exists.
88
:todo: mkdir() method.
90
def __init__(self, base, init=False, find_root=True):
91
"""Create new branch object at a particular location.
93
:param base: Base directory for the branch.
95
:param init: If True, create new control files in a previously
96
unversioned directory. If False, the branch must already
99
:param find_root: If true and init is false, find the root of the
100
existing branch containing base.
102
In the test suite, creation of new trees is tested using the
103
`ScratchBranch` class.
106
self.base = os.path.realpath(base)
109
self.base = find_branch_root(base)
111
self.base = os.path.realpath(base)
112
if not isdir(self.controlfilename('.')):
113
bailout("not a bzr branch: %s" % quotefn(base),
114
['use "bzr init" to initialize a new working tree',
115
'current bzr can only operate from top-of-tree'])
118
self.text_store = ImmutableStore(self.controlfilename('text-store'))
119
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
120
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
124
return '%s(%r)' % (self.__class__.__name__, self.base)
130
def abspath(self, name):
131
"""Return absolute filename for something in the branch"""
132
return os.path.join(self.base, name)
135
def relpath(self, path):
136
"""Return path relative to this branch of something inside it.
138
Raises an error if path is not in this branch."""
139
rp = os.path.realpath(path)
141
if not rp.startswith(self.base):
142
bailout("path %r is not within branch %r" % (rp, self.base))
143
rp = rp[len(self.base):]
144
rp = rp.lstrip(os.sep)
148
def controlfilename(self, file_or_path):
149
"""Return location relative to branch."""
150
if isinstance(file_or_path, types.StringTypes):
151
file_or_path = [file_or_path]
152
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
155
def controlfile(self, file_or_path, mode='r'):
156
"""Open a control file for this branch"""
157
return file(self.controlfilename(file_or_path), mode)
160
def _make_control(self):
161
os.mkdir(self.controlfilename([]))
162
self.controlfile('README', 'w').write(
163
"This is a Bazaar-NG control directory.\n"
164
"Do not change any files in this directory.")
165
self.controlfile('branch-format', 'wb').write(BZR_BRANCH_FORMAT)
166
for d in ('text-store', 'inventory-store', 'revision-store'):
167
os.mkdir(self.controlfilename(d))
168
for f in ('revision-history', 'merged-patches',
169
'pending-merged-patches', 'branch-name'):
170
self.controlfile(f, 'w').write('')
171
mutter('created control directory in ' + self.base)
172
Inventory().write_xml(self.controlfile('inventory','w'))
175
def _check_format(self):
176
"""Check this branch format is supported.
178
The current tool only supports the current unstable format.
180
In the future, we might need different in-memory Branch
181
classes to support downlevel branches. But not yet.
183
# This ignores newlines so that we can open branches created
184
# on Windows from Linux and so on. I think it might be better
185
# to always make all internal files in unix format.
186
fmt = self.controlfile('branch-format', 'rb').read()
187
fmt.replace('\r\n', '')
188
if fmt != BZR_BRANCH_FORMAT:
189
bailout('sorry, branch format %r not supported' % fmt,
190
['use a different bzr version',
191
'or remove the .bzr directory and "bzr init" again'])
194
def read_working_inventory(self):
195
"""Read the working inventory."""
197
inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
198
mutter("loaded inventory of %d items in %f"
199
% (len(inv), time.time() - before))
203
def _write_inventory(self, inv):
204
"""Update the working inventory.
206
That is to say, the inventory describing changes underway, that
207
will be committed to the next revision.
209
## TODO: factor out to atomicfile? is rename safe on windows?
210
## TODO: Maybe some kind of clean/dirty marker on inventory?
211
tmpfname = self.controlfilename('inventory.tmp')
212
tmpf = file(tmpfname, 'w')
215
inv_fname = self.controlfilename('inventory')
216
if sys.platform == 'win32':
218
os.rename(tmpfname, inv_fname)
219
mutter('wrote working inventory')
222
inventory = property(read_working_inventory, _write_inventory, None,
223
"""Inventory for the working copy.""")
226
def add(self, files, verbose=False):
227
"""Make files versioned.
229
This puts the files in the Added state, so that they will be
230
recorded by the next commit.
232
:todo: Perhaps have an option to add the ids even if the files do
235
:todo: Perhaps return the ids of the files? But then again it
236
is easy to retrieve them if they're needed.
238
:todo: Option to specify file id.
240
:todo: Adding a directory should optionally recurse down and
241
add all non-ignored children. Perhaps do that in a
244
>>> b = ScratchBranch(files=['foo'])
245
>>> 'foo' in b.unknowns()
250
>>> 'foo' in b.unknowns()
252
>>> bool(b.inventory.path2id('foo'))
258
Traceback (most recent call last):
260
BzrError: ('foo is already versioned', [])
262
>>> b.add(['nothere'])
263
Traceback (most recent call last):
264
BzrError: ('cannot add: not a regular file or directory: nothere', [])
267
# TODO: Re-adding a file that is removed in the working copy
268
# should probably put it back with the previous ID.
269
if isinstance(files, types.StringTypes):
272
inv = self.read_working_inventory()
274
if is_control_file(f):
275
bailout("cannot add control file %s" % quotefn(f))
280
bailout("cannot add top-level %r" % f)
282
fullpath = os.path.normpath(self.abspath(f))
285
kind = file_kind(fullpath)
287
# maybe something better?
288
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
290
if kind != 'file' and kind != 'directory':
291
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
293
file_id = gen_file_id(f)
294
inv.add_path(f, kind=kind, file_id=file_id)
297
show_status('A', kind, quotefn(f))
299
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
301
self._write_inventory(inv)
305
def remove(self, files, verbose=False):
306
"""Mark nominated files for removal from the inventory.
308
This does not remove their text. This does not run on
310
:todo: Refuse to remove modified files unless --force is given?
312
>>> b = ScratchBranch(files=['foo'])
314
>>> b.inventory.has_filename('foo')
317
>>> b.working_tree().has_filename('foo')
319
>>> b.inventory.has_filename('foo')
322
>>> b = ScratchBranch(files=['foo'])
327
>>> b.inventory.has_filename('foo')
329
>>> b.basis_tree().has_filename('foo')
331
>>> b.working_tree().has_filename('foo')
334
:todo: Do something useful with directories.
336
:todo: Should this remove the text or not? Tough call; not
337
removing may be useful and the user can just use use rm, and
338
is the opposite of add. Removing it is consistent with most
339
other tools. Maybe an option.
341
## TODO: Normalize names
342
## TODO: Remove nested loops; better scalability
344
if isinstance(files, types.StringTypes):
347
tree = self.working_tree()
350
# do this before any modifications
354
bailout("cannot remove unversioned file %s" % quotefn(f))
355
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
357
# having remove it, it must be either ignored or unknown
358
if tree.is_ignored(f):
362
show_status(new_status, inv[fid].kind, quotefn(f))
365
self._write_inventory(inv)
369
"""Return all unknown files.
371
These are files in the working directory that are not versioned or
372
control files or ignored.
374
>>> b = ScratchBranch(files=['foo', 'foo~'])
375
>>> list(b.unknowns())
378
>>> list(b.unknowns())
381
>>> list(b.unknowns())
384
return self.working_tree().unknowns()
387
def commit(self, message, timestamp=None, timezone=None,
390
"""Commit working copy as a new revision.
392
The basic approach is to add all the file texts into the
393
store, then the inventory, then make a new revision pointing
394
to that inventory and store that.
396
This is not quite safe if the working copy changes during the
397
commit; for the moment that is simply not allowed. A better
398
approach is to make a temporary copy of the files before
399
computing their hashes, and then add those hashes in turn to
400
the inventory. This should mean at least that there are no
401
broken hash pointers. There is no way we can get a snapshot
402
of the whole directory at an instant. This would also have to
403
be robust against files disappearing, moving, etc. So the
404
whole thing is a bit hard.
406
:param timestamp: if not None, seconds-since-epoch for a
407
postdated/predated commit.
410
## TODO: Show branch names
412
# TODO: Don't commit if there are no changes, unless forced?
414
# First walk over the working inventory; and both update that
415
# and also build a new revision inventory. The revision
416
# inventory needs to hold the text-id, sha1 and size of the
417
# actual file versions committed in the revision. (These are
418
# not present in the working inventory.) We also need to
419
# detect missing/deleted files, and remove them from the
422
work_inv = self.read_working_inventory()
424
basis = self.basis_tree()
425
basis_inv = basis.inventory
427
for path, entry in work_inv.iter_entries():
428
## TODO: Cope with files that have gone missing.
430
## TODO: Check that the file kind has not changed from the previous
431
## revision of this file (if any).
435
p = self.abspath(path)
436
file_id = entry.file_id
437
mutter('commit prep file %s, id %r ' % (p, file_id))
439
if not os.path.exists(p):
440
mutter(" file is missing, removing from inventory")
442
show_status('D', entry.kind, quotefn(path))
443
missing_ids.append(file_id)
446
# TODO: Handle files that have been deleted
448
# TODO: Maybe a special case for empty files? Seems a
449
# waste to store them many times.
453
if basis_inv.has_id(file_id):
454
old_kind = basis_inv[file_id].kind
455
if old_kind != entry.kind:
456
bailout("entry %r changed kind from %r to %r"
457
% (file_id, old_kind, entry.kind))
459
if entry.kind == 'directory':
461
bailout("%s is entered as directory but not a directory" % quotefn(p))
462
elif entry.kind == 'file':
464
bailout("%s is entered as file but is not a file" % quotefn(p))
466
content = file(p, 'rb').read()
468
entry.text_sha1 = sha_string(content)
469
entry.text_size = len(content)
471
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
473
and (old_ie.text_size == entry.text_size)
474
and (old_ie.text_sha1 == entry.text_sha1)):
475
## assert content == basis.get_file(file_id).read()
476
entry.text_id = basis_inv[file_id].text_id
477
mutter(' unchanged from previous text_id {%s}' %
481
entry.text_id = gen_file_id(entry.name)
482
self.text_store.add(content, entry.text_id)
483
mutter(' stored with text_id {%s}' % entry.text_id)
487
elif (old_ie.name == entry.name
488
and old_ie.parent_id == entry.parent_id):
493
show_status(state, entry.kind, quotefn(path))
495
for file_id in missing_ids:
496
# have to do this later so we don't mess up the iterator.
497
# since parents may be removed before their children we
500
# FIXME: There's probably a better way to do this; perhaps
501
# the workingtree should know how to filter itself.
502
if work_inv.has_id(file_id):
503
del work_inv[file_id]
506
inv_id = rev_id = _gen_revision_id(time.time())
508
inv_tmp = tempfile.TemporaryFile()
509
inv.write_xml(inv_tmp)
511
self.inventory_store.add(inv_tmp, inv_id)
512
mutter('new inventory_id is {%s}' % inv_id)
514
self._write_inventory(work_inv)
516
if timestamp == None:
517
timestamp = time.time()
519
if committer == None:
520
committer = username()
523
timezone = local_time_offset()
525
mutter("building commit log message")
526
rev = Revision(timestamp=timestamp,
529
precursor = self.last_patch(),
534
rev_tmp = tempfile.TemporaryFile()
535
rev.write_xml(rev_tmp)
537
self.revision_store.add(rev_tmp, rev_id)
538
mutter("new revision_id is {%s}" % rev_id)
540
## XXX: Everything up to here can simply be orphaned if we abort
541
## the commit; it will leave junk files behind but that doesn't
544
## TODO: Read back the just-generated changeset, and make sure it
545
## applies and recreates the right state.
547
## TODO: Also calculate and store the inventory SHA1
548
mutter("committing patch r%d" % (self.revno() + 1))
550
mutter("append to revision-history")
551
f = self.controlfile('revision-history', 'at')
552
f.write(rev_id + '\n')
556
note("commited r%d" % self.revno())
559
def get_revision(self, revision_id):
560
"""Return the Revision object for a named revision"""
561
r = Revision.read_xml(self.revision_store[revision_id])
562
assert r.revision_id == revision_id
566
def get_inventory(self, inventory_id):
567
"""Get Inventory object by hash.
569
:todo: Perhaps for this and similar methods, take a revision
570
parameter which can be either an integer revno or a
572
i = Inventory.read_xml(self.inventory_store[inventory_id])
576
def get_revision_inventory(self, revision_id):
577
"""Return inventory of a past revision."""
578
if revision_id == None:
581
return self.get_inventory(self.get_revision(revision_id).inventory_id)
584
def revision_history(self):
585
"""Return sequence of revision hashes on to this branch.
587
>>> ScratchBranch().revision_history()
590
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
594
"""Return current revision number for this branch.
596
That is equivalent to the number of revisions committed to
599
>>> b = ScratchBranch()
602
>>> b.commit('no foo')
606
return len(self.revision_history())
609
def last_patch(self):
610
"""Return last patch hash, or None if no history.
612
>>> ScratchBranch().last_patch() == None
615
ph = self.revision_history()
620
def lookup_revision(self, revno):
621
"""Return revision hash for revision number."""
626
# list is 0-based; revisions are 1-based
627
return self.revision_history()[revno-1]
629
bailout("no such revision %s" % revno)
632
def revision_tree(self, revision_id):
633
"""Return Tree for a revision on this branch.
635
`revision_id` may be None for the null revision, in which case
636
an `EmptyTree` is returned."""
638
if revision_id == None:
641
inv = self.get_revision_inventory(revision_id)
642
return RevisionTree(self.text_store, inv)
645
def working_tree(self):
646
"""Return a `Tree` for the working copy."""
647
return WorkingTree(self.base, self.read_working_inventory())
650
def basis_tree(self):
651
"""Return `Tree` object for last revision.
653
If there are no revisions yet, return an `EmptyTree`.
655
>>> b = ScratchBranch(files=['foo'])
656
>>> b.basis_tree().has_filename('foo')
658
>>> b.working_tree().has_filename('foo')
661
>>> b.commit('add foo')
662
>>> b.basis_tree().has_filename('foo')
665
r = self.last_patch()
669
return RevisionTree(self.text_store, self.get_revision_inventory(r))
673
def write_log(self, show_timezone='original'):
674
"""Write out human-readable log of commits to this branch
676
:param utc: If true, show dates in universal time, not local time."""
677
## TODO: Option to choose either original, utc or local timezone
680
for p in self.revision_history():
682
print 'revno:', revno
683
## TODO: Show hash if --id is given.
684
##print 'revision-hash:', p
685
rev = self.get_revision(p)
686
print 'committer:', rev.committer
687
print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
690
## opportunistic consistency check, same as check_patch_chaining
691
if rev.precursor != precursor:
692
bailout("mismatched precursor!")
696
print ' (no message)'
698
for l in rev.message.split('\n'):
705
def rename_one(self, from_rel, to_rel):
706
tree = self.working_tree()
708
if not tree.has_filename(from_rel):
709
bailout("can't rename: old working file %r does not exist" % from_rel)
710
if tree.has_filename(to_rel):
711
bailout("can't rename: new working file %r already exists" % to_rel)
713
file_id = inv.path2id(from_rel)
715
bailout("can't rename: old name %r is not versioned" % from_rel)
717
if inv.path2id(to_rel):
718
bailout("can't rename: new name %r is already versioned" % to_rel)
720
to_dir, to_tail = os.path.split(to_rel)
721
to_dir_id = inv.path2id(to_dir)
722
if to_dir_id == None and to_dir != '':
723
bailout("can't determine destination directory id for %r" % to_dir)
725
mutter("rename_one:")
726
mutter(" file_id {%s}" % file_id)
727
mutter(" from_rel %r" % from_rel)
728
mutter(" to_rel %r" % to_rel)
729
mutter(" to_dir %r" % to_dir)
730
mutter(" to_dir_id {%s}" % to_dir_id)
732
inv.rename(file_id, to_dir_id, to_tail)
733
os.rename(self.abspath(from_rel), self.abspath(to_rel))
735
self._write_inventory(inv)
739
def rename(self, from_paths, to_name):
742
If to_name exists and is a directory, the files are moved into
743
it, keeping their old names. If it is a directory,
745
Note that to_name is only the last component of the new name;
746
this doesn't change the directory.
748
## TODO: Option to move IDs only
749
assert not isinstance(from_paths, basestring)
750
tree = self.working_tree()
752
dest_dir = isdir(self.abspath(to_name))
754
# TODO: Wind back properly if some can't be moved?
755
dest_dir_id = inv.path2id(to_name)
756
if not dest_dir_id and to_name != '':
757
bailout("destination %r is not a versioned directory" % to_name)
759
name_tail = splitpath(f)[-1]
760
dest_path = appendpath(to_name, name_tail)
761
print "%s => %s" % (f, dest_path)
762
inv.rename(inv.path2id(f), dest_dir_id, name_tail)
763
os.rename(self.abspath(f), self.abspath(dest_path))
764
self._write_inventory(inv)
766
if len(from_paths) != 1:
767
bailout("when moving multiple files, destination must be a directory")
768
bailout("rename to non-directory %r not implemented sorry" % to_name)
772
def show_status(branch, show_all=False):
773
"""Display single-line status for non-ignored working files.
775
The list is show sorted in order by file name.
777
>>> b = ScratchBranch(files=['foo', 'foo~'])
783
>>> b.commit("add foo")
785
>>> os.unlink(b.abspath('foo'))
790
:todo: Get state for single files.
792
:todo: Perhaps show a slash at the end of directory names.
796
# We have to build everything into a list first so that it can
797
# sorted by name, incorporating all the different sources.
799
# FIXME: Rather than getting things in random order and then sorting,
800
# just step through in order.
802
# Interesting case: the old ID for a file has been removed,
803
# but a new file has been created under that name.
805
old = branch.basis_tree()
806
old_inv = old.inventory
807
new = branch.working_tree()
808
new_inv = new.inventory
810
for fs, fid, oldname, newname, kind in diff_trees(old, new):
812
show_status(fs, kind,
813
oldname + ' => ' + newname)
814
elif fs == 'A' or fs == 'M':
815
show_status(fs, kind, newname)
817
show_status(fs, kind, oldname)
820
show_status(fs, kind, newname)
823
show_status(fs, kind, newname)
825
show_status(fs, kind, newname)
827
bailout("wierd file state %r" % ((fs, fid),))
831
class ScratchBranch(Branch):
832
"""Special test class: a branch that cleans up after itself.
834
>>> b = ScratchBranch()
842
def __init__(self, files=[], dirs=[]):
843
"""Make a test branch.
845
This creates a temporary directory and runs init-tree in it.
847
If any files are listed, they are created in the working copy.
849
Branch.__init__(self, tempfile.mkdtemp(), init=True)
851
os.mkdir(self.abspath(d))
854
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
858
"""Destroy the test branch, removing the scratch directory."""
860
shutil.rmtree(self.base)
862
# Work around for shutil.rmtree failing on Windows when
863
# readonly files are encountered
864
for root, dirs, files in os.walk(self.base, topdown=False):
866
os.chmod(os.path.join(root, name), 0700)
867
shutil.rmtree(self.base)
871
######################################################################
875
def is_control_file(filename):
876
## FIXME: better check
877
filename = os.path.normpath(filename)
878
while filename != '':
879
head, tail = os.path.split(filename)
880
## mutter('check %r for control file' % ((head, tail), ))
881
if tail == bzrlib.BZRDIR:
890
def _gen_revision_id(when):
891
"""Return new revision-id."""
892
s = '%s-%s-' % (user_email(), compact_date(when))
893
s += hexlify(rand_bytes(8))
897
def gen_file_id(name):
898
"""Return new file id.
900
This should probably generate proper UUIDs, but for the moment we
901
cope with just randomness because running uuidgen every time is
903
idx = name.rfind('/')
905
name = name[idx+1 : ]
907
name = name.lstrip('.')
909
s = hexlify(rand_bytes(8))
910
return '-'.join((name, compact_date(time.time()), s))
added
removed
bzrlib/branch.py
