« back to all changes in this revision
Viewing changes to bzrlib/changeset.py
- browse files at revision 1534.7.183
- compare with another revision
- download diff
- download tarball
- view history from revision 1534.7.183
- Committer: Aaron Bentley
- Date: 2006-02-22 14:39:42 UTC
- mto: (2027.1.2 revert-subpath-56549)
- mto: This revision was merged to the branch mainline in revision 1570.
- Revision ID: abentley@panoramicfeedback.com-20060222143942-ae72299f2de66767
Fixed build_tree with symlinks
- files added:
- bzrlib/bzrdir.py
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/workingtree_implementations
- tools/doc_generate
- files removed:
- bzrlib/changeset.py
- patches
- files renamed:
- bzrlib/tests/test_status.py => bzrlib/tests/blackbox/test_status.py
- bzrlib/tests/test_branch.py => bzrlib/tests/branch_implementations/test_branch.py
- bzrlib/tests/test_parent.py => bzrlib/tests/branch_implementations/test_parent.py
- bzrlib/xml.py => bzrlib/xml_serializer.py
- bzr_man.py => tools/doc_generate/autodoc_man.py
- files modified:
- .bzrignore
added
removed
bzrlib/changeset.py
1
# Copyright (C) 2004 Aaron Bentley <aaron.bentley@utoronto.ca>
2
#
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.
7
#
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.
12
#
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
16
17
"""Represent and apply a changeset.
18
19
Conflicts in applying a changeset are represented as exceptions.
20
21
This only handles the in-memory objects representing changesets, which are
22
primarily used by the merge code.
23
"""
24
25
import os.path
26
import errno
27
import stat
28
from shutil import rmtree
29
from itertools import izip
30
31
from bzrlib.trace import mutter, warning
32
from bzrlib.osutils import rename, sha_file, pathjoin, mkdtemp
33
import bzrlib
34
from bzrlib.errors import BzrCheckError
35
36
__docformat__ = "restructuredtext"
37
38
39
NULL_ID = "!NULL"
40
41
42
class OldFailedTreeOp(Exception):
43
def __init__(self):
44
Exception.__init__(self, "bzr-tree-change contains files from a"
45
" previous failed merge operation.")
46
47
48
def invert_dict(dict):
49
newdict = {}
50
for (key,value) in dict.iteritems():
51
newdict[value] = key
52
return newdict
53
54
55
class ChangeExecFlag(object):
56
"""This is two-way change, suitable for file modification, creation,
57
deletion"""
58
def __init__(self, old_exec_flag, new_exec_flag):
59
self.old_exec_flag = old_exec_flag
60
self.new_exec_flag = new_exec_flag
61
62
def apply(self, filename, conflict_handler):
63
from_exec_flag = self.old_exec_flag
64
to_exec_flag = self.new_exec_flag
65
try:
66
current_exec_flag = bool(os.stat(filename).st_mode & 0111)
67
except OSError, e:
68
if e.errno == errno.ENOENT:
69
if conflict_handler.missing_for_exec_flag(filename) == "skip":
70
return
71
else:
72
current_exec_flag = from_exec_flag
73
74
if from_exec_flag is not None and current_exec_flag != from_exec_flag:
75
if conflict_handler.wrong_old_exec_flag(filename,
76
from_exec_flag, current_exec_flag) != "continue":
77
return
78
79
if to_exec_flag is not None:
80
current_mode = os.stat(filename).st_mode
81
if to_exec_flag:
82
umask = os.umask(0)
83
os.umask(umask)
84
to_mode = current_mode | (0100 & ~umask)
85
# Enable x-bit for others only if they can read it.
86
if current_mode & 0004:
87
to_mode |= 0001 & ~umask
88
if current_mode & 0040:
89
to_mode |= 0010 & ~umask
90
else:
91
to_mode = current_mode & ~0111
92
try:
93
os.chmod(filename, to_mode)
94
except IOError, e:
95
if e.errno == errno.ENOENT:
96
conflict_handler.missing_for_exec_flag(filename)
97
98
def __eq__(self, other):
99
return (isinstance(other, ChangeExecFlag) and
100
self.old_exec_flag == other.old_exec_flag and
101
self.new_exec_flag == other.new_exec_flag)
102
103
def __ne__(self, other):
104
return not (self == other)
105
106
107
def dir_create(filename, conflict_handler, reverse=False):
108
"""Creates the directory, or deletes it if reverse is true. Intended to be
109
used with ReplaceContents.
110
111
:param filename: The name of the directory to create
112
:type filename: str
113
:param reverse: If true, delete the directory, instead
114
:type reverse: bool
115
"""
116
if not reverse:
117
try:
118
os.mkdir(filename)
119
except OSError, e:
120
if e.errno != errno.EEXIST:
121
raise
122
if conflict_handler.dir_exists(filename) == "continue":
123
os.mkdir(filename)
124
except IOError, e:
125
if e.errno == errno.ENOENT:
126
if conflict_handler.missing_parent(filename)=="continue":
127
file(filename, "wb").write(self.contents)
128
else:
129
try:
130
os.rmdir(filename)
131
except OSError, e:
132
if e.errno != errno.ENOTEMPTY:
133
raise
134
if conflict_handler.rmdir_non_empty(filename) == "skip":
135
return
136
os.rmdir(filename)
137
138
139
class SymlinkCreate(object):
140
"""Creates or deletes a symlink (for use with ReplaceContents)"""
141
def __init__(self, contents):
142
"""Constructor.
143
144
:param contents: The filename of the target the symlink should point to
145
:type contents: str
146
"""
147
self.target = contents
148
149
def __repr__(self):
150
return "SymlinkCreate(%s)" % self.target
151
152
def __call__(self, filename, conflict_handler, reverse=False):
153
"""Creates or destroys the symlink.
154
155
:param filename: The name of the symlink to create
156
:type filename: str
157
"""
158
if reverse:
159
assert(os.readlink(filename) == self.target)
160
os.unlink(filename)
161
else:
162
try:
163
os.symlink(self.target, filename)
164
except OSError, e:
165
if e.errno != errno.EEXIST:
166
raise
167
if conflict_handler.link_name_exists(filename) == "continue":
168
os.symlink(self.target, filename)
169
170
def __eq__(self, other):
171
if not isinstance(other, SymlinkCreate):
172
return False
173
elif self.target != other.target:
174
return False
175
else:
176
return True
177
178
def __ne__(self, other):
179
return not (self == other)
180
181
182
class FileCreate(object):
183
"""Create or delete a file (for use with ReplaceContents)"""
184
def __init__(self, contents):
185
"""Constructor
186
187
:param contents: The contents of the file to write
188
:type contents: str
189
"""
190
self.contents = contents
191
192
def __repr__(self):
193
return "FileCreate(%i b)" % len(self.contents)
194
195
def __eq__(self, other):
196
if not isinstance(other, FileCreate):
197
return False
198
elif self.contents != other.contents:
199
return False
200
else:
201
return True
202
203
def __ne__(self, other):
204
return not (self == other)
205
206
def __call__(self, filename, conflict_handler, reverse=False):
207
"""Create or delete a file
208
209
:param filename: The name of the file to create
210
:type filename: str
211
:param reverse: Delete the file instead of creating it
212
:type reverse: bool
213
"""
214
if not reverse:
215
try:
216
file(filename, "wb").write(self.contents)
217
except IOError, e:
218
if e.errno == errno.ENOENT:
219
if conflict_handler.missing_parent(filename)=="continue":
220
file(filename, "wb").write(self.contents)
221
else:
222
raise
223
224
else:
225
try:
226
if (file(filename, "rb").read() != self.contents):
227
direction = conflict_handler.wrong_old_contents(filename,
228
self.contents)
229
if direction != "continue":
230
return
231
os.unlink(filename)
232
except IOError, e:
233
if e.errno != errno.ENOENT:
234
raise
235
if conflict_handler.missing_for_rm(filename, undo) == "skip":
236
return
237
238
239
class TreeFileCreate(object):
240
"""Create or delete a file (for use with ReplaceContents)"""
241
def __init__(self, tree, file_id):
242
"""Constructor
243
244
:param contents: The contents of the file to write
245
:type contents: str
246
"""
247
self.tree = tree
248
self.file_id = file_id
249
250
def __repr__(self):
251
return "TreeFileCreate(%s)" % self.file_id
252
253
def __eq__(self, other):
254
if not isinstance(other, TreeFileCreate):
255
return False
256
return self.tree.get_file_sha1(self.file_id) == \
257
other.tree.get_file_sha1(other.file_id)
258
259
def __ne__(self, other):
260
return not (self == other)
261
262
def write_file(self, filename):
263
outfile = file(filename, "wb")
264
for line in self.tree.get_file(self.file_id):
265
outfile.write(line)
266
267
def same_text(self, filename):
268
in_file = file(filename, "rb")
269
return sha_file(in_file) == self.tree.get_file_sha1(self.file_id)
270
271
def __call__(self, filename, conflict_handler, reverse=False):
272
"""Create or delete a file
273
274
:param filename: The name of the file to create
275
:type filename: str
276
:param reverse: Delete the file instead of creating it
277
:type reverse: bool
278
"""
279
if not reverse:
280
try:
281
self.write_file(filename)
282
except IOError, e:
283
if e.errno == errno.ENOENT:
284
if conflict_handler.missing_parent(filename)=="continue":
285
self.write_file(filename)
286
else:
287
raise
288
289
else:
290
try:
291
if not self.same_text(filename):
292
direction = conflict_handler.wrong_old_contents(filename,
293
self.tree.get_file(self.file_id).read())
294
if direction != "continue":
295
return
296
os.unlink(filename)
297
except IOError, e:
298
if e.errno != errno.ENOENT:
299
raise
300
if conflict_handler.missing_for_rm(filename, undo) == "skip":
301
return
302
303
304
class ReplaceContents(object):
305
"""A contents-replacement framework. It allows a file/directory/symlink to
306
be created, deleted, or replaced with another file/directory/symlink.
307
Arguments must be callable with (filename, reverse).
308
"""
309
def __init__(self, old_contents, new_contents):
310
"""Constructor.
311
312
:param old_contents: The change to reverse apply (e.g. a deletion), \
313
when going forwards.
314
:type old_contents: `dir_create`, `SymlinkCreate`, `FileCreate`, \
315
NoneType, etc.
316
:param new_contents: The second change to apply (e.g. a creation), \
317
when going forwards.
318
:type new_contents: `dir_create`, `SymlinkCreate`, `FileCreate`, \
319
NoneType, etc.
320
"""
321
self.old_contents=old_contents
322
self.new_contents=new_contents
323
324
def __repr__(self):
325
return "ReplaceContents(%r -> %r)" % (self.old_contents,
326
self.new_contents)
327
328
def __eq__(self, other):
329
if not isinstance(other, ReplaceContents):
330
return False
331
elif self.old_contents != other.old_contents:
332
return False
333
elif self.new_contents != other.new_contents:
334
return False
335
else:
336
return True
337
def __ne__(self, other):
338
return not (self == other)
339
340
def apply(self, filename, conflict_handler):
341
"""Applies the FileReplacement to the specified filename
342
343
:param filename: The name of the file to apply changes to
344
:type filename: str
345
"""
346
undo = self.old_contents
347
perform = self.new_contents
348
mode = None
349
if undo is not None:
350
try:
351
mode = os.lstat(filename).st_mode
352
if stat.S_ISLNK(mode):
353
mode = None
354
except OSError, e:
355
if e.errno != errno.ENOENT:
356
raise
357
if conflict_handler.missing_for_rm(filename, undo) == "skip":
358
return
359
undo(filename, conflict_handler, reverse=True)
360
if perform is not None:
361
perform(filename, conflict_handler)
362
if mode is not None:
363
os.chmod(filename, mode)
364
365
def is_creation(self):
366
return self.new_contents is not None and self.old_contents is None
367
368
def is_deletion(self):
369
return self.old_contents is not None and self.new_contents is None
370
371
372
class Diff3Merge(object):
373
history_based = False
374
def __init__(self, file_id, base, other):
375
self.file_id = file_id
376
self.base = base
377
self.other = other
378
379
def is_creation(self):
380
return False
381
382
def is_deletion(self):
383
return False
384
385
def __eq__(self, other):
386
if not isinstance(other, Diff3Merge):
387
return False
388
return (self.base == other.base and
389
self.other == other.other and self.file_id == other.file_id)
390
391
def __ne__(self, other):
392
return not (self == other)
393
394
def dump_file(self, temp_dir, name, tree):
395
out_path = pathjoin(temp_dir, name)
396
out_file = file(out_path, "wb")
397
in_file = tree.get_file(self.file_id)
398
for line in in_file:
399
out_file.write(line)
400
return out_path
401
402
def apply(self, filename, conflict_handler):
403
import bzrlib.patch
404
temp_dir = mkdtemp(prefix="bzr-")
405
try:
406
new_file = filename+".new"
407
base_file = self.dump_file(temp_dir, "base", self.base)
408
other_file = self.dump_file(temp_dir, "other", self.other)
409
base = base_file
410
other = other_file
411
status = bzrlib.patch.diff3(new_file, filename, base, other)
412
if status == 0:
413
os.chmod(new_file, os.stat(filename).st_mode)
414
rename(new_file, filename)
415
return
416
else:
417
assert(status == 1)
418
def get_lines(filename):
419
my_file = file(filename, "rb")
420
lines = my_file.readlines()
421
my_file.close()
422
return lines
423
base_lines = get_lines(base)
424
other_lines = get_lines(other)
425
conflict_handler.merge_conflict(new_file, filename, base_lines,
426
other_lines)
427
finally:
428
rmtree(temp_dir)
429
430
431
def CreateDir():
432
"""Convenience function to create a directory.
433
434
:return: A ReplaceContents that will create a directory
435
:rtype: `ReplaceContents`
436
"""
437
return ReplaceContents(None, dir_create)
438
439
440
def DeleteDir():
441
"""Convenience function to delete a directory.
442
443
:return: A ReplaceContents that will delete a directory
444
:rtype: `ReplaceContents`
445
"""
446
return ReplaceContents(dir_create, None)
447
448
449
def CreateFile(contents):
450
"""Convenience fucntion to create a file.
451
452
:param contents: The contents of the file to create
453
:type contents: str
454
:return: A ReplaceContents that will create a file
455
:rtype: `ReplaceContents`
456
"""
457
return ReplaceContents(None, FileCreate(contents))
458
459
460
def DeleteFile(contents):
461
"""Convenience fucntion to delete a file.
462
463
:param contents: The contents of the file to delete
464
:type contents: str
465
:return: A ReplaceContents that will delete a file
466
:rtype: `ReplaceContents`
467
"""
468
return ReplaceContents(FileCreate(contents), None)
469
470
471
def ReplaceFileContents(old_tree, new_tree, file_id):
472
"""Convenience fucntion to replace the contents of a file.
473
474
:param old_contents: The contents of the file to replace
475
:type old_contents: str
476
:param new_contents: The contents to replace the file with
477
:type new_contents: str
478
:return: A ReplaceContents that will replace the contents of a file a file
479
:rtype: `ReplaceContents`
480
"""
481
return ReplaceContents(TreeFileCreate(old_tree, file_id),
482
TreeFileCreate(new_tree, file_id))
483
484
485
def CreateSymlink(target):
486
"""Convenience fucntion to create a symlink.
487
488
:param target: The path the link should point to
489
:type target: str
490
:return: A ReplaceContents that will delete a file
491
:rtype: `ReplaceContents`
492
"""
493
return ReplaceContents(None, SymlinkCreate(target))
494
495
496
def DeleteSymlink(target):
497
"""Convenience fucntion to delete a symlink.
498
499
:param target: The path the link should point to
500
:type target: str
501
:return: A ReplaceContents that will delete a file
502
:rtype: `ReplaceContents`
503
"""
504
return ReplaceContents(SymlinkCreate(target), None)
505
506
507
def ChangeTarget(old_target, new_target):
508
"""Convenience fucntion to change the target of a symlink.
509
510
:param old_target: The current link target
511
:type old_target: str
512
:param new_target: The new link target to use
513
:type new_target: str
514
:return: A ReplaceContents that will delete a file
515
:rtype: `ReplaceContents`
516
"""
517
return ReplaceContents(SymlinkCreate(old_target), SymlinkCreate(new_target))
518
519
520
class InvalidEntry(Exception):
521
"""Raise when a ChangesetEntry is invalid in some way"""
522
def __init__(self, entry, problem):
523
"""Constructor.
524
525
:param entry: The invalid ChangesetEntry
526
:type entry: `ChangesetEntry`
527
:param problem: The problem with the entry
528
:type problem: str
529
"""
530
msg = "Changeset entry for %s (%s) is invalid.\n%s" % (entry.id,
531
entry.path,
532
problem)
533
Exception.__init__(self, msg)
534
self.entry = entry
535
536
537
class SourceRootHasName(InvalidEntry):
538
"""This changeset entry has a name other than "", but its parent is !NULL"""
539
def __init__(self, entry, name):
540
"""Constructor.
541
542
:param entry: The invalid ChangesetEntry
543
:type entry: `ChangesetEntry`
544
:param name: The name of the entry
545
:type name: str
546
"""
547
msg = 'Child of !NULL is named "%s", not "./.".' % name
548
InvalidEntry.__init__(self, entry, msg)
549
550
551
class NullIDAssigned(InvalidEntry):
552
"""The id !NULL was assigned to a real entry"""
553
def __init__(self, entry):
554
"""Constructor.
555
556
:param entry: The invalid ChangesetEntry
557
:type entry: `ChangesetEntry`
558
"""
559
msg = '"!NULL" id assigned to a file "%s".' % entry.path
560
InvalidEntry.__init__(self, entry, msg)
561
562
563
class ParentIDIsSelf(InvalidEntry):
564
"""An entry is marked as its own parent"""
565
def __init__(self, entry):
566
"""Constructor.
567
568
:param entry: The invalid ChangesetEntry
569
:type entry: `ChangesetEntry`
570
"""
571
msg = 'file %s has "%s" id for both self id and parent id.' % \
572
(entry.path, entry.id)
573
InvalidEntry.__init__(self, entry, msg)
574
575
576
class ChangesetEntry(object):
577
"""An entry the changeset"""
578
def __init__(self, id, parent, path):
579
"""Constructor. Sets parent and name assuming it was not
580
renamed/created/deleted.
581
:param id: The id associated with the entry
582
:param parent: The id of the parent of this entry (or !NULL if no
583
parent)
584
:param path: The file path relative to the tree root of this entry
585
"""
586
self.id = id
587
self.path = path
588
self.new_path = path
589
self.parent = parent
590
self.new_parent = parent
591
self.contents_change = None
592
self.metadata_change = None
593
if parent == NULL_ID and path !='./.':
594
raise SourceRootHasName(self, path)
595
if self.id == NULL_ID:
596
raise NullIDAssigned(self)
597
if self.id == self.parent:
598
raise ParentIDIsSelf(self)
599
600
def __repr__(self):
601
return "ChangesetEntry(%s)" % self.id
602
603
__str__ = __repr__
604
605
def __get_dir(self):
606
if self.path is None:
607
return None
608
return os.path.dirname(self.path)
609
610
def __set_dir(self, dir):
611
self.path = pathjoin(dir, os.path.basename(self.path))
612
613
dir = property(__get_dir, __set_dir)
614
615
def __get_name(self):
616
if self.path is None:
617
return None
618
return os.path.basename(self.path)
619
620
def __set_name(self, name):
621
self.path = pathjoin(os.path.dirname(self.path), name)
622
623
name = property(__get_name, __set_name)
624
625
def __get_new_dir(self):
626
if self.new_path is None:
627
return None
628
return os.path.dirname(self.new_path)
629
630
def __set_new_dir(self, dir):
631
self.new_path = pathjoin(dir, os.path.basename(self.new_path))
632
633
new_dir = property(__get_new_dir, __set_new_dir)
634
635
def __get_new_name(self):
636
if self.new_path is None:
637
return None
638
return os.path.basename(self.new_path)
639
640
def __set_new_name(self, name):
641
self.new_path = pathjoin(os.path.dirname(self.new_path), name)
642
643
new_name = property(__get_new_name, __set_new_name)
644
645
def needs_rename(self):
646
"""Determines whether the entry requires renaming.
647
648
:rtype: bool
649
"""
650
651
return (self.parent != self.new_parent or self.name != self.new_name)
652
653
def is_deletion(self, reverse=False):
654
"""Return true if applying the entry would delete a file/directory.
655
656
:param reverse: if true, the changeset is being applied in reverse
657
:rtype: bool
658
"""
659
return self.is_creation(not reverse)
660
661
def is_creation(self, reverse=False):
662
"""Return true if applying the entry would create a file/directory.
663
664
:param reverse: if true, the changeset is being applied in reverse
665
:rtype: bool
666
"""
667
if self.contents_change is None:
668
return False
669
if reverse:
670
return self.contents_change.is_deletion()
671
else:
672
return self.contents_change.is_creation()
673
674
def is_creation_or_deletion(self):
675
"""Return true if applying the entry would create or delete a
676
file/directory.
677
678
:rtype: bool
679
"""
680
return self.is_creation() or self.is_deletion()
681
682
def get_cset_path(self, mod=False):
683
"""Determine the path of the entry according to the changeset.
684
685
:param changeset: The changeset to derive the path from
686
:type changeset: `Changeset`
687
:param mod: If true, generate the MOD path. Otherwise, generate the \
688
ORIG path.
689
:return: the path of the entry, or None if it did not exist in the \
690
requested tree.
691
:rtype: str or NoneType
692
"""
693
if mod:
694
if self.new_parent == NULL_ID:
695
return "./."
696
elif self.new_parent is None:
697
return None
698
return self.new_path
699
else:
700
if self.parent == NULL_ID:
701
return "./."
702
elif self.parent is None:
703
return None
704
return self.path
705
706
def summarize_name(self):
707
"""Produce a one-line summary of the filename. Indicates renames as
708
old => new, indicates creation as None => new, indicates deletion as
709
old => None.
710
711
:rtype: str
712
"""
713
orig_path = self.get_cset_path(False)
714
mod_path = self.get_cset_path(True)
715
if orig_path and orig_path.startswith('./'):
716
orig_path = orig_path[2:]
717
if mod_path and mod_path.startswith('./'):
718
mod_path = mod_path[2:]
719
if orig_path == mod_path:
720
return orig_path
721
else:
722
return "%s => %s" % (orig_path, mod_path)
723
724
def get_new_path(self, id_map, changeset):
725
"""Determine the full pathname to rename to
726
727
:param id_map: The map of ids to filenames for the tree
728
:type id_map: Dictionary
729
:param changeset: The changeset to get data from
730
:type changeset: `Changeset`
731
:rtype: str
732
"""
733
mutter("Finding new path for %s", self.summarize_name())
734
parent = self.new_parent
735
to_dir = self.new_dir
736
from_dir = self.dir
737
to_name = self.new_name
738
from_name = self.name
739
740
if to_name is None:
741
return None
742
743
if parent == NULL_ID or parent is None:
744
if to_name != u'.':
745
raise SourceRootHasName(self, to_name)
746
else:
747
return u'.'
748
parent_entry = changeset.entries.get(parent)
749
if parent_entry is None:
750
dir = os.path.dirname(id_map[self.id])
751
else:
752
mutter("path, new_path: %r %r", self.path, self.new_path)
753
dir = parent_entry.get_new_path(id_map, changeset)
754
if from_name == to_name:
755
name = os.path.basename(id_map[self.id])
756
else:
757
name = to_name
758
assert(from_name is None or from_name == os.path.basename(id_map[self.id]))
759
return pathjoin(dir, name)
760
761
def is_boring(self):
762
"""Determines whether the entry does nothing
763
764
:return: True if the entry does no renames or content changes
765
:rtype: bool
766
"""
767
if self.contents_change is not None:
768
return False
769
elif self.metadata_change is not None:
770
return False
771
elif self.parent != self.new_parent:
772
return False
773
elif self.name != self.new_name:
774
return False
775
else:
776
return True
777
778
def apply(self, filename, conflict_handler):
779
"""Applies the file content and/or metadata changes.
780
781
:param filename: the filename of the entry
782
:type filename: str
783
"""
784
if self.is_deletion() and self.metadata_change is not None:
785
self.metadata_change.apply(filename, conflict_handler)
786
if self.contents_change is not None:
787
self.contents_change.apply(filename, conflict_handler)
788
if not self.is_deletion() and self.metadata_change is not None:
789
self.metadata_change.apply(filename, conflict_handler)
790
791
792
class IDPresent(Exception):
793
def __init__(self, id):
794
msg = "Cannot add entry because that id has already been used:\n%s" %\
795
id
796
Exception.__init__(self, msg)
797
self.id = id
798
799
800
class Changeset(object):
801
"""A set of changes to apply"""
802
def __init__(self):
803
self.entries = {}
804
805
def add_entry(self, entry):
806
"""Add an entry to the list of entries"""
807
if self.entries.has_key(entry.id):
808
raise IDPresent(entry.id)
809
self.entries[entry.id] = entry
810
811
812
def get_rename_entries(changeset, inventory):
813
"""Return a list of entries that will be renamed. Entries are sorted from
814
longest to shortest source path and from shortest to longest target path.
815
816
:param changeset: The changeset to look in
817
:type changeset: `Changeset`
818
:param inventory: The source of current tree paths for the given ids
819
:type inventory: Dictionary
820
:return: source entries and target entries as a tuple
821
:rtype: (List, List)
822
"""
823
source_entries = [x for x in changeset.entries.itervalues()
824
if x.needs_rename() or x.is_creation_or_deletion()]
825
# these are done from longest path to shortest, to avoid deleting a
826
# parent before its children are deleted/renamed
827
def longest_to_shortest(entry):
828
path = inventory.get(entry.id)
829
if path is None:
830
return 0
831
else:
832
return len(path)
833
source_entries.sort(None, longest_to_shortest, True)
834
835
target_entries = source_entries[:]
836
# These are done from shortest to longest path, to avoid creating a
837
# child before its parent has been created/renamed
838
def shortest_to_longest(entry):
839
path = entry.get_new_path(inventory, changeset)
840
if path is None:
841
return 0
842
else:
843
return len(path)
844
target_entries.sort(None, shortest_to_longest)
845
return (source_entries, target_entries)
846
847
848
def rename_to_temp_delete(source_entries, inventory, dir, temp_dir,
849
conflict_handler):
850
"""Delete and rename entries as appropriate. Entries are renamed to temp
851
names. A map of id -> temp name (or None, for deletions) is returned.
852
853
:param source_entries: The entries to rename and delete
854
:type source_entries: List of `ChangesetEntry`
855
:param inventory: The map of id -> filename in the current tree
856
:type inventory: Dictionary
857
:param dir: The directory to apply changes to
858
:type dir: str
859
:return: a mapping of id to temporary name
860
:rtype: Dictionary
861
"""
862
temp_name = {}
863
for i in range(len(source_entries)):
864
entry = source_entries[i]
865
if entry.is_deletion():
866
path = pathjoin(dir, inventory[entry.id])
867
entry.apply(path, conflict_handler)
868
temp_name[entry.id] = None
869
870
elif entry.needs_rename():
871
if entry.is_creation():
872
continue
873
to_name = pathjoin(temp_dir, str(i))
874
src_path = inventory.get(entry.id)
875
if src_path is not None:
876
src_path = pathjoin(dir, src_path)
877
try:
878
rename(src_path, to_name)
879
temp_name[entry.id] = to_name
880
except OSError, e:
881
if e.errno != errno.ENOENT:
882
raise
883
if conflict_handler.missing_for_rename(src_path, to_name) \
884
== "skip":
885
continue
886
887
return temp_name
888
889
890
def rename_to_new_create(changed_inventory, target_entries, inventory,
891
changeset, dir, conflict_handler):
892
"""Rename entries with temp names to their final names, create new files.
893
894
:param changed_inventory: A mapping of id to temporary name
895
:type changed_inventory: Dictionary
896
:param target_entries: The entries to apply changes to
897
:type target_entries: List of `ChangesetEntry`
898
:param changeset: The changeset to apply
899
:type changeset: `Changeset`
900
:param dir: The directory to apply changes to
901
:type dir: str
902
"""
903
for entry in target_entries:
904
new_tree_path = entry.get_new_path(inventory, changeset)
905
if new_tree_path is None:
906
continue
907
new_path = pathjoin(dir, new_tree_path)
908
old_path = changed_inventory.get(entry.id)
909
if bzrlib.osutils.lexists(new_path):
910
if conflict_handler.target_exists(entry, new_path, old_path) == \
911
"skip":
912
continue
913
if entry.is_creation():
914
entry.apply(new_path, conflict_handler)
915
changed_inventory[entry.id] = new_tree_path
916
elif entry.needs_rename():
917
if entry.is_deletion():
918
continue
919
if old_path is None:
920
continue
921
try:
922
mutter('rename %s to final name %s', old_path, new_path)
923
rename(old_path, new_path)
924
changed_inventory[entry.id] = new_tree_path
925
except OSError, e:
926
raise BzrCheckError('failed to rename %s to %s for changeset entry %s: %s'
927
% (old_path, new_path, entry, e))
928
929
930
class TargetExists(Exception):
931
def __init__(self, entry, target):
932
msg = "The path %s already exists" % target
933
Exception.__init__(self, msg)
934
self.entry = entry
935
self.target = target
936
937
938
class RenameConflict(Exception):
939
def __init__(self, id, this_name, base_name, other_name):
940
msg = """Trees all have different names for a file
941
this: %s
942
base: %s
943
other: %s
944
id: %s""" % (this_name, base_name, other_name, id)
945
Exception.__init__(self, msg)
946
self.this_name = this_name
947
self.base_name = base_name
948
self_other_name = other_name
949
950
951
class MoveConflict(Exception):
952
def __init__(self, id, this_parent, base_parent, other_parent):
953
msg = """The file is in different directories in every tree
954
this: %s
955
base: %s
956
other: %s
957
id: %s""" % (this_parent, base_parent, other_parent, id)
958
Exception.__init__(self, msg)
959
self.this_parent = this_parent
960
self.base_parent = base_parent
961
self_other_parent = other_parent
962
963
964
class MergeConflict(Exception):
965
def __init__(self, this_path):
966
Exception.__init__(self, "Conflict applying changes to %s" % this_path)
967
self.this_path = this_path
968
969
970
class WrongOldContents(Exception):
971
def __init__(self, filename):
972
msg = "Contents mismatch deleting %s" % filename
973
self.filename = filename
974
Exception.__init__(self, msg)
975
976
977
class WrongOldExecFlag(Exception):
978
def __init__(self, filename, old_exec_flag, new_exec_flag):
979
msg = "Executable flag missmatch on %s:\n" \
980
"Expected %s, got %s." % (filename, old_exec_flag, new_exec_flag)
981
self.filename = filename
982
Exception.__init__(self, msg)
983
984
985
class RemoveContentsConflict(Exception):
986
def __init__(self, filename):
987
msg = "Conflict deleting %s, which has different contents in BASE"\
988
" and THIS" % filename
989
self.filename = filename
990
Exception.__init__(self, msg)
991
992
993
class DeletingNonEmptyDirectory(Exception):
994
def __init__(self, filename):
995
msg = "Trying to remove dir %s while it still had files" % filename
996
self.filename = filename
997
Exception.__init__(self, msg)
998
999
1000
class PatchTargetMissing(Exception):
1001
def __init__(self, filename):
1002
msg = "Attempt to patch %s, which does not exist" % filename
1003
Exception.__init__(self, msg)
1004
self.filename = filename
1005
1006
1007
class MissingForSetExec(Exception):
1008
def __init__(self, filename):
1009
msg = "Attempt to change permissions on %s, which does not exist" %\
1010
filename
1011
Exception.__init__(self, msg)
1012
self.filename = filename
1013
1014
1015
class MissingForRm(Exception):
1016
def __init__(self, filename):
1017
msg = "Attempt to remove missing path %s" % filename
1018
Exception.__init__(self, msg)
1019
self.filename = filename
1020
1021
1022
class MissingForRename(Exception):
1023
def __init__(self, filename, to_path):
1024
msg = "Attempt to move missing path %s to %s" % (filename, to_path)
1025
Exception.__init__(self, msg)
1026
self.filename = filename
1027
1028
1029
class NewContentsConflict(Exception):
1030
def __init__(self, filename):
1031
msg = "Conflicting contents for new file %s" % (filename)
1032
Exception.__init__(self, msg)
1033
1034
1035
class WeaveMergeConflict(Exception):
1036
def __init__(self, filename):
1037
msg = "Conflicting contents for file %s" % (filename)
1038
Exception.__init__(self, msg)
1039
1040
1041
class ThreewayContentsConflict(Exception):
1042
def __init__(self, filename):
1043
msg = "Conflicting contents for file %s" % (filename)
1044
Exception.__init__(self, msg)
1045
1046
1047
class MissingForMerge(Exception):
1048
def __init__(self, filename):
1049
msg = "The file %s was modified, but does not exist in this tree"\
1050
% (filename)
1051
Exception.__init__(self, msg)
1052
1053
1054
class ExceptionConflictHandler(object):
1055
"""Default handler for merge exceptions.
1056
1057
This throws an error on any kind of conflict. Conflict handlers can
1058
descend from this class if they have a better way to handle some or
1059
all types of conflict.
1060
"""
1061
def missing_parent(self, pathname):
1062
parent = os.path.dirname(pathname)
1063
raise Exception("Parent directory missing for %s" % pathname)
1064
1065
def dir_exists(self, pathname):
1066
raise Exception("Directory already exists for %s" % pathname)
1067
1068
def failed_hunks(self, pathname):
1069
raise Exception("Failed to apply some hunks for %s" % pathname)
1070
1071
def target_exists(self, entry, target, old_path):
1072
raise TargetExists(entry, target)
1073
1074
def rename_conflict(self, id, this_name, base_name, other_name):
1075
raise RenameConflict(id, this_name, base_name, other_name)
1076
1077
def move_conflict(self, id, this_dir, base_dir, other_dir):
1078
raise MoveConflict(id, this_dir, base_dir, other_dir)
1079
1080
def merge_conflict(self, new_file, this_path, base_lines, other_lines):
1081
os.unlink(new_file)
1082
raise MergeConflict(this_path)
1083
1084
def wrong_old_contents(self, filename, expected_contents):
1085
raise WrongOldContents(filename)
1086
1087
def rem_contents_conflict(self, filename, this_contents, base_contents):
1088
raise RemoveContentsConflict(filename)
1089
1090
def wrong_old_exec_flag(self, filename, old_exec_flag, new_exec_flag):
1091
raise WrongOldExecFlag(filename, old_exec_flag, new_exec_flag)
1092
1093
def rmdir_non_empty(self, filename):
1094
raise DeletingNonEmptyDirectory(filename)
1095
1096
def link_name_exists(self, filename):
1097
raise TargetExists(filename)
1098
1099
def patch_target_missing(self, filename, contents):
1100
raise PatchTargetMissing(filename)
1101
1102
def missing_for_exec_flag(self, filename):
1103
raise MissingForExecFlag(filename)
1104
1105
def missing_for_rm(self, filename, change):
1106
raise MissingForRm(filename)
1107
1108
def missing_for_rename(self, filename, to_path):
1109
raise MissingForRename(filename, to_path)
1110
1111
def missing_for_merge(self, file_id, other_path):
1112
raise MissingForMerge(other_path)
1113
1114
def new_contents_conflict(self, filename, other_contents):
1115
raise NewContentsConflict(filename)
1116
1117
def weave_merge_conflict(self, filename, weave, other_i, out_file):
1118
raise WeaveMergeConflict(filename)
1119
1120
def threeway_contents_conflict(self, filename, this_contents,
1121
base_contents, other_contents):
1122
raise ThreewayContentsConflict(filename)
1123
1124
def finalize(self):
1125
pass
1126
1127
1128
def apply_changeset(changeset, inventory, dir, conflict_handler=None):
1129
"""Apply a changeset to a directory.
1130
1131
:param changeset: The changes to perform
1132
:type changeset: `Changeset`
1133
:param inventory: The mapping of id to filename for the directory
1134
:type inventory: Dictionary
1135
:param dir: The path of the directory to apply the changes to
1136
:type dir: str
1137
:return: The mapping of the changed entries
1138
:rtype: Dictionary
1139
"""
1140
if conflict_handler is None:
1141
conflict_handler = ExceptionConflictHandler()
1142
temp_dir = pathjoin(dir, "bzr-tree-change")
1143
try:
1144
os.mkdir(temp_dir)
1145
except OSError, e:
1146
if e.errno == errno.EEXIST:
1147
try:
1148
os.rmdir(temp_dir)
1149
except OSError, e:
1150
if e.errno == errno.ENOTEMPTY:
1151
raise OldFailedTreeOp()
1152
os.mkdir(temp_dir)
1153
else:
1154
raise
1155
1156
#apply changes that don't affect filenames
1157
for entry in changeset.entries.itervalues():
1158
if not entry.is_creation_or_deletion() and not entry.is_boring():
1159
if entry.id not in inventory:
1160
warning("entry {%s} no longer present, can't be updated",
1161
entry.id)
1162
continue
1163
path = pathjoin(dir, inventory[entry.id])
1164
entry.apply(path, conflict_handler)
1165
1166
# Apply renames in stages, to minimize conflicts:
1167
# Only files whose name or parent change are interesting, because their
1168
# target name may exist in the source tree. If a directory's name changes,
1169
# that doesn't make its children interesting.
1170
(source_entries, target_entries) = get_rename_entries(changeset, inventory)
1171
1172
changed_inventory = rename_to_temp_delete(source_entries, inventory, dir,
1173
temp_dir, conflict_handler)
1174
1175
rename_to_new_create(changed_inventory, target_entries, inventory,
1176
changeset, dir, conflict_handler)
1177
os.rmdir(temp_dir)
1178
return changed_inventory
1179
1180
1181
def apply_changeset_tree(cset, tree):
1182
r_inventory = {}
1183
for entry in tree.source_inventory().itervalues():
1184
inventory[entry.id] = entry.path
1185
new_inventory = apply_changeset(cset, r_inventory, tree.basedir)
1186
new_entries, remove_entries = \
1187
get_inventory_change(inventory, new_inventory, cset)
1188
tree.update_source_inventory(new_entries, remove_entries)
1189
1190
1191
def get_inventory_change(inventory, new_inventory, cset):
1192
new_entries = {}
1193
remove_entries = []
1194
for entry in cset.entries.itervalues():
1195
if entry.needs_rename():
1196
new_path = entry.get_new_path(inventory, cset)
1197
if new_path is None:
1198
remove_entries.append(entry.id)
1199
else:
1200
new_entries[new_path] = entry.id
1201
return new_entries, remove_entries
1202
1203
1204
def print_changeset(cset):
1205
"""Print all non-boring changeset entries
1206
1207
:param cset: The changeset to print
1208
:type cset: `Changeset`
1209
"""
1210
for entry in cset.entries.itervalues():
1211
if entry.is_boring():
1212
continue
1213
print entry.id
1214
print entry.summarize_name(cset)
1215
1216
1217
class UnsupportedFiletype(Exception):
1218
def __init__(self, kind, full_path):
1219
msg = "The file \"%s\" is a %s, which is not a supported filetype." \
1220
% (full_path, kind)
1221
Exception.__init__(self, msg)
1222
self.full_path = full_path
1223
self.kind = kind
1224
1225
1226
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1227
return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1228
1229
1230
class ChangesetGenerator(object):
1231
def __init__(self, tree_a, tree_b, interesting_ids=None):
1232
object.__init__(self)
1233
self.tree_a = tree_a
1234
self.tree_b = tree_b
1235
self._interesting_ids = interesting_ids
1236
1237
def iter_both_tree_ids(self):
1238
for file_id in self.tree_a:
1239
yield file_id
1240
for file_id in self.tree_b:
1241
if file_id not in self.tree_a:
1242
yield file_id
1243
1244
def __call__(self):
1245
cset = Changeset()
1246
for file_id in self.iter_both_tree_ids():
1247
cs_entry = self.make_entry(file_id)
1248
if cs_entry is not None and not cs_entry.is_boring():
1249
cset.add_entry(cs_entry)
1250
1251
for entry in list(cset.entries.itervalues()):
1252
if entry.parent != entry.new_parent:
1253
if not cset.entries.has_key(entry.parent) and\
1254
entry.parent != NULL_ID and entry.parent is not None:
1255
parent_entry = self.make_boring_entry(entry.parent)
1256
cset.add_entry(parent_entry)
1257
if not cset.entries.has_key(entry.new_parent) and\
1258
entry.new_parent != NULL_ID and \
1259
entry.new_parent is not None:
1260
parent_entry = self.make_boring_entry(entry.new_parent)
1261
cset.add_entry(parent_entry)
1262
return cset
1263
1264
def iter_inventory(self, tree):
1265
for file_id in tree:
1266
yield self.get_entry(file_id, tree)
1267
1268
def get_entry(self, file_id, tree):
1269
if not tree.has_or_had_id(file_id):
1270
return None
1271
return tree.inventory[file_id]
1272
1273
def get_entry_parent(self, entry):
1274
if entry is None:
1275
return None
1276
return entry.parent_id
1277
1278
def get_path(self, file_id, tree):
1279
if not tree.has_or_had_id(file_id):
1280
return None
1281
path = tree.id2path(file_id)
1282
if path == '':
1283
return './.'
1284
else:
1285
return path
1286
1287
def make_basic_entry(self, file_id, only_interesting):
1288
entry_a = self.get_entry(file_id, self.tree_a)
1289
entry_b = self.get_entry(file_id, self.tree_b)
1290
if only_interesting and not self.is_interesting(entry_a, entry_b):
1291
return None
1292
parent = self.get_entry_parent(entry_a)
1293
path = self.get_path(file_id, self.tree_a)
1294
cs_entry = ChangesetEntry(file_id, parent, path)
1295
new_parent = self.get_entry_parent(entry_b)
1296
1297
new_path = self.get_path(file_id, self.tree_b)
1298
1299
cs_entry.new_path = new_path
1300
cs_entry.new_parent = new_parent
1301
return cs_entry
1302
1303
def is_interesting(self, entry_a, entry_b):
1304
if self._interesting_ids is None:
1305
return True
1306
if entry_a is not None:
1307
file_id = entry_a.file_id
1308
elif entry_b is not None:
1309
file_id = entry_b.file_id
1310
else:
1311
return False
1312
return file_id in self._interesting_ids
1313
1314
def make_boring_entry(self, id):
1315
cs_entry = self.make_basic_entry(id, only_interesting=False)
1316
if cs_entry.is_creation_or_deletion():
1317
return self.make_entry(id, only_interesting=False)
1318
else:
1319
return cs_entry
1320
1321
def make_entry(self, id, only_interesting=True):
1322
cs_entry = self.make_basic_entry(id, only_interesting)
1323
1324
if cs_entry is None:
1325
return None
1326
1327
cs_entry.metadata_change = self.make_exec_flag_change(id)
1328
1329
if id in self.tree_a and id in self.tree_b:
1330
a_sha1 = self.tree_a.get_file_sha1(id)
1331
b_sha1 = self.tree_b.get_file_sha1(id)
1332
if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1333
return cs_entry
1334
1335
cs_entry.contents_change = self.make_contents_change(id)
1336
return cs_entry
1337
1338
def make_exec_flag_change(self, file_id):
1339
exec_flag_a = exec_flag_b = None
1340
if file_id in self.tree_a and self.tree_a.kind(file_id) == "file":
1341
exec_flag_a = self.tree_a.is_executable(file_id)
1342
1343
if file_id in self.tree_b and self.tree_b.kind(file_id) == "file":
1344
exec_flag_b = self.tree_b.is_executable(file_id)
1345
1346
if exec_flag_a == exec_flag_b:
1347
return None
1348
return ChangeExecFlag(exec_flag_a, exec_flag_b)
1349
1350
def make_contents_change(self, file_id):
1351
a_contents = get_contents(self.tree_a, file_id)
1352
b_contents = get_contents(self.tree_b, file_id)
1353
if a_contents == b_contents:
1354
return None
1355
return ReplaceContents(a_contents, b_contents)
1356
1357
1358
def get_contents(tree, file_id):
1359
"""Return the appropriate contents to create a copy of file_id from tree"""
1360
if file_id not in tree:
1361
return None
1362
kind = tree.kind(file_id)
1363
if kind == "file":
1364
return TreeFileCreate(tree, file_id)
1365
elif kind in ("directory", "root_directory"):
1366
return dir_create
1367
elif kind == "symlink":
1368
return SymlinkCreate(tree.get_symlink_target(file_id))
1369
else:
1370
raise UnsupportedFiletype(kind, tree.id2path(file_id))
1371
1372
1373
def full_path(entry, tree):
1374
return pathjoin(tree.basedir, entry.path)
1375
1376
1377
def new_delete_entry(entry, tree, inventory, delete):
1378
if entry.path == "":
1379
parent = NULL_ID
1380
else:
1381
parent = inventory[dirname(entry.path)].id
1382
cs_entry = ChangesetEntry(parent, entry.path)
1383
if delete:
1384
cs_entry.new_path = None
1385
cs_entry.new_parent = None
1386
else:
1387
cs_entry.path = None
1388
cs_entry.parent = None
1389
full_path = full_path(entry, tree)
1390
status = os.lstat(full_path)
1391
if stat.S_ISDIR(file_stat.st_mode):
1392
action = dir_create
1393
1394
1395
# XXX: Can't we unify this with the regular inventory object
1396
class Inventory(object):
1397
def __init__(self, inventory):
1398
self.inventory = inventory
1399
self.rinventory = None
1400
1401
def get_rinventory(self):
1402
if self.rinventory is None:
1403
self.rinventory = invert_dict(self.inventory)
1404
return self.rinventory
1405
1406
def get_path(self, id):
1407
return self.inventory.get(id)
1408
1409
def get_name(self, id):
1410
path = self.get_path(id)
1411
if path is None:
1412
return None
1413
else:
1414
return os.path.basename(path)
1415
1416
def get_dir(self, id):
1417
path = self.get_path(id)
1418
if path == "":
1419
return None
1420
if path is None:
1421
return None
1422
return os.path.dirname(path)
1423
1424
def get_parent(self, id):
1425
if self.get_path(id) is None:
1426
return None
1427
directory = self.get_dir(id)
1428
if directory == '.':
1429
directory = u'./.'
1430
if directory is None:
1431
return NULL_ID
1432
return self.get_rinventory().get(directory)
1433
1434
Loggerhead is a web-based interface for Breezy
Version: 2.0.1