83dfe2eb17304ba53317dc99901d0a8e79507bf1
[csit.git] / resources / tools / presentation / generator_alerts.py
1 # Copyright (c) 2019 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
5 #
6 #     http://www.apache.org/licenses/LICENSE-2.0
7 #
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
13
14 import smtplib
15 import logging
16
17 from email.mime.text import MIMEText
18 from email.mime.multipart import MIMEMultipart
19 from os.path import isdir
20
21 from utils import execute_command
22 from errors import PresentationError
23
24
25 class AlertingError(PresentationError):
26     """Exception(s) raised by the alerting module.
27
28     When raising this exception, put this information to the message in this
29     order:
30      - short description of the encountered problem (parameter msg),
31      - relevant messages if there are any collected, e.g., from caught
32        exception (optional parameter details),
33      - relevant data if there are any collected (optional parameter details).
34     """
35
36     def __init__(self, msg, details='', level="CRITICAL"):
37         """Sets the exception message and the level.
38
39         :param msg: Short description of the encountered problem.
40         :param details: Relevant messages if there are any collected, e.g.,
41             from caught exception (optional parameter details), or relevant data
42             if there are any collected (optional parameter details).
43         :param level: Level of the error, possible choices are: "DEBUG", "INFO",
44             "WARNING", "ERROR" and "CRITICAL".
45         :type msg: str
46         :type details: str
47         :type level: str
48         """
49
50         super(AlertingError, self).__init__(
51             "Alerting: {0}".format(msg), details, level)
52
53     def __repr__(self):
54         return (
55             "AlertingError(msg={msg!r},details={dets!r},level={level!r})".
56             format(msg=self._msg, dets=self._details, level=self._level))
57
58
59 class Alerting(object):
60     """Class implementing the alerting mechanism.
61     """
62
63     def __init__(self, spec):
64         """Initialization.
65
66         :param spec: The CPTA specification.
67         :type spec: Specification
68         """
69
70         # Implemented alerts:
71         self._ALERTS = ("failed-tests", )
72
73         try:
74             self._spec = spec.alerting
75         except KeyError as err:
76             raise  AlertingError("Alerting is not configured, skipped.",
77                                  repr(err),
78                                  "WARNING")
79
80         self._path_failed_tests = spec.environment["paths"]["DIR[STATIC,VPP]"]
81
82         # Verify and validate input specification:
83         self.configs = self._spec.get("configurations", None)
84         if not self.configs:
85             raise AlertingError("No alert configuration is specified.")
86         for config_type, config_data in self.configs.iteritems():
87             if config_type == "email":
88                 if not config_data.get("server", None):
89                     raise AlertingError("Parameter 'server' is missing.")
90                 if not config_data.get("address-to", None):
91                     raise AlertingError("Parameter 'address-to' (recipient) is "
92                                         "missing.")
93                 if not config_data.get("address-from", None):
94                     raise AlertingError("Parameter 'address-from' (sender) is "
95                                         "missing.")
96             elif config_type == "jenkins":
97                 if not isdir(config_data.get("output-dir", "")):
98                     raise AlertingError("Parameter 'output-dir' is "
99                                         "missing or it is not a directory.")
100                 if not config_data.get("output-file", None):
101                     raise AlertingError("Parameter 'output-file' is missing.")
102             else:
103                 raise AlertingError("Alert of type '{0}' is not implemented.".
104                                     format(config_type))
105
106         self.alerts = self._spec.get("alerts", None)
107         if not self.alerts:
108             raise AlertingError("No alert is specified.")
109         for alert, alert_data in self.alerts.iteritems():
110             if not alert_data.get("title", None):
111                 raise AlertingError("Parameter 'title' is missing.")
112             if not alert_data.get("type", None) in self._ALERTS:
113                 raise AlertingError("Parameter 'failed-tests' is missing or "
114                                     "incorrect.")
115             if not alert_data.get("way", None) in self.configs.keys():
116                 raise AlertingError("Parameter 'way' is missing or incorrect.")
117             if not alert_data.get("include", None):
118                 raise AlertingError("Parameter 'include' is missing or the "
119                                     "list is empty.")
120
121     def __str__(self):
122         """Return string with human readable description of the alert.
123
124         :returns: Readable description.
125         :rtype: str
126         """
127         return "configs={configs}, alerts={alerts}".format(
128             configs=self.configs, alerts=self.alerts)
129
130     def __repr__(self):
131         """Return string executable as Python constructor call.
132
133         :returns: Executable constructor call.
134         :rtype: str
135         """
136         return "Alerting(spec={spec})".format(
137             spec=self._spec)
138
139     def generate_alerts(self):
140         """Generate alert(s) using specified way(s).
141         """
142
143         for alert, alert_data in self.alerts.iteritems():
144             if alert_data["way"] == "email":
145                 text, html = self._create_alert_message(alert_data)
146                 conf = self.configs["email"]
147                 self._send_email(server=conf["server"],
148                                  addr_from=conf["address-from"],
149                                  addr_to=conf["address-to"],
150                                  subject=alert_data["title"],
151                                  text=text,
152                                  html=html)
153             elif alert_data["way"] == "jenkins":
154                 self._generate_files_for_jenkins(alert_data)
155             else:
156                 raise AlertingError("Alert with way '{0}' is not implemented.".
157                                     format(alert_data["way"]))
158
159     @staticmethod
160     def _send_email(server, addr_from, addr_to, subject, text=None, html=None):
161         """Send an email using predefined configuration.
162
163         :param server: SMTP server used to send email.
164         :param addr_from: Sender address.
165         :param addr_to: Recipient address(es).
166         :param subject: Subject of the email.
167         :param text: Message in the ASCII text format.
168         :param html: Message in the HTML format.
169         :type server: str
170         :type addr_from: str
171         :type addr_to: list
172         :type subject: str
173         :type text: str
174         :type html: str
175         """
176
177         if not text and not html:
178             raise AlertingError("No text/data to send.")
179
180         msg = MIMEMultipart('alternative')
181         msg['Subject'] = subject
182         msg['From'] = addr_from
183         msg['To'] = ", ".join(addr_to)
184
185         if text:
186             msg.attach(MIMEText(text, 'plain'))
187         if html:
188             msg.attach(MIMEText(html, 'html'))
189
190         smtp_server = None
191         try:
192             logging.info("Trying to send alert '{0}' ...".format(subject))
193             logging.debug("SMTP Server: {0}".format(server))
194             logging.debug("From: {0}".format(addr_from))
195             logging.debug("To: {0}".format(", ".join(addr_to)))
196             logging.debug("Message: {0}".format(msg.as_string()))
197             smtp_server = smtplib.SMTP(server)
198             smtp_server.sendmail(addr_from, addr_to, msg.as_string())
199         except smtplib.SMTPException as err:
200             raise AlertingError("Not possible to send the alert via email.",
201                                 str(err))
202         finally:
203             if smtp_server:
204                 smtp_server.quit()
205
206     def _create_alert_message(self, alert):
207         """Create the message which is used in the generated alert.
208
209         :param alert: Message is created for this alert.
210         :type alert: dict
211         :returns: Message in the ASCII text and HTML format.
212         :rtype: tuple(str, str)
213         """
214
215         if alert["type"] == "failed-tests":
216             text = ""
217             html = "<html><body>"
218             for item in alert["include"]:
219                 file_name = "{path}/{name}".format(
220                     path=self._path_failed_tests, name=item)
221                 try:
222                     with open("{0}.txt".format(file_name), 'r') as txt_file:
223                         text += "{0}:\n\n".format(
224                             item.replace("failed-tests-", ""))
225                         text += txt_file.read() + "\n" * 2
226                 except IOError:
227                     logging.error("Not possible to read the file '{0}.txt'.".
228                                   format(file_name))
229                 try:
230                     with open("{0}.rst".format(file_name), 'r') as rst_file:
231                         html += "<h2>{0}:</h2>".format(
232                             item.replace("failed-tests-", ""))
233                         html += rst_file.readlines()[2].\
234                             replace("../trending", alert.get("url", ""))
235                         html += "<br>" * 3
236                 except IOError:
237                     logging.error("Not possible to read the file '{0}.rst'.".
238                                   format(file_name))
239             html += "</body></html>"
240         else:
241             raise AlertingError("Alert of type '{0}' is not implemented.".
242                                 format(alert["type"]))
243         return text, html
244
245     def _generate_files_for_jenkins(self, alert):
246         """Create the file which is used in the generated alert.
247
248         :param alert: Files are created for this alert.
249         :type alert: dict
250         """
251
252         config = self.configs[alert["way"]]
253
254         if alert["type"] == "failed-tests":
255             text, html = self._create_alert_message(alert)
256             file_name = "{0}/{1}".format(config["output-dir"],
257                                          config["output-file"])
258             logging.info("Writing the file '{0}.txt' ...".format(file_name))
259             try:
260                 with open("{0}.txt".format(file_name), 'w') as txt_file:
261                     txt_file.write(text)
262             except IOError:
263                 logging.error("Not possible to write the file '{0}.txt'.".
264                               format(file_name))
265             logging.info("Writing the file '{0}.html' ...".format(file_name))
266             try:
267                 with open("{0}.html".format(file_name), 'w') as html_file:
268                     html_file.write(html)
269             except IOError:
270                 logging.error("Not possible to write the file '{0}.html'.".
271                               format(file_name))
272
273             zip_file = config.get("zip-output", None)
274             if zip_file:
275                 logging.info("Writing the file '{0}/{1}' ...".
276                              format(config["output-dir"], zip_file))
277                 execute_command("tar czvf {dir}/{zip} --directory={dir} "
278                                 "{input}.txt {input}.html".
279                                 format(dir=config["output-dir"],
280                                        zip=zip_file,
281                                        input=config["output-file"]))
282         else:
283             raise AlertingError("Alert of type '{0}' is not implemented.".
284                                 format(alert["type"]))

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.