« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 9
- compare with another revision
- download diff
- download tarball
- view history from revision 9
- Committer: mbp at sourcefrog
- Date: 2005-03-09 06:48:20 UTC
- Revision ID: mbp@sourcefrog.net-20050309064820-6e25df28956afa3c
doc
- files added:
- doc/roadmap.txt
- files removed:
- .bzrignore
- elementtree
- notes
- urlgrabber
- files renamed:
- bzrlib/commands.py => bzr.py
- files modified:
- README
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
28
29
from inventory import InventoryEntry, Inventory
29
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
226
159
That is to say, the inventory describing changes underway, that
227
160
will be committed to the next revision.
228
161
"""
229
## TODO: factor out to atomicfile? is rename safe on windows?
230
## TODO: Maybe some kind of clean/dirty marker on inventory?
231
tmpfname = self.controlfilename('inventory.tmp')
232
tmpf = file(tmpfname, 'wb')
233
inv.write_xml(tmpf)
234
tmpf.close()
235
inv_fname = self.controlfilename('inventory')
236
if sys.platform == 'win32':
237
os.remove(inv_fname)
238
os.rename(tmpfname, inv_fname)
239
mutter('wrote working inventory')
162
inv.write_xml(self.controlfile('inventory', 'w'))
163
mutter('wrote inventory to %s' % quotefn(self.controlfilename('inventory')))
240
164
241
165
242
166
inventory = property(read_working_inventory, _write_inventory, None,
246
170
def add(self, files, verbose=False):
247
171
"""Make files versioned.
248
172
249
Note that the command line normally calls smart_add instead.
250
251
173
This puts the files in the Added state, so that they will be
252
174
recorded by the next commit.
253
175
254
TODO: Perhaps have an option to add the ids even if the files do
176
:todo: Perhaps have an option to add the ids even if the files do
255
177
not (yet) exist.
256
178
257
TODO: Perhaps return the ids of the files? But then again it
179
:todo: Perhaps return the ids of the files? But then again it
258
180
is easy to retrieve them if they're needed.
259
181
260
TODO: Option to specify file id.
182
:todo: Option to specify file id.
261
183
262
TODO: Adding a directory should optionally recurse down and
184
:todo: Adding a directory should optionally recurse down and
263
185
add all non-ignored children. Perhaps do that in a
264
186
higher-level method.
265
187
301
223
if len(fp) == 0:
302
224
bailout("cannot add top-level %r" % f)
303
225
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
226
fullpath = os.path.normpath(self._rel(f))
227
228
if isfile(fullpath):
229
kind = 'file'
230
elif isdir(fullpath):
231
kind = 'directory'
232
else:
233
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
234
235
if len(fp) > 1:
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"
241
% joinpath(fp[:-1]))
242
else:
243
parent_id = None
244
245
file_id = _gen_file_id(fp[-1])
246
inv.add(InventoryEntry(file_id, fp[-1], kind=kind, parent_id=parent_id))
318
247
if verbose:
319
248
show_status('A', kind, quotefn(f))
320
249
321
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
322
250
mutter("add file %s file_id:{%s} kind=%r parent_id={%s}"
251
% (f, file_id, kind, parent_id))
323
252
self._write_inventory(inv)
324
253
325
254
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
255
336
256
def remove(self, files, verbose=False):
337
257
"""Mark nominated files for removal from the inventory.
338
258
339
259
This does not remove their text. This does not run on
340
260
341
TODO: Refuse to remove modified files unless --force is given?
261
:todo: Refuse to remove modified files unless --force is given?
342
262
343
263
>>> b = ScratchBranch(files=['foo'])
344
264
>>> b.add('foo')
362
282
>>> b.working_tree().has_filename('foo')
363
283
True
364
284
365
TODO: Do something useful with directories.
285
:todo: Do something useful with directories.
366
286
367
TODO: Should this remove the text or not? Tough call; not
287
:todo: Should this remove the text or not? Tough call; not
368
288
removing may be useful and the user can just use use rm, and
369
289
is the opposite of add. Removing it is consistent with most
370
290
other tools. Maybe an option.
375
295
if isinstance(files, types.StringTypes):
376
296
files = [files]
377
297
378
tree = self.working_tree()
379
inv = tree.inventory
298
inv = self.read_working_inventory()
380
299
381
300
# do this before any modifications
382
301
for f in files:
385
304
bailout("cannot remove unversioned file %s" % quotefn(f))
386
305
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
387
306
if verbose:
388
# having remove it, it must be either ignored or unknown
389
if tree.is_ignored(f):
390
new_status = 'I'
391
else:
392
new_status = '?'
393
show_status(new_status, inv[fid].kind, quotefn(f))
307
show_status('D', inv[fid].kind, quotefn(f))
394
308
del inv[fid]
395
309
396
310
self._write_inventory(inv)
434
348
be robust against files disappearing, moving, etc. So the
435
349
whole thing is a bit hard.
436
350
437
timestamp -- if not None, seconds-since-epoch for a
351
:param timestamp: if not None, seconds-since-epoch for a
438
352
postdated/predated commit.
439
353
"""
440
354
463
377
464
378
entry = entry.copy()
465
379
466
p = self.abspath(path)
380
p = self._rel(path)
467
381
file_id = entry.file_id
468
382
mutter('commit prep file %s, id %r ' % (p, file_id))
469
383
509
423
entry.text_id)
510
424
511
425
else:
512
entry.text_id = gen_file_id(entry.name)
426
entry.text_id = _gen_file_id(entry.name)
513
427
self.text_store.add(content, entry.text_id)
514
428
mutter(' stored with text_id {%s}' % entry.text_id)
515
429
if verbose:
517
431
state = 'A'
518
432
elif (old_ie.name == entry.name
519
433
and old_ie.parent_id == entry.parent_id):
434
state = 'R'
435
else:
520
436
state = 'M'
521
else:
522
state = 'R'
523
437
524
438
show_status(state, entry.kind, quotefn(path))
525
439
578
492
## TODO: Also calculate and store the inventory SHA1
579
493
mutter("committing patch r%d" % (self.revno() + 1))
580
494
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
495
mutter("append to revision-history")
496
self.controlfile('revision-history', 'at').write(rev_id + '\n')
497
498
mutter("done!")
605
499
606
500
607
501
def get_revision(self, revision_id):
614
508
def get_inventory(self, inventory_id):
615
509
"""Get Inventory object by hash.
616
510
617
TODO: Perhaps for this and similar methods, take a revision
511
:todo: Perhaps for this and similar methods, take a revision
618
512
parameter which can be either an integer revno or a
619
513
string hash."""
620
514
i = Inventory.read_xml(self.inventory_store[inventory_id])
635
529
>>> ScratchBranch().revision_history()
636
530
[]
637
531
"""
638
return [chomp(l) for l in self.controlfile('revision-history', 'r').readlines()]
532
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
639
533
640
534
641
535
def revno(self):
663
557
ph = self.revision_history()
664
558
if ph:
665
559
return ph[-1]
666
else:
667
return None
668
560
669
561
670
562
def lookup_revision(self, revno):
671
563
"""Return revision hash for revision number."""
676
568
# list is 0-based; revisions are 1-based
677
569
return self.revision_history()[revno-1]
678
570
except IndexError:
679
raise BzrError("no such revision %s" % revno)
571
bailout("no such revision %s" % revno)
680
572
681
573
682
574
def revision_tree(self, revision_id):
720
612
721
613
722
614
723
def write_log(self, show_timezone='original', verbose=False):
615
def write_log(self, utc=False):
724
616
"""Write out human-readable log of commits to this branch
725
617
726
utc -- If true, show dates in universal time, not local time."""
618
:param utc: If true, show dates in universal time, not local time."""
727
619
## TODO: Option to choose either original, utc or local timezone
728
620
revno = 1
729
621
precursor = None
734
626
##print 'revision-hash:', p
735
627
rev = self.get_revision(p)
736
628
print 'committer:', rev.committer
737
print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
738
show_timezone))
629
print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0))
739
630
740
631
## opportunistic consistency check, same as check_patch_chaining
741
632
if rev.precursor != precursor:
748
639
for l in rev.message.split('\n'):
749
640
print ' ' + l
750
641
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
642
revno += 1
767
643
precursor = p
768
644
769
645
770
def rename_one(self, from_rel, to_rel):
771
tree = self.working_tree()
772
inv = tree.inventory
773
if not tree.has_filename(from_rel):
774
bailout("can't rename: old working file %r does not exist" % from_rel)
775
if tree.has_filename(to_rel):
776
bailout("can't rename: new working file %r already exists" % to_rel)
777
778
file_id = inv.path2id(from_rel)
779
if file_id == None:
780
bailout("can't rename: old name %r is not versioned" % from_rel)
781
782
if inv.path2id(to_rel):
783
bailout("can't rename: new name %r is already versioned" % to_rel)
784
785
to_dir, to_tail = os.path.split(to_rel)
786
to_dir_id = inv.path2id(to_dir)
787
if to_dir_id == None and to_dir != '':
788
bailout("can't determine destination directory id for %r" % to_dir)
789
790
mutter("rename_one:")
791
mutter(" file_id {%s}" % file_id)
792
mutter(" from_rel %r" % from_rel)
793
mutter(" to_rel %r" % to_rel)
794
mutter(" to_dir %r" % to_dir)
795
mutter(" to_dir_id {%s}" % to_dir_id)
796
797
inv.rename(file_id, to_dir_id, to_tail)
798
799
print "%s => %s" % (from_rel, to_rel)
800
801
from_abs = self.abspath(from_rel)
802
to_abs = self.abspath(to_rel)
803
try:
804
os.rename(from_abs, to_abs)
805
except OSError, e:
806
bailout("failed to rename %r to %r: %s"
807
% (from_abs, to_abs, e[1]),
808
["rename rolled back"])
809
810
self._write_inventory(inv)
811
812
813
814
def move(self, from_paths, to_name):
815
"""Rename files.
816
817
to_name must exist as a versioned directory.
818
819
If to_name exists and is a directory, the files are moved into
820
it, keeping their old names. If it is a directory,
821
822
Note that to_name is only the last component of the new name;
823
this doesn't change the directory.
824
"""
825
## TODO: Option to move IDs only
826
assert not isinstance(from_paths, basestring)
827
tree = self.working_tree()
828
inv = tree.inventory
829
to_abs = self.abspath(to_name)
830
if not isdir(to_abs):
831
bailout("destination %r is not a directory" % to_abs)
832
if not tree.has_filename(to_name):
833
bailout("destination %r not in working directory" % to_abs)
834
to_dir_id = inv.path2id(to_name)
835
if to_dir_id == None and to_name != '':
836
bailout("destination %r is not a versioned directory" % to_name)
837
to_dir_ie = inv[to_dir_id]
838
if to_dir_ie.kind not in ('directory', 'root_directory'):
839
bailout("destination %r is not a directory" % to_abs)
840
841
to_idpath = Set(inv.get_idpath(to_dir_id))
842
843
for f in from_paths:
844
if not tree.has_filename(f):
845
bailout("%r does not exist in working tree" % f)
846
f_id = inv.path2id(f)
847
if f_id == None:
848
bailout("%r is not versioned" % f)
849
name_tail = splitpath(f)[-1]
850
dest_path = appendpath(to_name, name_tail)
851
if tree.has_filename(dest_path):
852
bailout("destination %r already exists" % dest_path)
853
if f_id in to_idpath:
854
bailout("can't move %r to a subdirectory of itself" % f)
855
856
# OK, so there's a race here, it's possible that someone will
857
# create a file in this interval and then the rename might be
858
# left half-done. But we should have caught most problems.
859
860
for f in from_paths:
861
name_tail = splitpath(f)[-1]
862
dest_path = appendpath(to_name, name_tail)
863
print "%s => %s" % (f, dest_path)
864
inv.rename(inv.path2id(f), to_dir_id, name_tail)
865
try:
866
os.rename(self.abspath(f), self.abspath(dest_path))
867
except OSError, e:
868
bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
869
["rename rolled back"])
870
871
self._write_inventory(inv)
872
873
874
875
def show_status(self, show_all=False):
646
647
def show_status(branch, show_all=False):
876
648
"""Display single-line status for non-ignored working files.
877
649
878
650
The list is show sorted in order by file name.
885
657
A foo
886
658
>>> b.commit("add foo")
887
659
>>> b.show_status()
888
>>> os.unlink(b.abspath('foo'))
889
>>> b.show_status()
890
D foo
891
892
TODO: Get state for single files.
660
661
:todo: Get state for single files.
662
663
:todo: Perhaps show a slash at the end of directory names.
664
893
665
"""
894
666
895
667
# We have to build everything into a list first so that it can
901
673
# Interesting case: the old ID for a file has been removed,
902
674
# but a new file has been created under that name.
903
675
904
old = self.basis_tree()
905
new = self.working_tree()
676
old = branch.basis_tree()
677
old_inv = old.inventory
678
new = branch.working_tree()
679
new_inv = new.inventory
906
680
907
681
for fs, fid, oldname, newname, kind in diff_trees(old, new):
908
682
if fs == 'R':
921
695
elif fs == '?':
922
696
show_status(fs, kind, newname)
923
697
else:
924
bailout("weird file state %r" % ((fs, fid),))
698
bailout("wierd file state %r" % ((fs, fid),))
925
699
926
700
927
701
936
710
>>> isdir(bd)
937
711
False
938
712
"""
939
def __init__(self, files=[], dirs=[]):
713
def __init__(self, files = []):
940
714
"""Make a test branch.
941
715
942
716
This creates a temporary directory and runs init-tree in it.
944
718
If any files are listed, they are created in the working copy.
945
719
"""
946
720
Branch.__init__(self, tempfile.mkdtemp(), init=True)
947
for d in dirs:
948
os.mkdir(self.abspath(d))
949
950
721
for f in files:
951
722
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
952
723
953
724
954
725
def __del__(self):
955
726
"""Destroy the test branch, removing the scratch directory."""
956
try:
957
shutil.rmtree(self.base)
958
except OSError:
959
# Work around for shutil.rmtree failing on Windows when
960
# readonly files are encountered
961
for root, dirs, files in os.walk(self.base, topdown=False):
962
for name in files:
963
os.chmod(os.path.join(root, name), 0700)
964
shutil.rmtree(self.base)
727
shutil.rmtree(self.base)
965
728
966
729
967
730
977
740
## mutter('check %r for control file' % ((head, tail), ))
978
741
if tail == bzrlib.BZRDIR:
979
742
return True
980
if filename == head:
981
break
982
743
filename = head
983
744
return False
984
745
991
752
return s
992
753
993
754
994
def gen_file_id(name):
755
def _gen_file_id(name):
995
756
"""Return new file id.
996
757
997
758
This should probably generate proper UUIDs, but for the moment we
998
759
cope with just randomness because running uuidgen every time is
999
760
slow."""
1000
idx = name.rfind('/')
1001
if idx != -1:
1002
name = name[idx+1 : ]
1003
idx = name.rfind('\\')
1004
if idx != -1:
1005
name = name[idx+1 : ]
1006
1007
name = name.lstrip('.')
1008
761
assert '/' not in name
762
while name[0] == '.':
763
name = name[1:]
1009
764
s = hexlify(rand_bytes(8))
1010
765
return '-'.join((name, compact_date(time.time()), s))
766
767
Loggerhead is a web-based interface for Breezy
Version: 2.0.1