322 lines
8.8 KiB
Python
Executable File
322 lines
8.8 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""Notify of drone.io CI pipeline results on Matrix chat.
|
|
|
|
Requires:
|
|
|
|
* <https://pypi.org/project/matrix-nio>
|
|
* Optional: <https://pypi.org/project/bleach/>
|
|
* Optional: <https://pypi.org/project/Jinja2/>
|
|
* Optional: <https://pypi.org/project/markdown/>
|
|
|
|
"""
|
|
|
|
import argparse
|
|
import asyncio
|
|
import fnmatch
|
|
import json
|
|
import logging
|
|
import os
|
|
import sys
|
|
from distutils.util import strtobool
|
|
from os.path import exists
|
|
from string import Template
|
|
|
|
from nio import AsyncClient, LoginResponse
|
|
|
|
PROG = "matrixchat-notify"
|
|
CONFIG_FILENAME = f"{PROG}-config.json"
|
|
DEFAULT_ALLOWED_ATTRS = {
|
|
"*": ["class"],
|
|
"a": ["href", "title"],
|
|
"abbr": ["title"],
|
|
"acronym": ["title"],
|
|
"img": ["alt", "src"],
|
|
}
|
|
DEFAULT_ALLOWED_TAGS = {
|
|
"a",
|
|
"abbr",
|
|
"acronym",
|
|
"b",
|
|
"blockquote",
|
|
"code",
|
|
"dd",
|
|
"div",
|
|
"dl",
|
|
"dt",
|
|
"em",
|
|
"h1",
|
|
"h2",
|
|
"h3",
|
|
"h4",
|
|
"h5",
|
|
"h6",
|
|
"i",
|
|
"li",
|
|
"ol",
|
|
"p",
|
|
"span",
|
|
"strong",
|
|
"table",
|
|
"td",
|
|
"th",
|
|
"thead",
|
|
"tr",
|
|
"ul",
|
|
}
|
|
DEFAULT_HOMESERVER = "https://matrix.org"
|
|
DEFAULT_MARKDOWN_EXTENSIONS = "admonition, extra, sane_lists, smarty"
|
|
DEFAULT_PASS_ENVIRONMENT = ["DRONE_*"]
|
|
DEFAULT_TEMPLATE = "${DRONE_BUILD_STATUS}"
|
|
SETTINGS_KEYS = (
|
|
"allowed_tags",
|
|
"allowed_attrs",
|
|
"accesstoken",
|
|
"deviceid",
|
|
"devicename",
|
|
"homeserver",
|
|
"jinja",
|
|
"markdown",
|
|
"markdown_extensions",
|
|
"pass_environment",
|
|
"password",
|
|
"roomid",
|
|
"template",
|
|
"userid",
|
|
)
|
|
log = logging.getLogger(PROG)
|
|
|
|
|
|
def tobool(s):
|
|
try:
|
|
return strtobool(str(s))
|
|
except ValueError:
|
|
return False
|
|
|
|
|
|
def read_config_from_file_and_env(filename):
|
|
config = {}
|
|
|
|
if exists(filename):
|
|
with open(filename) as fp:
|
|
config = json.load(fp)
|
|
|
|
for setting in SETTINGS_KEYS:
|
|
val = os.getenv("PLUGIN_" + setting.upper())
|
|
|
|
if val is not None:
|
|
config[setting] = val
|
|
|
|
if not config.get(setting):
|
|
log.debug(f"Configuration setting '{setting}' not set or empty in config.")
|
|
|
|
return config
|
|
|
|
|
|
async def send_notification(config, message):
|
|
token = config.get("accesstoken")
|
|
device_id = config.get("deviceid")
|
|
homeserver = config.get("homeserver", DEFAULT_HOMESERVER)
|
|
|
|
client = AsyncClient(homeserver, config["userid"])
|
|
log.debug("Created AsyncClient: %r", client)
|
|
|
|
if token and device_id:
|
|
log.debug("Using access token for authentication.")
|
|
client.access_token = token
|
|
client.device_id = device_id
|
|
else:
|
|
log.debug("Trying to log in with password...")
|
|
resp = await client.login(config["password"], device_name=config.get("devicename"))
|
|
|
|
# check that we logged in succesfully
|
|
if isinstance(resp, LoginResponse):
|
|
log.debug("Matrix login successful.")
|
|
log.debug("Access token: %s", resp.access_token)
|
|
log.debug("Device ID: %s", resp.device_id)
|
|
else:
|
|
log.error(f"Failed to log in: {resp}")
|
|
await client.close()
|
|
return
|
|
|
|
if isinstance(message, dict):
|
|
message.setdefault("msgtype", "m.notice")
|
|
resp = await client.room_send(
|
|
config["roomid"], message_type="m.room.message", content=message
|
|
)
|
|
else:
|
|
resp = await client.room_send(
|
|
config["roomid"],
|
|
message_type="m.room.message",
|
|
content={"msgtype": "m.notice", "body": message},
|
|
)
|
|
|
|
log.info(
|
|
"Sent notification message to %s. Response status: %s",
|
|
homeserver,
|
|
resp.transport_response.status,
|
|
)
|
|
await client.close()
|
|
|
|
|
|
def get_template_context(config):
|
|
pass_environment = config.get("pass_environment", [])
|
|
|
|
if not isinstance(pass_environment, list):
|
|
pass_environment = [pass_environment]
|
|
|
|
patterns = []
|
|
for value in pass_environment:
|
|
# expand any comma-separated names/patterns
|
|
if "," in value:
|
|
patterns.extend([p.strip() for p in value.split(",") if p.strip()])
|
|
else:
|
|
patterns.append(value)
|
|
|
|
env_names = tuple(os.environ)
|
|
filtered_names = set()
|
|
|
|
for pattern in patterns:
|
|
filtered_names.update(fnmatch.filter(env_names, pattern))
|
|
|
|
return {name: os.environ[name] for name in tuple(filtered_names)}
|
|
|
|
|
|
def render_message(config):
|
|
context = get_template_context(config)
|
|
template = config.get("template", DEFAULT_TEMPLATE)
|
|
|
|
if tobool(config.get("jinja")):
|
|
try:
|
|
from jinja2.sandbox import SandboxedEnvironment
|
|
|
|
env = SandboxedEnvironment()
|
|
return env.from_string(template).render(context)
|
|
except Exception as exc:
|
|
log.error("Could not render Jinja2 template: %s", exc)
|
|
return template
|
|
else:
|
|
return Template(template).safe_substitute(context)
|
|
|
|
|
|
def render_markdown(message, config):
|
|
import bleach
|
|
import markdown
|
|
|
|
allowed_attrs = config.get("allowed_attrs", DEFAULT_ALLOWED_ATTRS)
|
|
allowed_tags = config.get("allowed_tags", DEFAULT_ALLOWED_TAGS)
|
|
extensions = config.get("markdown_extensions", DEFAULT_MARKDOWN_EXTENSIONS)
|
|
|
|
if isinstance(allowed_attrs, str):
|
|
allowed_attrs = [attr.strip() for attr in allowed_attrs.split(",") if attr.strip()]
|
|
|
|
if isinstance(allowed_tags, str):
|
|
allowed_tags = [tag.strip() for tag in allowed_tags.split(",") if tag.strip()]
|
|
|
|
if isinstance(extensions, str):
|
|
extensions = [ext.strip() for ext in extensions.split(",") if ext.strip()]
|
|
|
|
try:
|
|
md = markdown.Markdown(extensions=extensions)
|
|
except (AttributeError, ImportError, TypeError) as exc:
|
|
log.error("Could not instantiate Markdown formatter: %s", exc)
|
|
return message
|
|
|
|
return {
|
|
"formatted_body": bleach.clean(
|
|
md.convert(message), tags=allowed_tags, attributes=allowed_attrs, strip=True
|
|
),
|
|
"body": message,
|
|
"format": "org.matrix.custom.html",
|
|
}
|
|
|
|
|
|
def main(args=None):
|
|
ap = argparse.ArgumentParser(prog=PROG, description=__doc__.splitlines()[0])
|
|
ap.add_argument(
|
|
"-c",
|
|
"--config",
|
|
metavar="PATH",
|
|
default=CONFIG_FILENAME,
|
|
help="Configuration file path (default: '%(default)s')",
|
|
)
|
|
ap.add_argument(
|
|
"-d",
|
|
"--dry-run",
|
|
action="store_true",
|
|
help="Don't send notification message, only print it.",
|
|
)
|
|
ap.add_argument(
|
|
"-e",
|
|
"--pass-environment",
|
|
nargs="*",
|
|
help=(
|
|
"Comma-separated white-list of environment variable names or name patterns. Only "
|
|
"environment variables matching any of the given names or patterns will be available "
|
|
"as valid placeholders in the message template. "
|
|
"Accepts shell glob patterns and may be passed more than once (default: 'DRONE_*')."
|
|
),
|
|
)
|
|
ap.add_argument(
|
|
"-m",
|
|
"--render-markdown",
|
|
action="store_true",
|
|
help="Message is in Markdown format and will be rendered to HTML.",
|
|
)
|
|
ap.add_argument(
|
|
"-v",
|
|
"--verbose",
|
|
action="store_true",
|
|
help="Enable debug level logging.",
|
|
)
|
|
|
|
args = ap.parse_args(args)
|
|
|
|
logging.basicConfig(
|
|
level="DEBUG" if args.verbose else os.environ.get("PLUGIN_LOG_LEVEL", "INFO").upper(),
|
|
format=os.environ.get("PLUGIN_LOG_FORMAT", "%(levelname)s: %(message)s"),
|
|
)
|
|
|
|
try:
|
|
config = read_config_from_file_and_env(args.config)
|
|
except Exception as exc:
|
|
return f"Could not parse configuration: {exc}"
|
|
|
|
if args.pass_environment is not None:
|
|
# Security feature: if any environment names/patterns are passed via -e|--pass-environment
|
|
# options, they completely replace any given via the config or environment.
|
|
config["pass_environment"] = args.pass_environment
|
|
|
|
if "pass_environment" not in config:
|
|
config["pass_environment"] = DEFAULT_PASS_ENVIRONMENT
|
|
|
|
message = render_message(config)
|
|
|
|
if tobool(config.get("markdown")) or args.render_markdown:
|
|
log.debug("Rendering markdown message to HTML.")
|
|
try:
|
|
message = render_markdown(message, config)
|
|
except: ## noqa
|
|
log.exception("Failed to render message with markdown.")
|
|
|
|
if not args.dry_run:
|
|
if not config.get("userid"):
|
|
return "userid not found in configuration."
|
|
|
|
if not config.get("roomid"):
|
|
return "roomid not found in configuration."
|
|
|
|
if not config.get("password") and not config.get("accesstoken"):
|
|
return "No password or accesstoken found in configuration."
|
|
|
|
try:
|
|
log.debug("Sending notification to Matrix chat...")
|
|
asyncio.run(send_notification(config, message))
|
|
except KeyboardInterrupt:
|
|
log.info("Interrupted.")
|
|
else:
|
|
print(message)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main() or 0)
|