From 732d954f89bb48e885072b9a50cf01c2cdd3e2cd Mon Sep 17 00:00:00 2001 From: Kegan Dougal Date: Tue, 26 Aug 2014 14:13:32 +0100 Subject: Added basic in-memory REST transaction storage. Only the latest transaction for a given path/access_token combo is stored in order to prevent storing ALL request/response pairs. --- synapse/rest/transactions.py | 93 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) create mode 100644 synapse/rest/transactions.py (limited to 'synapse/rest/transactions.py') diff --git a/synapse/rest/transactions.py b/synapse/rest/transactions.py new file mode 100644 index 0000000000..10be10e903 --- /dev/null +++ b/synapse/rest/transactions.py @@ -0,0 +1,93 @@ +# -*- coding: utf-8 -*- +# Copyright 2014 matrix.org +# +# 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. + +"""This module contains logic for storing HTTP PUT transactions. This is used +to ensure idempotency when performing PUTs using the REST API.""" +import logging + +logger = logging.getLogger(__name__) + + +class HttpTransactionStore(object): + + def __init__(self): + # { key : (txn_id, response) } + self.transactions = {} + + def get_response(self, key, txn_id): + """Retrieve a response for this request. + + Args: + key (str): A transaction-independent key for this request. Typically + this is a combination of the path (without the transaction id) and + the user's access token. + txn_id (str): The transaction ID for this request + Returns: + A tuple of (HTTP response code, response content) or None. + """ + try: + logger.debug("get_response Key: %s TxnId: %s", key, txn_id) + (last_txn_id, response) = self.transactions[key] + if txn_id == last_txn_id: + return response + except KeyError: + pass + return None + + def store_response(self, key, txn_id, response): + """Stores an HTTP response tuple. + + Args: + key (str): A transaction-independent key for this request. Typically + this is a combination of the path (without the transaction id) and + the user's access token. + txn_id (str): The transaction ID for this request. + response (tuple): A tuple of (HTTP response code, response content) + """ + logger.debug("store_response Key: %s TxnId: %s", key, txn_id) + self.transactions[key] = (txn_id, response) + + def store_client_transaction(self, request, txn_id, response): + """Stores the request/response pair of an HTTP transaction. + + Args: + request (twisted.web.http.Request): The twisted HTTP request. This + request must have the transaction ID as the last path segment. + response (tuple): A tuple of (response code, response dict) + txn_id (str): The transaction ID for this request. + """ + self.store_response(self._get_key(request), txn_id, response) + + def get_client_transaction(self, request, txn_id): + """Retrieves a stored response if there was one. + + Args: + request (twisted.web.http.Request): The twisted HTTP request. This + request must have the transaction ID as the last path segment. + txn_id (str): The transaction ID for this request. + Returns: + The response tuple or (None, None). + """ + response = self.get_response(self._get_key(request), txn_id) + if response is None: + return (None, None) + return response + + def _get_key(self, request): + token = request.args["access_token"][0] + path_without_txn_id = request.path.rsplit("/", 1)[0] + return path_without_txn_id + "/" + token + + -- cgit 1.4.1 From 5c0be8fde3602b9b7396cfdb2d689447f59217f7 Mon Sep 17 00:00:00 2001 From: Kegan Dougal Date: Tue, 26 Aug 2014 14:49:44 +0100 Subject: Implemented /rooms/$roomid/[invite|join|leave] with POST / PUT (incl txn ids) --- synapse/rest/room.py | 36 ++++++++++++++++++++++++++++++------ synapse/rest/transactions.py | 7 +++++-- 2 files changed, 35 insertions(+), 8 deletions(-) (limited to 'synapse/rest/transactions.py') diff --git a/synapse/rest/room.py b/synapse/rest/room.py index 4ca7e7e785..731317227d 100644 --- a/synapse/rest/room.py +++ b/synapse/rest/room.py @@ -374,17 +374,41 @@ class RoomMembershipRestServlet(RestServlet): "(?Pjoin|invite|leave)") register_txn_path(self, PATTERN, http_server) + @defer.inlineCallbacks def on_POST(self, request, room_id, membership_action): - return (200, "POST Not implemented") + user = yield self.auth.get_user_by_req(request) + + content = _parse_json(request) + # target user is you unless it is an invite + state_key = user.to_string() + if membership_action == "invite": + if "user_id" not in content: + raise SynapseError(400, "Missing user_id key.") + state_key = content["user_id"] + + event = self.event_factory.create_event( + etype=RoomMemberEvent.TYPE, + content={"membership": unicode(membership_action)}, + room_id=urllib.unquote(room_id), + user_id=user.to_string(), + state_key=state_key + ) + handler = self.handlers.room_member_handler + yield handler.change_membership(event) + defer.returnValue((200, "")) + + @defer.inlineCallbacks def on_PUT(self, request, room_id, membership_action, txn_id): - (code, response) = self.txns.get_client_transaction(request, txn_id) - if code: - return (code, response) + try: + defer.returnValue(self.txns.get_client_transaction(request, txn_id)) + except: + pass + + response = yield self.on_POST(request, room_id, membership_action) - response = (200, "PUT not implemented txnid %s" % txn_id) self.txns.store_client_transaction(request, txn_id, response) - return response + defer.returnValue(response) def _parse_json(request): diff --git a/synapse/rest/transactions.py b/synapse/rest/transactions.py index 10be10e903..b8aa1ef11c 100644 --- a/synapse/rest/transactions.py +++ b/synapse/rest/transactions.py @@ -41,6 +41,7 @@ class HttpTransactionStore(object): logger.debug("get_response Key: %s TxnId: %s", key, txn_id) (last_txn_id, response) = self.transactions[key] if txn_id == last_txn_id: + logger.info("get_response: Returning a response for %s", key) return response except KeyError: pass @@ -78,11 +79,13 @@ class HttpTransactionStore(object): request must have the transaction ID as the last path segment. txn_id (str): The transaction ID for this request. Returns: - The response tuple or (None, None). + The response tuple. + Raises: + KeyError if the transaction was not found. """ response = self.get_response(self._get_key(request), txn_id) if response is None: - return (None, None) + raise KeyError("Transaction not found.") return response def _get_key(self, request): -- cgit 1.4.1