summaryrefslogtreecommitdiffstats
path: root/geo-replication/syncdaemon/configinterface.py
blob: e55bec519e99363966b4f5b9ed572f97a413a0ea (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
try:
    import ConfigParser
except ImportError:
    # py 3
    import configparser as ConfigParser
import re
from string import Template

from syncdutils import escape, unescape, norm, update_file, GsyncdError

SECT_ORD = '__section_order__'
SECT_META = '__meta__'
config_version = 2.0

re_type = type(re.compile(''))


class MultiDict(object):
    """a virtual dict-like class which functions as the union of underlying dicts"""

    def __init__(self, *dd):
        self.dicts = dd

    def __getitem__(self, key):
        val = None
        for d in self.dicts:
            if d.get(key):
                val = d[key]
        if not val:
            raise KeyError(key)
        return val


class GConffile(object):
    """A high-level interface to ConfigParser which flattens the two-tiered
       config layout by implenting automatic section dispatch based on initial
       parameters.

    Also ensure section ordering in terms of their time of addition -- a compat
    hack for Python < 2.7.
    """

    def _normconfig(self):
        """normalize config keys by s/-/_/g"""
        for n, s in self.config._sections.items():
            if n.find('__') == 0:
                continue
            s2 = type(s)()
            for k, v in s.items():
                if k.find('__') != 0:
                    k = norm(k)
                s2[k] = v
            self.config._sections[n] = s2

    def __init__(self, path, peers, *dd):
        """
        - .path: location of config file
        - .config: underlying ConfigParser instance
        - .peers: on behalf of whom we flatten .config
          (master, or master-slave url pair)
        - .auxdicts: template subtituents
        """
        self.peers = peers
        self.path = path
        self.auxdicts = dd
        self.config = ConfigParser.RawConfigParser()
        self.config.read(path)
        self._normconfig()

    def section(self, rx=False):
        """get the section name of the section representing .peers in .config"""
        peers = self.peers
        if not peers:
            peers = ['.', '.']
            rx = True
        if rx:
            st = 'peersrx'
        else:
            st = 'peers'
        return ' '.join([st] + [escape(u) for u in peers])

    @staticmethod
    def parse_section(section):
        """retrieve peers sequence encoded by section name
           (as urls or regexen, depending on section type)
        """
        sl = section.split()
        st = sl.pop(0)
        sl = [unescape(u) for u in sl]
        if st == 'peersrx':
            sl = [re.compile(u) for u in sl]
        return sl

    def ord_sections(self):
        """Return an ordered list of sections.

        Ordering happens based on the auxiliary
        SECT_ORD section storing indices for each
        section added through the config API.

        To not to go corrupt in case of manually
        written config files, we take care to append
        also those sections which are not registered
        in SECT_ORD.

        Needed for python 2.{4,5,6} where ConfigParser
        cannot yet order sections/options internally.
        """
        so = {}
        if self.config.has_section(SECT_ORD):
            so = self.config._sections[SECT_ORD]
        so2 = {}
        for k, v in so.items():
            if k != '__name__':
                so2[k] = int(v)
        tv = 0
        if so2:
            tv = max(so2.values()) + 1
        ss = [s for s in self.config.sections() if s.find('__') != 0]
        for s in ss:
            if s in so.keys():
                continue
            so2[s] = tv
            tv += 1
        def scmp(x, y):
            return cmp(*(so2[s] for s in (x, y)))
        ss.sort(scmp)
        return ss

    def update_to(self, dct, allow_unresolved=False):
        """update @dct from key/values of ours.

        key/values are collected from .config by filtering the regexp sections
        according to match, and from .section. The values are treated as templates,
        which are substituted from .auxdicts and (in case of regexp sections)
        match groups.
        """
        if not self.peers:
            raise GsyncdError('no peers given, cannot select matching options')
        def update_from_sect(sect, mud):
            for k, v in self.config._sections[sect].items():
                if k == '__name__':
                    continue
                if allow_unresolved:
                    dct[k] = Template(v).safe_substitute(mud)
                else:
                    dct[k] = Template(v).substitute(mud)
        for sect in self.ord_sections():
            sp = self.parse_section(sect)
            if isinstance(sp[0], re_type) and len(sp) == len(self.peers):
                match = True
                mad = {}
                for i in range(len(sp)):
                    m = sp[i].search(self.peers[i])
                    if not m:
                        match = False
                        break
                    for j in range(len(m.groups())):
                        mad['match%d_%d' % (i+1, j+1)] = m.groups()[j]
                if match:
                    update_from_sect(sect, MultiDict(dct, mad, *self.auxdicts))
        if self.config.has_section(self.section()):
            update_from_sect(self.section(), MultiDict(dct, *self.auxdicts))

    def get(self, opt=None):
        """print the matching key/value pairs from .config,
           or if @opt given, the value for @opt (according to the
           logic described in .update_to)
        """
        d = {}
        self.update_to(d, allow_unresolved = True)
        if opt:
            opt = norm(opt)
            v = d.get(opt)
            if v:
                print(v)
        else:
            for k, v in d.iteritems():
                if k == '__name__':
                    continue
                print("%s: %s" % (k, v))

    def write(self, trfn, opt, *a, **kw):
        """update on-disk config transactionally

        @trfn is the transaction function
        """
        def mergeconf(f):
            self.config = ConfigParser.RawConfigParser()
            self.config.readfp(f)
            self._normconfig()
            if not self.config.has_section(SECT_META):
                self.config.add_section(SECT_META)
            self.config.set(SECT_META, 'version', config_version)
            return trfn(norm(opt), *a, **kw)
        def updateconf(f):
            self.config.write(f)
        update_file(self.path, updateconf, mergeconf)

    def _set(self, opt, val, rx=False):
        """set @opt to @val in .section"""
        sect = self.section(rx)
        if not self.config.has_section(sect):
            self.config.add_section(sect)
            # regarding SECT_ORD, cf. ord_sections
            if not self.config.has_section(SECT_ORD):
                self.config.add_section(SECT_ORD)
            self.config.set(SECT_ORD, sect, len(self.config._sections[SECT_ORD]))
        self.config.set(sect, opt, val)
        return True

    def set(self, opt, *a, **kw):
        """perform ._set transactionally"""
        self.write(self._set, opt, *a, **kw)

    def _delete(self, opt, rx=False):
        """delete @opt from .section"""
        sect = self.section(rx)
        if self.config.has_section(sect):
            return self.config.remove_option(sect, opt)

    def delete(self, opt, *a, **kw):
        """perform ._delete transactionally"""
        self.write(self._delete, opt, *a, **kw)