summaryrefslogtreecommitdiffstats
path: root/src/lib/Bcfg2/Server/Plugins/TemplateHelper.py
blob: b0b8d006118e52296ce60b74b1c4ae9888f62f25 (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
""" A plugin to provide helper classes and functions to templates """

import re
import imp
import sys
import lxml.etree
from Bcfg2.Server.Plugin import Plugin, Connector, DirectoryBacked, \
    TemplateDataProvider, DefaultTemplateDataProvider
from Bcfg2.Logger import Debuggable
from Bcfg2.Utils import safe_module_name

MODULE_RE = re.compile(r'(?P<filename>(?P<module>[^\/]+)\.py)$')


class HelperModule(Debuggable):
    """ Representation of a TemplateHelper module """

    def __init__(self, name):
        Debuggable.__init__(self)
        self.name = name

        #: The name of the module as used by get_additional_data().
        #: the name of the file with .py stripped off.
        self._module_name = MODULE_RE.search(self.name).group('module')

        #: The attributes exported by this module
        self._attrs = []

        #: The attributes added to the template namespace by this module
        self.defaults = []

        default_prov = DefaultTemplateDataProvider()
        self.reserved_defaults = default_prov.get_template_data(
            lxml.etree.Element("Path", name="/dummy"),
            None, None).keys() + ["path"]

    def HandleEvent(self, event=None):
        """ HandleEvent is called whenever the FAM registers an event.

        :param event: The event object
        :type event: Bcfg2.Server.FileMonitor.Event
        :returns: None
        """
        if event and event.code2str() not in ['exists', 'changed', 'created']:
            return

        try:
            module = imp.load_source(
                safe_module_name('TemplateHelper', self._module_name),
                self.name)
        except:  # pylint: disable=W0702
            # this needs to be a blanket except because the
            # imp.load_source() call can raise literally any error,
            # since it imports the module and just passes through any
            # exceptions raised.
            err = sys.exc_info()[1]
            self.logger.error("TemplateHelper: Failed to import %s: %s" %
                              (self.name, err))
            return

        if not hasattr(module, "__export__"):
            self.logger.error("TemplateHelper: %s has no __export__ list" %
                              self.name)
            return

        newattrs = []
        for sym in module.__export__ + getattr(module, "__default__", []):
            if sym in newattrs:
                # already added to attribute list
                continue
            if sym not in self._attrs and hasattr(self, sym):
                self.logger.warning(
                    "TemplateHelper: %s: %s is a reserved keyword, "
                    "skipping export" % (self.name, sym))
                continue
            try:
                setattr(self, sym, getattr(module, sym))
                newattrs.append(sym)
            except AttributeError:
                self.logger.warning(
                    "TemplateHelper: %s exports %s, but has no such attribute"
                    % (self.name, sym))

        # remove old exports
        for sym in set(self._attrs) - set(newattrs):
            delattr(self, sym)

        self._attrs = newattrs

        self.defaults = []
        for sym in getattr(module, "__default__", []):
            if sym in self.reserved_defaults:
                self.logger.warning(
                    "TemplateHelper: %s: %s is a reserved keyword, not adding "
                    "as default" % (self.name, sym))
            self.defaults.append(sym)


class TemplateHelper(Plugin, Connector, DirectoryBacked, TemplateDataProvider):
    """ A plugin to provide helper classes and functions to templates """
    __author__ = 'chris.a.st.pierre@gmail.com'
    ignore = re.compile(r'^(\.#.*|.*~|\..*\.(sw[px])|.*\.py[co])$')
    patterns = MODULE_RE
    __child__ = HelperModule

    def __init__(self, core):
        Plugin.__init__(self, core)
        Connector.__init__(self)
        DirectoryBacked.__init__(self, self.data)
        TemplateDataProvider.__init__(self)

    def get_additional_data(self, _):
        return dict([(h._module_name, h)  # pylint: disable=W0212
                     for h in self.entries.values()])

    def get_template_data(self, *_):
        rv = dict()
        source = dict()
        for helper in self.entries.values():
            for key in helper.defaults:
                if key not in rv:
                    rv[key] = getattr(helper, key)
                    source[key] = helper
                else:
                    self.logger.warning(
                        "TemplateHelper: Duplicate default variable %s "
                        "provided by both %s and %s" %
                        (key, helper.name, source[key].name))
        return rv