From dfa0cd1d90cb80de7e42fc2c8aaac8911287d718 Mon Sep 17 00:00:00 2001 From: Kegan Dougal Date: Wed, 27 Aug 2014 09:43:42 +0100 Subject: Modified /join/$identifier to support $identifier being a room ID in addition to a room alias. --- synapse/rest/room.py | 63 +++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 50 insertions(+), 13 deletions(-) (limited to 'synapse/rest') diff --git a/synapse/rest/room.py b/synapse/rest/room.py index 5eee49e513..b8d5cb87fd 100644 --- a/synapse/rest/room.py +++ b/synapse/rest/room.py @@ -18,10 +18,8 @@ from twisted.internet import defer from base import RestServlet, client_path_pattern from synapse.api.errors import SynapseError, Codes -from synapse.api.events.room import ( - MessageEvent, RoomMemberEvent, FeedbackEvent -) -from synapse.api.constants import Feedback +from synapse.api.events.room import RoomMemberEvent +from synapse.api.constants import Membership from synapse.api.streams import PaginationConfig import json @@ -210,24 +208,63 @@ class RoomSendEventRestServlet(RestServlet): defer.returnValue(response) +# TODO: Needs unit testing for room ID + alias joins class JoinRoomAliasServlet(RestServlet): - PATTERN = client_path_pattern("/join/(?P[^/]+)$") + + def register(self, http_server): + # /join/$room_identifier[/$txn_id] + PATTERN = ("/join/(?P[^/]*)") + register_txn_path(self, PATTERN, http_server) @defer.inlineCallbacks - def on_PUT(self, request, room_alias): + def on_POST(self, request, room_identifier): user = yield self.auth.get_user_by_req(request) - if not user: - defer.returnValue((403, "Unrecognized user")) + # the identifier could be a room alias or a room id. Try one then the + # other if it fails to parse, without swallowing other valid + # SynapseErrors. - logger.debug("room_alias: %s", room_alias) + identifier = None + is_room_alias = False + try: + identifier = self.hs.parse_roomalias( + urllib.unquote(room_identifier) + ) + is_room_alias = True + except SynapseError: + identifier = self.hs.parse_roomid( + urllib.unquote(room_identifier) + ) - room_alias = self.hs.parse_roomalias(urllib.unquote(room_alias)) + # TODO: Support for specifying the home server to join with? - handler = self.handlers.room_member_handler - ret_dict = yield handler.join_room_alias(user, room_alias) + if is_room_alias: + handler = self.handlers.room_member_handler + ret_dict = yield handler.join_room_alias(user, identifier) + defer.returnValue((200, ret_dict)) + else: # room id + event = self.event_factory.create_event( + etype=RoomMemberEvent.TYPE, + content={"membership": Membership.JOIN}, + room_id=urllib.unquote(identifier.to_string()), + user_id=user.to_string(), + state_key=user.to_string() + ) + handler = self.handlers.room_member_handler + yield handler.change_membership(event) + defer.returnValue((200, "")) + + @defer.inlineCallbacks + def on_PUT(self, request, room_identifier, txn_id): + try: + defer.returnValue(self.txns.get_client_transaction(request, txn_id)) + except KeyError: + pass + + response = yield self.on_POST(request, room_identifier) - defer.returnValue((200, ret_dict)) + self.txns.store_client_transaction(request, txn_id, response) + defer.returnValue(response) # TODO: Needs unit testing -- cgit 1.5.1 From c65885e1668d4a241a04a7cb3b970a0d6833a5ad Mon Sep 17 00:00:00 2001 From: Kegan Dougal Date: Wed, 27 Aug 2014 10:33:01 +0100 Subject: Added support for GET /events/$eventid with auth checks. --- synapse/handlers/__init__.py | 3 ++- synapse/handlers/events.py | 26 ++++++++++++++++++++++++++ synapse/rest/events.py | 17 +++++++++++++++++ synapse/storage/__init__.py | 1 - 4 files changed, 45 insertions(+), 2 deletions(-) (limited to 'synapse/rest') diff --git a/synapse/handlers/__init__.py b/synapse/handlers/__init__.py index 8a4aa6e5d6..7417a02cea 100644 --- a/synapse/handlers/__init__.py +++ b/synapse/handlers/__init__.py @@ -17,7 +17,7 @@ from .register import RegistrationHandler from .room import ( MessageHandler, RoomCreationHandler, RoomMemberHandler, RoomListHandler ) -from .events import EventStreamHandler +from .events import EventStreamHandler, EventHandler from .federation import FederationHandler from .login import LoginHandler from .profile import ProfileHandler @@ -39,6 +39,7 @@ class Handlers(object): self.room_creation_handler = RoomCreationHandler(hs) self.room_member_handler = RoomMemberHandler(hs) self.event_stream_handler = EventStreamHandler(hs) + self.event_handler = EventHandler(hs) self.federation_handler = FederationHandler(hs) self.profile_handler = ProfileHandler(hs) self.presence_handler = PresenceHandler(hs) diff --git a/synapse/handlers/events.py b/synapse/handlers/events.py index 6bb797caf2..1bd173acd8 100644 --- a/synapse/handlers/events.py +++ b/synapse/handlers/events.py @@ -144,3 +144,29 @@ class EventStreamHandler(BaseHandler): self._stop_timer_per_user[auth_user] = ( self.clock.call_later(5, _later) ) + + +class EventHandler(BaseHandler): + + @defer.inlineCallbacks + def get_event(self, user, event_id): + """Retrieve a single specified event. + + Args: + user (synapse.types.UserID): The user requesting the event + event_id (str): The event ID to obtain. + Returns: + dict: An event, or None if there is no event matching this ID. + Raises: + SynapseError if there was a problem retrieving this event, or + AuthError if the user does not have the rights to inspect this + event. + """ + event = yield self.store.get_event(event_id) + + if not event: + defer.returnValue(None) + return + + yield self.auth.check(event, raises=True) + defer.returnValue(event) diff --git a/synapse/rest/events.py b/synapse/rest/events.py index ca2f6978e5..d89dfc193c 100644 --- a/synapse/rest/events.py +++ b/synapse/rest/events.py @@ -47,5 +47,22 @@ class EventStreamRestServlet(RestServlet): return (200, {}) +# TODO: Unit test gets, with and without auth, with different kinds of events. +class EventRestServlet(RestServlet): + PATTERN = client_path_pattern("/events/(?P[^/]*)$") + + @defer.inlineCallbacks + def on_GET(self, request, event_id): + auth_user = yield self.auth.get_user_by_req(request) + handler = self.handlers.event_handler + event = yield handler.get_event(auth_user, event_id) + + if event: + defer.returnValue((200, event.get_dict())) + else: + defer.returnValue((404, "Event not found.")) + + def register_servlets(hs, http_server): EventStreamRestServlet(hs).register(http_server) + EventRestServlet(hs).register(http_server) diff --git a/synapse/storage/__init__.py b/synapse/storage/__init__.py index a97a42e1e3..38ab03c45c 100644 --- a/synapse/storage/__init__.py +++ b/synapse/storage/__init__.py @@ -80,7 +80,6 @@ class DataStore(RoomMemberStore, RoomStore, [ "event_id", "type", - "sender", "room_id", "content", "unrecognized_keys" -- cgit 1.5.1 From dd661769e1846b627d26203f6ca7936e0820d93c Mon Sep 17 00:00:00 2001 From: Kegan Dougal Date: Wed, 27 Aug 2014 11:33:56 +0100 Subject: Renamed /rooms to /createRoom. Removed ability to PUT raw room IDs, and removed tests which tested that. Updated cmdclient and webclient. --- cmdclient/console.py | 2 +- synapse/rest/room.py | 31 +++---- tests/rest/test_events.py | 5 +- tests/rest/test_rooms.py | 122 +++++++------------------- tests/rest/utils.py | 8 +- webclient/components/matrix/matrix-service.js | 2 +- 6 files changed, 55 insertions(+), 115 deletions(-) (limited to 'synapse/rest') diff --git a/cmdclient/console.py b/cmdclient/console.py index 4cb604e796..a4d8145d72 100755 --- a/cmdclient/console.py +++ b/cmdclient/console.py @@ -471,7 +471,7 @@ class SynapseCmd(cmd.Cmd): room_name = args["vis"] body["room_alias_name"] = room_name - reactor.callFromThread(self._run_and_pprint, "POST", "/rooms", body) + reactor.callFromThread(self._run_and_pprint, "POST", "/createRoom", body) def do_raw(self, line): """Directly send a JSON object: "raw " diff --git a/synapse/rest/room.py b/synapse/rest/room.py index b8d5cb87fd..1cbb31e301 100644 --- a/synapse/rest/room.py +++ b/synapse/rest/room.py @@ -34,31 +34,28 @@ class RoomCreateRestServlet(RestServlet): # No PATTERN; we have custom dispatch rules here def register(self, http_server): - # /rooms OR /rooms/ - http_server.register_path("POST", - client_path_pattern("/rooms$"), - self.on_POST) - http_server.register_path("PUT", - client_path_pattern( - "/rooms/(?P[^/]*)$"), - self.on_PUT) + PATTERN = "/createRoom" + register_txn_path(self, PATTERN, http_server) # define CORS for all of /rooms in RoomCreateRestServlet for simplicity http_server.register_path("OPTIONS", client_path_pattern("/rooms(?:/.*)?$"), self.on_OPTIONS) + # define CORS for /createRoom[/txnid] + http_server.register_path("OPTIONS", + client_path_pattern("/createRoom(?:/.*)?$"), + self.on_OPTIONS) @defer.inlineCallbacks - def on_PUT(self, request, room_id): - room_id = urllib.unquote(room_id) - auth_user = yield self.auth.get_user_by_req(request) + def on_PUT(self, request, txn_id): + try: + defer.returnValue(self.txns.get_client_transaction(request, txn_id)) + except KeyError: + pass - if not room_id: - raise SynapseError(400, "PUT must specify a room ID") + response = yield self.on_POST(request) - room_config = self.get_room_config(request) - info = yield self.make_room(room_config, auth_user, room_id) - room_config.update(info) - defer.returnValue((200, info)) + self.txns.store_client_transaction(request, txn_id, response) + defer.returnValue(response) @defer.inlineCallbacks def on_POST(self, request): diff --git a/tests/rest/test_events.py b/tests/rest/test_events.py index 7bc05dc2b6..94ad8910e3 100644 --- a/tests/rest/test_events.py +++ b/tests/rest/test_events.py @@ -178,9 +178,8 @@ class EventStreamPermissionsTestCase(RestTestCase): @defer.inlineCallbacks def test_stream_room_permissions(self): - room_id = "!rid1:test" - yield self.create_room_as(room_id, self.other_user, - tok=self.other_token) + room_id = yield self.create_room_as(self.other_user, + tok=self.other_token) yield self.send(room_id, tok=self.other_token) # invited to room (expect no content for room) diff --git a/tests/rest/test_rooms.py b/tests/rest/test_rooms.py index f18c506a7d..589b434446 100644 --- a/tests/rest/test_rooms.py +++ b/tests/rest/test_rooms.py @@ -74,13 +74,11 @@ class RoomPermissionsTestCase(RestTestCase): # create some rooms under the name rmcreator_id self.uncreated_rmid = "!aa:test" - self.created_rmid = "!abc:test" - yield self.create_room_as(self.created_rmid, self.rmcreator_id, - is_public=False) + self.created_rmid = yield self.create_room_as(self.rmcreator_id, + is_public=False) - self.created_public_rmid = "!def1234ghi:test" - yield self.create_room_as(self.created_public_rmid, self.rmcreator_id, - is_public=True) + self.created_public_rmid = yield self.create_room_as(self.rmcreator_id, + is_public=True) # send a message in one of the rooms self.created_rmid_msg_path = ("/rooms/%s/send/m.room.message/a1" % @@ -423,8 +421,7 @@ class RoomsMemberListTestCase(RestTestCase): @defer.inlineCallbacks def test_get_member_list(self): - room_id = "!aa:test" - yield self.create_room_as(room_id, self.user_id) + room_id = yield self.create_room_as(self.user_id) (code, response) = yield self.mock_resource.trigger_get( "/rooms/%s/members" % room_id) self.assertEquals(200, code, msg=str(response)) @@ -437,18 +434,16 @@ class RoomsMemberListTestCase(RestTestCase): @defer.inlineCallbacks def test_get_member_list_no_permission(self): - room_id = "!bb:test" - yield self.create_room_as(room_id, "@some_other_guy:red") + room_id = yield self.create_room_as("@some_other_guy:red") (code, response) = yield self.mock_resource.trigger_get( "/rooms/%s/members" % room_id) self.assertEquals(403, code, msg=str(response)) @defer.inlineCallbacks def test_get_member_list_mixed_memberships(self): - room_id = "!bb:test" room_creator = "@some_other_guy:blue" + room_id = yield self.create_room_as(room_creator) room_path = "/rooms/%s/members" % room_id - yield self.create_room_as(room_id, room_creator) yield self.invite(room=room_id, src=room_creator, targ=self.user_id) # can't see list if you're just invited. @@ -503,107 +498,57 @@ class RoomsCreateTestCase(RestTestCase): @defer.inlineCallbacks def test_post_room_no_keys(self): # POST with no config keys, expect new room id - (code, response) = yield self.mock_resource.trigger("POST", "/rooms", - "{}") + (code, response) = yield self.mock_resource.trigger("POST", + "/createRoom", + "{}") self.assertEquals(200, code, response) self.assertTrue("room_id" in response) @defer.inlineCallbacks def test_post_room_visibility_key(self): # POST with visibility config key, expect new room id - (code, response) = yield self.mock_resource.trigger("POST", "/rooms", - '{"visibility":"private"}') + (code, response) = yield self.mock_resource.trigger( + "POST", + "/createRoom", + '{"visibility":"private"}') self.assertEquals(200, code) self.assertTrue("room_id" in response) @defer.inlineCallbacks def test_post_room_custom_key(self): # POST with custom config keys, expect new room id - (code, response) = yield self.mock_resource.trigger("POST", "/rooms", - '{"custom":"stuff"}') + (code, response) = yield self.mock_resource.trigger( + "POST", + "/createRoom", + '{"custom":"stuff"}') self.assertEquals(200, code) self.assertTrue("room_id" in response) @defer.inlineCallbacks def test_post_room_known_and_unknown_keys(self): # POST with custom + known config keys, expect new room id - (code, response) = yield self.mock_resource.trigger("POST", "/rooms", - '{"visibility":"private","custom":"things"}') + (code, response) = yield self.mock_resource.trigger( + "POST", + "/createRoom", + '{"visibility":"private","custom":"things"}') self.assertEquals(200, code) self.assertTrue("room_id" in response) @defer.inlineCallbacks def test_post_room_invalid_content(self): # POST with invalid content / paths, expect 400 - (code, response) = yield self.mock_resource.trigger("POST", "/rooms", - '{"visibili') - self.assertEquals(400, code) - - (code, response) = yield self.mock_resource.trigger("POST", "/rooms", - '["hello"]') - self.assertEquals(400, code) - - @defer.inlineCallbacks - def test_put_room_no_keys(self): - # PUT with no config keys, expect new room id - (code, response) = yield self.mock_resource.trigger( - "PUT", "/rooms/%21aa%3Atest", "{}" - ) - self.assertEquals(200, code) - self.assertTrue("room_id" in response) - - @defer.inlineCallbacks - def test_put_room_visibility_key(self): - # PUT with known config keys, expect new room id - (code, response) = yield self.mock_resource.trigger( - "PUT", "/rooms/%21bb%3Atest", '{"visibility":"private"}' - ) - self.assertEquals(200, code) - self.assertTrue("room_id" in response) - - @defer.inlineCallbacks - def test_put_room_custom_key(self): - # PUT with custom config keys, expect new room id - (code, response) = yield self.mock_resource.trigger( - "PUT", "/rooms/%21cc%3Atest", '{"custom":"stuff"}' - ) - self.assertEquals(200, code) - self.assertTrue("room_id" in response) - - @defer.inlineCallbacks - def test_put_room_known_and_unknown_keys(self): - # PUT with custom + known config keys, expect new room id (code, response) = yield self.mock_resource.trigger( - "PUT", "/rooms/%21dd%3Atest", - '{"visibility":"private","custom":"things"}' - ) - self.assertEquals(200, code) - self.assertTrue("room_id" in response) - - @defer.inlineCallbacks - def test_put_room_invalid_content(self): - # PUT with invalid content / room names, expect 400 - - (code, response) = yield self.mock_resource.trigger( - "PUT", "/rooms/ee", '{"sdf"' - ) + "POST", + "/createRoom", + '{"visibili') self.assertEquals(400, code) (code, response) = yield self.mock_resource.trigger( - "PUT", "/rooms/ee", '["hello"]' - ) + "POST", + "/createRoom", + '["hello"]') self.assertEquals(400, code) - @defer.inlineCallbacks - def test_put_room_conflict(self): - yield self.create_room_as("!aa:test", self.user_id) - - # PUT with conflicting room ID, expect 409 - (code, response) = yield self.mock_resource.trigger( - "PUT", "/rooms/%21aa%3Atest", "{}" - ) - self.assertEquals(409, code) - class RoomTopicTestCase(RestTestCase): """ Tests /rooms/$room_id/topic REST events. """ @@ -613,8 +558,6 @@ class RoomTopicTestCase(RestTestCase): def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.auth_user_id = self.user_id - self.room_id = "!rid1:test" - self.path = "/rooms/%s/state/m.room.topic" % self.room_id state_handler = Mock(spec=["handle_new_event"]) state_handler.handle_new_event.return_value = True @@ -640,7 +583,8 @@ class RoomTopicTestCase(RestTestCase): synapse.rest.room.register_servlets(hs, self.mock_resource) # create the room - yield self.create_room_as(self.room_id, self.user_id) + self.room_id = yield self.create_room_as(self.user_id) + self.path = "/rooms/%s/state/m.room.topic" % self.room_id def tearDown(self): pass @@ -717,7 +661,6 @@ class RoomMemberStateTestCase(RestTestCase): def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.auth_user_id = self.user_id - self.room_id = "!rid1:test" state_handler = Mock(spec=["handle_new_event"]) state_handler.handle_new_event.return_value = True @@ -742,7 +685,7 @@ class RoomMemberStateTestCase(RestTestCase): synapse.rest.room.register_servlets(hs, self.mock_resource) - yield self.create_room_as(self.room_id, self.user_id) + self.room_id = yield self.create_room_as(self.user_id) def tearDown(self): pass @@ -843,7 +786,6 @@ class RoomMessagesTestCase(RestTestCase): def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.auth_user_id = self.user_id - self.room_id = "!rid1:test" state_handler = Mock(spec=["handle_new_event"]) state_handler.handle_new_event.return_value = True @@ -868,7 +810,7 @@ class RoomMessagesTestCase(RestTestCase): synapse.rest.room.register_servlets(hs, self.mock_resource) - yield self.create_room_as(self.room_id, self.user_id) + self.room_id = yield self.create_room_as(self.user_id) def tearDown(self): pass diff --git a/tests/rest/utils.py b/tests/rest/utils.py index 590d12f155..ef9a6071e2 100644 --- a/tests/rest/utils.py +++ b/tests/rest/utils.py @@ -24,6 +24,7 @@ from synapse.api.constants import Membership import json import time + class RestTestCase(unittest.TestCase): """Contains extra helper functions to quickly and clearly perform a given REST action, which isn't the focus of the test. @@ -40,18 +41,19 @@ class RestTestCase(unittest.TestCase): return self.auth_user_id @defer.inlineCallbacks - def create_room_as(self, room_id, room_creator, is_public=True, tok=None): + def create_room_as(self, room_creator, is_public=True, tok=None): temp_id = self.auth_user_id self.auth_user_id = room_creator - path = "/rooms/%s" % room_id + path = "/createRoom" content = "{}" if not is_public: content = '{"visibility":"private"}' if tok: path = path + "?access_token=%s" % tok - (code, response) = yield self.mock_resource.trigger("PUT", path, content) + (code, response) = yield self.mock_resource.trigger("POST", path, content) self.assertEquals(200, code, msg=str(response)) self.auth_user_id = temp_id + defer.returnValue(response["room_id"]) @defer.inlineCallbacks def invite(self, room=None, src=None, targ=None, expect_code=200, tok=None): diff --git a/webclient/components/matrix/matrix-service.js b/webclient/components/matrix/matrix-service.js index 2286485605..ba4c3aeeca 100644 --- a/webclient/components/matrix/matrix-service.js +++ b/webclient/components/matrix/matrix-service.js @@ -97,7 +97,7 @@ angular.module('matrixService', []) // Create a room create: function(room_id, visibility) { // The REST path spec - var path = "/rooms"; + var path = "/createRoom"; return doRequest("POST", path, undefined, { visibility: visibility, -- cgit 1.5.1 From 135a1aa229f09badb7aeb79e803ab5d7654230ac Mon Sep 17 00:00:00 2001 From: Kegan Dougal Date: Wed, 27 Aug 2014 11:37:53 +0100 Subject: Final url modifications: renamed /presence_list to /presence/list to keep the top-level namespace clean. Updated tests. --- synapse/rest/presence.py | 2 +- tests/rest/test_presence.py | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) (limited to 'synapse/rest') diff --git a/synapse/rest/presence.py b/synapse/rest/presence.py index 6043848595..e013b20853 100644 --- a/synapse/rest/presence.py +++ b/synapse/rest/presence.py @@ -68,7 +68,7 @@ class PresenceStatusRestServlet(RestServlet): class PresenceListRestServlet(RestServlet): - PATTERN = client_path_pattern("/presence_list/(?P[^/]*)") + PATTERN = client_path_pattern("/presence/list/(?P[^/]*)") @defer.inlineCallbacks def on_GET(self, request, user_id): diff --git a/tests/rest/test_presence.py b/tests/rest/test_presence.py index 970405d271..e249a0d48a 100644 --- a/tests/rest/test_presence.py +++ b/tests/rest/test_presence.py @@ -171,7 +171,7 @@ class PresenceListTestCase(unittest.TestCase): ) (code, response) = yield self.mock_resource.trigger("GET", - "/presence_list/%s" % (myid), None) + "/presence/list/%s" % (myid), None) self.assertEquals(200, code) self.assertEquals( @@ -192,7 +192,7 @@ class PresenceListTestCase(unittest.TestCase): ) (code, response) = yield self.mock_resource.trigger("POST", - "/presence_list/%s" % (myid), + "/presence/list/%s" % (myid), """{"invite": ["@banana:test"]}""" ) @@ -212,7 +212,7 @@ class PresenceListTestCase(unittest.TestCase): ) (code, response) = yield self.mock_resource.trigger("POST", - "/presence_list/%s" % (myid), + "/presence/list/%s" % (myid), """{"drop": ["@banana:test"]}""" ) -- cgit 1.5.1