]> git.somenet.org - pub/jan/mattermost.git/blob - somebot/core/MMBot.py
[somebot] /ta-announce-all <text>
[pub/jan/mattermost.git] / somebot / core / MMBot.py
1 # Mattermost Bot.
2 #  Copyright (c) 2016-2020 by Someone <someone@somenet.org> (aka. Jan Vales <jan@jvales.net>)
3 #  published under MIT-License
4
5
6 import asyncio
7 import atexit
8 import json
9 import logging
10 import os
11 import pprint
12 import signal
13 import sys
14 import threading
15 import traceback
16 import urllib
17
18 from http.server import BaseHTTPRequestHandler, HTTPServer
19 from socketserver import ThreadingMixIn
20
21 import mattermost
22 import mattermost.ws
23
24
25 class MMBot():
26     def __init__(self, local_websrv_hostname="localhost", local_websrv_port=18065, api_user=None, api_user_pw=None, mm_api_url="http://localhost:8065/api", mm_ws_url="ws://localhost:8065/api/v4/websocket", debug_chan_id=None):
27         self.local_websrv_hostname = local_websrv_hostname
28         self.local_websrv_port = local_websrv_port
29         self.api_user = api_user
30         self.mm_api_url = mm_api_url
31         self.mm_ws_url = mm_ws_url
32
33         self.local_websrv_url = ("http://"+self.local_websrv_hostname+":"+str(self.local_websrv_port)+"/").strip("/")
34         self.modules = dict()
35         self.wsmodules = dict()
36         self.api = None
37         self.debug_chan_id = None
38         self.loop = asyncio.new_event_loop()
39         self.command_stats = dict()
40         self.admin_ids = []
41
42         self.mmws = None
43
44         atexit.register(self.shutdown)
45         signal.signal(signal.SIGUSR1, self.command_stats_dump)
46         signal.signal(signal.SIGTERM, self.sig_shutdown)
47         signal.signal(signal.SIGINT, self.sig_shutdown)
48
49
50         # Core-Command: /use-data
51         self.USETOPICS = {"bot":("##### 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.\n"
52                                  "Written by ``@someone`` in python. Big thanks to contributors: ``@ju``, ``@gittenburg``\n"
53                                  "Inspired by: ``@bearza``, ``@frunobulax``\n"
54                                  "\n"
55                                  "Feel like contributing too? Talk to ``@someone``. :)\n"
56                                  "The repository is here: https://git.somenet.org/pub/jan/mattermost.git")}
57
58         if api_user is not None and api_user_pw is not None:
59             logging.info("User credentials given. Trying to login.")
60             self.api = mattermost.MMApi(self.mm_api_url)
61             self.api.login(api_user, api_user_pw)
62             self.debug_chan_id = debug_chan_id
63
64
65     # Register a module with the bot.
66     def register(self, module):
67         if module.TEAM_ID not in self.modules:
68             self.modules[module.TEAM_ID] = dict()
69
70         if module.TRIGGER not in self.modules[module.TEAM_ID]:
71             self.modules[module.TEAM_ID][module.TRIGGER] = module
72             module._on_register(self)
73
74         else:
75             raise Exception("Multiple registration attempts for module: "+module.TRIGGER+" and team: "+module.TEAM_ID)
76
77
78     # Register a websocket handling module with the bot.
79     # There is no useful way to discriminate WS-events by originating teams atm. :(
80     def register_ws(self, module, eventlist):
81         for evtype in eventlist:
82             if evtype not in self.wsmodules:
83                 self.wsmodules[evtype] = dict()
84
85             if module.NAME not in self.wsmodules[evtype]:
86                 self.wsmodules[evtype][module.NAME] = module
87                 module._on_register_ws_evtype(self, evtype)
88
89             else:
90                 raise Exception("Multiple registration attempts for module: "+module.NAME+" and evtype: "+evtype)
91
92
93     def start(self):
94         logging.info("Starting: Almost there.")
95         logging.info(pprint.pformat(self.modules))
96         logging.info(pprint.pformat(self.wsmodules))
97
98         if self.mm_ws_url is not None:
99             self.mmws = mattermost.ws.MMws(self.websocket_handler, self.api, self.mm_ws_url)
100
101         if self.local_websrv_hostname is not None and self.local_websrv_port is not None:
102             self.start_webserver()
103
104
105     def shutdown(self):
106         logging.info("Shutting down ...")
107
108         self.mmws.close_websocket()
109         # todo: stop webserver + WS?
110
111         for team_modules in self.modules:
112             for module in self.modules[team_modules]:
113                 self.modules[team_modules][module]._on_shutdown()
114
115         for evtype in self.wsmodules:
116             for module in self.wsmodules[evtype]:
117                 self.wsmodules[evtype][module]._on_shutdown()
118
119         self.api.logout()
120         self.command_stats_dump()
121         logging.info("BYE.")
122
123
124
125     ########
126     # misc #
127     ########
128     def debug_chan(self, message):
129         if self.debug_chan_id is None:
130             logging.info("debug_chan() called, but debug_chan_id is unspecified.")
131             return
132
133         self.api.create_post(self.debug_chan_id, "``BOT-AUTODELETE-FAST``\n"+message)
134
135
136     def command_stats_inc(self, command, amount=1):
137         if command in self.command_stats:
138             self.command_stats[command] += amount
139         else:
140             self.command_stats[command] = amount
141
142
143     def sig_shutdown(self, unk1=None, unk2=None):
144         sys.exit(0)
145
146
147     def command_stats_dump(self, unk1=None, unk2=None):
148         self.command_stats_inc("internal::command_stats_dump")
149         stats = self.command_stats.copy()
150         self.command_stats = dict()
151
152         print("updating command stats: /tmp/somebot_command_stats.json", file=sys.stderr)
153         try:
154             with open("/tmp/somebot_command_stats.json", "r") as file:
155                 old_stats = json.load(file)
156             for item, cnt in old_stats.items():
157                 if item in stats:
158                     stats[item] += cnt
159                 else:
160                     stats[item] = cnt
161         except:
162             pass
163
164         with open("/tmp/somebot_command_stats.json", "w", encoding="utf-8") as file:
165             json.dump(stats, file, ensure_ascii=False, indent=2)
166
167
168     ##########################
169     # Bot's websocket client #
170     ##########################
171     def websocket_handler(self, mmws, event_data):
172         for evtype in self.wsmodules:
173             if evtype == event_data["event"]:
174                 for module_name in self.wsmodules[evtype]:
175                     try:
176                         print(module_name)
177                         if self.wsmodules[evtype][module_name].on_WS_EVENT(event_data):
178                             self.command_stats_inc("ws::"+evtype+"::"+module_name)
179                     except:
180                         exctxt = "".join(traceback.format_exc())
181                         logging.error(exctxt)
182
183
184     ###################
185     # Bot's webserver #
186     ###################
187     def start_webserver(self):
188         logging.info("Starting webserver.")
189
190         class RequestHandler(BaseHTTPRequestHandler):
191             bot = None
192
193             def do_POST(self):
194                 self.handled = False
195
196                 if self.headers["Content-Type"] == "application/x-www-form-urlencoded":
197                     data = urllib.parse.parse_qs(self.rfile.read(int(self.headers["Content-Length"])).decode("utf-8"), keep_blank_values=True)
198                     # only accept first occurence
199                     data = dict([(k, v[0]) for k, v in data.items()])
200                 elif self.headers["Content-Type"] == "application/json":
201                     data = json.loads(self.rfile.read(int(self.headers["Content-Length"])).decode("utf-8"))
202                 else:
203                     self.respond(415)
204                     return
205
206                 splitpath = self.path.strip("/").split("/")
207                 if self.bot.modules[splitpath[0]] and self.bot.modules[splitpath[0]][splitpath[1]]:
208                     module = self.bot.modules[splitpath[0]][splitpath[1]]
209
210                     # /command
211                     if len(splitpath) > 2 and splitpath[2] == "command":
212                         if "token" in data and module.mm_secret_token == data["token"]:
213                             self.bot.command_stats_inc("/"+splitpath[1]+"/"+splitpath[2])
214                             module._on_POST(self, data)
215                         else:
216                             logging.warning("mm_secret_token mismatch expected/got -"+module.mm_secret_token+"-"+data["token"]+"-")
217                             self.respond(403)
218
219                     # interactive button-handler. TODO auth!
220                     elif len(splitpath) > 2 and splitpath[2] == "interactive":
221                         self.bot.command_stats_inc("/"+splitpath[1]+"/"+splitpath[2])
222                         module._on_POST_interactive(self, data)
223
224                     # dialog-handler: TODO: auth!
225                     elif len(splitpath) > 2 and splitpath[2] == "dialog":
226                         self.bot.command_stats_inc("/"+splitpath[1]+"/"+splitpath[2])
227                         module._on_POST_dialog(self, data)
228
229                     else: #something weird.
230                         self.bot.command_stats_inc("/"+splitpath[1]+' --- SOMETHINGS WEIRD!!!')
231
232                 # always try to fail. If previously responded to, nothing will happen.
233                 self.respond(400)
234
235
236             def cmd_respond_text_temp(self, message, props=None):
237                 if props is None:
238                     self.respond(200, {"skip_slack_parsing":True, "response_type":"ephemeral", "text":message})
239                 else:
240                     self.respond(200, {"skip_slack_parsing":True, "response_type":"ephemeral", "text":message, "props":props})
241
242
243             def cmd_respond_text_chan(self, message, props=None):
244                 if props is None:
245                     self.respond(200, {"skip_slack_parsing":True, "response_type":"in_channel", "text":message})
246                 else:
247                     self.respond(200, {"skip_slack_parsing":True, "response_type":"in_channel", "text":message, "props":props})
248
249
250             def respond(self, err, message=None):
251                 if self.handled:
252                     return
253
254                 self.handled = True
255                 self.send_response(err)
256                 self.send_header("Content-Type", "application/json")
257                 self.end_headers()
258                 if message is not None:
259                     self.wfile.write(bytes(json.dumps(message), "utf8"))
260
261
262         class MyHTTPServer(ThreadingMixIn, HTTPServer):
263             def serve_forever(self, bot):
264                 self.RequestHandlerClass.bot = bot
265                 HTTPServer.serve_forever(self)
266
267         self.httpd = MyHTTPServer((self.local_websrv_hostname, self.local_websrv_port), RequestHandler)
268         self.httpd.serve_forever(self)