mirror of
https://github.com/matrix-org/dendrite
synced 2024-09-08 20:25:36 +02:00
* Add Pushserver component with Pushers API Co-authored-by: Tommie Gannert <tommie@gannert.se> Co-authored-by: Dan Peleg <dan@globekeeper.com> * Wire Pushserver component Co-authored-by: Neil Alexander <neilalexander@users.noreply.github.com> * Add PushGatewayClient. The full event format is required for Sytest. * Add a pushrules module. * Change user API account creation to use the new pushrules module's defaults. Introduces "scope" as required by client API, and some small field tweaks to make some 61push Sytests pass. * Add push rules query/put API in Pushserver. This manipulates account data over User API, and fires sync messages for changes. Those sync messages should, according to an existing TODO in clientapi, be moved to userapi. Forks clientapi/producers/syncapi.go to pushserver/ for later extension. * Add clientapi routes for push rules to Pushserver. A cleanup would be to move more of the name-splitting logic into pushrules.go, to depollute routing.go. * Output rooms.join.unread_notifications in /sync. This is the read-side. Pushserver will be the write-side. * Implement pushserver/storage for notifications. * Use PushGatewayClient and the pushrules module in Pushserver's room consumer. * Use one goroutine per user to avoid locking up the entire server for one bad push gateway. * Split pushing by format. * Send one device per push. Sytest does not support coalescing multiple devices into one push. Matches Synapse. Either we change Sytest, or remove the group-by-url-and-format logic. * Write OutputNotificationData from push server. Sync API is already the consumer. * Implement read receipt consumers in Pushserver. Supports m.read and m.fully_read receipts. * Add clientapi route for /unstable/notifications. * Rename to UpsertPusher for clarity and handle pusher update * Fix linter errors * Ignore body.Close() error check * Fix push server internal http wiring * Add 40 newly passing 61push tests to whitelist * Add next 12 newly passing 61push tests to whitelist * Send notification data before notifying users in EDU server consumer * NATS JetStream * Goodbye sarama * Fix `NewStreamTokenFromString` * Consume on the correct topic for the roomserver * Don't panic, NAK instead * Move push notifications into the User API * Don't set null values since that apparently causes Element upsetti * Also set omitempty on conditions * Fix bug so that we don't override the push rules unnecessarily * Tweak defaults * Update defaults * More tweaks * Move `/notifications` onto `r0`/`v3` mux * User API will consume events and read/fully read markers from the sync API with stream positions, instead of consuming directly Co-authored-by: Piotr Kozimor <p1996k@gmail.com> Co-authored-by: Tommie Gannert <tommie@gannert.se> Co-authored-by: Neil Alexander <neilalexander@users.noreply.github.com>
171 lines
5.4 KiB
Go
171 lines
5.4 KiB
Go
// Copyright 2020 The Matrix.org Foundation C.I.C.
|
|
//
|
|
// 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.
|
|
|
|
package sqlutil
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/matrix-org/util"
|
|
)
|
|
|
|
// ErrUserExists is returned if a username already exists in the database.
|
|
var ErrUserExists = errors.New("username already exists")
|
|
|
|
// A Transaction is something that can be committed or rolledback.
|
|
type Transaction interface {
|
|
// Commit the transaction
|
|
Commit() error
|
|
// Rollback the transaction.
|
|
Rollback() error
|
|
}
|
|
|
|
// EndTransaction ends a transaction.
|
|
// If the transaction succeeded then it is committed, otherwise it is rolledback.
|
|
// You MUST check the error returned from this function to be sure that the transaction
|
|
// was applied correctly. For example, 'database is locked' errors in sqlite will happen here.
|
|
func EndTransaction(txn Transaction, succeeded *bool) error {
|
|
if *succeeded {
|
|
return txn.Commit()
|
|
} else {
|
|
return txn.Rollback()
|
|
}
|
|
}
|
|
|
|
// EndTransactionWithCheck ends a transaction and overwrites the error pointer if its value was nil.
|
|
// If the transaction succeeded then it is committed, otherwise it is rolledback.
|
|
// Designed to be used with defer (see EndTransaction otherwise).
|
|
func EndTransactionWithCheck(txn Transaction, succeeded *bool, err *error) {
|
|
if e := EndTransaction(txn, succeeded); e != nil && *err == nil {
|
|
*err = e
|
|
}
|
|
}
|
|
|
|
// WithTransaction runs a block of code passing in an SQL transaction
|
|
// If the code returns an error or panics then the transactions is rolledback
|
|
// Otherwise the transaction is committed.
|
|
func WithTransaction(db *sql.DB, fn func(txn *sql.Tx) error) (err error) {
|
|
txn, err := db.Begin()
|
|
if err != nil {
|
|
return fmt.Errorf("sqlutil.WithTransaction.Begin: %w", err)
|
|
}
|
|
succeeded := false
|
|
defer EndTransactionWithCheck(txn, &succeeded, &err)
|
|
|
|
err = fn(txn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
succeeded = true
|
|
return
|
|
}
|
|
|
|
// TxStmt wraps an SQL stmt inside an optional transaction.
|
|
// If the transaction is nil then it returns the original statement that will
|
|
// run outside of a transaction.
|
|
// Otherwise returns a copy of the statement that will run inside the transaction.
|
|
func TxStmt(transaction *sql.Tx, statement *sql.Stmt) *sql.Stmt {
|
|
if transaction != nil {
|
|
statement = transaction.Stmt(statement)
|
|
}
|
|
return statement
|
|
}
|
|
|
|
// TxStmtContext behaves similarly to TxStmt, with support for also passing context.
|
|
func TxStmtContext(context context.Context, transaction *sql.Tx, statement *sql.Stmt) *sql.Stmt {
|
|
if transaction != nil {
|
|
statement = transaction.StmtContext(context, statement)
|
|
}
|
|
return statement
|
|
}
|
|
|
|
// Hack of the century
|
|
func QueryVariadic(count int) string {
|
|
return QueryVariadicOffset(count, 0)
|
|
}
|
|
|
|
func QueryVariadicOffset(count, offset int) string {
|
|
str := "("
|
|
for i := 0; i < count; i++ {
|
|
str += fmt.Sprintf("$%d", i+offset+1)
|
|
if i < (count - 1) {
|
|
str += ", "
|
|
}
|
|
}
|
|
str += ")"
|
|
return str
|
|
}
|
|
|
|
func minOfInts(a, b int) int {
|
|
if a <= b {
|
|
return a
|
|
}
|
|
return b
|
|
}
|
|
|
|
// QueryProvider defines the interface for querys used by RunLimitedVariablesQuery.
|
|
type QueryProvider interface {
|
|
QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)
|
|
}
|
|
|
|
// SQLite3MaxVariables is the default maximum number of host parameters in a single SQL statement
|
|
// SQLlite can handle. See https://www.sqlite.org/limits.html for more information.
|
|
const SQLite3MaxVariables = 999
|
|
|
|
// RunLimitedVariablesQuery split up a query with more variables than the used database can handle in multiple queries.
|
|
func RunLimitedVariablesQuery(ctx context.Context, query string, qp QueryProvider, variables []interface{}, limit uint, rowHandler func(*sql.Rows) error) error {
|
|
var start int
|
|
for start < len(variables) {
|
|
n := minOfInts(len(variables)-start, int(limit))
|
|
nextQuery := strings.Replace(query, "($1)", QueryVariadic(n), 1)
|
|
rows, err := qp.QueryContext(ctx, nextQuery, variables[start:start+n]...)
|
|
if err != nil {
|
|
util.GetLogger(ctx).WithError(err).Error("QueryContext returned an error")
|
|
return err
|
|
}
|
|
err = rowHandler(rows)
|
|
if closeErr := rows.Close(); closeErr != nil {
|
|
util.GetLogger(ctx).WithError(closeErr).Error("RunLimitedVariablesQuery: failed to close rows")
|
|
return err
|
|
}
|
|
if err != nil {
|
|
util.GetLogger(ctx).WithError(err).Error("RunLimitedVariablesQuery: rowHandler returned error")
|
|
return err
|
|
}
|
|
start = start + n
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// StatementList is a list of SQL statements to prepare and a pointer to where to store the resulting prepared statement.
|
|
type StatementList []struct {
|
|
Statement **sql.Stmt
|
|
SQL string
|
|
}
|
|
|
|
// Prepare the SQL for each statement in the list and assign the result to the prepared statement.
|
|
func (s StatementList) Prepare(db *sql.DB) (err error) {
|
|
for _, statement := range s {
|
|
if *statement.Statement, err = db.Prepare(statement.SQL); err != nil {
|
|
err = fmt.Errorf("Error %q while preparing statement: %s", err, statement.SQL)
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|