← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/changeset.py

  • Committer: Martin Pool
  • Date: 2005-09-05 05:35:25 UTC
  • mfrom: (974.1.55)
  • Revision ID: mbp@sourcefrog.net-20050905053525-2112bac069dbe331
- merge various bug fixes from aaron

aaron.bentley@utoronto.ca-20050905020131-a2d5b7711dd6cd98

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/changeset.py
18
18
import patch
19
19
import stat
20
20
from bzrlib.trace import mutter
21
 
from bzrlib.osutils import rename
22
 
import bzrlib
23
21
 
24
22
# XXX: mbp: I'm not totally convinced that we should handle conflicts
25
23
# as part of changeset application, rather than only in the merge
44
42
        newdict[value] = key
45
43
    return newdict
46
44
 
 
45
 
47
46
       
48
 
class ChangeExecFlag(object):
 
47
class ChangeUnixPermissions(object):
49
48
    """This is two-way change, suitable for file modification, creation,
50
49
    deletion"""
51
 
    def __init__(self, old_exec_flag, new_exec_flag):
52
 
        self.old_exec_flag = old_exec_flag
53
 
        self.new_exec_flag = new_exec_flag
 
50
    def __init__(self, old_mode, new_mode):
 
51
        self.old_mode = old_mode
 
52
        self.new_mode = new_mode
54
53
 
55
54
    def apply(self, filename, conflict_handler, reverse=False):
56
55
        if not reverse:
57
 
            from_exec_flag = self.old_exec_flag
58
 
            to_exec_flag = self.new_exec_flag
 
56
            from_mode = self.old_mode
 
57
            to_mode = self.new_mode
59
58
        else:
60
 
            from_exec_flag = self.new_exec_flag
61
 
            to_exec_flag = self.old_exec_flag
 
59
            from_mode = self.new_mode
 
60
            to_mode = self.old_mode
62
61
        try:
63
 
            current_exec_flag = bool(os.stat(filename).st_mode & 0111)
 
62
            current_mode = os.stat(filename).st_mode &0777
64
63
        except OSError, e:
65
64
            if e.errno == errno.ENOENT:
66
 
                if conflict_handler.missing_for_exec_flag(filename) == "skip":
 
65
                if conflict_handler.missing_for_chmod(filename) == "skip":
67
66
                    return
68
67
                else:
69
 
                    current_exec_flag = from_exec_flag
 
68
                    current_mode = from_mode
70
69
 
71
 
        if from_exec_flag is not None and current_exec_flag != from_exec_flag:
72
 
            if conflict_handler.wrong_old_exec_flag(filename,
73
 
                        from_exec_flag, current_exec_flag) != "continue":
 
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":
74
73
                return
75
74
 
76
 
        if to_exec_flag is not None:
77
 
            current_mode = os.stat(filename).st_mode
78
 
            if to_exec_flag:
79
 
                umask = os.umask(0)
80
 
                os.umask(umask)
81
 
                to_mode = current_mode | (0100 & ~umask)
82
 
                # Enable x-bit for others only if they can read it.
83
 
                if current_mode & 0004:
84
 
                    to_mode |= 0001 & ~umask
85
 
                if current_mode & 0040:
86
 
                    to_mode |= 0010 & ~umask
87
 
            else:
88
 
                to_mode = current_mode & ~0111
 
75
        if to_mode is not None:
89
76
            try:
90
77
                os.chmod(filename, to_mode)
91
78
            except IOError, e:
92
79
                if e.errno == errno.ENOENT:
93
 
                    conflict_handler.missing_for_exec_flag(filename)
 
80
                    conflict_handler.missing_for_chmod(filename)
94
81
 
95
82
    def __eq__(self, other):
96
 
        return (isinstance(other, ChangeExecFlag) and
97
 
                self.old_exec_flag == other.old_exec_flag and
98
 
                self.new_exec_flag == other.new_exec_flag)
 
83
        if not isinstance(other, ChangeUnixPermissions):
 
84
            return False
 
85
        elif self.old_mode != other.old_mode:
 
86
            return False
 
87
        elif self.new_mode != other.new_mode:
 
88
            return False
 
89
        else:
 
90
            return True
99
91
 
100
92
    def __ne__(self, other):
101
93
        return not (self == other)
102
94
 
103
 
 
104
95
def dir_create(filename, conflict_handler, reverse):
105
96
    """Creates the directory, or deletes it if reverse is true.  Intended to be
106
97
    used with ReplaceContents.
126
117
        try:
127
118
            os.rmdir(filename)
128
119
        except OSError, e:
129
 
            if e.errno != errno.ENOTEMPTY:
 
120
            if e.errno != 39:
130
121
                raise
131
122
            if conflict_handler.rmdir_non_empty(filename) == "skip":
132
123
                return
133
124
            os.rmdir(filename)
134
125
 
 
126
                
 
127
            
135
128
 
136
129
class SymlinkCreate(object):
137
130
    """Creates or deletes a symlink (for use with ReplaceContents)"""
360
353
        status = patch.diff3(new_file, filename, base, other)
361
354
        if status == 0:
362
355
            os.chmod(new_file, os.stat(filename).st_mode)
363
 
            rename(new_file, filename)
 
356
            os.rename(new_file, filename)
364
357
            return
365
358
        else:
366
359
            assert(status == 1)
367
360
            def get_lines(filename):
368
 
                my_file = file(filename, "rb")
 
361
                my_file = file(base, "rb")
369
362
                lines = my_file.readlines()
370
363
                my_file.close()
371
 
                return lines
372
364
            base_lines = get_lines(base)
373
365
            other_lines = get_lines(other)
374
366
            conflict_handler.merge_conflict(new_file, filename, base_lines, 
839
831
            if src_path is not None:
840
832
                src_path = os.path.join(dir, src_path)
841
833
                try:
842
 
                    rename(src_path, to_name)
 
834
                    os.rename(src_path, to_name)
843
835
                    temp_name[entry.id] = to_name
844
836
                except OSError, e:
845
837
                    if e.errno != errno.ENOENT:
871
863
            continue
872
864
        new_path = os.path.join(dir, new_tree_path)
873
865
        old_path = changed_inventory.get(entry.id)
874
 
        if bzrlib.osutils.lexists(new_path):
 
866
        if os.path.exists(new_path):
875
867
            if conflict_handler.target_exists(entry, new_path, old_path) == \
876
868
                "skip":
877
869
                continue
882
874
            if old_path is None:
883
875
                continue
884
876
            try:
885
 
                rename(old_path, new_path)
 
877
                os.rename(old_path, new_path)
886
878
                changed_inventory[entry.id] = new_tree_path
887
879
            except OSError, e:
888
880
                raise Exception ("%s is missing" % new_path)
923
915
        Exception.__init__(self, "Conflict applying changes to %s" % this_path)
924
916
        self.this_path = this_path
925
917
 
 
918
class MergePermissionConflict(Exception):
 
919
    def __init__(self, this_path, base_path, other_path):
 
920
        this_perms = os.stat(this_path).st_mode & 0755
 
921
        base_perms = os.stat(base_path).st_mode & 0755
 
922
        other_perms = os.stat(other_path).st_mode & 0755
 
923
        msg = """Conflicting permission for %s
 
924
this: %o
 
925
base: %o
 
926
other: %o
 
927
        """ % (this_path, this_perms, base_perms, other_perms)
 
928
        self.this_path = this_path
 
929
        self.base_path = base_path
 
930
        self.other_path = other_path
 
931
        Exception.__init__(self, msg)
 
932
 
926
933
class WrongOldContents(Exception):
927
934
    def __init__(self, filename):
928
935
        msg = "Contents mismatch deleting %s" % filename
929
936
        self.filename = filename
930
937
        Exception.__init__(self, msg)
931
938
 
932
 
class WrongOldExecFlag(Exception):
933
 
    def __init__(self, filename, old_exec_flag, new_exec_flag):
934
 
        msg = "Executable flag missmatch on %s:\n" \
935
 
        "Expected %s, got %s." % (filename, old_exec_flag, new_exec_flag)
 
939
class WrongOldPermissions(Exception):
 
940
    def __init__(self, filename, old_perms, new_perms):
 
941
        msg = "Permission missmatch on %s:\n" \
 
942
        "Expected 0%o, got 0%o." % (filename, old_perms, new_perms)
936
943
        self.filename = filename
937
944
        Exception.__init__(self, msg)
938
945
 
956
963
        Exception.__init__(self, msg)
957
964
        self.filename = filename
958
965
 
959
 
class MissingForSetExec(Exception):
 
966
class MissingPermsFile(Exception):
960
967
    def __init__(self, filename):
961
968
        msg = "Attempt to change permissions on  %s, which does not exist" %\
962
969
            filename
996
1003
    descend from this class if they have a better way to handle some or
997
1004
    all types of conflict.
998
1005
    """
 
1006
    def __init__(self, dir):
 
1007
        self.dir = dir
 
1008
    
999
1009
    def missing_parent(self, pathname):
1000
1010
        parent = os.path.dirname(pathname)
1001
1011
        raise Exception("Parent directory missing for %s" % pathname)
1019
1029
        os.unlink(new_file)
1020
1030
        raise MergeConflict(this_path)
1021
1031
 
 
1032
    def permission_conflict(self, this_path, base_path, other_path):
 
1033
        raise MergePermissionConflict(this_path, base_path, other_path)
 
1034
 
1022
1035
    def wrong_old_contents(self, filename, expected_contents):
1023
1036
        raise WrongOldContents(filename)
1024
1037
 
1025
1038
    def rem_contents_conflict(self, filename, this_contents, base_contents):
1026
1039
        raise RemoveContentsConflict(filename)
1027
1040
 
1028
 
    def wrong_old_exec_flag(self, filename, old_exec_flag, new_exec_flag):
1029
 
        raise WrongOldExecFlag(filename, old_exec_flag, new_exec_flag)
 
1041
    def wrong_old_perms(self, filename, old_perms, new_perms):
 
1042
        raise WrongOldPermissions(filename, old_perms, new_perms)
1030
1043
 
1031
1044
    def rmdir_non_empty(self, filename):
1032
1045
        raise DeletingNonEmptyDirectory(filename)
1037
1050
    def patch_target_missing(self, filename, contents):
1038
1051
        raise PatchTargetMissing(filename)
1039
1052
 
1040
 
    def missing_for_exec_flag(self, filename):
1041
 
        raise MissingForExecFlag(filename)
 
1053
    def missing_for_chmod(self, filename):
 
1054
        raise MissingPermsFile(filename)
1042
1055
 
1043
1056
    def missing_for_rm(self, filename, change):
1044
1057
        raise MissingForRm(filename)
1071
1084
    :rtype: Dictionary
1072
1085
    """
1073
1086
    if conflict_handler is None:
1074
 
        conflict_handler = ExceptionConflictHandler()
 
1087
        conflict_handler = ExceptionConflictHandler(dir)
1075
1088
    temp_dir = os.path.join(dir, "bzr-tree-change")
1076
1089
    try:
1077
1090
        os.mkdir(temp_dir)
1254
1267
        return new_meta
1255
1268
    elif new_meta is None:
1256
1269
        return old_meta
1257
 
    elif (isinstance(old_meta, ChangeExecFlag) and
1258
 
          isinstance(new_meta, ChangeExecFlag)):
1259
 
        return ChangeExecFlag(old_meta.old_exec_flag, new_meta.new_exec_flag)
 
1270
    elif isinstance(old_meta, ChangeUnixPermissions) and \
 
1271
        isinstance(new_meta, ChangeUnixPermissions):
 
1272
        return ChangeUnixPermissions(old_meta.old_mode, new_meta.new_mode)
1260
1273
    else:
1261
1274
        return ApplySequence(old_meta, new_meta)
1262
1275
 
1277
1290
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1278
1291
    return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1279
1292
 
1280
 
 
1281
1293
class ChangesetGenerator(object):
1282
1294
    def __init__(self, tree_a, tree_b, interesting_ids=None):
1283
1295
        object.__init__(self)
1375
1387
 
1376
1388
        if cs_entry is None:
1377
1389
            return None
1378
 
 
1379
 
        full_path_a = self.tree_a.readonly_path(id)
1380
 
        full_path_b = self.tree_b.readonly_path(id)
1381
 
        stat_a = self.lstat(full_path_a)
1382
 
        stat_b = self.lstat(full_path_b)
1383
 
 
1384
 
        cs_entry.metadata_change = self.make_exec_flag_change(stat_a, stat_b)
1385
 
 
1386
1390
        if id in self.tree_a and id in self.tree_b:
1387
1391
            a_sha1 = self.tree_a.get_file_sha1(id)
1388
1392
            b_sha1 = self.tree_b.get_file_sha1(id)
1389
1393
            if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1390
1394
                return cs_entry
1391
1395
 
 
1396
        full_path_a = self.tree_a.readonly_path(id)
 
1397
        full_path_b = self.tree_b.readonly_path(id)
 
1398
        stat_a = self.lstat(full_path_a)
 
1399
        stat_b = self.lstat(full_path_b)
 
1400
        
 
1401
        cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
1392
1402
        cs_entry.contents_change = self.make_contents_change(full_path_a,
1393
1403
                                                             stat_a, 
1394
1404
                                                             full_path_b, 
1395
1405
                                                             stat_b)
1396
1406
        return cs_entry
1397
1407
 
1398
 
    def make_exec_flag_change(self, stat_a, stat_b):
1399
 
        exec_flag_a = exec_flag_b = None
 
1408
    def make_mode_change(self, stat_a, stat_b):
 
1409
        mode_a = None
1400
1410
        if stat_a is not None and not stat.S_ISLNK(stat_a.st_mode):
1401
 
            exec_flag_a = bool(stat_a.st_mode & 0111)
 
1411
            mode_a = stat_a.st_mode & 0777
 
1412
        mode_b = None
1402
1413
        if stat_b is not None and not stat.S_ISLNK(stat_b.st_mode):
1403
 
            exec_flag_b = bool(stat_b.st_mode & 0111)
1404
 
        if exec_flag_a == exec_flag_b:
 
1414
            mode_b = stat_b.st_mode & 0777
 
1415
        if mode_a == mode_b:
1405
1416
            return None
1406
 
        return ChangeExecFlag(exec_flag_a, exec_flag_b)
 
1417
        return ChangeUnixPermissions(mode_a, mode_b)
1407
1418
 
1408
1419
    def make_contents_change(self, full_path_a, stat_a, full_path_b, stat_b):
1409
1420
        if stat_a is None and stat_b is None: