2
# -*- coding: UTF-8 -*-
4
# This program is free software; you can redistribute it and/or modify
5
# it under the terms of the GNU General Public License as published by
6
# the Free Software Foundation; either version 2 of the License, or
7
# (at your option) any later version.
9
# This program is distributed in the hope that it will be useful,
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
# GNU General Public License for more details.
14
# You should have received a copy of the GNU General Public License
15
# along with this program; if not, write to the Free Software
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
22
import traceback, socket, fnmatch, difflib, time
23
from binascii import hexlify
26
from inventory import Inventory
27
from trace import mutter, note
28
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
29
from inventory import InventoryEntry, Inventory
30
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
31
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
32
joinpath, sha_string, file_kind
33
from store import ImmutableStore
34
from revision import Revision
35
from errors import bailout
36
from textui import show_status
37
from diff import diff_trees
39
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
40
## TODO: Maybe include checks for common corruption of newlines, etc?
46
######################################################################
50
"""Branch holding a history of revisions.
52
:todo: Perhaps use different stores for different classes of object,
53
so that we can keep track of how much space each one uses,
54
or garbage-collect them.
56
:todo: Add a RemoteBranch subclass. For the basic case of read-only
57
HTTP access this should be very easy by,
58
just redirecting controlfile access into HTTP requests.
59
We would need a RemoteStore working similarly.
61
:todo: Keep the on-disk branch locked while the object exists.
63
:todo: mkdir() method.
65
def __init__(self, base, init=False):
66
"""Create new branch object at a particular location.
68
:param base: Base directory for the branch.
70
:param init: If True, create new control files in a previously
71
unversioned directory. If False, the branch must already
74
In the test suite, creation of new trees is tested using the
75
`ScratchBranch` class.
77
self.base = os.path.realpath(base)
81
if not isdir(self.controlfilename('.')):
82
bailout("not a bzr branch: %s" % quotefn(base),
83
['use "bzr init" to initialize a new working tree',
84
'current bzr can only operate from top-of-tree'])
87
self.text_store = ImmutableStore(self.controlfilename('text-store'))
88
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
89
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
93
return '%s(%r)' % (self.__class__.__name__, self.base)
100
"""Return filename relative to branch top"""
101
return os.path.join(self.base, name)
104
def controlfilename(self, file_or_path):
105
"""Return location relative to branch."""
106
if isinstance(file_or_path, types.StringTypes):
107
file_or_path = [file_or_path]
108
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
111
def controlfile(self, file_or_path, mode='r'):
112
"""Open a control file for this branch"""
113
return file(self.controlfilename(file_or_path), mode)
116
def _make_control(self):
117
os.mkdir(self.controlfilename([]))
118
self.controlfile('README', 'w').write(
119
"This is a Bazaar-NG control directory.\n"
120
"Do not change any files in this directory.")
121
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
122
for d in ('text-store', 'inventory-store', 'revision-store'):
123
os.mkdir(self.controlfilename(d))
124
for f in ('revision-history', 'merged-patches',
125
'pending-merged-patches', 'branch-name'):
126
self.controlfile(f, 'w').write('')
127
mutter('created control directory in ' + self.base)
128
Inventory().write_xml(self.controlfile('inventory','w'))
131
def _check_format(self):
132
"""Check this branch format is supported.
134
The current tool only supports the current unstable format.
136
In the future, we might need different in-memory Branch
137
classes to support downlevel branches. But not yet.
139
# read in binary mode to detect newline wierdness.
140
fmt = self.controlfile('branch-format', 'rb').read()
141
if fmt != BZR_BRANCH_FORMAT:
142
bailout('sorry, branch format %r not supported' % fmt,
143
['use a different bzr version',
144
'or remove the .bzr directory and "bzr init" again'])
147
def read_working_inventory(self):
148
"""Read the working inventory."""
150
inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
151
mutter("loaded inventory of %d items in %f"
152
% (len(inv), time.time() - before))
156
def _write_inventory(self, inv):
157
"""Update the working inventory.
159
That is to say, the inventory describing changes underway, that
160
will be committed to the next revision.
162
inv.write_xml(self.controlfile('inventory', 'w'))
163
mutter('wrote inventory to %s' % quotefn(self.controlfilename('inventory')))
166
inventory = property(read_working_inventory, _write_inventory, None,
167
"""Inventory for the working copy.""")
170
def add(self, files, verbose=False):
171
"""Make files versioned.
173
This puts the files in the Added state, so that they will be
174
recorded by the next commit.
176
:todo: Perhaps have an option to add the ids even if the files do
179
:todo: Perhaps return the ids of the files? But then again it
180
is easy to retrieve them if they're needed.
182
:todo: Option to specify file id.
184
:todo: Adding a directory should optionally recurse down and
185
add all non-ignored children. Perhaps do that in a
188
>>> b = ScratchBranch(files=['foo'])
189
>>> 'foo' in b.unknowns()
194
>>> 'foo' in b.unknowns()
196
>>> bool(b.inventory.path2id('foo'))
202
Traceback (most recent call last):
204
BzrError: ('foo is already versioned', [])
206
>>> b.add(['nothere'])
207
Traceback (most recent call last):
208
BzrError: ('cannot add: not a regular file or directory: nothere', [])
211
# TODO: Re-adding a file that is removed in the working copy
212
# should probably put it back with the previous ID.
213
if isinstance(files, types.StringTypes):
216
inv = self.read_working_inventory()
218
if is_control_file(f):
219
bailout("cannot add control file %s" % quotefn(f))
224
bailout("cannot add top-level %r" % f)
226
fullpath = os.path.normpath(self._rel(f))
230
elif isdir(fullpath):
233
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
236
parent_name = joinpath(fp[:-1])
237
mutter("lookup parent %r" % parent_name)
238
parent_id = inv.path2id(parent_name)
239
if parent_id == None:
240
bailout("cannot add: parent %r is not versioned"
245
file_id = _gen_file_id(fp[-1])
246
inv.add(InventoryEntry(file_id, fp[-1], kind=kind, parent_id=parent_id))
248
show_status('A', kind, quotefn(f))
250
mutter("add file %s file_id:{%s} kind=%r parent_id={%s}"
251
% (f, file_id, kind, parent_id))
252
self._write_inventory(inv)
256
def remove(self, files, verbose=False):
257
"""Mark nominated files for removal from the inventory.
259
This does not remove their text. This does not run on
261
:todo: Refuse to remove modified files unless --force is given?
263
>>> b = ScratchBranch(files=['foo'])
265
>>> b.inventory.has_filename('foo')
268
>>> b.working_tree().has_filename('foo')
270
>>> b.inventory.has_filename('foo')
273
>>> b = ScratchBranch(files=['foo'])
278
>>> b.inventory.has_filename('foo')
280
>>> b.basis_tree().has_filename('foo')
282
>>> b.working_tree().has_filename('foo')
285
:todo: Do something useful with directories.
287
:todo: Should this remove the text or not? Tough call; not
288
removing may be useful and the user can just use use rm, and
289
is the opposite of add. Removing it is consistent with most
290
other tools. Maybe an option.
292
## TODO: Normalize names
293
## TODO: Remove nested loops; better scalability
295
if isinstance(files, types.StringTypes):
298
inv = self.read_working_inventory()
300
# do this before any modifications
304
bailout("cannot remove unversioned file %s" % quotefn(f))
305
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
307
show_status('D', inv[fid].kind, quotefn(f))
310
self._write_inventory(inv)
314
"""Return all unknown files.
316
These are files in the working directory that are not versioned or
317
control files or ignored.
319
>>> b = ScratchBranch(files=['foo', 'foo~'])
320
>>> list(b.unknowns())
323
>>> list(b.unknowns())
326
>>> list(b.unknowns())
329
return self.working_tree().unknowns()
332
def commit(self, message, timestamp=None, committer=None,
334
"""Commit working copy as a new revision.
336
The basic approach is to add all the file texts into the
337
store, then the inventory, then make a new revision pointing
338
to that inventory and store that.
340
This is not quite safe if the working copy changes during the
341
commit; for the moment that is simply not allowed. A better
342
approach is to make a temporary copy of the files before
343
computing their hashes, and then add those hashes in turn to
344
the inventory. This should mean at least that there are no
345
broken hash pointers. There is no way we can get a snapshot
346
of the whole directory at an instant. This would also have to
347
be robust against files disappearing, moving, etc. So the
348
whole thing is a bit hard.
350
:param timestamp: if not None, seconds-since-epoch for a
351
postdated/predated commit.
354
## TODO: Show branch names
356
# TODO: Don't commit if there are no changes, unless forced?
358
# First walk over the working inventory; and both update that
359
# and also build a new revision inventory. The revision
360
# inventory needs to hold the text-id, sha1 and size of the
361
# actual file versions committed in the revision. (These are
362
# not present in the working inventory.) We also need to
363
# detect missing/deleted files, and remove them from the
366
work_inv = self.read_working_inventory()
368
basis = self.basis_tree()
369
basis_inv = basis.inventory
371
for path, entry in work_inv.iter_entries():
372
## TODO: Cope with files that have gone missing.
374
## TODO: Check that the file kind has not changed from the previous
375
## revision of this file (if any).
380
file_id = entry.file_id
381
mutter('commit prep file %s, id %r ' % (p, file_id))
383
if not os.path.exists(p):
384
mutter(" file is missing, removing from inventory")
386
show_status('D', entry.kind, quotefn(path))
387
missing_ids.append(file_id)
390
# TODO: Handle files that have been deleted
392
# TODO: Maybe a special case for empty files? Seems a
393
# waste to store them many times.
397
if basis_inv.has_id(file_id):
398
old_kind = basis_inv[file_id].kind
399
if old_kind != entry.kind:
400
bailout("entry %r changed kind from %r to %r"
401
% (file_id, old_kind, entry.kind))
403
if entry.kind == 'directory':
405
bailout("%s is entered as directory but not a directory" % quotefn(p))
406
elif entry.kind == 'file':
408
bailout("%s is entered as file but is not a file" % quotefn(p))
410
content = file(p, 'rb').read()
412
entry.text_sha1 = sha_string(content)
413
entry.text_size = len(content)
415
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
417
and (old_ie.text_size == entry.text_size)
418
and (old_ie.text_sha1 == entry.text_sha1)):
419
## assert content == basis.get_file(file_id).read()
420
entry.text_id = basis_inv[file_id].text_id
421
mutter(' unchanged from previous text_id {%s}' %
425
entry.text_id = _gen_file_id(entry.name)
426
self.text_store.add(content, entry.text_id)
427
mutter(' stored with text_id {%s}' % entry.text_id)
431
elif (old_ie.name == entry.name
432
and old_ie.parent_id == entry.parent_id):
437
show_status(state, entry.kind, quotefn(path))
439
for file_id in missing_ids:
440
# have to do this later so we don't mess up the iterator.
441
# since parents may be removed before their children we
444
# FIXME: There's probably a better way to do this; perhaps
445
# the workingtree should know how to filter itself.
446
if work_inv.has_id(file_id):
447
del work_inv[file_id]
450
inv_id = rev_id = _gen_revision_id(time.time())
452
inv_tmp = tempfile.TemporaryFile()
453
inv.write_xml(inv_tmp)
455
self.inventory_store.add(inv_tmp, inv_id)
456
mutter('new inventory_id is {%s}' % inv_id)
458
self._write_inventory(work_inv)
460
if timestamp == None:
461
timestamp = time.time()
463
if committer == None:
464
committer = username()
466
mutter("building commit log message")
467
rev = Revision(timestamp=timestamp,
469
precursor = self.last_patch(),
474
rev_tmp = tempfile.TemporaryFile()
475
rev.write_xml(rev_tmp)
477
self.revision_store.add(rev_tmp, rev_id)
478
mutter("new revision_id is {%s}" % rev_id)
480
## XXX: Everything up to here can simply be orphaned if we abort
481
## the commit; it will leave junk files behind but that doesn't
484
## TODO: Read back the just-generated changeset, and make sure it
485
## applies and recreates the right state.
487
## TODO: Also calculate and store the inventory SHA1
488
mutter("committing patch r%d" % (self.revno() + 1))
490
mutter("append to revision-history")
491
self.controlfile('revision-history', 'at').write(rev_id + '\n')
496
def get_revision(self, revision_id):
497
"""Return the Revision object for a named revision"""
498
r = Revision.read_xml(self.revision_store[revision_id])
499
assert r.revision_id == revision_id
503
def get_inventory(self, inventory_id):
504
"""Get Inventory object by hash.
506
:todo: Perhaps for this and similar methods, take a revision
507
parameter which can be either an integer revno or a
509
i = Inventory.read_xml(self.inventory_store[inventory_id])
513
def get_revision_inventory(self, revision_id):
514
"""Return inventory of a past revision."""
515
if revision_id == None:
518
return self.get_inventory(self.get_revision(revision_id).inventory_id)
521
def revision_history(self):
522
"""Return sequence of revision hashes on to this branch.
524
>>> ScratchBranch().revision_history()
527
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
531
"""Return current revision number for this branch.
533
That is equivalent to the number of revisions committed to
536
>>> b = ScratchBranch()
539
>>> b.commit('no foo')
543
return len(self.revision_history())
546
def last_patch(self):
547
"""Return last patch hash, or None if no history.
549
>>> ScratchBranch().last_patch() == None
552
ph = self.revision_history()
557
def lookup_revision(self, revno):
558
"""Return revision hash for revision number."""
563
# list is 0-based; revisions are 1-based
564
return self.revision_history()[revno-1]
566
bailout("no such revision %s" % revno)
569
def revision_tree(self, revision_id):
570
"""Return Tree for a revision on this branch.
572
`revision_id` may be None for the null revision, in which case
573
an `EmptyTree` is returned."""
575
if revision_id == None:
578
inv = self.get_revision_inventory(revision_id)
579
return RevisionTree(self.text_store, inv)
582
def working_tree(self):
583
"""Return a `Tree` for the working copy."""
584
return WorkingTree(self.base, self.read_working_inventory())
587
def basis_tree(self):
588
"""Return `Tree` object for last revision.
590
If there are no revisions yet, return an `EmptyTree`.
592
>>> b = ScratchBranch(files=['foo'])
593
>>> b.basis_tree().has_filename('foo')
595
>>> b.working_tree().has_filename('foo')
598
>>> b.commit('add foo')
599
>>> b.basis_tree().has_filename('foo')
602
r = self.last_patch()
606
return RevisionTree(self.text_store, self.get_revision_inventory(r))
610
def write_log(self, utc=False):
611
"""Write out human-readable log of commits to this branch
613
:param utc: If true, show dates in universal time, not local time."""
616
for p in self.revision_history():
618
print 'revno:', revno
619
## TODO: Show hash if --id is given.
620
##print 'revision-hash:', p
621
rev = self.get_revision(p)
622
print 'committer:', rev.committer
623
print 'timestamp: %s' % (format_date(rev.timestamp, utc))
625
## opportunistic consistency check, same as check_patch_chaining
626
if rev.precursor != precursor:
627
bailout("mismatched precursor!")
631
print ' (no message)'
633
for l in rev.message.split('\n'):
641
def show_status(branch, show_all=False):
642
"""Display single-line status for non-ignored working files.
644
The list is show sorted in order by file name.
646
>>> b = ScratchBranch(files=['foo', 'foo~'])
652
>>> b.commit("add foo")
655
:todo: Get state for single files.
657
:todo: Perhaps show a slash at the end of directory names.
661
# We have to build everything into a list first so that it can
662
# sorted by name, incorporating all the different sources.
664
# FIXME: Rather than getting things in random order and then sorting,
665
# just step through in order.
667
# Interesting case: the old ID for a file has been removed,
668
# but a new file has been created under that name.
670
old = branch.basis_tree()
671
old_inv = old.inventory
672
new = branch.working_tree()
673
new_inv = new.inventory
675
for fs, fid, oldname, newname, kind in diff_trees(old, new):
677
show_status(fs, kind,
678
oldname + ' => ' + newname)
679
elif fs == 'A' or fs == 'M':
680
show_status(fs, kind, newname)
682
show_status(fs, kind, oldname)
685
show_status(fs, kind, newname)
688
show_status(fs, kind, newname)
690
show_status(fs, kind, newname)
692
bailout("wierd file state %r" % ((fs, fid),))
696
class ScratchBranch(Branch):
697
"""Special test class: a branch that cleans up after itself.
699
>>> b = ScratchBranch()
707
def __init__(self, files = []):
708
"""Make a test branch.
710
This creates a temporary directory and runs init-tree in it.
712
If any files are listed, they are created in the working copy.
714
Branch.__init__(self, tempfile.mkdtemp(), init=True)
716
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
720
"""Destroy the test branch, removing the scratch directory."""
721
shutil.rmtree(self.base)
725
######################################################################
729
def is_control_file(filename):
730
## FIXME: better check
731
filename = os.path.normpath(filename)
732
while filename != '':
733
head, tail = os.path.split(filename)
734
## mutter('check %r for control file' % ((head, tail), ))
735
if tail == bzrlib.BZRDIR:
742
def _gen_revision_id(when):
743
"""Return new revision-id."""
744
s = '%s-%s-' % (user_email(), compact_date(when))
745
s += hexlify(rand_bytes(8))
749
def _gen_file_id(name):
750
"""Return new file id.
752
This should probably generate proper UUIDs, but for the moment we
753
cope with just randomness because running uuidgen every time is
755
assert '/' not in name
756
while name[0] == '.':
758
s = hexlify(rand_bytes(8))
759
return '-'.join((name, compact_date(time.time()), s))
added
removed
bzrlib/branch.py
