MatrixSynapse/synapse/storage/transactions.py

371 lines
11 KiB
Python
Raw Normal View History

2014-08-12 16:10:52 +02:00
# -*- coding: utf-8 -*-
2015-01-06 14:21:39 +01:00
# Copyright 2014, 2015 OpenMarket Ltd
2014-08-12 16:10:52 +02: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.
2015-03-23 14:43:21 +01:00
from ._base import SQLBaseStore, cached
2014-08-12 16:10:52 +02:00
from collections import namedtuple
from syutil.jsonutil import encode_canonical_json
2014-08-12 16:10:52 +02:00
import logging
logger = logging.getLogger(__name__)
class TransactionStore(SQLBaseStore):
"""A collection of queries for handling PDUs.
"""
2014-12-10 11:16:09 +01:00
2014-08-12 16:10:52 +02:00
def get_received_txn_response(self, transaction_id, origin):
"""For an incoming transaction from a given origin, check if we have
already responded to it. If so, return the response code and response
body (as a dict).
Args:
transaction_id (str)
origin(str)
Returns:
tuple: None if we have not previously responded to
this transaction or a 2-tuple of (int, dict)
"""
return self.runInteraction(
"get_received_txn_response",
2014-08-12 16:10:52 +02:00
self._get_received_txn_response, transaction_id, origin
)
def _get_received_txn_response(self, txn, transaction_id, origin):
2015-03-20 16:05:44 +01:00
result = self._simple_select_one_txn(
txn,
table=ReceivedTransactionsTable.table_name,
keyvalues={
"transaction_id": transaction_id,
"origin": origin,
},
retcols=ReceivedTransactionsTable.fields,
allow_none=True,
)
2014-08-12 16:10:52 +02:00
2015-03-20 16:05:44 +01:00
if result and result.response_code:
return result["response_code"], result["response_json"]
2014-08-12 16:10:52 +02:00
else:
return None
def set_received_txn_response(self, transaction_id, origin, code,
response_dict):
"""Persist the response we returened for an incoming transaction, and
should return for subsequent transactions with the same transaction_id
and origin.
Args:
txn
transaction_id (str)
origin (str)
code (int)
response_json (str)
"""
return self._simple_insert(
2015-03-23 14:43:21 +01:00
table=ReceivedTransactionsTable.table_name,
values={
2015-03-23 14:43:21 +01:00
"transaction_id": transaction_id,
"origin": origin,
"response_code": code,
"response_json": buffer(encode_canonical_json(response_dict)),
},
or_ignore=True,
desc="set_received_txn_response",
2015-03-23 14:43:21 +01:00
)
2014-08-12 16:10:52 +02:00
def prep_send_transaction(self, transaction_id, destination,
origin_server_ts):
2014-08-12 16:10:52 +02:00
"""Persists an outgoing transaction and calculates the values for the
previous transaction id list.
This should be called before sending the transaction so that it has the
correct value for the `prev_ids` key.
Args:
transaction_id (str)
destination (str)
origin_server_ts (int)
2014-08-12 16:10:52 +02:00
Returns:
list: A list of previous transaction ids.
"""
return self.runInteraction(
"prep_send_transaction",
2014-08-12 16:10:52 +02:00
self._prep_send_transaction,
transaction_id, destination, origin_server_ts
2014-08-12 16:10:52 +02:00
)
def _prep_send_transaction(self, txn, transaction_id, destination,
origin_server_ts):
2014-08-12 16:10:52 +02:00
next_id = self._transaction_id_gen.get_next_txn(txn)
# First we find out what the prev_txns should be.
2014-08-12 16:10:52 +02:00
# Since we know that we are only sending one transaction at a time,
# we can simply take the last one.
2015-03-23 14:43:21 +01:00
query = (
"SELECT * FROM sent_transactions"
" WHERE destination = ?"
" ORDER BY id DESC LIMIT 1"
)
2014-08-12 16:10:52 +02:00
txn.execute(query, (destination,))
2015-03-23 14:43:21 +01:00
results = self.cursor_to_dict(txn)
2014-08-12 16:10:52 +02:00
2015-03-23 14:43:21 +01:00
prev_txns = [r["transaction_id"] for r in results]
2014-08-12 16:10:52 +02:00
# Actually add the new transaction to the sent_transactions table.
2015-03-23 14:43:21 +01:00
self._simple_insert_txn(
txn,
table=SentTransactions.table_name,
values={
"id": next_id,
2015-03-24 17:20:05 +01:00
"transaction_id": transaction_id,
2015-03-23 14:43:21 +01:00
"destination": destination,
"ts": origin_server_ts,
"response_code": 0,
"response_json": None,
}
)
# TODO Update the tx id -> pdu id mapping
2014-08-12 16:10:52 +02:00
return prev_txns
def delivered_txn(self, transaction_id, destination, code, response_dict):
"""Persists the response for an outgoing transaction.
Args:
transaction_id (str)
destination (str)
code (int)
response_json (str)
"""
return self.runInteraction(
"delivered_txn",
2014-08-12 16:10:52 +02:00
self._delivered_txn,
2015-05-05 19:20:01 +02:00
transaction_id, destination, code,
buffer(encode_canonical_json(response_dict)),
2014-08-12 16:10:52 +02:00
)
2015-03-23 14:43:21 +01:00
def _delivered_txn(self, txn, transaction_id, destination,
2014-08-12 16:10:52 +02:00
code, response_json):
2015-03-23 14:43:21 +01:00
self._simple_update_one_txn(
txn,
table=SentTransactions.table_name,
keyvalues={
"transaction_id": transaction_id,
"destination": destination,
},
updatevalues={
"response_code": code,
"response_json": None, # For now, don't persist response_json
2015-03-23 14:43:21 +01:00
}
)
2014-08-12 16:10:52 +02:00
def get_transactions_after(self, transaction_id, destination):
"""Get all transactions after a given local transaction_id.
Args:
transaction_id (str)
destination (str)
Returns:
2015-03-23 14:43:21 +01:00
list: A list of dicts
2014-08-12 16:10:52 +02:00
"""
return self.runInteraction(
"get_transactions_after",
2014-08-12 16:10:52 +02:00
self._get_transactions_after, transaction_id, destination
)
2015-03-23 14:43:21 +01:00
def _get_transactions_after(self, txn, transaction_id, destination):
query = (
"SELECT * FROM sent_transactions"
" WHERE destination = ? AND id >"
" ("
" SELECT id FROM sent_transactions"
" WHERE transaction_id = ? AND destination = ?"
" )"
2014-08-12 16:10:52 +02:00
)
txn.execute(query, (destination, transaction_id, destination))
2015-03-23 14:43:21 +01:00
return self.cursor_to_dict(txn)
2014-08-12 16:10:52 +02:00
@cached()
def get_destination_retry_timings(self, destination):
"""Gets the current retry timings (if any) for a given destination.
2014-12-10 11:16:09 +01:00
Args:
destination (str)
2014-12-10 11:16:09 +01:00
Returns:
None if not retrying
2015-03-23 14:43:21 +01:00
Otherwise a dict for the retry scheme
"""
return self.runInteraction(
"get_destination_retry_timings",
self._get_destination_retry_timings, destination)
2014-12-10 11:16:09 +01:00
2015-03-23 14:43:21 +01:00
def _get_destination_retry_timings(self, txn, destination):
result = self._simple_select_one_txn(
txn,
table=DestinationsTable.table_name,
keyvalues={
"destination": destination,
},
retcols=DestinationsTable.fields,
allow_none=True,
)
2015-03-24 17:20:05 +01:00
if result and result["retry_last_ts"] > 0:
2015-03-23 14:43:21 +01:00
return result
else:
return None
2014-12-10 11:16:09 +01:00
2014-12-10 01:03:55 +01:00
def set_destination_retry_timings(self, destination,
retry_last_ts, retry_interval):
"""Sets the current retry timings for a given destination.
Both timings should be zero if retrying is no longer occuring.
2014-12-10 11:16:09 +01:00
Args:
destination (str)
retry_last_ts (int) - time of last retry attempt in unix epoch ms
retry_interval (int) - how long until next retry in ms
"""
2014-12-10 11:16:09 +01:00
# As this is the new value, we might as well prefill the cache
self.get_destination_retry_timings.prefill(
destination,
2015-03-23 14:43:21 +01:00
{
"destination": destination,
"retry_last_ts": retry_last_ts,
"retry_interval": retry_interval
},
)
2014-12-10 11:16:09 +01:00
2014-12-10 01:03:55 +01:00
# XXX: we could chose to not bother persisting this if our cache thinks
# this is a NOOP
return self.runInteraction(
"set_destination_retry_timings",
2014-12-10 11:16:09 +01:00
self._set_destination_retry_timings,
destination,
retry_last_ts,
retry_interval,
)
def _set_destination_retry_timings(self, txn, destination,
2014-12-10 01:03:55 +01:00
retry_last_ts, retry_interval):
query = (
"UPDATE destinations"
" SET retry_last_ts = ?, retry_interval = ?"
2015-03-25 18:15:20 +01:00
" WHERE destination = ?"
2015-03-23 14:43:21 +01:00
)
2015-03-23 14:43:21 +01:00
txn.execute(
query,
(
retry_last_ts, retry_interval, destination,
2015-03-23 14:43:21 +01:00
)
)
if txn.rowcount == 0:
# destination wasn't already in table. Insert it.
self._simple_insert_txn(
txn,
table="destinations",
values={
"destination": destination,
"retry_last_ts": retry_last_ts,
"retry_interval": retry_interval,
}
)
def get_destinations_needing_retry(self):
"""Get all destinations which are due a retry for sending a transaction.
2014-12-10 11:16:09 +01:00
Returns:
2015-03-23 14:43:21 +01:00
list: A list of dicts
"""
2014-12-10 11:16:09 +01:00
return self.runInteraction(
"get_destinations_needing_retry",
self._get_destinations_needing_retry
)
2014-12-10 11:16:09 +01:00
2015-03-23 14:43:21 +01:00
def _get_destinations_needing_retry(self, txn):
query = (
"SELECT * FROM destinations"
" WHERE retry_last_ts > 0 and retry_next_ts < ?"
)
txn.execute(query, (self._clock.time_msec(),))
return self.cursor_to_dict(txn)
2014-12-10 11:16:09 +01:00
2014-08-12 16:10:52 +02:00
2015-03-23 14:43:21 +01:00
class ReceivedTransactionsTable(object):
2014-08-12 16:10:52 +02:00
table_name = "received_transactions"
fields = [
"transaction_id",
"origin",
"ts",
2014-08-12 16:10:52 +02:00
"response_code",
"response_json",
"has_been_referenced",
]
2015-03-23 14:43:21 +01:00
class SentTransactions(object):
2014-08-12 16:10:52 +02:00
table_name = "sent_transactions"
fields = [
"id",
"transaction_id",
"destination",
"ts",
2014-08-12 16:10:52 +02:00
"response_code",
"response_json",
]
EntryType = namedtuple("SentTransactionsEntry", fields)
2015-03-23 14:43:21 +01:00
class TransactionsToPduTable(object):
2014-08-12 16:10:52 +02:00
table_name = "transaction_id_to_pdu"
fields = [
"transaction_id",
"destination",
"pdu_id",
"pdu_origin",
]
2014-12-10 11:16:09 +01:00
2015-03-23 14:43:21 +01:00
class DestinationsTable(object):
table_name = "destinations"
2014-12-10 11:16:09 +01:00
fields = [
"destination",
"retry_last_ts",
"retry_interval",
]