]> git.somenet.org - pub/jan/mattermost-bot.git/blob - core/MMBot.py
core/CoreCommandUse.py
[pub/jan/mattermost-bot.git] / core / MMBot.py
1 # Mattermost Bot.
2 #  Copyright (c) 2016-2021 by Someone <someone@somenet.org> (aka. Jan Vales <jan@jvales.net>)
3 #  published under MIT-License
4
5 import atexit
6 import json
7 import logging
8 import os
9 import pprint
10 import signal
11 import sys
12 import threading
13 import traceback
14 import urllib
15
16 from inspect import cleandoc
17 from http.server import BaseHTTPRequestHandler, HTTPServer
18 from urllib.request import Request, urlopen
19 from socketserver import ThreadingMixIn
20
21 import mattermost
22 import mattermost.ws
23
24
25 logger = logging.getLogger(__name__)
26
27
28 class MMBot():
29     def __init__(self, local_websrv_hostname="localhost", local_websrv_port=18065, api_user=None, api_user_pw=None, api_bearer=None, mm_api_url="http://localhost:8065/api", mm_ws_url="ws://localhost:8065/api/v4/websocket", debug_chan_id=None):
30         self.local_websrv_hostname = local_websrv_hostname
31         self.local_websrv_port = local_websrv_port
32         self.api_user = api_user
33         self.mm_api_url = mm_api_url
34         self.mm_ws_url = mm_ws_url
35
36         self.local_websrv_url = ("http://"+self.local_websrv_hostname+":"+str(self.local_websrv_port)+"/").strip("/")
37         self.modules = {}
38         self.wsmodules = {}
39         self.api = None
40         self.debug_chan_id = debug_chan_id
41         self.command_stats = {}
42         self.admin_ids = []
43
44         self.mmws = None
45         self.sigusr1_cnt = 0
46
47         atexit.register(self.on_shutdown)
48         signal.signal(signal.SIGUSR1, self.on_SIGUSR1)
49         signal.signal(signal.SIGTERM, self.shutdown)
50         signal.signal(signal.SIGINT, self.shutdown)
51
52         # monkey-patch thread naming
53         try:
54             import pyprctl
55             def _rename_current_thread(self, name, thread):
56                 if thread == threading.current_thread():
57                     thread.setName(name)
58                     pyprctl.set_name(name)
59
60             def _bootstrap_named_thread(self):
61                 self.rename_current_thread(self._name, threading.current_thread())
62                 self.original_bootstrap()
63
64             threading.Thread.original_bootstrap = threading.Thread._bootstrap
65             threading.Thread._bootstrap = _bootstrap_named_thread
66
67         except ImportError:
68             logger.error('pyprctl module is not installed. You will not be able to see thread names')
69             def _rename_current_thread(self, name, thread):
70                 if thread == threading.current_thread():
71                     thread.setName(name)
72
73         threading.Thread.rename_current_thread = _rename_current_thread
74
75
76         # Core-Command: /use-data
77         self.USETOPICS = {"bot":cleandoc("""##### Here I am, brain the size of a planet, and they ask me to fill in some missing MM-features and be fun ... It gives me a headache.
78                                  Written by **``@someone``** in python3. Big thanks to contributors: **``@ju``**, **``@gittenburg``**
79                                  Inspiring ideas by: ``@bearza``, ``@frunobulax``, **``@x5468656f``**
80
81                                  Feel like contributing too? Talk to **``@someone``**. :)
82                                  The repository is here: https://git.somenet.org/pub/jan/mattermost-bot.git
83                                  """)}
84
85         if api_user is not None and api_user_pw is not None:
86             logger.info("User credentials given. Trying to login.")
87             self.api = mattermost.MMApi(self.mm_api_url)
88             self.api.login(api_user, api_user_pw)
89         elif api_user is not None:
90             self.api = mattermost.MMApi(self.mm_api_url)
91             self.api.login(bearer=api_bearer)
92
93
94
95     # Register a module with the bot.
96     def register(self, module):
97         if module.TEAM_ID not in self.modules:
98             self.modules[module.TEAM_ID] = {}
99
100         if module.TRIGGER not in self.modules[module.TEAM_ID]:
101             self.modules[module.TEAM_ID][module.TRIGGER] = module
102             module._on_register(self)
103
104         else:
105             raise Exception("Multiple registration attempts for module: "+module.TRIGGER+" and team: "+module.TEAM_ID)
106
107
108
109     # Register a websocket handling module with the bot.
110     # There is no useful way to discriminate WS-events by originating teams atm. :(
111     def register_ws(self, module, eventlist):
112         for evtype in eventlist:
113             if evtype not in self.wsmodules:
114                 self.wsmodules[evtype] = {}
115
116             if module.NAME not in self.wsmodules[evtype]:
117                 self.wsmodules[evtype][module.NAME] = module
118                 module._on_register_ws_evtype(self, evtype)
119
120             else:
121                 raise Exception("Multiple registration attempts for module: "+module.NAME+" and evtype: "+evtype)
122
123
124
125     def start(self):
126         logger.info("Starting: Almost there.")
127         logger.info(pprint.pformat(self.modules))
128         logger.info(pprint.pformat(self.wsmodules))
129
130         if self.mm_ws_url is not None:
131             self.mmws = mattermost.ws.MMws(self.websocket_handler, self.api, self.mm_ws_url)
132
133         if self.local_websrv_hostname is not None and self.local_websrv_port is not None:
134             self.start_webserver()
135
136
137
138     def on_shutdown(self):
139         logger.info("Shutting down ...")
140
141         if self.mmws:
142             self.mmws.close_websocket()
143
144         for team_modules in self.modules:
145             for module in self.modules[team_modules]:
146                 self.modules[team_modules][module]._on_shutdown()
147
148         for evtype in self.wsmodules:
149             for module in self.wsmodules[evtype]:
150                 self.wsmodules[evtype][module]._on_shutdown()
151
152         self.api.logout()
153         self.command_stats_dump()
154         logger.info("BYE.")
155
156
157
158     ########
159     # misc #
160     ########
161     def shutdown(self, unk1=None, unk2=None, exit_code=0):
162         sys.exit(exit_code)
163
164
165     def on_SIGUSR1(self, unk1=None, unk2=None):
166         logger.info("on_SIGUSR1()")
167         self.sigusr1_cnt += 1
168         self.command_stats_inc("internal::SIGUSR1")
169         self.command_stats_dump()
170
171         for team_modules in self.modules:
172             for module in self.modules[team_modules]:
173                 self.modules[team_modules][module]._on_SIGUSR1(self.sigusr1_cnt)
174
175         for evtype in self.wsmodules:
176             for module in self.wsmodules[evtype]:
177                 self.wsmodules[evtype][module]._on_SIGUSR1(self.sigusr1_cnt)
178
179
180
181     def debug_chan(self, message):
182         if self.debug_chan_id is None:
183             logger.error("debug_chan() called, but debug_chan_id is unspecified.")
184             return
185         self.api.create_post(self.debug_chan_id, "``AUTODELETE-DAY``\n"+message)
186
187
188
189     def command_stats_inc(self, command, amount=1):
190         if command in self.command_stats:
191             self.command_stats[command] += amount
192         else:
193             self.command_stats[command] = amount
194
195
196
197     def command_stats_dump(self):
198         self.dump_stats_json(self.command_stats, "/tmp/somebot_command_stats.json", "#command_usage #mmstats")
199         self.command_stats = {}
200
201
202
203     def dump_stats_json(self, stats_data, file_path, header="", footer="", no_data_text=""):
204         do_write = False
205         if stats_data:
206             do_write = True
207
208         try:
209             with open(file_path, "r") as file:
210                 old_stats = json.load(file)
211             for item, cnt in old_stats["data"].items():
212                 if item in stats_data:
213                     stats_data[item] += cnt
214                 else:
215                     stats_data[item] = cnt
216         except (FileNotFoundError, json.JSONDecodeError, KeyError):
217             do_write = True
218
219         # if no data, but file exists: skip write
220         if not do_write and "header" in old_stats and "footer" in old_stats and "no_data_text" in old_stats and old_stats["header"] == header and old_stats["footer"] == footer and old_stats["no_data_text"] == no_data_text:
221             return
222
223         logger.info("dump_stats_json(): writing file: %s", file_path)
224         self.command_stats_inc("internal::dump_stats_json:"+file_path)
225
226         with open(file_path, "w", encoding="utf-8") as file:
227             json.dump({"header":header, "footer":footer, "no_data_text":no_data_text, "data":dict(sorted(stats_data.items()))}, file, ensure_ascii=False, indent=2)
228
229
230
231     ##########################
232     # Bot's websocket client #
233     ##########################
234     def websocket_handler(self, mmws, event_data):
235         for evtype in self.wsmodules:
236             if evtype == event_data["event"]:
237                 for module_name in self.wsmodules[evtype]:
238                     try:
239                         if self.wsmodules[evtype][module_name].on_WS_EVENT(event_data):
240                             self.command_stats_inc("ws::"+evtype+"::"+module_name)
241                     except Exception:
242                         exctxt = "".join(traceback.format_exc())
243                         logger.error(exctxt)
244
245
246
247     ###################
248     # Bot's webserver #
249     ###################
250     def start_webserver(self):
251         logger.info("Starting webserver.")
252
253         class HTTPRequestHandler(BaseHTTPRequestHandler):
254             bot = None
255             handled = False
256             responseURL = None
257
258             def do_POST(self):
259                 threading.current_thread().rename_current_thread("HTTPRequestHandler", threading.current_thread())
260                 self.handled = False
261
262                 if self.headers["Content-Type"] == "application/x-www-form-urlencoded":
263                     data = urllib.parse.parse_qs(self.rfile.read(int(self.headers["Content-Length"])).decode("utf-8"), keep_blank_values=True)
264                     # only accept first occurence
265                     data = {k: v[0] for k, v in data.items()}
266
267                 elif self.headers["Content-Type"] == "application/json":
268                     data = json.loads(self.rfile.read(int(self.headers["Content-Length"])).decode("utf-8"))
269
270                 else:
271                     self.respond(415)
272                     return
273
274
275                 # store responseURL
276                 if "response_url" in data:
277                     self.responseURL = data["response_url"]
278
279
280                 # handle call
281                 logger.debug("do_POST(): request incomming.")
282                 try:
283                     module = 'not yet known'
284                     splitpath = self.path.strip("/").split("/")
285                     if splitpath[0] in self.bot.modules and splitpath[1] in self.bot.modules[splitpath[0]]:
286                         module = self.bot.modules[splitpath[0]][splitpath[1]]
287
288                         # /command
289                         if len(splitpath) > 2 and splitpath[2] == "command":
290                             if "token" in data and module.mm_secret_token == data["token"]:
291                                 self.bot.command_stats_inc("/"+splitpath[1]+"/"+splitpath[2])
292                                 module._on_POST(self, data)
293
294                             else:
295                                 logger.error("do_POST(): Auth problem: Shutting down: mm_secret_token mismatch expected/got -%s-%s-", module.mm_secret_token, data["token"])
296                                 traceback.print_stack()
297                                 self.respond(403)
298                                 self.bot.on_shutdown()
299                                 os._exit(1)
300
301                         # interactive button-handler. TODO auth!
302                         elif len(splitpath) > 2 and splitpath[2] == "interactive":
303                             self.bot.command_stats_inc("/"+splitpath[1]+"/"+splitpath[2])
304                             module._on_POST_interactive(self, data)
305
306                         # dialog-handler: TODO: auth!
307                         elif len(splitpath) > 2 and splitpath[2] == "dialog":
308                             self.bot.command_stats_inc("/"+splitpath[1]+"/"+splitpath[2])
309                             module._on_POST_dialog(self, data)
310
311                         else: # Invalid command action
312                             logger.error("do_POST(): Invalid command action.")
313                             self.bot.debug_chan("do_POST(): Invalid command action.\n# :boom::boom::boom::boom::boom:\n```\n"+self.path+"\n```")
314                             self.respond_cmd_err("Invalid command action")
315
316                     else: # Invalid command/unknown command
317                         logger.error("do_POST(): Invalid command/unknown command.")
318                         self.bot.debug_chan("do_POST(): Invalid command/unknown command.\n# :boom::boom::boom::boom::boom:\n```\n"+self.path+"\n```")
319                         self.respond_cmd_err("Invalid command/unknown command")
320
321                 except:
322                     self.bot.debug_chan("##### Error in module: ``"+repr(module)+"``\n# :boom::boom::boom::boom::boom:\n```\n"+traceback.format_exc()+"\n```")
323
324                 # always try to fail to retain userinput. If previously responded to, nothing will happen.
325                 self.respond(400, if_nonzero_secondary='ignore')
326
327
328
329             # Send a response to the channel.
330             def respond_cmd_chan(self, message, props=None, att=None, http_code=200):
331                 data = {"skip_slack_parsing":True, "response_type":"in_channel", "text":message}
332
333                 if props:
334                     data.update({"props": props})
335
336                 if att:
337                     data.update({"attachments": att})
338
339                 self.respond(http_code, data)
340
341
342
343             # Send a ephemeral response to the user.
344             def respond_cmd_temp(self, message, props=None, att=None, http_code=200):
345                 data = {"skip_slack_parsing":True, "response_type":"ephemeral", "text":message}
346
347                 if props:
348                     data.update({"props": props})
349
350                 if att:
351                     data.update({"attachments": att})
352
353                 self.respond(http_code, data)
354
355
356             def respond_interactive_temp(self, message, http_code=200):
357                 # cant be secondary, because no response url (interactive messages only?)
358                 self.respond(http_code, {"ephemeral_text":message})
359
360
361
362             # Use to send a failure to the user. Use only the first time during a request. Should retain input on clientside.
363             def respond_cmd_err(self, message, props=None):
364                 data = {"skip_slack_parsing":True, "response_type":"ephemeral", "text": "## :x: Failure! :(\n### "+message}
365
366                 if props:
367                     data.update({"props": props})
368
369                 # must be 2 separatecalls, as the message is ignored in a non-200.
370                 self.respond(400)
371                 self.respond(000, data)
372
373
374
375             def respond(self, http_code=200, data=None, if_nonzero_secondary='exc'):
376                 """
377                     First response call must have a valid http code.
378                     Secondary responses should have http_code = 0.
379                       use if_nonzero_secondary = 'ignore' to ignore response with http_code != 0.
380                       use if_nonzero_secondary = 'force' to send secondary with http_code != 0.
381                 """
382
383                 if data is None:
384                     data = {}
385
386                 # First response
387                 if not self.handled:
388                     if http_code >= 600 or http_code < 100:
389                         raise Exception("respond(): Primary response must have a valid http code.")
390
391                     self.handled = True
392                     self.send_response(http_code)
393                     self.send_header("Content-Type", "application/json")
394                     self.send_header("Content-Length", len(bytes(json.dumps(data), "utf8")))
395                     self.end_headers()
396                     self.wfile.write(bytes(json.dumps(data), "utf8"))
397                     logger.debug("respond(): Primary response send.")
398
399
400                 # Secondary responses
401                 else:
402                     if http_code != 0 and if_nonzero_secondary == "ignore":
403                         logger.info("respond(): Secondary responses must have a zero http code, but if_nonzero_secondary='ignore'. Doing nothing.")
404                         return
405
406                     elif http_code != 0 and if_nonzero_secondary == "force":
407                         logger.warning("respond(): Secondary responses must have a zero http code, but if_nonzero_secondary='force'. Sending anyway.")
408                         traceback.print_stack()
409
410                     elif http_code != 0:
411                         raise Exception("respond(): Secondary responses must have a zero http code.")
412
413
414                     if not self.responseURL:
415                         raise Exception("respond(): Secondary response attempt without response url.")
416
417
418                     logger.debug("respond(): Secondary response. Using responseURL: %s", self.responseURL)
419                     req = Request(self.responseURL, data=bytes(json.dumps(data), "utf8"), method='POST')
420                     req.add_header("Content-Type", "application/json")
421                     conn = urlopen(req, timeout=3)
422                     logger.debug("respond(): Secondary response send. Status: %s", conn.status)
423
424
425
426         class MyHTTPServer(ThreadingMixIn, HTTPServer):
427             def serve_forever(self, bot):
428                 self.RequestHandlerClass.bot = bot
429                 HTTPServer.serve_forever(self)
430
431         self.httpd = MyHTTPServer((self.local_websrv_hostname, self.local_websrv_port), HTTPRequestHandler)
432         threading.current_thread().rename_current_thread("HTTPServer", threading.current_thread())
433         self.httpd.serve_forever(self)