2015-12-09 08:51:34 -07:00
|
|
|
# -*- coding: utf-8 -*-
|
2016-01-06 21:26:29 -07:00
|
|
|
# Copyright 2015, 2016 OpenMarket Ltd
|
2017-10-10 04:21:41 -06:00
|
|
|
# Copyright 2017 New Vector Ltd
|
2015-12-09 08:51:34 -07:00
|
|
|
#
|
|
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
# you may not use this file except in compliance with the License.
|
|
|
|
# You may obtain a copy of the License at
|
|
|
|
#
|
|
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
#
|
|
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
# See the License for the specific language governing permissions and
|
|
|
|
# limitations under the License.
|
|
|
|
|
|
|
|
import logging
|
|
|
|
import re
|
|
|
|
|
2018-07-09 00:09:20 -06:00
|
|
|
from six import string_types
|
|
|
|
|
2016-01-18 07:09:47 -07:00
|
|
|
from synapse.types import UserID
|
2017-03-29 08:53:14 -06:00
|
|
|
from synapse.util.caches import CACHE_SIZE_FACTOR, register_cache
|
2016-01-19 09:01:05 -07:00
|
|
|
from synapse.util.caches.lrucache import LruCache
|
2016-01-18 07:09:47 -07:00
|
|
|
|
2015-12-09 08:51:34 -07:00
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
|
|
|
2019-06-20 03:32:02 -06:00
|
|
|
GLOB_REGEX = re.compile(r"\\\[(\\\!|)(.*)\\\]")
|
|
|
|
IS_GLOB = re.compile(r"[\?\*\[\]]")
|
2016-01-18 07:09:47 -07:00
|
|
|
INEQUALITY_EXPR = re.compile("^([=<>]*)([0-9]*)$")
|
|
|
|
|
|
|
|
|
|
|
|
def _room_member_count(ev, condition, room_member_count):
|
2017-10-05 05:39:18 -06:00
|
|
|
return _test_ineq_condition(condition, room_member_count)
|
|
|
|
|
2017-10-05 06:08:02 -06:00
|
|
|
|
2017-10-10 08:23:00 -06:00
|
|
|
def _sender_notification_permission(ev, condition, sender_power_level, power_levels):
|
2019-06-20 03:32:02 -06:00
|
|
|
notif_level_key = condition.get("key")
|
2017-10-10 08:23:00 -06:00
|
|
|
if notif_level_key is None:
|
|
|
|
return False
|
|
|
|
|
2019-06-20 03:32:02 -06:00
|
|
|
notif_levels = power_levels.get("notifications", {})
|
2017-10-10 08:23:00 -06:00
|
|
|
room_notif_level = notif_levels.get(notif_level_key, 50)
|
|
|
|
|
2017-10-10 08:53:34 -06:00
|
|
|
return sender_power_level >= room_notif_level
|
2017-10-05 05:39:18 -06:00
|
|
|
|
2017-10-05 06:08:02 -06:00
|
|
|
|
2017-10-05 05:39:18 -06:00
|
|
|
def _test_ineq_condition(condition, number):
|
2019-06-20 03:32:02 -06:00
|
|
|
if "is" not in condition:
|
2016-01-18 07:09:47 -07:00
|
|
|
return False
|
2019-06-20 03:32:02 -06:00
|
|
|
m = INEQUALITY_EXPR.match(condition["is"])
|
2016-01-18 07:09:47 -07:00
|
|
|
if not m:
|
|
|
|
return False
|
|
|
|
ineq = m.group(1)
|
|
|
|
rhs = m.group(2)
|
|
|
|
if not rhs.isdigit():
|
|
|
|
return False
|
|
|
|
rhs = int(rhs)
|
|
|
|
|
2019-06-20 03:32:02 -06:00
|
|
|
if ineq == "" or ineq == "==":
|
2017-10-05 05:39:18 -06:00
|
|
|
return number == rhs
|
2019-06-20 03:32:02 -06:00
|
|
|
elif ineq == "<":
|
2017-10-05 05:39:18 -06:00
|
|
|
return number < rhs
|
2019-06-20 03:32:02 -06:00
|
|
|
elif ineq == ">":
|
2017-10-05 05:39:18 -06:00
|
|
|
return number > rhs
|
2019-06-20 03:32:02 -06:00
|
|
|
elif ineq == ">=":
|
2017-10-05 05:39:18 -06:00
|
|
|
return number >= rhs
|
2019-06-20 03:32:02 -06:00
|
|
|
elif ineq == "<=":
|
2017-10-05 05:39:18 -06:00
|
|
|
return number <= rhs
|
2016-01-18 07:09:47 -07:00
|
|
|
else:
|
|
|
|
return False
|
|
|
|
|
2017-10-05 06:08:02 -06:00
|
|
|
|
2016-04-07 09:31:38 -06:00
|
|
|
def tweaks_for_actions(actions):
|
|
|
|
tweaks = {}
|
|
|
|
for a in actions:
|
|
|
|
if not isinstance(a, dict):
|
|
|
|
continue
|
2019-06-20 03:32:02 -06:00
|
|
|
if "set_tweak" in a and "value" in a:
|
|
|
|
tweaks[a["set_tweak"]] = a["value"]
|
2016-04-07 09:31:38 -06:00
|
|
|
return tweaks
|
2015-12-09 08:51:34 -07:00
|
|
|
|
|
|
|
|
2016-01-18 07:09:47 -07:00
|
|
|
class PushRuleEvaluatorForEvent(object):
|
2017-10-10 08:23:00 -06:00
|
|
|
def __init__(self, event, room_member_count, sender_power_level, power_levels):
|
2016-01-18 07:09:47 -07:00
|
|
|
self._event = event
|
|
|
|
self._room_member_count = room_member_count
|
2017-10-05 05:39:18 -06:00
|
|
|
self._sender_power_level = sender_power_level
|
2017-10-10 08:23:00 -06:00
|
|
|
self._power_levels = power_levels
|
2016-01-18 07:09:47 -07:00
|
|
|
|
2016-01-18 08:42:23 -07:00
|
|
|
# Maps strings of e.g. 'content.body' -> event["content"]["body"]
|
2016-01-18 07:09:47 -07:00
|
|
|
self._value_cache = _flatten_dict(event)
|
2015-12-09 08:51:34 -07:00
|
|
|
|
2016-02-18 09:05:13 -07:00
|
|
|
def matches(self, condition, user_id, display_name):
|
2019-06-20 03:32:02 -06:00
|
|
|
if condition["kind"] == "event_match":
|
2016-01-18 03:09:14 -07:00
|
|
|
return self._event_match(condition, user_id)
|
2019-06-20 03:32:02 -06:00
|
|
|
elif condition["kind"] == "contains_display_name":
|
2016-01-18 07:09:47 -07:00
|
|
|
return self._contains_display_name(display_name)
|
2019-06-20 03:32:02 -06:00
|
|
|
elif condition["kind"] == "room_member_count":
|
|
|
|
return _room_member_count(self._event, condition, self._room_member_count)
|
|
|
|
elif condition["kind"] == "sender_notification_permission":
|
2017-10-10 08:23:00 -06:00
|
|
|
return _sender_notification_permission(
|
2019-06-20 03:32:02 -06:00
|
|
|
self._event, condition, self._sender_power_level, self._power_levels
|
2017-10-05 05:39:18 -06:00
|
|
|
)
|
2015-12-09 08:51:34 -07:00
|
|
|
else:
|
|
|
|
return True
|
|
|
|
|
2016-01-18 03:09:14 -07:00
|
|
|
def _event_match(self, condition, user_id):
|
2019-06-20 03:32:02 -06:00
|
|
|
pattern = condition.get("pattern", None)
|
2016-01-18 07:09:47 -07:00
|
|
|
|
2016-01-18 03:09:14 -07:00
|
|
|
if not pattern:
|
2019-06-20 03:32:02 -06:00
|
|
|
pattern_type = condition.get("pattern_type", None)
|
2016-01-18 03:09:14 -07:00
|
|
|
if pattern_type == "user_id":
|
|
|
|
pattern = user_id
|
|
|
|
elif pattern_type == "user_localpart":
|
|
|
|
pattern = UserID.from_string(user_id).localpart
|
|
|
|
|
2016-01-18 07:09:47 -07:00
|
|
|
if not pattern:
|
2019-10-31 04:23:24 -06:00
|
|
|
logger.warning("event_match condition with no pattern")
|
2016-01-18 07:09:47 -07:00
|
|
|
return False
|
|
|
|
|
|
|
|
# XXX: optimisation: cache our pattern regexps
|
2019-06-20 03:32:02 -06:00
|
|
|
if condition["key"] == "content.body":
|
2018-11-02 07:44:12 -06:00
|
|
|
body = self._event.content.get("body", None)
|
2016-01-18 09:48:17 -07:00
|
|
|
if not body:
|
|
|
|
return False
|
2016-01-18 07:09:47 -07:00
|
|
|
|
2016-01-18 09:48:17 -07:00
|
|
|
return _glob_matches(pattern, body, word_boundary=True)
|
2016-01-18 07:09:47 -07:00
|
|
|
else:
|
2019-06-20 03:32:02 -06:00
|
|
|
haystack = self._get_value(condition["key"])
|
2016-01-18 07:09:47 -07:00
|
|
|
if haystack is None:
|
|
|
|
return False
|
|
|
|
|
2016-01-18 09:48:17 -07:00
|
|
|
return _glob_matches(pattern, haystack)
|
2016-01-18 07:09:47 -07:00
|
|
|
|
|
|
|
def _contains_display_name(self, display_name):
|
|
|
|
if not display_name:
|
|
|
|
return False
|
|
|
|
|
2018-11-02 07:44:12 -06:00
|
|
|
body = self._event.content.get("body", None)
|
2016-01-18 09:48:17 -07:00
|
|
|
if not body:
|
|
|
|
return False
|
2016-01-18 07:09:47 -07:00
|
|
|
|
2016-01-18 09:48:17 -07:00
|
|
|
return _glob_matches(display_name, body, word_boundary=True)
|
2016-01-18 07:09:47 -07:00
|
|
|
|
|
|
|
def _get_value(self, dotted_key):
|
|
|
|
return self._value_cache.get(dotted_key, None)
|
|
|
|
|
2015-12-09 08:51:34 -07:00
|
|
|
|
2017-03-29 08:53:14 -06:00
|
|
|
# Caches (glob, word_boundary) -> regex for push. See _glob_matches
|
|
|
|
regex_cache = LruCache(50000 * CACHE_SIZE_FACTOR)
|
2018-05-21 18:47:37 -06:00
|
|
|
register_cache("cache", "regex_push_cache", regex_cache)
|
2017-03-29 08:53:14 -06:00
|
|
|
|
|
|
|
|
2016-01-18 09:48:17 -07:00
|
|
|
def _glob_matches(glob, value, word_boundary=False):
|
|
|
|
"""Tests if value matches glob.
|
2016-01-18 07:09:47 -07:00
|
|
|
|
2016-01-18 09:48:17 -07:00
|
|
|
Args:
|
|
|
|
glob (string)
|
|
|
|
value (string): String to test against glob.
|
|
|
|
word_boundary (bool): Whether to match against word boundaries or entire
|
|
|
|
string. Defaults to False.
|
2016-01-18 07:09:47 -07:00
|
|
|
|
2016-01-18 09:48:17 -07:00
|
|
|
Returns:
|
|
|
|
bool
|
|
|
|
"""
|
2016-01-18 10:04:36 -07:00
|
|
|
|
2017-03-29 08:53:14 -06:00
|
|
|
try:
|
|
|
|
r = regex_cache.get((glob, word_boundary), None)
|
|
|
|
if not r:
|
|
|
|
r = _glob_to_re(glob, word_boundary)
|
|
|
|
regex_cache[(glob, word_boundary)] = r
|
|
|
|
return r.search(value)
|
2016-01-19 07:43:24 -07:00
|
|
|
except re.error:
|
2019-10-31 04:23:24 -06:00
|
|
|
logger.warning("Failed to parse glob to regex: %r", glob)
|
2016-01-19 07:43:24 -07:00
|
|
|
return False
|
2016-01-18 07:09:47 -07:00
|
|
|
|
|
|
|
|
2017-03-29 08:53:14 -06:00
|
|
|
def _glob_to_re(glob, word_boundary):
|
|
|
|
"""Generates regex for a given glob.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
glob (string)
|
|
|
|
word_boundary (bool): Whether to match against word boundaries or entire
|
|
|
|
string. Defaults to False.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
regex object
|
|
|
|
"""
|
|
|
|
if IS_GLOB.search(glob):
|
|
|
|
r = re.escape(glob)
|
|
|
|
|
2019-06-20 03:32:02 -06:00
|
|
|
r = r.replace(r"\*", ".*?")
|
|
|
|
r = r.replace(r"\?", ".")
|
2017-03-29 08:53:14 -06:00
|
|
|
|
|
|
|
# handle [abc], [a-z] and [!a-z] style ranges.
|
|
|
|
r = GLOB_REGEX.sub(
|
|
|
|
lambda x: (
|
2019-06-20 03:32:02 -06:00
|
|
|
"[%s%s]" % (x.group(1) and "^" or "", x.group(2).replace(r"\\\-", "-"))
|
2017-03-29 08:53:14 -06:00
|
|
|
),
|
|
|
|
r,
|
|
|
|
)
|
|
|
|
if word_boundary:
|
2017-10-05 04:33:30 -06:00
|
|
|
r = _re_word_boundary(r)
|
2017-03-29 08:53:14 -06:00
|
|
|
|
|
|
|
return re.compile(r, flags=re.IGNORECASE)
|
|
|
|
else:
|
|
|
|
r = "^" + r + "$"
|
|
|
|
|
|
|
|
return re.compile(r, flags=re.IGNORECASE)
|
|
|
|
elif word_boundary:
|
|
|
|
r = re.escape(glob)
|
2017-10-05 04:33:30 -06:00
|
|
|
r = _re_word_boundary(r)
|
2017-03-29 08:53:14 -06:00
|
|
|
|
|
|
|
return re.compile(r, flags=re.IGNORECASE)
|
|
|
|
else:
|
|
|
|
r = "^" + re.escape(glob) + "$"
|
|
|
|
return re.compile(r, flags=re.IGNORECASE)
|
|
|
|
|
2017-10-05 04:43:10 -06:00
|
|
|
|
2017-10-05 04:33:30 -06:00
|
|
|
def _re_word_boundary(r):
|
|
|
|
"""
|
|
|
|
Adds word boundary characters to the start and end of an
|
|
|
|
expression to require that the match occur as a whole word,
|
|
|
|
but do so respecting the fact that strings starting or ending
|
|
|
|
with non-word characters will change word boundaries.
|
|
|
|
"""
|
2017-10-05 04:57:43 -06:00
|
|
|
# we can't use \b as it chokes on unicode. however \W seems to be okay
|
|
|
|
# as shorthand for [^0-9A-Za-z_].
|
|
|
|
return r"(^|\W)%s(\W|$)" % (r,)
|
2017-10-05 04:33:30 -06:00
|
|
|
|
2017-03-29 08:53:14 -06:00
|
|
|
|
2017-07-04 17:28:43 -06:00
|
|
|
def _flatten_dict(d, prefix=[], result=None):
|
|
|
|
if result is None:
|
|
|
|
result = {}
|
2016-01-18 07:09:47 -07:00
|
|
|
for key, value in d.items():
|
2018-04-15 13:43:35 -06:00
|
|
|
if isinstance(value, string_types):
|
2016-01-18 07:09:47 -07:00
|
|
|
result[".".join(prefix + [key])] = value.lower()
|
|
|
|
elif hasattr(value, "items"):
|
2016-02-02 10:18:50 -07:00
|
|
|
_flatten_dict(value, prefix=(prefix + [key]), result=result)
|
2016-01-18 07:09:47 -07:00
|
|
|
|
|
|
|
return result
|