/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_walker.py

  • Committer: Tim Marston
  • Date: 2014-02-26 19:10:31 UTC
  • Revision ID: tim@ed.am-20140226191031-elcqy5j09h2syn2j
moved copy-in, copy-out and deployment conflict checking to a set of "walkers";
bzr vcs back-end now parses affected files during update; deployment state now
includes affected files

Show diffs side-by-side

added added

removed removed

lib/stdhome/walker/conflict_walker.py
1
 
# conflict.py
 
1
# conflict_walker.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
23
22
from walker import Walker
24
23
import stdhome.the as the
25
24
 
28
27
        """The conflict walker traverses the repo looking for "deployment conflicts"
29
28
        (i.e., changes in the type of file).  This is run prior to running the
30
29
        copy-out walker and, as such, is given a list of files that were copied-in
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).
 
30
        and which is can, therefore, safely ignore.
33
31
 
34
32
        Walker source:       repo
35
33
        Walker destination:  home dir
36
34
        Walker traversing:   repo
37
35
        """
38
36
 
39
 
        def __init__( self, ignore_files, walk_files = None ):
 
37
        def __init__( self, ignore_files, updated_files = None ):
40
38
                self.src_dir = 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 \
 
39
                self.dst_dir = the.full_fsdir
 
40
                self.walk_list = updated_files if updated_files is not None else \
43
41
                                                 self.generate_walk_list( the.repo.full_dir )
44
42
 
45
43
                self.ignore_files = ignore_files
46
44
                self.changed = list()
47
 
                self.obstructed = list()
48
 
 
49
 
 
50
 
        def process( self, rel_file, src, dst ):
 
45
 
 
46
 
 
47
        def process( self, rel_file, src_file, src_type, dst_file, dst_type ):
51
48
 
52
49
                # if entity is missing in home dir, it's ok to copy out (and there's no
53
50
                # need to recurse)
54
 
                if dst.type == '_': return False
 
51
                if dst_type == '_': return False
55
52
 
56
53
                # if entity was copied-in, it's ok to copy out
57
 
                elif rel_file in self.ignore_files:
58
 
 
 
54
                if rel_file in self.ignore_files:
59
55
                        # we recurse only if this is a directory in the home dir, because if
60
56
                        # it isn't copying-out will replace whatever's in the home dir with
61
57
                        # the whole directory from the repo
62
 
                        return dst.type == 'd'
 
58
                        return dst_type == 'd'
63
59
 
64
60
                # entity has changed 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() ) )
 
61
                elif src_type != dst_type:
 
62
                        self.changed.append( "%s (now %s)" % (
 
63
                                rel_file, self.name_of_type( src_type ) ) )
68
64
 
69
65
                        # if an entity has changed to/from a directory, we don't care about
70
66
                        # anything that directory does/did contain
71
67
                        return False
72
68
 
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
 
 
89
69
                # nothing to see here
90
70
                return True