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'):
706
def rename(self, from_paths, to_name):
709
If to_name exists and is a directory, the files are moved into
710
it, keeping their old names. If it is a directory,
712
Note that to_name is only the last component of the new name;
713
this doesn't change the directory.
715
## TODO: Option to move IDs only
716
assert not isinstance(from_paths, basestring)
717
tree = self.working_tree()
719
dest_dir = isdir(self.abspath(to_name))
721
# TODO: Wind back properly if some can't be moved?
722
dest_dir_id = inv.path2id(to_name)
723
if not dest_dir_id and to_name != '':
724
bailout("destination %r is not a versioned directory" % to_name)
726
name_tail = splitpath(f)[-1]
727
dest_path = appendpath(to_name, name_tail)
728
print "%s => %s" % (f, dest_path)
729
inv.rename(inv.path2id(f), dest_dir_id, name_tail)
730
os.rename(self.abspath(f), self.abspath(dest_path))
731
self._write_inventory(inv)
733
if len(from_paths) != 1:
734
bailout("when moving multiple files, destination must be a directory")
735
bailout("rename to non-directory %r not implemented sorry" % to_name)
739
def show_status(branch, show_all=False):
740
"""Display single-line status for non-ignored working files.
742
The list is show sorted in order by file name.
744
>>> b = ScratchBranch(files=['foo', 'foo~'])
750
>>> b.commit("add foo")
752
>>> os.unlink(b.abspath('foo'))
757
:todo: Get state for single files.
759
:todo: Perhaps show a slash at the end of directory names.
763
# We have to build everything into a list first so that it can
764
# sorted by name, incorporating all the different sources.
766
# FIXME: Rather than getting things in random order and then sorting,
767
# just step through in order.
769
# Interesting case: the old ID for a file has been removed,
770
# but a new file has been created under that name.
772
old = branch.basis_tree()
773
old_inv = old.inventory
774
new = branch.working_tree()
775
new_inv = new.inventory
777
for fs, fid, oldname, newname, kind in diff_trees(old, new):
779
show_status(fs, kind,
780
oldname + ' => ' + newname)
781
elif fs == 'A' or fs == 'M':
782
show_status(fs, kind, newname)
784
show_status(fs, kind, oldname)
787
show_status(fs, kind, newname)
790
show_status(fs, kind, newname)
792
show_status(fs, kind, newname)
794
bailout("wierd file state %r" % ((fs, fid),))
798
class ScratchBranch(Branch):
799
"""Special test class: a branch that cleans up after itself.
801
>>> b = ScratchBranch()
809
def __init__(self, files=[], dirs=[]):
810
"""Make a test branch.
812
This creates a temporary directory and runs init-tree in it.
814
If any files are listed, they are created in the working copy.
816
Branch.__init__(self, tempfile.mkdtemp(), init=True)
818
os.mkdir(self.abspath(d))
821
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
825
"""Destroy the test branch, removing the scratch directory."""
827
shutil.rmtree(self.base)
829
# Work around for shutil.rmtree failing on Windows when
830
# readonly files are encountered
831
for root, dirs, files in os.walk(self.base, topdown=False):
833
os.chmod(os.path.join(root, name), 0700)
834
shutil.rmtree(self.base)
838
######################################################################
842
def is_control_file(filename):
843
## FIXME: better check
844
filename = os.path.normpath(filename)
845
while filename != '':
846
head, tail = os.path.split(filename)
847
## mutter('check %r for control file' % ((head, tail), ))
848
if tail == bzrlib.BZRDIR:
857
def _gen_revision_id(when):
858
"""Return new revision-id."""
859
s = '%s-%s-' % (user_email(), compact_date(when))
860
s += hexlify(rand_bytes(8))
864
def gen_file_id(name):
865
"""Return new file id.
867
This should probably generate proper UUIDs, but for the moment we
868
cope with just randomness because running uuidgen every time is
870
idx = name.rfind('/')
872
name = name[idx+1 : ]
874
name = name.lstrip('.')
876
s = hexlify(rand_bytes(8))
877
return '-'.join((name, compact_date(time.time()), s))
added
removed
bzrlib/branch.py
