1
# Copyright (C) 2004 Aaron Bentley <aaron.bentley@utoronto.ca>
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21
Represent and apply a changeset
23
__docformat__ = "restructuredtext"
28
def invert_dict(dict):
30
for (key,value) in dict.iteritems():
35
class PatchApply(object):
36
"""Patch application as a kind of content change"""
37
def __init__(self, contents):
40
:param contents: The text of the patch to apply
41
:type contents: str"""
42
self.contents = contents
44
def __eq__(self, other):
45
if not isinstance(other, PatchApply):
47
elif self.contents != other.contents:
52
def __ne__(self, other):
53
return not (self == other)
55
def apply(self, filename, conflict_handler, reverse=False):
56
"""Applies the patch to the specified file.
58
:param filename: the file to apply the patch to
60
:param reverse: If true, apply the patch in reverse
63
input_name = filename+".orig"
65
os.rename(filename, input_name)
67
if e.errno != errno.ENOENT:
69
if conflict_handler.patch_target_missing(filename, self.contents)\
72
os.rename(filename, input_name)
75
status = patch.patch(self.contents, input_name, filename,
77
os.chmod(filename, os.stat(input_name).st_mode)
81
conflict_handler.failed_hunks(filename)
84
class ChangeUnixPermissions(object):
85
"""This is two-way change, suitable for file modification, creation,
87
def __init__(self, old_mode, new_mode):
88
self.old_mode = old_mode
89
self.new_mode = new_mode
91
def apply(self, filename, conflict_handler, reverse=False):
93
from_mode = self.old_mode
94
to_mode = self.new_mode
96
from_mode = self.new_mode
97
to_mode = self.old_mode
99
current_mode = os.stat(filename).st_mode &0777
101
if e.errno == errno.ENOENT:
102
if conflict_handler.missing_for_chmod(filename) == "skip":
105
current_mode = from_mode
107
if from_mode is not None and current_mode != from_mode:
108
if conflict_handler.wrong_old_perms(filename, from_mode,
109
current_mode) != "continue":
112
if to_mode is not None:
114
os.chmod(filename, to_mode)
116
if e.errno == errno.ENOENT:
117
conflict_handler.missing_for_chmod(filename)
119
def __eq__(self, other):
120
if not isinstance(other, ChangeUnixPermissions):
122
elif self.old_mode != other.old_mode:
124
elif self.new_mode != other.new_mode:
129
def __ne__(self, other):
130
return not (self == other)
132
def dir_create(filename, conflict_handler, reverse):
133
"""Creates the directory, or deletes it if reverse is true. Intended to be
134
used with ReplaceContents.
136
:param filename: The name of the directory to create
138
:param reverse: If true, delete the directory, instead
145
if e.errno != errno.EEXIST:
147
if conflict_handler.dir_exists(filename) == "continue":
150
if e.errno == errno.ENOENT:
151
if conflict_handler.missing_parent(filename)=="continue":
152
file(filename, "wb").write(self.contents)
159
if conflict_handler.rmdir_non_empty(filename) == "skip":
166
class SymlinkCreate(object):
167
"""Creates or deletes a symlink (for use with ReplaceContents)"""
168
def __init__(self, contents):
171
:param contents: The filename of the target the symlink should point to
174
self.target = contents
176
def __call__(self, filename, conflict_handler, reverse):
177
"""Creates or destroys the symlink.
179
:param filename: The name of the symlink to create
183
assert(os.readlink(filename) == self.target)
187
os.symlink(self.target, filename)
189
if e.errno != errno.EEXIST:
191
if conflict_handler.link_name_exists(filename) == "continue":
192
os.symlink(self.target, filename)
194
def __eq__(self, other):
195
if not isinstance(other, SymlinkCreate):
197
elif self.target != other.target:
202
def __ne__(self, other):
203
return not (self == other)
205
class FileCreate(object):
206
"""Create or delete a file (for use with ReplaceContents)"""
207
def __init__(self, contents):
210
:param contents: The contents of the file to write
213
self.contents = contents
216
return "FileCreate(%i b)" % len(self.contents)
218
def __eq__(self, other):
219
if not isinstance(other, FileCreate):
221
elif self.contents != other.contents:
226
def __ne__(self, other):
227
return not (self == other)
229
def __call__(self, filename, conflict_handler, reverse):
230
"""Create or delete a file
232
:param filename: The name of the file to create
234
:param reverse: Delete the file instead of creating it
239
file(filename, "wb").write(self.contents)
241
if e.errno == errno.ENOENT:
242
if conflict_handler.missing_parent(filename)=="continue":
243
file(filename, "wb").write(self.contents)
249
if (file(filename, "rb").read() != self.contents):
250
direction = conflict_handler.wrong_old_contents(filename,
252
if direction != "continue":
256
if e.errno != errno.ENOENT:
258
if conflict_handler.missing_for_rm(filename, undo) == "skip":
263
def reversed(sequence):
264
max = len(sequence) - 1
265
for i in range(len(sequence)):
266
yield sequence[max - i]
268
class ReplaceContents(object):
269
"""A contents-replacement framework. It allows a file/directory/symlink to
270
be created, deleted, or replaced with another file/directory/symlink.
271
Arguments must be callable with (filename, reverse).
273
def __init__(self, old_contents, new_contents):
276
:param old_contents: The change to reverse apply (e.g. a deletion), \
278
:type old_contents: `dir_create`, `SymlinkCreate`, `FileCreate`, \
280
:param new_contents: The second change to apply (e.g. a creation), \
282
:type new_contents: `dir_create`, `SymlinkCreate`, `FileCreate`, \
285
self.old_contents=old_contents
286
self.new_contents=new_contents
289
return "ReplaceContents(%r -> %r)" % (self.old_contents,
292
def __eq__(self, other):
293
if not isinstance(other, ReplaceContents):
295
elif self.old_contents != other.old_contents:
297
elif self.new_contents != other.new_contents:
301
def __ne__(self, other):
302
return not (self == other)
304
def apply(self, filename, conflict_handler, reverse=False):
305
"""Applies the FileReplacement to the specified filename
307
:param filename: The name of the file to apply changes to
309
:param reverse: If true, apply the change in reverse
313
undo = self.old_contents
314
perform = self.new_contents
316
undo = self.new_contents
317
perform = self.old_contents
321
mode = os.lstat(filename).st_mode
322
if stat.S_ISLNK(mode):
325
if e.errno != errno.ENOENT:
327
if conflict_handler.missing_for_rm(filename, undo) == "skip":
329
undo(filename, conflict_handler, reverse=True)
330
if perform is not None:
331
perform(filename, conflict_handler, reverse=False)
333
os.chmod(filename, mode)
335
class ApplySequence(object):
336
def __init__(self, changes=None):
338
if changes is not None:
339
self.changes.extend(changes)
341
def __eq__(self, other):
342
if not isinstance(other, ApplySequence):
344
elif len(other.changes) != len(self.changes):
347
for i in range(len(self.changes)):
348
if self.changes[i] != other.changes[i]:
352
def __ne__(self, other):
353
return not (self == other)
356
def apply(self, filename, conflict_handler, reverse=False):
360
iter = reversed(self.changes)
362
change.apply(filename, conflict_handler, reverse)
365
class Diff3Merge(object):
366
def __init__(self, base_file, other_file):
367
self.base_file = base_file
368
self.other_file = other_file
370
def __eq__(self, other):
371
if not isinstance(other, Diff3Merge):
373
return (self.base_file == other.base_file and
374
self.other_file == other.other_file)
376
def __ne__(self, other):
377
return not (self == other)
379
def apply(self, filename, conflict_handler, reverse=False):
380
new_file = filename+".new"
382
base = self.base_file
383
other = self.other_file
385
base = self.other_file
386
other = self.base_file
387
status = patch.diff3(new_file, filename, base, other)
389
os.chmod(new_file, os.stat(filename).st_mode)
390
os.rename(new_file, filename)
394
conflict_handler.merge_conflict(new_file, filename, base, other)
398
"""Convenience function to create a directory.
400
:return: A ReplaceContents that will create a directory
401
:rtype: `ReplaceContents`
403
return ReplaceContents(None, dir_create)
406
"""Convenience function to delete a directory.
408
:return: A ReplaceContents that will delete a directory
409
:rtype: `ReplaceContents`
411
return ReplaceContents(dir_create, None)
413
def CreateFile(contents):
414
"""Convenience fucntion to create a file.
416
:param contents: The contents of the file to create
418
:return: A ReplaceContents that will create a file
419
:rtype: `ReplaceContents`
421
return ReplaceContents(None, FileCreate(contents))
423
def DeleteFile(contents):
424
"""Convenience fucntion to delete a file.
426
:param contents: The contents of the file to delete
428
:return: A ReplaceContents that will delete a file
429
:rtype: `ReplaceContents`
431
return ReplaceContents(FileCreate(contents), None)
433
def ReplaceFileContents(old_contents, new_contents):
434
"""Convenience fucntion to replace the contents of a file.
436
:param old_contents: The contents of the file to replace
437
:type old_contents: str
438
:param new_contents: The contents to replace the file with
439
:type new_contents: str
440
:return: A ReplaceContents that will replace the contents of a file a file
441
:rtype: `ReplaceContents`
443
return ReplaceContents(FileCreate(old_contents), FileCreate(new_contents))
445
def CreateSymlink(target):
446
"""Convenience fucntion to create a symlink.
448
:param target: The path the link should point to
450
:return: A ReplaceContents that will delete a file
451
:rtype: `ReplaceContents`
453
return ReplaceContents(None, SymlinkCreate(target))
455
def DeleteSymlink(target):
456
"""Convenience fucntion to delete a symlink.
458
:param target: The path the link should point to
460
:return: A ReplaceContents that will delete a file
461
:rtype: `ReplaceContents`
463
return ReplaceContents(SymlinkCreate(target), None)
465
def ChangeTarget(old_target, new_target):
466
"""Convenience fucntion to change the target of a symlink.
468
:param old_target: The current link target
469
:type old_target: str
470
:param new_target: The new link target to use
471
:type new_target: str
472
:return: A ReplaceContents that will delete a file
473
:rtype: `ReplaceContents`
475
return ReplaceContents(SymlinkCreate(old_target), SymlinkCreate(new_target))
478
class InvalidEntry(Exception):
479
"""Raise when a ChangesetEntry is invalid in some way"""
480
def __init__(self, entry, problem):
483
:param entry: The invalid ChangesetEntry
484
:type entry: `ChangesetEntry`
485
:param problem: The problem with the entry
488
msg = "Changeset entry for %s (%s) is invalid.\n%s" % (entry.id,
491
Exception.__init__(self, msg)
495
class SourceRootHasName(InvalidEntry):
496
"""This changeset entry has a name other than "", but its parent is !NULL"""
497
def __init__(self, entry, name):
500
:param entry: The invalid ChangesetEntry
501
:type entry: `ChangesetEntry`
502
:param name: The name of the entry
505
msg = 'Child of !NULL is named "%s", not "./.".' % name
506
InvalidEntry.__init__(self, entry, msg)
508
class NullIDAssigned(InvalidEntry):
509
"""The id !NULL was assigned to a real entry"""
510
def __init__(self, entry):
513
:param entry: The invalid ChangesetEntry
514
:type entry: `ChangesetEntry`
516
msg = '"!NULL" id assigned to a file "%s".' % entry.path
517
InvalidEntry.__init__(self, entry, msg)
519
class ParentIDIsSelf(InvalidEntry):
520
"""An entry is marked as its own parent"""
521
def __init__(self, entry):
524
:param entry: The invalid ChangesetEntry
525
:type entry: `ChangesetEntry`
527
msg = 'file %s has "%s" id for both self id and parent id.' % \
528
(entry.path, entry.id)
529
InvalidEntry.__init__(self, entry, msg)
531
class ChangesetEntry(object):
532
"""An entry the changeset"""
533
def __init__(self, id, parent, path):
534
"""Constructor. Sets parent and name assuming it was not
535
renamed/created/deleted.
536
:param id: The id associated with the entry
537
:param parent: The id of the parent of this entry (or !NULL if no
539
:param path: The file path relative to the tree root of this entry
545
self.new_parent = parent
546
self.contents_change = None
547
self.metadata_change = None
548
if parent == NULL_ID and path !='./.':
549
raise SourceRootHasName(self, path)
550
if self.id == NULL_ID:
551
raise NullIDAssigned(self)
552
if self.id == self.parent:
553
raise ParentIDIsSelf(self)
556
return "ChangesetEntry(%s)" % self.id
559
if self.path is None:
561
return os.path.dirname(self.path)
563
def __set_dir(self, dir):
564
self.path = os.path.join(dir, os.path.basename(self.path))
566
dir = property(__get_dir, __set_dir)
568
def __get_name(self):
569
if self.path is None:
571
return os.path.basename(self.path)
573
def __set_name(self, name):
574
self.path = os.path.join(os.path.dirname(self.path), name)
576
name = property(__get_name, __set_name)
578
def __get_new_dir(self):
579
if self.new_path is None:
581
return os.path.dirname(self.new_path)
583
def __set_new_dir(self, dir):
584
self.new_path = os.path.join(dir, os.path.basename(self.new_path))
586
new_dir = property(__get_new_dir, __set_new_dir)
588
def __get_new_name(self):
589
if self.new_path is None:
591
return os.path.basename(self.new_path)
593
def __set_new_name(self, name):
594
self.new_path = os.path.join(os.path.dirname(self.new_path), name)
596
new_name = property(__get_new_name, __set_new_name)
598
def needs_rename(self):
599
"""Determines whether the entry requires renaming.
604
return (self.parent != self.new_parent or self.name != self.new_name)
606
def is_deletion(self, reverse):
607
"""Return true if applying the entry would delete a file/directory.
609
:param reverse: if true, the changeset is being applied in reverse
612
return ((self.new_parent is None and not reverse) or
613
(self.parent is None and reverse))
615
def is_creation(self, reverse):
616
"""Return true if applying the entry would create a file/directory.
618
:param reverse: if true, the changeset is being applied in reverse
621
return ((self.parent is None and not reverse) or
622
(self.new_parent is None and reverse))
624
def is_creation_or_deletion(self):
625
"""Return true if applying the entry would create or delete a
630
return self.parent is None or self.new_parent is None
632
def get_cset_path(self, mod=False):
633
"""Determine the path of the entry according to the changeset.
635
:param changeset: The changeset to derive the path from
636
:type changeset: `Changeset`
637
:param mod: If true, generate the MOD path. Otherwise, generate the \
639
:return: the path of the entry, or None if it did not exist in the \
641
:rtype: str or NoneType
644
if self.new_parent == NULL_ID:
646
elif self.new_parent is None:
650
if self.parent == NULL_ID:
652
elif self.parent is None:
656
def summarize_name(self, changeset, reverse=False):
657
"""Produce a one-line summary of the filename. Indicates renames as
658
old => new, indicates creation as None => new, indicates deletion as
661
:param changeset: The changeset to get paths from
662
:type changeset: `Changeset`
663
:param reverse: If true, reverse the names in the output
667
orig_path = self.get_cset_path(False)
668
mod_path = self.get_cset_path(True)
669
if orig_path is not None:
670
orig_path = orig_path[2:]
671
if mod_path is not None:
672
mod_path = mod_path[2:]
673
if orig_path == mod_path:
677
return "%s => %s" % (orig_path, mod_path)
679
return "%s => %s" % (mod_path, orig_path)
682
def get_new_path(self, id_map, changeset, reverse=False):
683
"""Determine the full pathname to rename to
685
:param id_map: The map of ids to filenames for the tree
686
:type id_map: Dictionary
687
:param changeset: The changeset to get data from
688
:type changeset: `Changeset`
689
:param reverse: If true, we're applying the changeset in reverse
696
from_dir = self.new_dir
698
from_name = self.new_name
700
parent = self.new_parent
701
to_dir = self.new_dir
703
to_name = self.new_name
704
from_name = self.name
709
if parent == NULL_ID or parent is None:
711
raise SourceRootHasName(self, to_name)
714
if from_dir == to_dir:
715
dir = os.path.dirname(id_map[self.id])
717
parent_entry = changeset.entries[parent]
718
dir = parent_entry.get_new_path(id_map, changeset, reverse)
719
if from_name == to_name:
720
name = os.path.basename(id_map[self.id])
723
assert(from_name is None or from_name == os.path.basename(id_map[self.id]))
724
return os.path.join(dir, name)
727
"""Determines whether the entry does nothing
729
:return: True if the entry does no renames or content changes
732
if self.contents_change is not None:
734
elif self.metadata_change is not None:
736
elif self.parent != self.new_parent:
738
elif self.name != self.new_name:
743
def apply(self, filename, conflict_handler, reverse=False):
744
"""Applies the file content and/or metadata changes.
746
:param filename: the filename of the entry
748
:param reverse: If true, apply the changes in reverse
751
if self.is_deletion(reverse) and self.metadata_change is not None:
752
self.metadata_change.apply(filename, conflict_handler, reverse)
753
if self.contents_change is not None:
754
self.contents_change.apply(filename, conflict_handler, reverse)
755
if not self.is_deletion(reverse) and self.metadata_change is not None:
756
self.metadata_change.apply(filename, conflict_handler, reverse)
758
class IDPresent(Exception):
759
def __init__(self, id):
760
msg = "Cannot add entry because that id has already been used:\n%s" %\
762
Exception.__init__(self, msg)
765
class Changeset(object):
766
"""A set of changes to apply"""
770
def add_entry(self, entry):
771
"""Add an entry to the list of entries"""
772
if self.entries.has_key(entry.id):
773
raise IDPresent(entry.id)
774
self.entries[entry.id] = entry
776
def my_sort(sequence, key, reverse=False):
777
"""A sort function that supports supplying a key for comparison
779
:param sequence: The sequence to sort
780
:param key: A callable object that returns the values to be compared
781
:param reverse: If true, sort in reverse order
784
def cmp_by_key(entry_a, entry_b):
789
return cmp(key(entry_a), key(entry_b))
790
sequence.sort(cmp_by_key)
792
def get_rename_entries(changeset, inventory, reverse):
793
"""Return a list of entries that will be renamed. Entries are sorted from
794
longest to shortest source path and from shortest to longest target path.
796
:param changeset: The changeset to look in
797
:type changeset: `Changeset`
798
:param inventory: The source of current tree paths for the given ids
799
:type inventory: Dictionary
800
:param reverse: If true, the changeset is being applied in reverse
802
:return: source entries and target entries as a tuple
805
source_entries = [x for x in changeset.entries.itervalues()
807
# these are done from longest path to shortest, to avoid deleting a
808
# parent before its children are deleted/renamed
809
def longest_to_shortest(entry):
810
path = inventory.get(entry.id)
815
my_sort(source_entries, longest_to_shortest, reverse=True)
817
target_entries = source_entries[:]
818
# These are done from shortest to longest path, to avoid creating a
819
# child before its parent has been created/renamed
820
def shortest_to_longest(entry):
821
path = entry.get_new_path(inventory, changeset, reverse)
826
my_sort(target_entries, shortest_to_longest)
827
return (source_entries, target_entries)
829
def rename_to_temp_delete(source_entries, inventory, dir, conflict_handler,
831
"""Delete and rename entries as appropriate. Entries are renamed to temp
832
names. A map of id -> temp name is returned.
834
:param source_entries: The entries to rename and delete
835
:type source_entries: List of `ChangesetEntry`
836
:param inventory: The map of id -> filename in the current tree
837
:type inventory: Dictionary
838
:param dir: The directory to apply changes to
840
:param reverse: Apply changes in reverse
842
:return: a mapping of id to temporary name
845
temp_dir = os.path.join(dir, "temp")
847
for i in range(len(source_entries)):
848
entry = source_entries[i]
849
if entry.is_deletion(reverse):
850
path = os.path.join(dir, inventory[entry.id])
851
entry.apply(path, conflict_handler, reverse)
854
to_name = temp_dir+"/"+str(i)
855
src_path = inventory.get(entry.id)
856
if src_path is not None:
857
src_path = os.path.join(dir, src_path)
859
os.rename(src_path, to_name)
860
temp_name[entry.id] = to_name
862
if e.errno != errno.ENOENT:
864
if conflict_handler.missing_for_rename(src_path) == "skip":
870
def rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
871
conflict_handler, reverse):
872
"""Rename entries with temp names to their final names, create new files.
874
:param temp_name: A mapping of id to temporary name
875
:type temp_name: Dictionary
876
:param target_entries: The entries to apply changes to
877
:type target_entries: List of `ChangesetEntry`
878
:param changeset: The changeset to apply
879
:type changeset: `Changeset`
880
:param dir: The directory to apply changes to
882
:param reverse: If true, apply changes in reverse
885
for entry in target_entries:
886
new_path = entry.get_new_path(inventory, changeset, reverse)
889
new_path = os.path.join(dir, new_path)
890
old_path = temp_name.get(entry.id)
891
if os.path.exists(new_path):
892
if conflict_handler.target_exists(entry, new_path, old_path) == \
895
if entry.is_creation(reverse):
896
entry.apply(new_path, conflict_handler, reverse)
901
os.rename(old_path, new_path)
903
raise Exception ("%s is missing" % new_path)
905
class TargetExists(Exception):
906
def __init__(self, entry, target):
907
msg = "The path %s already exists" % target
908
Exception.__init__(self, msg)
912
class RenameConflict(Exception):
913
def __init__(self, id, this_name, base_name, other_name):
914
msg = """Trees all have different names for a file
918
id: %s""" % (this_name, base_name, other_name, id)
919
Exception.__init__(self, msg)
920
self.this_name = this_name
921
self.base_name = base_name
922
self_other_name = other_name
924
class MoveConflict(Exception):
925
def __init__(self, id, this_parent, base_parent, other_parent):
926
msg = """The file is in different directories in every tree
930
id: %s""" % (this_parent, base_parent, other_parent, id)
931
Exception.__init__(self, msg)
932
self.this_parent = this_parent
933
self.base_parent = base_parent
934
self_other_parent = other_parent
936
class MergeConflict(Exception):
937
def __init__(self, this_path):
938
Exception.__init__(self, "Conflict applying changes to %s" % this_path)
939
self.this_path = this_path
941
class MergePermissionConflict(Exception):
942
def __init__(self, this_path, base_path, other_path):
943
this_perms = os.stat(this_path).st_mode & 0755
944
base_perms = os.stat(base_path).st_mode & 0755
945
other_perms = os.stat(other_path).st_mode & 0755
946
msg = """Conflicting permission for %s
950
""" % (this_path, this_perms, base_perms, other_perms)
951
self.this_path = this_path
952
self.base_path = base_path
953
self.other_path = other_path
954
Exception.__init__(self, msg)
956
class WrongOldContents(Exception):
957
def __init__(self, filename):
958
msg = "Contents mismatch deleting %s" % filename
959
self.filename = filename
960
Exception.__init__(self, msg)
962
class WrongOldPermissions(Exception):
963
def __init__(self, filename, old_perms, new_perms):
964
msg = "Permission missmatch on %s:\n" \
965
"Expected 0%o, got 0%o." % (filename, old_perms, new_perms)
966
self.filename = filename
967
Exception.__init__(self, msg)
969
class RemoveContentsConflict(Exception):
970
def __init__(self, filename):
971
msg = "Conflict deleting %s, which has different contents in BASE"\
972
" and THIS" % filename
973
self.filename = filename
974
Exception.__init__(self, msg)
976
class DeletingNonEmptyDirectory(Exception):
977
def __init__(self, filename):
978
msg = "Trying to remove dir %s while it still had files" % filename
979
self.filename = filename
980
Exception.__init__(self, msg)
983
class PatchTargetMissing(Exception):
984
def __init__(self, filename):
985
msg = "Attempt to patch %s, which does not exist" % filename
986
Exception.__init__(self, msg)
987
self.filename = filename
989
class MissingPermsFile(Exception):
990
def __init__(self, filename):
991
msg = "Attempt to change permissions on %s, which does not exist" %\
993
Exception.__init__(self, msg)
994
self.filename = filename
996
class MissingForRm(Exception):
997
def __init__(self, filename):
998
msg = "Attempt to remove missing path %s" % filename
999
Exception.__init__(self, msg)
1000
self.filename = filename
1003
class MissingForRename(Exception):
1004
def __init__(self, filename):
1005
msg = "Attempt to move missing path %s" % (filename)
1006
Exception.__init__(self, msg)
1007
self.filename = filename
1009
class ExceptionConflictHandler(object):
1010
def __init__(self, dir):
1013
def missing_parent(self, pathname):
1014
parent = os.path.dirname(pathname)
1015
raise Exception("Parent directory missing for %s" % pathname)
1017
def dir_exists(self, pathname):
1018
raise Exception("Directory already exists for %s" % pathname)
1020
def failed_hunks(self, pathname):
1021
raise Exception("Failed to apply some hunks for %s" % pathname)
1023
def target_exists(self, entry, target, old_path):
1024
raise TargetExists(entry, target)
1026
def rename_conflict(self, id, this_name, base_name, other_name):
1027
raise RenameConflict(id, this_name, base_name, other_name)
1029
def move_conflict(self, id, inventory):
1030
this_dir = inventory.this.get_dir(id)
1031
base_dir = inventory.base.get_dir(id)
1032
other_dir = inventory.other.get_dir(id)
1033
raise MoveConflict(id, this_dir, base_dir, other_dir)
1035
def merge_conflict(self, new_file, this_path, base_path, other_path):
1037
raise MergeConflict(this_path)
1039
def permission_conflict(self, this_path, base_path, other_path):
1040
raise MergePermissionConflict(this_path, base_path, other_path)
1042
def wrong_old_contents(self, filename, expected_contents):
1043
raise WrongOldContents(filename)
1045
def rem_contents_conflict(self, filename, this_contents, base_contents):
1046
raise RemoveContentsConflict(filename)
1048
def wrong_old_perms(self, filename, old_perms, new_perms):
1049
raise WrongOldPermissions(filename, old_perms, new_perms)
1051
def rmdir_non_empty(self, filename):
1052
raise DeletingNonEmptyDirectory(filename)
1054
def link_name_exists(self, filename):
1055
raise TargetExists(filename)
1057
def patch_target_missing(self, filename, contents):
1058
raise PatchTargetMissing(filename)
1060
def missing_for_chmod(self, filename):
1061
raise MissingPermsFile(filename)
1063
def missing_for_rm(self, filename, change):
1064
raise MissingForRm(filename)
1066
def missing_for_rename(self, filename):
1067
raise MissingForRename(filename)
1072
def apply_changeset(changeset, inventory, dir, conflict_handler=None,
1074
"""Apply a changeset to a directory.
1076
:param changeset: The changes to perform
1077
:type changeset: `Changeset`
1078
:param inventory: The mapping of id to filename for the directory
1079
:type inventory: Dictionary
1080
:param dir: The path of the directory to apply the changes to
1082
:param reverse: If true, apply the changes in reverse
1084
:return: The mapping of the changed entries
1087
if conflict_handler is None:
1088
conflict_handler = ExceptionConflictHandler(dir)
1089
temp_dir = dir+"/temp"
1092
#apply changes that don't affect filenames
1093
for entry in changeset.entries.itervalues():
1094
if not entry.is_creation_or_deletion():
1095
path = os.path.join(dir, inventory[entry.id])
1096
entry.apply(path, conflict_handler, reverse)
1098
# Apply renames in stages, to minimize conflicts:
1099
# Only files whose name or parent change are interesting, because their
1100
# target name may exist in the source tree. If a directory's name changes,
1101
# that doesn't make its children interesting.
1102
(source_entries, target_entries) = get_rename_entries(changeset, inventory,
1105
temp_name = rename_to_temp_delete(source_entries, inventory, dir,
1106
conflict_handler, reverse)
1108
rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
1109
conflict_handler, reverse)
1111
r_inventory = invert_dict(inventory)
1112
new_entries, removed_entries = get_inventory_change(inventory,
1113
r_inventory, changeset, reverse)
1115
for path, file_id in new_entries.iteritems():
1116
new_inventory[file_id] = path
1117
for file_id in removed_entries:
1118
new_inventory[file_id] = None
1119
return new_inventory
1122
def apply_changeset_tree(cset, tree, reverse=False):
1124
for entry in tree.source_inventory().itervalues():
1125
inventory[entry.id] = entry.path
1126
new_inventory = apply_changeset(cset, r_inventory, tree.root,
1128
new_entries, remove_entries = \
1129
get_inventory_change(inventory, new_inventory, cset, reverse)
1130
tree.update_source_inventory(new_entries, remove_entries)
1133
def get_inventory_change(inventory, new_inventory, cset, reverse=False):
1136
r_inventory = invert_dict(inventory)
1137
r_new_inventory = invert_dict(new_inventory)
1138
for entry in cset.entries.itervalues():
1139
if entry.needs_rename():
1140
old_path = r_inventory.get(entry.id)
1141
if old_path is not None:
1142
remove_entries.append(old_path)
1144
new_path = entry.get_new_path(inventory, cset)
1145
if new_path is not None:
1146
new_entries[new_path] = entry.id
1147
return new_entries, remove_entries
1150
def print_changeset(cset):
1151
"""Print all non-boring changeset entries
1153
:param cset: The changeset to print
1154
:type cset: `Changeset`
1156
for entry in cset.entries.itervalues():
1157
if entry.is_boring():
1160
print entry.summarize_name(cset)
1162
class CompositionFailure(Exception):
1163
def __init__(self, old_entry, new_entry, problem):
1164
msg = "Unable to conpose entries.\n %s" % problem
1165
Exception.__init__(self, msg)
1167
class IDMismatch(CompositionFailure):
1168
def __init__(self, old_entry, new_entry):
1169
problem = "Attempt to compose entries with different ids: %s and %s" %\
1170
(old_entry.id, new_entry.id)
1171
CompositionFailure.__init__(self, old_entry, new_entry, problem)
1173
def compose_changesets(old_cset, new_cset):
1174
"""Combine two changesets into one. This works well for exact patching.
1175
Otherwise, not so well.
1177
:param old_cset: The first changeset that would be applied
1178
:type old_cset: `Changeset`
1179
:param new_cset: The second changeset that would be applied
1180
:type new_cset: `Changeset`
1181
:return: A changeset that combines the changes in both changesets
1184
composed = Changeset()
1185
for old_entry in old_cset.entries.itervalues():
1186
new_entry = new_cset.entries.get(old_entry.id)
1187
if new_entry is None:
1188
composed.add_entry(old_entry)
1190
composed_entry = compose_entries(old_entry, new_entry)
1191
if composed_entry.parent is not None or\
1192
composed_entry.new_parent is not None:
1193
composed.add_entry(composed_entry)
1194
for new_entry in new_cset.entries.itervalues():
1195
if not old_cset.entries.has_key(new_entry.id):
1196
composed.add_entry(new_entry)
1199
def compose_entries(old_entry, new_entry):
1200
"""Combine two entries into one.
1202
:param old_entry: The first entry that would be applied
1203
:type old_entry: ChangesetEntry
1204
:param old_entry: The second entry that would be applied
1205
:type old_entry: ChangesetEntry
1206
:return: A changeset entry combining both entries
1207
:rtype: `ChangesetEntry`
1209
if old_entry.id != new_entry.id:
1210
raise IDMismatch(old_entry, new_entry)
1211
output = ChangesetEntry(old_entry.id, old_entry.parent, old_entry.path)
1213
if (old_entry.parent != old_entry.new_parent or
1214
new_entry.parent != new_entry.new_parent):
1215
output.new_parent = new_entry.new_parent
1217
if (old_entry.path != old_entry.new_path or
1218
new_entry.path != new_entry.new_path):
1219
output.new_path = new_entry.new_path
1221
output.contents_change = compose_contents(old_entry, new_entry)
1222
output.metadata_change = compose_metadata(old_entry, new_entry)
1225
def compose_contents(old_entry, new_entry):
1226
"""Combine the contents of two changeset entries. Entries are combined
1227
intelligently where possible, but the fallback behavior returns an
1230
:param old_entry: The first entry that would be applied
1231
:type old_entry: `ChangesetEntry`
1232
:param new_entry: The second entry that would be applied
1233
:type new_entry: `ChangesetEntry`
1234
:return: A combined contents change
1235
:rtype: anything supporting the apply(reverse=False) method
1237
old_contents = old_entry.contents_change
1238
new_contents = new_entry.contents_change
1239
if old_entry.contents_change is None:
1240
return new_entry.contents_change
1241
elif new_entry.contents_change is None:
1242
return old_entry.contents_change
1243
elif isinstance(old_contents, ReplaceContents) and \
1244
isinstance(new_contents, ReplaceContents):
1245
if old_contents.old_contents == new_contents.new_contents:
1248
return ReplaceContents(old_contents.old_contents,
1249
new_contents.new_contents)
1250
elif isinstance(old_contents, ApplySequence):
1251
output = ApplySequence(old_contents.changes)
1252
if isinstance(new_contents, ApplySequence):
1253
output.changes.extend(new_contents.changes)
1255
output.changes.append(new_contents)
1257
elif isinstance(new_contents, ApplySequence):
1258
output = ApplySequence((old_contents.changes,))
1259
output.extend(new_contents.changes)
1262
return ApplySequence((old_contents, new_contents))
1264
def compose_metadata(old_entry, new_entry):
1265
old_meta = old_entry.metadata_change
1266
new_meta = new_entry.metadata_change
1267
if old_meta is None:
1269
elif new_meta is None:
1271
elif isinstance(old_meta, ChangeUnixPermissions) and \
1272
isinstance(new_meta, ChangeUnixPermissions):
1273
return ChangeUnixPermissions(old_meta.old_mode, new_meta.new_mode)
1275
return ApplySequence(old_meta, new_meta)
1278
def changeset_is_null(changeset):
1279
for entry in changeset.entries.itervalues():
1280
if not entry.is_boring():
1284
class UnsuppportedFiletype(Exception):
1285
def __init__(self, full_path, stat_result):
1286
msg = "The file \"%s\" is not a supported filetype." % full_path
1287
Exception.__init__(self, msg)
1288
self.full_path = full_path
1289
self.stat_result = stat_result
1291
def generate_changeset(tree_a, tree_b, inventory_a=None, inventory_b=None):
1292
return ChangesetGenerator(tree_a, tree_b, inventory_a, inventory_b)()
1294
class ChangesetGenerator(object):
1295
def __init__(self, tree_a, tree_b, inventory_a=None, inventory_b=None):
1296
object.__init__(self)
1297
self.tree_a = tree_a
1298
self.tree_b = tree_b
1299
if inventory_a is not None:
1300
self.inventory_a = inventory_a
1302
self.inventory_a = tree_a.inventory()
1303
if inventory_b is not None:
1304
self.inventory_b = inventory_b
1306
self.inventory_b = tree_b.inventory()
1307
self.r_inventory_a = self.reverse_inventory(self.inventory_a)
1308
self.r_inventory_b = self.reverse_inventory(self.inventory_b)
1310
def reverse_inventory(self, inventory):
1312
for entry in inventory.itervalues():
1313
if entry.id is None:
1315
r_inventory[entry.id] = entry
1320
for entry in self.inventory_a.itervalues():
1321
if entry.id is None:
1323
cs_entry = self.make_entry(entry.id)
1324
if cs_entry is not None and not cs_entry.is_boring():
1325
cset.add_entry(cs_entry)
1327
for entry in self.inventory_b.itervalues():
1328
if entry.id is None:
1330
if not self.r_inventory_a.has_key(entry.id):
1331
cs_entry = self.make_entry(entry.id)
1332
if cs_entry is not None and not cs_entry.is_boring():
1333
cset.add_entry(cs_entry)
1334
for entry in list(cset.entries.itervalues()):
1335
if entry.parent != entry.new_parent:
1336
if not cset.entries.has_key(entry.parent) and\
1337
entry.parent != NULL_ID and entry.parent is not None:
1338
parent_entry = self.make_boring_entry(entry.parent)
1339
cset.add_entry(parent_entry)
1340
if not cset.entries.has_key(entry.new_parent) and\
1341
entry.new_parent != NULL_ID and \
1342
entry.new_parent is not None:
1343
parent_entry = self.make_boring_entry(entry.new_parent)
1344
cset.add_entry(parent_entry)
1347
def get_entry_parent(self, entry, inventory):
1350
if entry.path == "./.":
1352
dirname = os.path.dirname(entry.path)
1355
parent = inventory[dirname]
1358
def get_paths(self, entry, tree):
1361
full_path = tree.readonly_path(entry.id)
1362
if entry.path == ".":
1363
return ("", full_path)
1364
return (entry.path, full_path)
1366
def make_basic_entry(self, id, only_interesting):
1367
entry_a = self.r_inventory_a.get(id)
1368
entry_b = self.r_inventory_b.get(id)
1369
if only_interesting and not self.is_interesting(entry_a, entry_b):
1370
return (None, None, None)
1371
parent = self.get_entry_parent(entry_a, self.inventory_a)
1372
(path, full_path_a) = self.get_paths(entry_a, self.tree_a)
1373
cs_entry = ChangesetEntry(id, parent, path)
1374
new_parent = self.get_entry_parent(entry_b, self.inventory_b)
1377
(new_path, full_path_b) = self.get_paths(entry_b, self.tree_b)
1379
cs_entry.new_path = new_path
1380
cs_entry.new_parent = new_parent
1381
return (cs_entry, full_path_a, full_path_b)
1383
def is_interesting(self, entry_a, entry_b):
1384
if entry_a is not None:
1385
if entry_a.interesting:
1387
if entry_b is not None:
1388
if entry_b.interesting:
1392
def make_boring_entry(self, id):
1393
(cs_entry, full_path_a, full_path_b) = \
1394
self.make_basic_entry(id, only_interesting=False)
1395
if cs_entry.is_creation_or_deletion():
1396
return self.make_entry(id, only_interesting=False)
1401
def make_entry(self, id, only_interesting=True):
1402
(cs_entry, full_path_a, full_path_b) = \
1403
self.make_basic_entry(id, only_interesting)
1405
if cs_entry is None:
1408
stat_a = self.lstat(full_path_a)
1409
stat_b = self.lstat(full_path_b)
1411
cs_entry.new_parent = None
1412
cs_entry.new_path = None
1414
cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
1415
cs_entry.contents_change = self.make_contents_change(full_path_a,
1421
def make_mode_change(self, stat_a, stat_b):
1423
if stat_a is not None and not stat.S_ISLNK(stat_a.st_mode):
1424
mode_a = stat_a.st_mode & 0777
1426
if stat_b is not None and not stat.S_ISLNK(stat_b.st_mode):
1427
mode_b = stat_b.st_mode & 0777
1428
if mode_a == mode_b:
1430
return ChangeUnixPermissions(mode_a, mode_b)
1432
def make_contents_change(self, full_path_a, stat_a, full_path_b, stat_b):
1433
if stat_a is None and stat_b is None:
1435
if None not in (stat_a, stat_b) and stat.S_ISDIR(stat_a.st_mode) and\
1436
stat.S_ISDIR(stat_b.st_mode):
1438
if None not in (stat_a, stat_b) and stat.S_ISREG(stat_a.st_mode) and\
1439
stat.S_ISREG(stat_b.st_mode):
1440
if stat_a.st_ino == stat_b.st_ino and \
1441
stat_a.st_dev == stat_b.st_dev:
1443
if file(full_path_a, "rb").read() == \
1444
file(full_path_b, "rb").read():
1447
patch_contents = patch.diff(full_path_a,
1448
file(full_path_b, "rb").read())
1449
if patch_contents is None:
1451
return PatchApply(patch_contents)
1453
a_contents = self.get_contents(stat_a, full_path_a)
1454
b_contents = self.get_contents(stat_b, full_path_b)
1455
if a_contents == b_contents:
1457
return ReplaceContents(a_contents, b_contents)
1459
def get_contents(self, stat_result, full_path):
1460
if stat_result is None:
1462
elif stat.S_ISREG(stat_result.st_mode):
1463
return FileCreate(file(full_path, "rb").read())
1464
elif stat.S_ISDIR(stat_result.st_mode):
1466
elif stat.S_ISLNK(stat_result.st_mode):
1467
return SymlinkCreate(os.readlink(full_path))
1469
raise UnsupportedFiletype(full_path, stat_result)
1471
def lstat(self, full_path):
1473
if full_path is not None:
1475
stat_result = os.lstat(full_path)
1477
if e.errno != errno.ENOENT:
1482
def full_path(entry, tree):
1483
return os.path.join(tree.root, entry.path)
1485
def new_delete_entry(entry, tree, inventory, delete):
1486
if entry.path == "":
1489
parent = inventory[dirname(entry.path)].id
1490
cs_entry = ChangesetEntry(parent, entry.path)
1492
cs_entry.new_path = None
1493
cs_entry.new_parent = None
1495
cs_entry.path = None
1496
cs_entry.parent = None
1497
full_path = full_path(entry, tree)
1498
status = os.lstat(full_path)
1499
if stat.S_ISDIR(file_stat.st_mode):
1506
class Inventory(object):
1507
def __init__(self, inventory):
1508
self.inventory = inventory
1509
self.rinventory = None
1511
def get_rinventory(self):
1512
if self.rinventory is None:
1513
self.rinventory = invert_dict(self.inventory)
1514
return self.rinventory
1516
def get_path(self, id):
1517
return self.inventory.get(id)
1519
def get_name(self, id):
1520
return os.path.basename(self.get_path(id))
1522
def get_dir(self, id):
1523
path = self.get_path(id)
1526
return os.path.dirname(path)
1528
def get_parent(self, id):
1529
directory = self.get_dir(id)
1530
if directory == '.':
1532
if directory is None:
1534
return self.get_rinventory().get(directory)
1
# Copyright (C) 2005, 2006 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
from bzrlib.symbol_versioning import deprecated_function, deprecated_in
18
from bzrlib.lazy_import import lazy_import
19
lazy_import(globals(), """
24
from bzrlib.bundle import serializer as _serializer
25
from bzrlib.transport import (
26
do_catching_redirections,
30
from bzrlib.trace import note
33
@deprecated_function(deprecated_in((1, 12, 0)))
34
def read_bundle_from_url(url):
35
return read_mergeable_from_url(url, _do_directive=False)
38
def read_mergeable_from_url(url, _do_directive=True, possible_transports=None):
39
"""Read mergable object from a given URL.
41
:return: An object supporting get_target_revision. Raises NotABundle if
42
the target is not a mergeable type.
44
child_transport = get_transport(url,
45
possible_transports=possible_transports)
46
transport = child_transport.clone('..')
47
filename = transport.relpath(child_transport.base)
48
mergeable, transport = read_mergeable_from_transport(transport, filename,
53
def read_mergeable_from_transport(transport, filename, _do_directive=True):
54
# All of this must be in the try/except
55
# Some transports cannot detect that we are trying to read a
56
# directory until we actually issue read() on the handle.
58
def get_bundle(transport):
59
return transport.get(filename), transport
61
def redirected_transport(transport, exception, redirection_notice):
62
note(redirection_notice)
63
url, filename = urlutils.split(exception.target,
64
exclude_trailing_slash=False)
66
raise errors.NotABundle('A directory cannot be a bundle')
67
return get_transport(url)
70
f, transport = do_catching_redirections(get_bundle, transport,
72
except errors.TooManyRedirections:
73
raise errors.NotABundle(transport.clone(filename).base)
76
from bzrlib.merge_directive import MergeDirective
77
directive = MergeDirective.from_lines(f.readlines())
78
return directive, transport
80
return _serializer.read_bundle(f), transport
81
except (errors.ConnectionReset, errors.ConnectionError), e:
83
except (errors.TransportError, errors.PathError), e:
84
raise errors.NotABundle(str(e))
87
# Abstraction leakage, SFTPTransport.get('directory')
88
# doesn't always fail at get() time. Sometimes it fails
89
# during read. And that raises a generic IOError with
90
# just the string 'Failure'
91
# StubSFTPServer does fail during get() (because of prefetch)
92
# so it has an opportunity to translate the error.
93
raise errors.NotABundle(str(e))
94
except errors.NotAMergeDirective:
96
return _serializer.read_bundle(f), transport
added
removed
bzrlib/bundle/__init__.py
