/stdhome

To get this branch, use:
bzr branch http://bzr.ed.am/stdhome

« back to all changes in this revision

Viewing changes to lib/stdhome/walker/conflict.py

  • Committer: Tim Marston
  • Date: 2016-05-22 16:40:51 UTC
  • Revision ID: tim@ed.am-20160522164051-h2n54oaxg25c7x7c
updated todo

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/stdhome/walker/conflict.py
1
 
# conflict_walker.py
 
1
# conflict.py
2
2
#
3
3
# Copyright (C) 2013 to 2014 Tim Marston <tim@edm.am>
4
4
#
19
19
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
20
20
 
21
21
 
 
22
import filecmp, os
22
23
from walker import Walker
23
24
import stdhome.the as the
24
25
 
27
28
        """The conflict walker traverses the repo looking for "deployment conflicts"
28
29
        (i.e., changes in the type of file).  This is run prior to running the
29
30
        copy-out walker and, as such, is given a list of files that were copied-in
30
 
        and which is can, therefore, safely ignore.
 
31
        and which is can, therefore, safely ignore.  It can also be given a list of
 
32
        files affected by the update (it will walk all repo files otherwise).
31
33
 
32
34
        Walker source:       repo
33
35
        Walker destination:  home dir
34
36
        Walker traversing:   repo
35
37
        """
36
38
 
37
 
        def __init__( self, ignore_files, updated_files = None ):
 
39
        def __init__( self, ignore_files, walk_files = None ):
38
40
                self.src_dir = the.repo.full_dir
39
 
                self.dst_dir = the.full_fsdir
40
 
                self.walk_list = updated_files if updated_files is not None else \
41
 
                                                 self.generate_walk_list( the.repo.full_dir )
 
41
                self.dst_dir = the.full_home_dir
 
42
                self.walk_list = walk_files if walk_files is not None else \
 
43
                                                 self.generate_walk_list()
42
44
 
43
45
                self.ignore_files = ignore_files
44
46
                self.changed = list()
45
 
 
46
 
 
47
 
        def process( self, rel_file, src_file, src_type, dst_file, dst_type ):
 
47
                self.obstructed = list()
 
48
 
 
49
 
 
50
        def process( self, rel_file, src, dst ):
48
51
 
49
52
                # if entity is missing in home dir, it's ok to copy out (and there's no
50
53
                # need to recurse)
51
 
                if dst_type == '_': return False
 
54
                if dst.type == '_': return False
52
55
 
53
56
                # if entity was copied-in, it's ok to copy out
54
 
                if rel_file in self.ignore_files:
 
57
                elif rel_file in self.ignore_files:
 
58
 
55
59
                        # we recurse only if this is a directory in the home dir, because if
56
60
                        # it isn't copying-out will replace whatever's in the home dir with
57
61
                        # the whole directory from the repo
58
 
                        return dst_type == 'd'
 
62
                        return dst.type == 'd'
59
63
 
60
64
                # entity has changed type?
61
 
                elif src_type != dst_type:
62
 
                        self.changed.append( "%s (now %s)" % (
63
 
                                rel_file, self.name_of_type( src_type ) ) )
 
65
                elif src.get_type_name() != dst.get_type_name():
 
66
                        self.changed.append( "%s (%s => %s)" % (
 
67
                                rel_file, src.get_type_name(), dst.get_type_name() ) )
64
68
 
65
69
                        # if an entity has changed to/from a directory, we don't care about
66
70
                        # anything that directory does/did contain
67
71
                        return False
68
72
 
 
73
                # entity is a file (that wasn't copyied-in)?
 
74
                elif dst.type == 'f':
 
75
 
 
76
                        # only a problem if its content is different
 
77
                        if not filecmp.cmp( src.file, dst.file ):
 
78
                                self.obstructed.append( rel_file )
 
79
                                return False
 
80
 
 
81
                # entity is a symlink (that wasn't copied-in)?
 
82
                if dst.type == 'l':
 
83
 
 
84
                        # only a problem if the symlink is different
 
85
                        if os.readlink( src.file ) != os.readlink( dst.file ):
 
86
                                self.obstructed.append( rel_file )
 
87
                                return False
 
88
 
69
89
                # nothing to see here
70
90
                return True