1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
# -*- coding: utf-8 -*-
# Copyright 2015 OpenMarket Ltd
#
# 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.
from synapse.api.errors import StoreError
from ._base import SQLBaseStore
# XXX: This feels like it should belong in a "models" module, not storage.
class ApplicationService(object):
"""Defines an application service.
Provides methods to check if this service is "interested" in events.
"""
def __init__(self, token, url=None, namespaces=None):
self.token = token
if url:
self.url = url
if namespaces:
self.namespaces = namespaces
def is_interested(self, event):
"""Check if this service is interested in this event.
Args:
event(Event): The event to check.
Returns:
bool: True if this service would like to know about this event.
"""
# NB: This does not check room alias regex matches because that requires
# more context that an Event can provide. Room alias matches are checked
# in the ApplicationServiceHandler.
# TODO check if event.room_id regex matches
# TODO check if event.user_id regex matches (or m.room.member state_key)
return True
def __str__(self):
return "ApplicationService: %s" % (self.__dict__,)
class ApplicationServiceCache(object):
"""Caches ApplicationServices and provides utility functions on top.
This class is designed to be invoked on incoming events in order to avoid
hammering the database every time to extract a list of application service
regexes.
"""
def __init__(self):
self.services = []
def get_services_for_event(self, event):
"""Retrieve a list of application services interested in this event.
Args:
event(Event): The event to check.
Returns:
list<ApplicationService>: A list of services interested in this
event based on the service regex.
"""
interested_list = [
s for s in self.services if s.is_event_claimed(event)
]
return interested_list
class ApplicationServiceStore(SQLBaseStore):
def __init__(self, hs):
super(ApplicationServiceStore, self).__init__(hs)
self.cache = ApplicationServiceCache()
self._populate_cache()
def unregister_app_service(self, token):
"""Unregisters this service.
This removes all AS specific regex and the base URL. The token is the
only thing preserved for future registration attempts.
"""
# TODO: DELETE FROM application_services_regex WHERE id=this service
# TODO: SET url=NULL WHERE token=token
# TODO: Update cache
pass
def update_app_service(self, service):
"""Update an application service, clobbering what was previously there.
Args:
service(ApplicationService): The updated service.
"""
# NB: There is no "insert" since we provide no public-facing API to
# allocate new ASes. It relies on the server admin inserting the AS
# token into the database manually.
# TODO: UPDATE application_services, SET url WHERE token=service.token
# TODO: DELETE FROM application_services_regex WHERE id=this service
# TODO: INSERT INTO application_services_regex <new namespace regex>
# TODO: Update cache
pass
def get_services_for_event(self, event):
return self.cache.get_services_for_event(event)
def get_app_service(self, token, from_cache=True):
"""Get the application service with the given token.
Args:
token (str): The application service token.
from_cache (bool): True to get this service from the cache, False to
check the database.
Raises:
StoreError if there was a problem retrieving this service.
"""
if from_cache:
for service in self.cache.services:
if service.token == token:
return service
return None
# TODO: This should be JOINed with the application_services_regex table.
row = self._simple_select_one(
"application_services", {"token": token},
["url", "token"]
)
if not row:
raise StoreError(400, "Bad application services token supplied.")
return row
def _populate_cache(self):
"""Populates the ApplicationServiceCache from the database."""
pass
|
