« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 51
- compare with another revision
- download diff
- download tarball
- view history from revision 51
- Committer: mbp at sourcefrog
- Date: 2005-03-19 23:50:21 UTC
- Revision ID: mbp@sourcefrog.net-20050319235021-a4a900883ea8e2d8
better notes on how to install
- files added:
- doc/roadmap.txt
- files removed:
- .rsyncexclude
- contrib
- contrib/bash
- contrib/zsh
- elementtree
- urlgrabber
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
1
# Copyright (C) 2005 Canonical Ltd
1
#! /usr/bin/env python
2
# -*- coding: UTF-8 -*-
2
3
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
26
27
from trace import mutter, note
27
28
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
28
29
from inventory import InventoryEntry, Inventory
29
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
30
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
30
31
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
31
joinpath, sha_string, file_kind, local_time_offset, appendpath
32
joinpath, sha_string, file_kind, local_time_offset
32
33
from store import ImmutableStore
33
34
from revision import Revision
34
from errors import bailout, BzrError
35
from errors import bailout
35
36
from textui import show_status
36
37
from diff import diff_trees
37
38
40
41
41
42
42
43
43
def find_branch_root(f=None):
44
"""Find the branch root enclosing f, or pwd.
45
46
It is not necessary that f exists.
47
48
Basically we keep looking up until we find the control directory or
49
run into the root."""
50
if f == None:
51
f = os.getcwd()
52
elif hasattr(os.path, 'realpath'):
53
f = os.path.realpath(f)
54
else:
55
f = os.path.abspath(f)
56
57
orig_f = f
58
59
while True:
60
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
61
return f
62
head, tail = os.path.split(f)
63
if head == f:
64
# reached the root, whatever that may be
65
raise BzrError('%r is not in a branch' % orig_f)
66
f = head
67
68
44
69
45
70
46
######################################################################
73
49
class Branch:
74
50
"""Branch holding a history of revisions.
75
51
76
TODO: Perhaps use different stores for different classes of object,
52
:todo: Perhaps use different stores for different classes of object,
77
53
so that we can keep track of how much space each one uses,
78
54
or garbage-collect them.
79
55
80
TODO: Add a RemoteBranch subclass. For the basic case of read-only
56
:todo: Add a RemoteBranch subclass. For the basic case of read-only
81
57
HTTP access this should be very easy by,
82
58
just redirecting controlfile access into HTTP requests.
83
59
We would need a RemoteStore working similarly.
84
60
85
TODO: Keep the on-disk branch locked while the object exists.
61
:todo: Keep the on-disk branch locked while the object exists.
86
62
87
TODO: mkdir() method.
63
:todo: mkdir() method.
88
64
"""
89
def __init__(self, base, init=False, find_root=True):
65
def __init__(self, base, init=False):
90
66
"""Create new branch object at a particular location.
91
67
92
base -- Base directory for the branch.
93
94
init -- If True, create new control files in a previously
68
:param base: Base directory for the branch.
69
70
:param init: If True, create new control files in a previously
95
71
unversioned directory. If False, the branch must already
96
72
be versioned.
97
73
98
find_root -- If true and init is false, find the root of the
99
existing branch containing base.
100
101
74
In the test suite, creation of new trees is tested using the
102
75
`ScratchBranch` class.
103
76
"""
77
self.base = os.path.realpath(base)
104
78
if init:
105
self.base = os.path.realpath(base)
106
79
self._make_control()
107
elif find_root:
108
self.base = find_branch_root(base)
109
80
else:
110
self.base = os.path.realpath(base)
111
81
if not isdir(self.controlfilename('.')):
112
82
bailout("not a bzr branch: %s" % quotefn(base),
113
83
['use "bzr init" to initialize a new working tree',
114
84
'current bzr can only operate from top-of-tree'])
115
self._check_format()
85
self._check_format()
116
86
117
87
self.text_store = ImmutableStore(self.controlfilename('text-store'))
118
88
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
126
96
__repr__ = __str__
127
97
128
98
129
def abspath(self, name):
130
"""Return absolute filename for something in the branch"""
99
def _rel(self, name):
100
"""Return filename relative to branch top"""
131
101
return os.path.join(self.base, name)
132
133
134
def relpath(self, path):
135
"""Return path relative to this branch of something inside it.
136
137
Raises an error if path is not in this branch."""
138
rp = os.path.realpath(path)
139
# FIXME: windows
140
if not rp.startswith(self.base):
141
bailout("path %r is not within branch %r" % (rp, self.base))
142
rp = rp[len(self.base):]
143
rp = rp.lstrip(os.sep)
144
return rp
145
102
146
103
147
104
def controlfilename(self, file_or_path):
148
105
"""Return location relative to branch."""
152
109
153
110
154
111
def controlfile(self, file_or_path, mode='r'):
155
"""Open a control file for this branch.
156
157
There are two classes of file in the control directory: text
158
and binary. binary files are untranslated byte streams. Text
159
control files are stored with Unix newlines and in UTF-8, even
160
if the platform or locale defaults are different.
161
"""
162
163
fn = self.controlfilename(file_or_path)
164
165
if mode == 'rb' or mode == 'wb':
166
return file(fn, mode)
167
elif mode == 'r' or mode == 'w':
168
# open in binary mode anyhow so there's no newline translation;
169
# codecs uses line buffering by default; don't want that.
170
import codecs
171
return codecs.open(fn, mode + 'b', 'utf-8',
172
buffering=60000)
173
else:
174
raise BzrError("invalid controlfile mode %r" % mode)
175
112
"""Open a control file for this branch"""
113
return file(self.controlfilename(file_or_path), mode)
176
114
177
115
178
116
def _make_control(self):
197
135
198
136
In the future, we might need different in-memory Branch
199
137
classes to support downlevel branches. But not yet.
200
"""
201
# This ignores newlines so that we can open branches created
202
# on Windows from Linux and so on. I think it might be better
203
# to always make all internal files in unix format.
204
fmt = self.controlfile('branch-format', 'r').read()
205
fmt.replace('\r\n', '')
138
"""
139
# read in binary mode to detect newline wierdness.
140
fmt = self.controlfile('branch-format', 'rb').read()
206
141
if fmt != BZR_BRANCH_FORMAT:
207
142
bailout('sorry, branch format %r not supported' % fmt,
208
143
['use a different bzr version',
212
147
def read_working_inventory(self):
213
148
"""Read the working inventory."""
214
149
before = time.time()
215
# ElementTree does its own conversion from UTF-8, so open in
216
# binary.
217
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
150
inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
218
151
mutter("loaded inventory of %d items in %f"
219
152
% (len(inv), time.time() - before))
220
153
return inv
227
160
will be committed to the next revision.
228
161
"""
229
162
## TODO: factor out to atomicfile? is rename safe on windows?
230
## TODO: Maybe some kind of clean/dirty marker on inventory?
231
163
tmpfname = self.controlfilename('inventory.tmp')
232
tmpf = file(tmpfname, 'wb')
164
tmpf = file(tmpfname, 'w')
233
165
inv.write_xml(tmpf)
234
166
tmpf.close()
235
inv_fname = self.controlfilename('inventory')
236
if sys.platform == 'win32':
237
os.remove(inv_fname)
238
os.rename(tmpfname, inv_fname)
167
os.rename(tmpfname, self.controlfilename('inventory'))
239
168
mutter('wrote working inventory')
240
169
241
170
246
175
def add(self, files, verbose=False):
247
176
"""Make files versioned.
248
177
249
Note that the command line normally calls smart_add instead.
250
251
178
This puts the files in the Added state, so that they will be
252
179
recorded by the next commit.
253
180
254
TODO: Perhaps have an option to add the ids even if the files do
181
:todo: Perhaps have an option to add the ids even if the files do
255
182
not (yet) exist.
256
183
257
TODO: Perhaps return the ids of the files? But then again it
184
:todo: Perhaps return the ids of the files? But then again it
258
185
is easy to retrieve them if they're needed.
259
186
260
TODO: Option to specify file id.
187
:todo: Option to specify file id.
261
188
262
TODO: Adding a directory should optionally recurse down and
189
:todo: Adding a directory should optionally recurse down and
263
190
add all non-ignored children. Perhaps do that in a
264
191
higher-level method.
265
192
301
228
if len(fp) == 0:
302
229
bailout("cannot add top-level %r" % f)
303
230
304
fullpath = os.path.normpath(self.abspath(f))
305
306
try:
307
kind = file_kind(fullpath)
308
except OSError:
309
# maybe something better?
310
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
311
312
if kind != 'file' and kind != 'directory':
313
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
314
315
file_id = gen_file_id(f)
316
inv.add_path(f, kind=kind, file_id=file_id)
317
231
fullpath = os.path.normpath(self._rel(f))
232
233
if isfile(fullpath):
234
kind = 'file'
235
elif isdir(fullpath):
236
kind = 'directory'
237
else:
238
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
239
240
if len(fp) > 1:
241
parent_name = joinpath(fp[:-1])
242
mutter("lookup parent %r" % parent_name)
243
parent_id = inv.path2id(parent_name)
244
if parent_id == None:
245
bailout("cannot add: parent %r is not versioned"
246
% joinpath(fp[:-1]))
247
else:
248
parent_id = None
249
250
file_id = _gen_file_id(fp[-1])
251
inv.add(InventoryEntry(file_id, fp[-1], kind=kind, parent_id=parent_id))
318
252
if verbose:
319
253
show_status('A', kind, quotefn(f))
320
254
321
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
322
255
mutter("add file %s file_id:{%s} kind=%r parent_id={%s}"
256
% (f, file_id, kind, parent_id))
323
257
self._write_inventory(inv)
324
258
325
259
326
def print_file(self, file, revno):
327
"""Print `file` to stdout."""
328
tree = self.revision_tree(self.lookup_revision(revno))
329
# use inventory as it was in that revision
330
file_id = tree.inventory.path2id(file)
331
if not file_id:
332
bailout("%r is not present in revision %d" % (file, revno))
333
tree.print_file(file_id)
334
335
260
336
261
def remove(self, files, verbose=False):
337
262
"""Mark nominated files for removal from the inventory.
338
263
339
264
This does not remove their text. This does not run on
340
265
341
TODO: Refuse to remove modified files unless --force is given?
266
:todo: Refuse to remove modified files unless --force is given?
342
267
343
268
>>> b = ScratchBranch(files=['foo'])
344
269
>>> b.add('foo')
362
287
>>> b.working_tree().has_filename('foo')
363
288
True
364
289
365
TODO: Do something useful with directories.
290
:todo: Do something useful with directories.
366
291
367
TODO: Should this remove the text or not? Tough call; not
292
:todo: Should this remove the text or not? Tough call; not
368
293
removing may be useful and the user can just use use rm, and
369
294
is the opposite of add. Removing it is consistent with most
370
295
other tools. Maybe an option.
434
359
be robust against files disappearing, moving, etc. So the
435
360
whole thing is a bit hard.
436
361
437
timestamp -- if not None, seconds-since-epoch for a
362
:param timestamp: if not None, seconds-since-epoch for a
438
363
postdated/predated commit.
439
364
"""
440
365
463
388
464
389
entry = entry.copy()
465
390
466
p = self.abspath(path)
391
p = self._rel(path)
467
392
file_id = entry.file_id
468
393
mutter('commit prep file %s, id %r ' % (p, file_id))
469
394
509
434
entry.text_id)
510
435
511
436
else:
512
entry.text_id = gen_file_id(entry.name)
437
entry.text_id = _gen_file_id(entry.name)
513
438
self.text_store.add(content, entry.text_id)
514
439
mutter(' stored with text_id {%s}' % entry.text_id)
515
440
if verbose:
517
442
state = 'A'
518
443
elif (old_ie.name == entry.name
519
444
and old_ie.parent_id == entry.parent_id):
445
state = 'R'
446
else:
520
447
state = 'M'
521
else:
522
state = 'R'
523
448
524
449
show_status(state, entry.kind, quotefn(path))
525
450
578
503
## TODO: Also calculate and store the inventory SHA1
579
504
mutter("committing patch r%d" % (self.revno() + 1))
580
505
581
582
self.append_revision(rev_id)
583
584
if verbose:
585
note("commited r%d" % self.revno())
586
587
588
def append_revision(self, revision_id):
589
mutter("add {%s} to revision-history" % revision_id)
590
rev_history = self.revision_history()
591
592
tmprhname = self.controlfilename('revision-history.tmp')
593
rhname = self.controlfilename('revision-history')
594
595
f = file(tmprhname, 'wt')
596
rev_history.append(revision_id)
597
f.write('\n'.join(rev_history))
598
f.write('\n')
599
f.close()
600
601
if sys.platform == 'win32':
602
os.remove(rhname)
603
os.rename(tmprhname, rhname)
604
506
mutter("append to revision-history")
507
self.controlfile('revision-history', 'at').write(rev_id + '\n')
508
509
mutter("done!")
605
510
606
511
607
512
def get_revision(self, revision_id):
614
519
def get_inventory(self, inventory_id):
615
520
"""Get Inventory object by hash.
616
521
617
TODO: Perhaps for this and similar methods, take a revision
522
:todo: Perhaps for this and similar methods, take a revision
618
523
parameter which can be either an integer revno or a
619
524
string hash."""
620
525
i = Inventory.read_xml(self.inventory_store[inventory_id])
635
540
>>> ScratchBranch().revision_history()
636
541
[]
637
542
"""
638
return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
543
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
639
544
640
545
641
546
def revno(self):
663
568
ph = self.revision_history()
664
569
if ph:
665
570
return ph[-1]
666
else:
667
return None
668
571
669
572
670
573
def lookup_revision(self, revno):
671
574
"""Return revision hash for revision number."""
676
579
# list is 0-based; revisions are 1-based
677
580
return self.revision_history()[revno-1]
678
581
except IndexError:
679
raise BzrError("no such revision %s" % revno)
582
bailout("no such revision %s" % revno)
680
583
681
584
682
585
def revision_tree(self, revision_id):
720
623
721
624
722
625
723
def write_log(self, show_timezone='original', verbose=False):
626
def write_log(self, show_timezone='original'):
724
627
"""Write out human-readable log of commits to this branch
725
628
726
utc -- If true, show dates in universal time, not local time."""
629
:param utc: If true, show dates in universal time, not local time."""
727
630
## TODO: Option to choose either original, utc or local timezone
728
631
revno = 1
729
632
precursor = None
748
651
for l in rev.message.split('\n'):
749
652
print ' ' + l
750
653
751
if verbose == True and precursor != None:
752
print 'changed files:'
753
tree = self.revision_tree(p)
754
prevtree = self.revision_tree(precursor)
755
756
for file_state, fid, old_name, new_name, kind in \
757
diff_trees(prevtree, tree, ):
758
if file_state == 'A' or file_state == 'M':
759
show_status(file_state, kind, new_name)
760
elif file_state == 'D':
761
show_status(file_state, kind, old_name)
762
elif file_state == 'R':
763
show_status(file_state, kind,
764
old_name + ' => ' + new_name)
765
766
654
revno += 1
767
655
precursor = p
768
656
769
657
770
def rename_one(self, from_rel, to_rel):
771
"""Rename one file.
772
773
This can change the directory or the filename or both.
774
"""
775
tree = self.working_tree()
776
inv = tree.inventory
777
if not tree.has_filename(from_rel):
778
bailout("can't rename: old working file %r does not exist" % from_rel)
779
if tree.has_filename(to_rel):
780
bailout("can't rename: new working file %r already exists" % to_rel)
781
782
file_id = inv.path2id(from_rel)
783
if file_id == None:
784
bailout("can't rename: old name %r is not versioned" % from_rel)
785
786
if inv.path2id(to_rel):
787
bailout("can't rename: new name %r is already versioned" % to_rel)
788
789
to_dir, to_tail = os.path.split(to_rel)
790
to_dir_id = inv.path2id(to_dir)
791
if to_dir_id == None and to_dir != '':
792
bailout("can't determine destination directory id for %r" % to_dir)
793
794
mutter("rename_one:")
795
mutter(" file_id {%s}" % file_id)
796
mutter(" from_rel %r" % from_rel)
797
mutter(" to_rel %r" % to_rel)
798
mutter(" to_dir %r" % to_dir)
799
mutter(" to_dir_id {%s}" % to_dir_id)
800
801
inv.rename(file_id, to_dir_id, to_tail)
802
803
print "%s => %s" % (from_rel, to_rel)
804
805
from_abs = self.abspath(from_rel)
806
to_abs = self.abspath(to_rel)
807
try:
808
os.rename(from_abs, to_abs)
809
except OSError, e:
810
bailout("failed to rename %r to %r: %s"
811
% (from_abs, to_abs, e[1]),
812
["rename rolled back"])
813
814
self._write_inventory(inv)
815
816
817
818
def move(self, from_paths, to_name):
819
"""Rename files.
820
821
to_name must exist as a versioned directory.
822
823
If to_name exists and is a directory, the files are moved into
824
it, keeping their old names. If it is a directory,
825
826
Note that to_name is only the last component of the new name;
827
this doesn't change the directory.
828
"""
829
## TODO: Option to move IDs only
830
assert not isinstance(from_paths, basestring)
831
tree = self.working_tree()
832
inv = tree.inventory
833
to_abs = self.abspath(to_name)
834
if not isdir(to_abs):
835
bailout("destination %r is not a directory" % to_abs)
836
if not tree.has_filename(to_name):
837
bailout("destination %r not in working directory" % to_abs)
838
to_dir_id = inv.path2id(to_name)
839
if to_dir_id == None and to_name != '':
840
bailout("destination %r is not a versioned directory" % to_name)
841
to_dir_ie = inv[to_dir_id]
842
if to_dir_ie.kind not in ('directory', 'root_directory'):
843
bailout("destination %r is not a directory" % to_abs)
844
845
to_idpath = Set(inv.get_idpath(to_dir_id))
846
847
for f in from_paths:
848
if not tree.has_filename(f):
849
bailout("%r does not exist in working tree" % f)
850
f_id = inv.path2id(f)
851
if f_id == None:
852
bailout("%r is not versioned" % f)
853
name_tail = splitpath(f)[-1]
854
dest_path = appendpath(to_name, name_tail)
855
if tree.has_filename(dest_path):
856
bailout("destination %r already exists" % dest_path)
857
if f_id in to_idpath:
858
bailout("can't move %r to a subdirectory of itself" % f)
859
860
# OK, so there's a race here, it's possible that someone will
861
# create a file in this interval and then the rename might be
862
# left half-done. But we should have caught most problems.
863
864
for f in from_paths:
865
name_tail = splitpath(f)[-1]
866
dest_path = appendpath(to_name, name_tail)
867
print "%s => %s" % (f, dest_path)
868
inv.rename(inv.path2id(f), to_dir_id, name_tail)
869
try:
870
os.rename(self.abspath(f), self.abspath(dest_path))
871
except OSError, e:
872
bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
873
["rename rolled back"])
874
875
self._write_inventory(inv)
876
877
878
879
def show_status(self, show_all=False):
658
659
def show_status(branch, show_all=False):
880
660
"""Display single-line status for non-ignored working files.
881
661
882
662
The list is show sorted in order by file name.
889
669
A foo
890
670
>>> b.commit("add foo")
891
671
>>> b.show_status()
892
>>> os.unlink(b.abspath('foo'))
672
>>> os.unlink(b._rel('foo'))
893
673
>>> b.show_status()
894
674
D foo
895
675
896
TODO: Get state for single files.
676
677
:todo: Get state for single files.
678
679
:todo: Perhaps show a slash at the end of directory names.
680
897
681
"""
898
682
899
683
# We have to build everything into a list first so that it can
905
689
# Interesting case: the old ID for a file has been removed,
906
690
# but a new file has been created under that name.
907
691
908
old = self.basis_tree()
909
new = self.working_tree()
692
old = branch.basis_tree()
693
old_inv = old.inventory
694
new = branch.working_tree()
695
new_inv = new.inventory
910
696
911
697
for fs, fid, oldname, newname, kind in diff_trees(old, new):
912
698
if fs == 'R':
925
711
elif fs == '?':
926
712
show_status(fs, kind, newname)
927
713
else:
928
bailout("weird file state %r" % ((fs, fid),))
714
bailout("wierd file state %r" % ((fs, fid),))
929
715
930
716
931
717
940
726
>>> isdir(bd)
941
727
False
942
728
"""
943
def __init__(self, files=[], dirs=[]):
729
def __init__(self, files = []):
944
730
"""Make a test branch.
945
731
946
732
This creates a temporary directory and runs init-tree in it.
948
734
If any files are listed, they are created in the working copy.
949
735
"""
950
736
Branch.__init__(self, tempfile.mkdtemp(), init=True)
951
for d in dirs:
952
os.mkdir(self.abspath(d))
953
954
737
for f in files:
955
738
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
956
739
957
740
958
741
def __del__(self):
959
742
"""Destroy the test branch, removing the scratch directory."""
960
try:
961
shutil.rmtree(self.base)
962
except OSError:
963
# Work around for shutil.rmtree failing on Windows when
964
# readonly files are encountered
965
for root, dirs, files in os.walk(self.base, topdown=False):
966
for name in files:
967
os.chmod(os.path.join(root, name), 0700)
968
shutil.rmtree(self.base)
743
shutil.rmtree(self.base)
969
744
970
745
971
746
981
756
## mutter('check %r for control file' % ((head, tail), ))
982
757
if tail == bzrlib.BZRDIR:
983
758
return True
984
if filename == head:
985
break
986
759
filename = head
987
760
return False
988
761
995
768
return s
996
769
997
770
998
def gen_file_id(name):
771
def _gen_file_id(name):
999
772
"""Return new file id.
1000
773
1001
774
This should probably generate proper UUIDs, but for the moment we
1002
775
cope with just randomness because running uuidgen every time is
1003
776
slow."""
1004
idx = name.rfind('/')
1005
if idx != -1:
1006
name = name[idx+1 : ]
1007
idx = name.rfind('\\')
1008
if idx != -1:
1009
name = name[idx+1 : ]
1010
1011
name = name.lstrip('.')
1012
777
assert '/' not in name
778
while name[0] == '.':
779
name = name[1:]
1013
780
s = hexlify(rand_bytes(8))
1014
781
return '-'.join((name, compact_date(time.time()), s))
782
783
Loggerhead is a web-based interface for Breezy
Version: 2.0.1