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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
from StringIO import StringIO
19
from bzrlib.lazy_import import lazy_import
20
lazy_import(globals(), """
25
from bzrlib.bundle import serializer as _serializer
26
from bzrlib.transport import (
27
do_catching_redirections,
31
from bzrlib.trace import note
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):
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
url = urlutils.normalize_url(url)
45
url, filename = urlutils.split(url, exclude_trailing_slash=False)
47
# A path to a directory was passed in
48
# definitely not a bundle
49
raise errors.NotABundle('A directory cannot be a bundle')
51
transport = get_transport(url)
52
mergeable, transport = read_mergeable_from_transport(transport, filename,
57
def read_mergeable_from_transport(transport, filename, _do_directive=True):
58
# All of this must be in the try/except
59
# Some transports cannot detect that we are trying to read a
60
# directory until we actually issue read() on the handle.
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
20
from bzrlib.trace import mutter
21
from bzrlib.osutils import rename
23
# XXX: mbp: I'm not totally convinced that we should handle conflicts
24
# as part of changeset application, rather than only in the merge
27
"""Represent and apply a changeset
29
Conflicts in applying a changeset are represented as exceptions.
32
__docformat__ = "restructuredtext"
36
class OldFailedTreeOp(Exception):
38
Exception.__init__(self, "bzr-tree-change contains files from a"
39
" previous failed merge operation.")
40
def invert_dict(dict):
42
for (key,value) in dict.iteritems():
47
class ChangeUnixPermissions(object):
48
"""This is two-way change, suitable for file modification, creation,
50
def __init__(self, old_mode, new_mode):
51
self.old_mode = old_mode
52
self.new_mode = new_mode
54
def apply(self, filename, conflict_handler, reverse=False):
56
from_mode = self.old_mode
57
to_mode = self.new_mode
59
from_mode = self.new_mode
60
to_mode = self.old_mode
62
current_mode = os.stat(filename).st_mode &0777
64
if e.errno == errno.ENOENT:
65
if conflict_handler.missing_for_chmod(filename) == "skip":
68
current_mode = from_mode
70
if from_mode is not None and current_mode != from_mode:
71
if conflict_handler.wrong_old_perms(filename, from_mode,
72
current_mode) != "continue":
75
if to_mode is not None:
77
os.chmod(filename, to_mode)
79
if e.errno == errno.ENOENT:
80
conflict_handler.missing_for_chmod(filename)
82
def __eq__(self, other):
83
if not isinstance(other, ChangeUnixPermissions):
85
elif self.old_mode != other.old_mode:
87
elif self.new_mode != other.new_mode:
92
def __ne__(self, other):
93
return not (self == other)
96
def dir_create(filename, conflict_handler, reverse):
97
"""Creates the directory, or deletes it if reverse is true. Intended to be
98
used with ReplaceContents.
100
:param filename: The name of the directory to create
102
:param reverse: If true, delete the directory, instead
109
if e.errno != errno.EEXIST:
111
if conflict_handler.dir_exists(filename) == "continue":
114
if e.errno == errno.ENOENT:
115
if conflict_handler.missing_parent(filename)=="continue":
116
file(filename, "wb").write(self.contents)
121
if e.errno != errno.ENOTEMPTY:
123
if conflict_handler.rmdir_non_empty(filename) == "skip":
128
class SymlinkCreate(object):
129
"""Creates or deletes a symlink (for use with ReplaceContents)"""
130
def __init__(self, contents):
133
:param contents: The filename of the target the symlink should point to
136
self.target = contents
138
def __call__(self, filename, conflict_handler, reverse):
139
"""Creates or destroys the symlink.
141
:param filename: The name of the symlink to create
145
assert(os.readlink(filename) == self.target)
149
os.symlink(self.target, filename)
151
if e.errno != errno.EEXIST:
153
if conflict_handler.link_name_exists(filename) == "continue":
154
os.symlink(self.target, filename)
156
def __eq__(self, other):
157
if not isinstance(other, SymlinkCreate):
159
elif self.target != other.target:
164
def __ne__(self, other):
165
return not (self == other)
167
class FileCreate(object):
168
"""Create or delete a file (for use with ReplaceContents)"""
169
def __init__(self, contents):
172
:param contents: The contents of the file to write
175
self.contents = contents
178
return "FileCreate(%i b)" % len(self.contents)
180
def __eq__(self, other):
181
if not isinstance(other, FileCreate):
183
elif self.contents != other.contents:
188
def __ne__(self, other):
189
return not (self == other)
191
def __call__(self, filename, conflict_handler, reverse):
192
"""Create or delete a file
194
:param filename: The name of the file to create
196
:param reverse: Delete the file instead of creating it
201
file(filename, "wb").write(self.contents)
203
if e.errno == errno.ENOENT:
204
if conflict_handler.missing_parent(filename)=="continue":
205
file(filename, "wb").write(self.contents)
211
if (file(filename, "rb").read() != self.contents):
212
direction = conflict_handler.wrong_old_contents(filename,
214
if direction != "continue":
218
if e.errno != errno.ENOENT:
220
if conflict_handler.missing_for_rm(filename, undo) == "skip":
225
def reversed(sequence):
226
max = len(sequence) - 1
227
for i in range(len(sequence)):
228
yield sequence[max - i]
230
class ReplaceContents(object):
231
"""A contents-replacement framework. It allows a file/directory/symlink to
232
be created, deleted, or replaced with another file/directory/symlink.
233
Arguments must be callable with (filename, reverse).
235
def __init__(self, old_contents, new_contents):
238
:param old_contents: The change to reverse apply (e.g. a deletion), \
240
:type old_contents: `dir_create`, `SymlinkCreate`, `FileCreate`, \
242
:param new_contents: The second change to apply (e.g. a creation), \
244
:type new_contents: `dir_create`, `SymlinkCreate`, `FileCreate`, \
247
self.old_contents=old_contents
248
self.new_contents=new_contents
251
return "ReplaceContents(%r -> %r)" % (self.old_contents,
254
def __eq__(self, other):
255
if not isinstance(other, ReplaceContents):
257
elif self.old_contents != other.old_contents:
259
elif self.new_contents != other.new_contents:
263
def __ne__(self, other):
264
return not (self == other)
266
def apply(self, filename, conflict_handler, reverse=False):
267
"""Applies the FileReplacement to the specified filename
269
:param filename: The name of the file to apply changes to
271
:param reverse: If true, apply the change in reverse
275
undo = self.old_contents
276
perform = self.new_contents
278
undo = self.new_contents
279
perform = self.old_contents
283
mode = os.lstat(filename).st_mode
284
if stat.S_ISLNK(mode):
287
if e.errno != errno.ENOENT:
289
if conflict_handler.missing_for_rm(filename, undo) == "skip":
291
undo(filename, conflict_handler, reverse=True)
292
if perform is not None:
293
perform(filename, conflict_handler, reverse=False)
295
os.chmod(filename, mode)
297
class ApplySequence(object):
298
def __init__(self, changes=None):
300
if changes is not None:
301
self.changes.extend(changes)
303
def __eq__(self, other):
304
if not isinstance(other, ApplySequence):
306
elif len(other.changes) != len(self.changes):
309
for i in range(len(self.changes)):
310
if self.changes[i] != other.changes[i]:
314
def __ne__(self, other):
315
return not (self == other)
318
def apply(self, filename, conflict_handler, reverse=False):
322
iter = reversed(self.changes)
324
change.apply(filename, conflict_handler, reverse)
327
class Diff3Merge(object):
328
def __init__(self, file_id, base, other):
329
self.file_id = file_id
333
def __eq__(self, other):
334
if not isinstance(other, Diff3Merge):
336
return (self.base == other.base and
337
self.other == other.other and self.file_id == other.file_id)
339
def __ne__(self, other):
340
return not (self == other)
342
def apply(self, filename, conflict_handler, reverse=False):
343
new_file = filename+".new"
344
base_file = self.base.readonly_path(self.file_id)
345
other_file = self.other.readonly_path(self.file_id)
352
status = patch.diff3(new_file, filename, base, other)
354
os.chmod(new_file, os.stat(filename).st_mode)
355
rename(new_file, filename)
359
def get_lines(filename):
360
my_file = file(base, "rb")
361
lines = my_file.readlines()
363
base_lines = get_lines(base)
364
other_lines = get_lines(other)
365
conflict_handler.merge_conflict(new_file, filename, base_lines,
370
"""Convenience function to create a directory.
372
:return: A ReplaceContents that will create a directory
373
:rtype: `ReplaceContents`
375
return ReplaceContents(None, dir_create)
378
"""Convenience function to delete a directory.
380
:return: A ReplaceContents that will delete a directory
381
:rtype: `ReplaceContents`
383
return ReplaceContents(dir_create, None)
385
def CreateFile(contents):
386
"""Convenience fucntion to create a file.
388
:param contents: The contents of the file to create
390
:return: A ReplaceContents that will create a file
391
:rtype: `ReplaceContents`
393
return ReplaceContents(None, FileCreate(contents))
395
def DeleteFile(contents):
396
"""Convenience fucntion to delete a file.
398
:param contents: The contents of the file to delete
400
:return: A ReplaceContents that will delete a file
401
:rtype: `ReplaceContents`
403
return ReplaceContents(FileCreate(contents), None)
405
def ReplaceFileContents(old_contents, new_contents):
406
"""Convenience fucntion to replace the contents of a file.
408
:param old_contents: The contents of the file to replace
409
:type old_contents: str
410
:param new_contents: The contents to replace the file with
411
:type new_contents: str
412
:return: A ReplaceContents that will replace the contents of a file a file
413
:rtype: `ReplaceContents`
415
return ReplaceContents(FileCreate(old_contents), FileCreate(new_contents))
417
def CreateSymlink(target):
418
"""Convenience fucntion to create a symlink.
420
:param target: The path the link should point to
422
:return: A ReplaceContents that will delete a file
423
:rtype: `ReplaceContents`
425
return ReplaceContents(None, SymlinkCreate(target))
427
def DeleteSymlink(target):
428
"""Convenience fucntion to delete a symlink.
430
:param target: The path the link should point to
432
:return: A ReplaceContents that will delete a file
433
:rtype: `ReplaceContents`
435
return ReplaceContents(SymlinkCreate(target), None)
437
def ChangeTarget(old_target, new_target):
438
"""Convenience fucntion to change the target of a symlink.
440
:param old_target: The current link target
441
:type old_target: str
442
:param new_target: The new link target to use
443
:type new_target: str
444
:return: A ReplaceContents that will delete a file
445
:rtype: `ReplaceContents`
447
return ReplaceContents(SymlinkCreate(old_target), SymlinkCreate(new_target))
450
class InvalidEntry(Exception):
451
"""Raise when a ChangesetEntry is invalid in some way"""
452
def __init__(self, entry, problem):
455
:param entry: The invalid ChangesetEntry
456
:type entry: `ChangesetEntry`
457
:param problem: The problem with the entry
460
msg = "Changeset entry for %s (%s) is invalid.\n%s" % (entry.id,
463
Exception.__init__(self, msg)
467
class SourceRootHasName(InvalidEntry):
468
"""This changeset entry has a name other than "", but its parent is !NULL"""
469
def __init__(self, entry, name):
472
:param entry: The invalid ChangesetEntry
473
:type entry: `ChangesetEntry`
474
:param name: The name of the entry
477
msg = 'Child of !NULL is named "%s", not "./.".' % name
478
InvalidEntry.__init__(self, entry, msg)
480
class NullIDAssigned(InvalidEntry):
481
"""The id !NULL was assigned to a real entry"""
482
def __init__(self, entry):
485
:param entry: The invalid ChangesetEntry
486
:type entry: `ChangesetEntry`
488
msg = '"!NULL" id assigned to a file "%s".' % entry.path
489
InvalidEntry.__init__(self, entry, msg)
491
class ParentIDIsSelf(InvalidEntry):
492
"""An entry is marked as its own parent"""
493
def __init__(self, entry):
496
:param entry: The invalid ChangesetEntry
497
:type entry: `ChangesetEntry`
499
msg = 'file %s has "%s" id for both self id and parent id.' % \
500
(entry.path, entry.id)
501
InvalidEntry.__init__(self, entry, msg)
503
class ChangesetEntry(object):
504
"""An entry the changeset"""
505
def __init__(self, id, parent, path):
506
"""Constructor. Sets parent and name assuming it was not
507
renamed/created/deleted.
508
:param id: The id associated with the entry
509
:param parent: The id of the parent of this entry (or !NULL if no
511
:param path: The file path relative to the tree root of this entry
517
self.new_parent = parent
518
self.contents_change = None
519
self.metadata_change = None
520
if parent == NULL_ID and path !='./.':
521
raise SourceRootHasName(self, path)
522
if self.id == NULL_ID:
523
raise NullIDAssigned(self)
524
if self.id == self.parent:
525
raise ParentIDIsSelf(self)
528
return "ChangesetEntry(%s)" % self.id
531
if self.path is None:
533
return os.path.dirname(self.path)
535
def __set_dir(self, dir):
536
self.path = os.path.join(dir, os.path.basename(self.path))
538
dir = property(__get_dir, __set_dir)
540
def __get_name(self):
541
if self.path is None:
543
return os.path.basename(self.path)
545
def __set_name(self, name):
546
self.path = os.path.join(os.path.dirname(self.path), name)
548
name = property(__get_name, __set_name)
550
def __get_new_dir(self):
551
if self.new_path is None:
553
return os.path.dirname(self.new_path)
555
def __set_new_dir(self, dir):
556
self.new_path = os.path.join(dir, os.path.basename(self.new_path))
558
new_dir = property(__get_new_dir, __set_new_dir)
560
def __get_new_name(self):
561
if self.new_path is None:
563
return os.path.basename(self.new_path)
565
def __set_new_name(self, name):
566
self.new_path = os.path.join(os.path.dirname(self.new_path), name)
568
new_name = property(__get_new_name, __set_new_name)
570
def needs_rename(self):
571
"""Determines whether the entry requires renaming.
576
return (self.parent != self.new_parent or self.name != self.new_name)
578
def is_deletion(self, reverse):
579
"""Return true if applying the entry would delete a file/directory.
581
:param reverse: if true, the changeset is being applied in reverse
584
return ((self.new_parent is None and not reverse) or
585
(self.parent is None and reverse))
587
def is_creation(self, reverse):
588
"""Return true if applying the entry would create a file/directory.
590
:param reverse: if true, the changeset is being applied in reverse
593
return ((self.parent is None and not reverse) or
594
(self.new_parent is None and reverse))
596
def is_creation_or_deletion(self):
597
"""Return true if applying the entry would create or delete a
602
return self.parent is None or self.new_parent is None
604
def get_cset_path(self, mod=False):
605
"""Determine the path of the entry according to the changeset.
607
:param changeset: The changeset to derive the path from
608
:type changeset: `Changeset`
609
:param mod: If true, generate the MOD path. Otherwise, generate the \
611
:return: the path of the entry, or None if it did not exist in the \
613
:rtype: str or NoneType
616
if self.new_parent == NULL_ID:
618
elif self.new_parent is None:
622
if self.parent == NULL_ID:
624
elif self.parent is None:
628
def summarize_name(self, reverse=False):
629
"""Produce a one-line summary of the filename. Indicates renames as
630
old => new, indicates creation as None => new, indicates deletion as
633
:param changeset: The changeset to get paths from
634
:type changeset: `Changeset`
635
:param reverse: If true, reverse the names in the output
639
orig_path = self.get_cset_path(False)
640
mod_path = self.get_cset_path(True)
641
if orig_path is not None:
642
orig_path = orig_path[2:]
643
if mod_path is not None:
644
mod_path = mod_path[2:]
645
if orig_path == mod_path:
649
return "%s => %s" % (orig_path, mod_path)
651
return "%s => %s" % (mod_path, orig_path)
654
def get_new_path(self, id_map, changeset, reverse=False):
655
"""Determine the full pathname to rename to
657
:param id_map: The map of ids to filenames for the tree
658
:type id_map: Dictionary
659
:param changeset: The changeset to get data from
660
:type changeset: `Changeset`
661
:param reverse: If true, we're applying the changeset in reverse
665
mutter("Finding new path for %s" % self.summarize_name())
669
from_dir = self.new_dir
671
from_name = self.new_name
673
parent = self.new_parent
674
to_dir = self.new_dir
676
to_name = self.new_name
677
from_name = self.name
682
if parent == NULL_ID or parent is None:
684
raise SourceRootHasName(self, to_name)
687
if from_dir == to_dir:
688
dir = os.path.dirname(id_map[self.id])
690
mutter("path, new_path: %r %r" % (self.path, self.new_path))
691
parent_entry = changeset.entries[parent]
692
dir = parent_entry.get_new_path(id_map, changeset, reverse)
693
if from_name == to_name:
694
name = os.path.basename(id_map[self.id])
697
assert(from_name is None or from_name == os.path.basename(id_map[self.id]))
698
return os.path.join(dir, name)
701
"""Determines whether the entry does nothing
703
:return: True if the entry does no renames or content changes
706
if self.contents_change is not None:
708
elif self.metadata_change is not None:
710
elif self.parent != self.new_parent:
712
elif self.name != self.new_name:
717
def apply(self, filename, conflict_handler, reverse=False):
718
"""Applies the file content and/or metadata changes.
720
:param filename: the filename of the entry
722
:param reverse: If true, apply the changes in reverse
725
if self.is_deletion(reverse) and self.metadata_change is not None:
726
self.metadata_change.apply(filename, conflict_handler, reverse)
727
if self.contents_change is not None:
728
self.contents_change.apply(filename, conflict_handler, reverse)
729
if not self.is_deletion(reverse) and self.metadata_change is not None:
730
self.metadata_change.apply(filename, conflict_handler, reverse)
732
class IDPresent(Exception):
733
def __init__(self, id):
734
msg = "Cannot add entry because that id has already been used:\n%s" %\
736
Exception.__init__(self, msg)
739
class Changeset(object):
740
"""A set of changes to apply"""
744
def add_entry(self, entry):
745
"""Add an entry to the list of entries"""
746
if self.entries.has_key(entry.id):
747
raise IDPresent(entry.id)
748
self.entries[entry.id] = entry
750
def my_sort(sequence, key, reverse=False):
751
"""A sort function that supports supplying a key for comparison
753
:param sequence: The sequence to sort
754
:param key: A callable object that returns the values to be compared
755
:param reverse: If true, sort in reverse order
758
def cmp_by_key(entry_a, entry_b):
763
return cmp(key(entry_a), key(entry_b))
764
sequence.sort(cmp_by_key)
766
def get_rename_entries(changeset, inventory, reverse):
767
"""Return a list of entries that will be renamed. Entries are sorted from
768
longest to shortest source path and from shortest to longest target path.
770
:param changeset: The changeset to look in
771
:type changeset: `Changeset`
772
:param inventory: The source of current tree paths for the given ids
773
:type inventory: Dictionary
774
:param reverse: If true, the changeset is being applied in reverse
776
:return: source entries and target entries as a tuple
779
source_entries = [x for x in changeset.entries.itervalues()
781
# these are done from longest path to shortest, to avoid deleting a
782
# parent before its children are deleted/renamed
783
def longest_to_shortest(entry):
784
path = inventory.get(entry.id)
789
my_sort(source_entries, longest_to_shortest, reverse=True)
791
target_entries = source_entries[:]
792
# These are done from shortest to longest path, to avoid creating a
793
# child before its parent has been created/renamed
794
def shortest_to_longest(entry):
795
path = entry.get_new_path(inventory, changeset, reverse)
800
my_sort(target_entries, shortest_to_longest)
801
return (source_entries, target_entries)
803
def rename_to_temp_delete(source_entries, inventory, dir, temp_dir,
804
conflict_handler, reverse):
805
"""Delete and rename entries as appropriate. Entries are renamed to temp
806
names. A map of id -> temp name (or None, for deletions) is returned.
808
:param source_entries: The entries to rename and delete
809
:type source_entries: List of `ChangesetEntry`
810
:param inventory: The map of id -> filename in the current tree
811
:type inventory: Dictionary
812
:param dir: The directory to apply changes to
814
:param reverse: Apply changes in reverse
816
:return: a mapping of id to temporary name
820
for i in range(len(source_entries)):
821
entry = source_entries[i]
822
if entry.is_deletion(reverse):
823
path = os.path.join(dir, inventory[entry.id])
824
entry.apply(path, conflict_handler, reverse)
825
temp_name[entry.id] = None
828
to_name = os.path.join(temp_dir, str(i))
829
src_path = inventory.get(entry.id)
830
if src_path is not None:
831
src_path = os.path.join(dir, src_path)
833
rename(src_path, to_name)
834
temp_name[entry.id] = to_name
836
if e.errno != errno.ENOENT:
838
if conflict_handler.missing_for_rename(src_path) == "skip":
844
def rename_to_new_create(changed_inventory, target_entries, inventory,
845
changeset, dir, conflict_handler, reverse):
846
"""Rename entries with temp names to their final names, create new files.
848
:param changed_inventory: A mapping of id to temporary name
849
:type changed_inventory: Dictionary
850
:param target_entries: The entries to apply changes to
851
:type target_entries: List of `ChangesetEntry`
852
:param changeset: The changeset to apply
853
:type changeset: `Changeset`
854
:param dir: The directory to apply changes to
856
:param reverse: If true, apply changes in reverse
859
for entry in target_entries:
860
new_tree_path = entry.get_new_path(inventory, changeset, reverse)
861
if new_tree_path is None:
863
new_path = os.path.join(dir, new_tree_path)
864
old_path = changed_inventory.get(entry.id)
865
if os.path.exists(new_path):
866
if conflict_handler.target_exists(entry, new_path, old_path) == \
869
if entry.is_creation(reverse):
870
entry.apply(new_path, conflict_handler, reverse)
871
changed_inventory[entry.id] = new_tree_path
876
rename(old_path, new_path)
877
changed_inventory[entry.id] = new_tree_path
879
raise Exception ("%s is missing" % new_path)
881
class TargetExists(Exception):
882
def __init__(self, entry, target):
883
msg = "The path %s already exists" % target
884
Exception.__init__(self, msg)
888
class RenameConflict(Exception):
889
def __init__(self, id, this_name, base_name, other_name):
890
msg = """Trees all have different names for a file
894
id: %s""" % (this_name, base_name, other_name, id)
895
Exception.__init__(self, msg)
896
self.this_name = this_name
897
self.base_name = base_name
898
self_other_name = other_name
900
class MoveConflict(Exception):
901
def __init__(self, id, this_parent, base_parent, other_parent):
902
msg = """The file is in different directories in every tree
906
id: %s""" % (this_parent, base_parent, other_parent, id)
907
Exception.__init__(self, msg)
908
self.this_parent = this_parent
909
self.base_parent = base_parent
910
self_other_parent = other_parent
912
class MergeConflict(Exception):
913
def __init__(self, this_path):
914
Exception.__init__(self, "Conflict applying changes to %s" % this_path)
915
self.this_path = this_path
917
class MergePermissionConflict(Exception):
918
def __init__(self, this_path, base_path, other_path):
919
this_perms = os.stat(this_path).st_mode & 0755
920
base_perms = os.stat(base_path).st_mode & 0755
921
other_perms = os.stat(other_path).st_mode & 0755
922
msg = """Conflicting permission for %s
926
""" % (this_path, this_perms, base_perms, other_perms)
927
self.this_path = this_path
928
self.base_path = base_path
929
self.other_path = other_path
930
Exception.__init__(self, msg)
932
class WrongOldContents(Exception):
933
def __init__(self, filename):
934
msg = "Contents mismatch deleting %s" % filename
935
self.filename = filename
936
Exception.__init__(self, msg)
938
class WrongOldPermissions(Exception):
939
def __init__(self, filename, old_perms, new_perms):
940
msg = "Permission missmatch on %s:\n" \
941
"Expected 0%o, got 0%o." % (filename, old_perms, new_perms)
942
self.filename = filename
943
Exception.__init__(self, msg)
945
class RemoveContentsConflict(Exception):
946
def __init__(self, filename):
947
msg = "Conflict deleting %s, which has different contents in BASE"\
948
" and THIS" % filename
949
self.filename = filename
950
Exception.__init__(self, msg)
952
class DeletingNonEmptyDirectory(Exception):
953
def __init__(self, filename):
954
msg = "Trying to remove dir %s while it still had files" % filename
955
self.filename = filename
956
Exception.__init__(self, msg)
959
class PatchTargetMissing(Exception):
960
def __init__(self, filename):
961
msg = "Attempt to patch %s, which does not exist" % filename
962
Exception.__init__(self, msg)
963
self.filename = filename
965
class MissingPermsFile(Exception):
966
def __init__(self, filename):
967
msg = "Attempt to change permissions on %s, which does not exist" %\
969
Exception.__init__(self, msg)
970
self.filename = filename
972
class MissingForRm(Exception):
973
def __init__(self, filename):
974
msg = "Attempt to remove missing path %s" % filename
975
Exception.__init__(self, msg)
976
self.filename = filename
979
class MissingForRename(Exception):
980
def __init__(self, filename):
981
msg = "Attempt to move missing path %s" % (filename)
982
Exception.__init__(self, msg)
983
self.filename = filename
985
class NewContentsConflict(Exception):
986
def __init__(self, filename):
987
msg = "Conflicting contents for new file %s" % (filename)
988
Exception.__init__(self, msg)
991
class MissingForMerge(Exception):
992
def __init__(self, filename):
993
msg = "The file %s was modified, but does not exist in this tree"\
995
Exception.__init__(self, msg)
998
class ExceptionConflictHandler(object):
999
"""Default handler for merge exceptions.
1001
This throws an error on any kind of conflict. Conflict handlers can
1002
descend from this class if they have a better way to handle some or
1003
all types of conflict.
1005
def missing_parent(self, pathname):
1006
parent = os.path.dirname(pathname)
1007
raise Exception("Parent directory missing for %s" % pathname)
1009
def dir_exists(self, pathname):
1010
raise Exception("Directory already exists for %s" % pathname)
1012
def failed_hunks(self, pathname):
1013
raise Exception("Failed to apply some hunks for %s" % pathname)
1015
def target_exists(self, entry, target, old_path):
1016
raise TargetExists(entry, target)
1018
def rename_conflict(self, id, this_name, base_name, other_name):
1019
raise RenameConflict(id, this_name, base_name, other_name)
1021
def move_conflict(self, id, this_dir, base_dir, other_dir):
1022
raise MoveConflict(id, this_dir, base_dir, other_dir)
1024
def merge_conflict(self, new_file, this_path, base_lines, other_lines):
1026
raise MergeConflict(this_path)
1028
def permission_conflict(self, this_path, base_path, other_path):
1029
raise MergePermissionConflict(this_path, base_path, other_path)
1031
def wrong_old_contents(self, filename, expected_contents):
1032
raise WrongOldContents(filename)
1034
def rem_contents_conflict(self, filename, this_contents, base_contents):
1035
raise RemoveContentsConflict(filename)
1037
def wrong_old_perms(self, filename, old_perms, new_perms):
1038
raise WrongOldPermissions(filename, old_perms, new_perms)
1040
def rmdir_non_empty(self, filename):
1041
raise DeletingNonEmptyDirectory(filename)
1043
def link_name_exists(self, filename):
1044
raise TargetExists(filename)
1046
def patch_target_missing(self, filename, contents):
1047
raise PatchTargetMissing(filename)
1049
def missing_for_chmod(self, filename):
1050
raise MissingPermsFile(filename)
1052
def missing_for_rm(self, filename, change):
1053
raise MissingForRm(filename)
1055
def missing_for_rename(self, filename):
1056
raise MissingForRename(filename)
1058
def missing_for_merge(self, file_id, other_path):
1059
raise MissingForMerge(other_path)
1061
def new_contents_conflict(self, filename, other_contents):
1062
raise NewContentsConflict(filename)
1067
def apply_changeset(changeset, inventory, dir, conflict_handler=None,
1069
"""Apply a changeset to a directory.
1071
:param changeset: The changes to perform
1072
:type changeset: `Changeset`
1073
:param inventory: The mapping of id to filename for the directory
1074
:type inventory: Dictionary
1075
:param dir: The path of the directory to apply the changes to
1077
:param reverse: If true, apply the changes in reverse
1079
:return: The mapping of the changed entries
1082
if conflict_handler is None:
1083
conflict_handler = ExceptionConflictHandler()
1084
temp_dir = os.path.join(dir, "bzr-tree-change")
62
def get_bundle(transport):
63
return transport.get(filename), transport
65
def redirected_transport(transport, exception, redirection_notice):
66
note(redirection_notice)
67
url, filename = urlutils.split(exception.target,
68
exclude_trailing_slash=False)
70
raise errors.NotABundle('A directory cannot be a bundle')
71
return get_transport(url)
74
f, transport = do_catching_redirections(get_bundle, transport,
76
except errors.TooManyRedirections:
77
raise errors.NotABundle(str(url))
80
from bzrlib.merge_directive import MergeDirective
81
directive = MergeDirective.from_lines(f.readlines())
82
return directive, transport
84
return _serializer.read_bundle(f), transport
85
except (errors.TransportError, errors.PathError), e:
86
raise errors.NotABundle(str(e))
89
# Abstraction leakage, SFTPTransport.get('directory')
90
# doesn't always fail at get() time. Sometimes it fails
91
# during read. And that raises a generic IOError with
92
# just the string 'Failure'
93
# StubSFTPServer does fail during get() (because of prefetch)
94
# so it has an opportunity to translate the error.
95
raise errors.NotABundle(str(e))
96
except errors.NotAMergeDirective:
98
return _serializer.read_bundle(f), transport
1088
if e.errno == errno.EEXIST:
1092
if e.errno == errno.ENOTEMPTY:
1093
raise OldFailedTreeOp()
1098
#apply changes that don't affect filenames
1099
for entry in changeset.entries.itervalues():
1100
if not entry.is_creation_or_deletion():
1101
path = os.path.join(dir, inventory[entry.id])
1102
entry.apply(path, conflict_handler, reverse)
1104
# Apply renames in stages, to minimize conflicts:
1105
# Only files whose name or parent change are interesting, because their
1106
# target name may exist in the source tree. If a directory's name changes,
1107
# that doesn't make its children interesting.
1108
(source_entries, target_entries) = get_rename_entries(changeset, inventory,
1111
changed_inventory = rename_to_temp_delete(source_entries, inventory, dir,
1112
temp_dir, conflict_handler,
1115
rename_to_new_create(changed_inventory, target_entries, inventory,
1116
changeset, dir, conflict_handler, reverse)
1118
return changed_inventory
1121
def apply_changeset_tree(cset, tree, reverse=False):
1123
for entry in tree.source_inventory().itervalues():
1124
inventory[entry.id] = entry.path
1125
new_inventory = apply_changeset(cset, r_inventory, tree.root,
1127
new_entries, remove_entries = \
1128
get_inventory_change(inventory, new_inventory, cset, reverse)
1129
tree.update_source_inventory(new_entries, remove_entries)
1132
def get_inventory_change(inventory, new_inventory, cset, reverse=False):
1135
for entry in cset.entries.itervalues():
1136
if entry.needs_rename():
1137
new_path = entry.get_new_path(inventory, cset)
1138
if new_path is None:
1139
remove_entries.append(entry.id)
1141
new_entries[new_path] = entry.id
1142
return new_entries, remove_entries
1145
def print_changeset(cset):
1146
"""Print all non-boring changeset entries
1148
:param cset: The changeset to print
1149
:type cset: `Changeset`
1151
for entry in cset.entries.itervalues():
1152
if entry.is_boring():
1155
print entry.summarize_name(cset)
1157
class CompositionFailure(Exception):
1158
def __init__(self, old_entry, new_entry, problem):
1159
msg = "Unable to conpose entries.\n %s" % problem
1160
Exception.__init__(self, msg)
1162
class IDMismatch(CompositionFailure):
1163
def __init__(self, old_entry, new_entry):
1164
problem = "Attempt to compose entries with different ids: %s and %s" %\
1165
(old_entry.id, new_entry.id)
1166
CompositionFailure.__init__(self, old_entry, new_entry, problem)
1168
def compose_changesets(old_cset, new_cset):
1169
"""Combine two changesets into one. This works well for exact patching.
1170
Otherwise, not so well.
1172
:param old_cset: The first changeset that would be applied
1173
:type old_cset: `Changeset`
1174
:param new_cset: The second changeset that would be applied
1175
:type new_cset: `Changeset`
1176
:return: A changeset that combines the changes in both changesets
1179
composed = Changeset()
1180
for old_entry in old_cset.entries.itervalues():
1181
new_entry = new_cset.entries.get(old_entry.id)
1182
if new_entry is None:
1183
composed.add_entry(old_entry)
1185
composed_entry = compose_entries(old_entry, new_entry)
1186
if composed_entry.parent is not None or\
1187
composed_entry.new_parent is not None:
1188
composed.add_entry(composed_entry)
1189
for new_entry in new_cset.entries.itervalues():
1190
if not old_cset.entries.has_key(new_entry.id):
1191
composed.add_entry(new_entry)
1194
def compose_entries(old_entry, new_entry):
1195
"""Combine two entries into one.
1197
:param old_entry: The first entry that would be applied
1198
:type old_entry: ChangesetEntry
1199
:param old_entry: The second entry that would be applied
1200
:type old_entry: ChangesetEntry
1201
:return: A changeset entry combining both entries
1202
:rtype: `ChangesetEntry`
1204
if old_entry.id != new_entry.id:
1205
raise IDMismatch(old_entry, new_entry)
1206
output = ChangesetEntry(old_entry.id, old_entry.parent, old_entry.path)
1208
if (old_entry.parent != old_entry.new_parent or
1209
new_entry.parent != new_entry.new_parent):
1210
output.new_parent = new_entry.new_parent
1212
if (old_entry.path != old_entry.new_path or
1213
new_entry.path != new_entry.new_path):
1214
output.new_path = new_entry.new_path
1216
output.contents_change = compose_contents(old_entry, new_entry)
1217
output.metadata_change = compose_metadata(old_entry, new_entry)
1220
def compose_contents(old_entry, new_entry):
1221
"""Combine the contents of two changeset entries. Entries are combined
1222
intelligently where possible, but the fallback behavior returns an
1225
:param old_entry: The first entry that would be applied
1226
:type old_entry: `ChangesetEntry`
1227
:param new_entry: The second entry that would be applied
1228
:type new_entry: `ChangesetEntry`
1229
:return: A combined contents change
1230
:rtype: anything supporting the apply(reverse=False) method
1232
old_contents = old_entry.contents_change
1233
new_contents = new_entry.contents_change
1234
if old_entry.contents_change is None:
1235
return new_entry.contents_change
1236
elif new_entry.contents_change is None:
1237
return old_entry.contents_change
1238
elif isinstance(old_contents, ReplaceContents) and \
1239
isinstance(new_contents, ReplaceContents):
1240
if old_contents.old_contents == new_contents.new_contents:
1243
return ReplaceContents(old_contents.old_contents,
1244
new_contents.new_contents)
1245
elif isinstance(old_contents, ApplySequence):
1246
output = ApplySequence(old_contents.changes)
1247
if isinstance(new_contents, ApplySequence):
1248
output.changes.extend(new_contents.changes)
1250
output.changes.append(new_contents)
1252
elif isinstance(new_contents, ApplySequence):
1253
output = ApplySequence((old_contents.changes,))
1254
output.extend(new_contents.changes)
1257
return ApplySequence((old_contents, new_contents))
1259
def compose_metadata(old_entry, new_entry):
1260
old_meta = old_entry.metadata_change
1261
new_meta = new_entry.metadata_change
1262
if old_meta is None:
1264
elif new_meta is None:
1266
elif isinstance(old_meta, ChangeUnixPermissions) and \
1267
isinstance(new_meta, ChangeUnixPermissions):
1268
return ChangeUnixPermissions(old_meta.old_mode, new_meta.new_mode)
1270
return ApplySequence(old_meta, new_meta)
1273
def changeset_is_null(changeset):
1274
for entry in changeset.entries.itervalues():
1275
if not entry.is_boring():
1279
class UnsuppportedFiletype(Exception):
1280
def __init__(self, full_path, stat_result):
1281
msg = "The file \"%s\" is not a supported filetype." % full_path
1282
Exception.__init__(self, msg)
1283
self.full_path = full_path
1284
self.stat_result = stat_result
1286
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1287
return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1289
class ChangesetGenerator(object):
1290
def __init__(self, tree_a, tree_b, interesting_ids=None):
1291
object.__init__(self)
1292
self.tree_a = tree_a
1293
self.tree_b = tree_b
1294
self._interesting_ids = interesting_ids
1296
def iter_both_tree_ids(self):
1297
for file_id in self.tree_a:
1299
for file_id in self.tree_b:
1300
if file_id not in self.tree_a:
1305
for file_id in self.iter_both_tree_ids():
1306
cs_entry = self.make_entry(file_id)
1307
if cs_entry is not None and not cs_entry.is_boring():
1308
cset.add_entry(cs_entry)
1310
for entry in list(cset.entries.itervalues()):
1311
if entry.parent != entry.new_parent:
1312
if not cset.entries.has_key(entry.parent) and\
1313
entry.parent != NULL_ID and entry.parent is not None:
1314
parent_entry = self.make_boring_entry(entry.parent)
1315
cset.add_entry(parent_entry)
1316
if not cset.entries.has_key(entry.new_parent) and\
1317
entry.new_parent != NULL_ID and \
1318
entry.new_parent is not None:
1319
parent_entry = self.make_boring_entry(entry.new_parent)
1320
cset.add_entry(parent_entry)
1323
def iter_inventory(self, tree):
1324
for file_id in tree:
1325
yield self.get_entry(file_id, tree)
1327
def get_entry(self, file_id, tree):
1328
if not tree.has_or_had_id(file_id):
1330
return tree.tree.inventory[file_id]
1332
def get_entry_parent(self, entry):
1335
return entry.parent_id
1337
def get_path(self, file_id, tree):
1338
if not tree.has_or_had_id(file_id):
1340
path = tree.id2path(file_id)
1346
def make_basic_entry(self, file_id, only_interesting):
1347
entry_a = self.get_entry(file_id, self.tree_a)
1348
entry_b = self.get_entry(file_id, self.tree_b)
1349
if only_interesting and not self.is_interesting(entry_a, entry_b):
1351
parent = self.get_entry_parent(entry_a)
1352
path = self.get_path(file_id, self.tree_a)
1353
cs_entry = ChangesetEntry(file_id, parent, path)
1354
new_parent = self.get_entry_parent(entry_b)
1356
new_path = self.get_path(file_id, self.tree_b)
1358
cs_entry.new_path = new_path
1359
cs_entry.new_parent = new_parent
1362
def is_interesting(self, entry_a, entry_b):
1363
if self._interesting_ids is None:
1365
if entry_a is not None:
1366
file_id = entry_a.file_id
1367
elif entry_b is not None:
1368
file_id = entry_b.file_id
1371
return file_id in self._interesting_ids
1373
def make_boring_entry(self, id):
1374
cs_entry = self.make_basic_entry(id, only_interesting=False)
1375
if cs_entry.is_creation_or_deletion():
1376
return self.make_entry(id, only_interesting=False)
1381
def make_entry(self, id, only_interesting=True):
1382
cs_entry = self.make_basic_entry(id, only_interesting)
1384
if cs_entry is None:
1386
if id in self.tree_a and id in self.tree_b:
1387
a_sha1 = self.tree_a.get_file_sha1(id)
1388
b_sha1 = self.tree_b.get_file_sha1(id)
1389
if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1392
full_path_a = self.tree_a.readonly_path(id)
1393
full_path_b = self.tree_b.readonly_path(id)
1394
stat_a = self.lstat(full_path_a)
1395
stat_b = self.lstat(full_path_b)
1397
cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
1398
cs_entry.contents_change = self.make_contents_change(full_path_a,
1404
def make_mode_change(self, stat_a, stat_b):
1406
if stat_a is not None and not stat.S_ISLNK(stat_a.st_mode):
1407
mode_a = stat_a.st_mode & 0777
1409
if stat_b is not None and not stat.S_ISLNK(stat_b.st_mode):
1410
mode_b = stat_b.st_mode & 0777
1411
if mode_a == mode_b:
1413
return ChangeUnixPermissions(mode_a, mode_b)
1415
def make_contents_change(self, full_path_a, stat_a, full_path_b, stat_b):
1416
if stat_a is None and stat_b is None:
1418
if None not in (stat_a, stat_b) and stat.S_ISDIR(stat_a.st_mode) and\
1419
stat.S_ISDIR(stat_b.st_mode):
1421
if None not in (stat_a, stat_b) and stat.S_ISREG(stat_a.st_mode) and\
1422
stat.S_ISREG(stat_b.st_mode):
1423
if stat_a.st_ino == stat_b.st_ino and \
1424
stat_a.st_dev == stat_b.st_dev:
1427
a_contents = self.get_contents(stat_a, full_path_a)
1428
b_contents = self.get_contents(stat_b, full_path_b)
1429
if a_contents == b_contents:
1431
return ReplaceContents(a_contents, b_contents)
1433
def get_contents(self, stat_result, full_path):
1434
if stat_result is None:
1436
elif stat.S_ISREG(stat_result.st_mode):
1437
return FileCreate(file(full_path, "rb").read())
1438
elif stat.S_ISDIR(stat_result.st_mode):
1440
elif stat.S_ISLNK(stat_result.st_mode):
1441
return SymlinkCreate(os.readlink(full_path))
1443
raise UnsupportedFiletype(full_path, stat_result)
1445
def lstat(self, full_path):
1447
if full_path is not None:
1449
stat_result = os.lstat(full_path)
1451
if e.errno != errno.ENOENT:
1456
def full_path(entry, tree):
1457
return os.path.join(tree.root, entry.path)
1459
def new_delete_entry(entry, tree, inventory, delete):
1460
if entry.path == "":
1463
parent = inventory[dirname(entry.path)].id
1464
cs_entry = ChangesetEntry(parent, entry.path)
1466
cs_entry.new_path = None
1467
cs_entry.new_parent = None
1469
cs_entry.path = None
1470
cs_entry.parent = None
1471
full_path = full_path(entry, tree)
1472
status = os.lstat(full_path)
1473
if stat.S_ISDIR(file_stat.st_mode):
1479
# XXX: Can't we unify this with the regular inventory object
1480
class Inventory(object):
1481
def __init__(self, inventory):
1482
self.inventory = inventory
1483
self.rinventory = None
1485
def get_rinventory(self):
1486
if self.rinventory is None:
1487
self.rinventory = invert_dict(self.inventory)
1488
return self.rinventory
1490
def get_path(self, id):
1491
return self.inventory.get(id)
1493
def get_name(self, id):
1494
path = self.get_path(id)
1498
return os.path.basename(path)
1500
def get_dir(self, id):
1501
path = self.get_path(id)
1506
return os.path.dirname(path)
1508
def get_parent(self, id):
1509
if self.get_path(id) is None:
1511
directory = self.get_dir(id)
1512
if directory == '.':
1514
if directory is None:
1516
return self.get_rinventory().get(directory)
added
removed
bzrlib/changeset.py
