diff --git a/synapse/__init__.py b/synapse/__init__.py
index 723e15d506..7e49e1fd08 100644
--- a/synapse/__init__.py
+++ b/synapse/__init__.py
@@ -16,4 +16,4 @@
""" This is a reference implementation of a synapse home server.
"""
-__version__ = "0.5.4"
+__version__ = "0.5.4a"
diff --git a/synapse/config/_base.py b/synapse/config/_base.py
index 1426436dcb..1cdd03e414 100644
--- a/synapse/config/_base.py
+++ b/synapse/config/_base.py
@@ -44,9 +44,9 @@ class Config(object):
)
if not os.path.exists(file_path):
raise ConfigError(
- "File % config for %s doesn't exist."
+ "File %s config for %s doesn't exist."
" Try running again with --generate-config"
- % (config_name,)
+ % (file_path, config_name,)
)
return cls.abspath(file_path)
diff --git a/synapse/handlers/room.py b/synapse/handlers/room.py
index e771cf317b..a1d542854d 100644
--- a/synapse/handlers/room.py
+++ b/synapse/handlers/room.py
@@ -244,6 +244,7 @@ class RoomMemberHandler(BaseHandler):
self.distributor = hs.get_distributor()
self.distributor.declare("user_joined_room")
+ self.distributor.declare("user_left_room")
@defer.inlineCallbacks
def get_room_members(self, room_id, membership=Membership.JOIN):
@@ -370,6 +371,12 @@ class RoomMemberHandler(BaseHandler):
do_auth=do_auth,
)
+ if prev_state and prev_state.membership == Membership.JOIN:
+ user = self.hs.parse_userid(event.user_id)
+ self.distributor.fire(
+ "user_left_room", user=user, room_id=event.room_id
+ )
+
defer.returnValue({"room_id": room_id})
@defer.inlineCallbacks
diff --git a/synapse/handlers/typing.py b/synapse/handlers/typing.py
index be67fb2fc2..34bc955c15 100644
--- a/synapse/handlers/typing.py
+++ b/synapse/handlers/typing.py
@@ -43,7 +43,23 @@ class TypingNotificationHandler(BaseHandler):
self.federation.register_edu_handler("m.typing", self._recv_edu)
- self._member_typing_until = {}
+ hs.get_distributor().observe("user_left_room", self.user_left_room)
+
+ self._member_typing_until = {} # clock time we expect to stop
+ self._member_typing_timer = {} # deferreds to manage theabove
+
+ # map room IDs to serial numbers
+ self._room_serials = {}
+ self._latest_room_serial = 0
+ # map room IDs to sets of users currently typing
+ self._room_typing = {}
+
+ def tearDown(self):
+ """Cancels all the pending timers.
+ Normally this shouldn't be needed, but it's required from unit tests
+ to avoid a "Reactor was unclean" warning."""
+ for t in self._member_typing_timer.values():
+ self.clock.cancel_call_later(t)
@defer.inlineCallbacks
def started_typing(self, target_user, auth_user, room_id, timeout):
@@ -53,12 +69,24 @@ class TypingNotificationHandler(BaseHandler):
if target_user != auth_user:
raise AuthError(400, "Cannot set another user's typing state")
+ yield self.auth.check_joined_room(room_id, target_user.to_string())
+
+ logger.debug(
+ "%s has started typing in %s", target_user.to_string(), room_id
+ )
+
until = self.clock.time_msec() + timeout
member = RoomMember(room_id=room_id, user=target_user)
was_present = member in self._member_typing_until
+ if member in self._member_typing_timer:
+ self.clock.cancel_call_later(self._member_typing_timer[member])
+
self._member_typing_until[member] = until
+ self._member_typing_timer[member] = self.clock.call_later(
+ timeout / 1000, lambda: self._stopped_typing(member)
+ )
if was_present:
# No point sending another notification
@@ -78,18 +106,39 @@ class TypingNotificationHandler(BaseHandler):
if target_user != auth_user:
raise AuthError(400, "Cannot set another user's typing state")
+ yield self.auth.check_joined_room(room_id, target_user.to_string())
+
+ logger.debug(
+ "%s has stopped typing in %s", target_user.to_string(), room_id
+ )
+
member = RoomMember(room_id=room_id, user=target_user)
+ yield self._stopped_typing(member)
+
+ @defer.inlineCallbacks
+ def user_left_room(self, user, room_id):
+ if user.is_mine:
+ member = RoomMember(room_id=room_id, user=user)
+ yield self._stopped_typing(member)
+
+ @defer.inlineCallbacks
+ def _stopped_typing(self, member):
if member not in self._member_typing_until:
# No point
defer.returnValue(None)
yield self._push_update(
- room_id=room_id,
- user=target_user,
+ room_id=member.room_id,
+ user=member.user,
typing=False,
)
+ del self._member_typing_until[member]
+
+ self.clock.cancel_call_later(self._member_typing_timer[member])
+ del self._member_typing_timer[member]
+
@defer.inlineCallbacks
def _push_update(self, room_id, user, typing):
localusers = set()
@@ -97,16 +146,14 @@ class TypingNotificationHandler(BaseHandler):
rm_handler = self.homeserver.get_handlers().room_member_handler
yield rm_handler.fetch_room_distributions_into(
- room_id, localusers=localusers, remotedomains=remotedomains,
- ignore_user=user
+ room_id, localusers=localusers, remotedomains=remotedomains
)
- for u in localusers:
- self.push_update_to_clients(
+ if localusers:
+ self._push_update_local(
room_id=room_id,
- observer_user=u,
- observed_user=user,
- typing=typing,
+ user=user,
+ typing=typing
)
deferreds = []
@@ -135,29 +182,67 @@ class TypingNotificationHandler(BaseHandler):
room_id, localusers=localusers
)
- for u in localusers:
- self.push_update_to_clients(
+ if localusers:
+ self._push_update_local(
room_id=room_id,
- observer_user=u,
- observed_user=user,
+ user=user,
typing=content["typing"]
)
- def push_update_to_clients(self, room_id, observer_user, observed_user,
- typing):
- # TODO(paul) steal this from presence.py
- pass
+ def _push_update_local(self, room_id, user, typing):
+ if room_id not in self._room_serials:
+ self._room_serials[room_id] = 0
+ self._room_typing[room_id] = set()
+
+ room_set = self._room_typing[room_id]
+ if typing:
+ room_set.add(user)
+ elif user in room_set:
+ room_set.remove(user)
+
+ self._latest_room_serial += 1
+ self._room_serials[room_id] = self._latest_room_serial
+
+ self.notifier.on_new_user_event(rooms=[room_id])
class TypingNotificationEventSource(object):
def __init__(self, hs):
self.hs = hs
+ self._handler = None
+
+ def handler(self):
+ # Avoid cyclic dependency in handler setup
+ if not self._handler:
+ self._handler = self.hs.get_handlers().typing_notification_handler
+ return self._handler
+
+ def _make_event_for(self, room_id):
+ typing = self.handler()._room_typing[room_id]
+ return {
+ "type": "m.typing",
+ "room_id": room_id,
+ "content": {
+ "user_ids": [u.to_string() for u in typing],
+ },
+ }
def get_new_events_for_user(self, user, from_key, limit):
- return ([], from_key)
+ from_key = int(from_key)
+ handler = self.handler()
+
+ events = []
+ for room_id in handler._room_serials:
+ if handler._room_serials[room_id] <= from_key:
+ continue
+
+ # TODO: check if user is in room
+ events.append(self._make_event_for(room_id))
+
+ return (events, handler._latest_room_serial)
def get_current_key(self):
- return 0
+ return self.handler()._latest_room_serial
def get_pagination_rows(self, user, pagination_config, key):
return ([], pagination_config.from_key)
diff --git a/synapse/media/v1/media_repository.py b/synapse/media/v1/media_repository.py
index a0dc56be4b..cbc49aa325 100644
--- a/synapse/media/v1/media_repository.py
+++ b/synapse/media/v1/media_repository.py
@@ -26,7 +26,7 @@ logger = logging.getLogger(__name__)
class MediaRepositoryResource(Resource):
- """Profiles file uploading and downloading.
+ """File uploading and downloading.
Uploads are POSTed to a resource which returns a token which is used to GET
the download::
@@ -39,9 +39,9 @@ class MediaRepositoryResource(Resource):
<= HTTP/1.1 200 OK
Content-Type: application/json
- { "token": <media-id> }
+ { "content-uri": "mxc://<server-name>/<media-id>" }
- => GET /_matrix/media/v1/download/<media-id> HTTP/1.1
+ => GET /_matrix/media/v1/download/<server-name>/<media-id> HTTP/1.1
<= HTTP/1.1 200 OK
Content-Type: <media-type>
@@ -52,8 +52,8 @@ class MediaRepositoryResource(Resource):
Clients can get thumbnails by supplying a desired width and height and
thumbnailing method::
- => GET /_matrix/media/v1
- /thumbnail/<media-id>?width=<w>&height=<h>&method=<m> HTTP/1.1
+ => GET /_matrix/media/v1/thumbnail/<server_name>
+ /<media-id>?width=<w>&height=<h>&method=<m> HTTP/1.1
<= HTTP/1.1 200 OK
Content-Type: image/jpeg or image/png
diff --git a/synapse/media/v1/upload_resource.py b/synapse/media/v1/upload_resource.py
index b2449ff03d..5645b0df46 100644
--- a/synapse/media/v1/upload_resource.py
+++ b/synapse/media/v1/upload_resource.py
@@ -95,8 +95,10 @@ class UploadResource(BaseMediaResource):
yield self._generate_local_thumbnails(media_id, media_info)
+ content_uri = "mxc://%s/%s" % (self.server_name, media_id)
+
respond_with_json(
- request, 200, {"content_token": media_id}, send_cors=True
+ request, 200, {"content_uri": content_uri}, send_cors=True
)
except CodeMessageException as e:
logger.exception(e)
diff --git a/synapse/rest/room.py b/synapse/rest/room.py
index 7fb5aca0a7..25ee964555 100644
--- a/synapse/rest/room.py
+++ b/synapse/rest/room.py
@@ -466,6 +466,37 @@ class RoomRedactEventRestServlet(RestServlet):
defer.returnValue(response)
+class RoomTypingRestServlet(RestServlet):
+ PATTERN = client_path_pattern("/rooms/(?P<room_id>[^/]*)/typing/(?P<user_id>[^/]*)$")
+
+ @defer.inlineCallbacks
+ def on_PUT(self, request, room_id, user_id):
+ auth_user = yield self.auth.get_user_by_req(request)
+
+ room_id = urllib.unquote(room_id)
+ target_user = self.hs.parse_userid(urllib.unquote(user_id))
+
+ content = _parse_json(request)
+
+ typing_handler = self.handlers.typing_notification_handler
+
+ if content["typing"]:
+ yield typing_handler.started_typing(
+ target_user=target_user,
+ auth_user=auth_user,
+ room_id=room_id,
+ timeout=content.get("timeout", 30000),
+ )
+ else:
+ yield typing_handler.stopped_typing(
+ target_user=target_user,
+ auth_user=auth_user,
+ room_id=room_id,
+ )
+
+ defer.returnValue((200, {}))
+
+
def _parse_json(request):
try:
content = json.loads(request.content.read())
@@ -521,3 +552,4 @@ def register_servlets(hs, http_server):
RoomStateRestServlet(hs).register(http_server)
RoomInitialSyncRestServlet(hs).register(http_server)
RoomRedactEventRestServlet(hs).register(http_server)
+ RoomTypingRestServlet(hs).register(http_server)
|
