dendrite/roomserver/storage/postgres/storage.go
Till 8196b29657
Change detection of already executed migrations (#2665)
This changes the detection of already executed migrations for the
roomserver state block and keychange refactor. It now uses schema tables
provided by the database engine to check if the column was already
removed. We now also store the migration in the migrations table.

This should stop e.g. Postgres from logging errors like `ERROR: column
"event_nid" does not exist at character 8`.
2022-09-09 13:14:52 +01:00

215 lines
5.7 KiB
Go

// Copyright 2017-2018 New Vector Ltd
// Copyright 2019-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 implie
// See the License for the specific language governing permissions and
// limitations under the License.
package postgres
import (
"context"
"database/sql"
"errors"
"fmt"
"github.com/sirupsen/logrus"
// Import the postgres database driver.
_ "github.com/lib/pq"
"github.com/matrix-org/dendrite/internal/caching"
"github.com/matrix-org/dendrite/internal/sqlutil"
"github.com/matrix-org/dendrite/roomserver/storage/postgres/deltas"
"github.com/matrix-org/dendrite/roomserver/storage/shared"
"github.com/matrix-org/dendrite/setup/base"
"github.com/matrix-org/dendrite/setup/config"
)
// A Database is used to store room events and stream offsets.
type Database struct {
shared.Database
}
// Open a postgres database.
func Open(base *base.BaseDendrite, dbProperties *config.DatabaseOptions, cache caching.RoomServerCaches) (*Database, error) {
var d Database
var err error
db, writer, err := base.DatabaseConnection(dbProperties, sqlutil.NewDummyWriter())
if err != nil {
return nil, fmt.Errorf("sqlutil.Open: %w", err)
}
// Create the tables.
if err = d.create(db); err != nil {
return nil, err
}
// Special case, since this migration uses several tables, so it needs to
// be sure that all tables are created first.
if err = executeMigration(base.Context(), db); err != nil {
return nil, err
}
// Then prepare the statements. Now that the migrations have run, any columns referred
// to in the database code should now exist.
if err = d.prepare(db, writer, cache); err != nil {
return nil, err
}
return &d, nil
}
func executeMigration(ctx context.Context, db *sql.DB) error {
// TODO: Remove when we are sure we are not having goose artefacts in the db
// This forces an error, which indicates the migration is already applied, since the
// column event_nid was removed from the table
migrationName := "roomserver: state blocks refactor"
var cName string
err := db.QueryRowContext(ctx, "select column_name from information_schema.columns where table_name = 'roomserver_state_block' AND column_name = 'event_nid'").Scan(&cName)
if err != nil {
if errors.Is(err, sql.ErrNoRows) { // migration was already executed, as the column was removed
if err = sqlutil.InsertMigration(ctx, db, migrationName); err != nil {
// not a fatal error, log and continue
logrus.WithError(err).Warnf("unable to manually insert migration '%s'", migrationName)
}
return nil
}
return err
}
m := sqlutil.NewMigrator(db)
m.AddMigrations(sqlutil.Migration{
Version: migrationName,
Up: deltas.UpStateBlocksRefactor,
})
return m.Up(ctx)
}
func (d *Database) create(db *sql.DB) error {
if err := CreateEventStateKeysTable(db); err != nil {
return err
}
if err := CreateEventTypesTable(db); err != nil {
return err
}
if err := CreateEventJSONTable(db); err != nil {
return err
}
if err := CreateEventsTable(db); err != nil {
return err
}
if err := CreateRoomsTable(db); err != nil {
return err
}
if err := CreateStateBlockTable(db); err != nil {
return err
}
if err := CreateStateSnapshotTable(db); err != nil {
return err
}
if err := CreatePrevEventsTable(db); err != nil {
return err
}
if err := CreateRoomAliasesTable(db); err != nil {
return err
}
if err := CreateInvitesTable(db); err != nil {
return err
}
if err := CreateMembershipTable(db); err != nil {
return err
}
if err := CreatePublishedTable(db); err != nil {
return err
}
if err := CreateRedactionsTable(db); err != nil {
return err
}
return nil
}
func (d *Database) prepare(db *sql.DB, writer sqlutil.Writer, cache caching.RoomServerCaches) error {
eventStateKeys, err := PrepareEventStateKeysTable(db)
if err != nil {
return err
}
eventTypes, err := PrepareEventTypesTable(db)
if err != nil {
return err
}
eventJSON, err := PrepareEventJSONTable(db)
if err != nil {
return err
}
events, err := PrepareEventsTable(db)
if err != nil {
return err
}
rooms, err := PrepareRoomsTable(db)
if err != nil {
return err
}
stateBlock, err := PrepareStateBlockTable(db)
if err != nil {
return err
}
stateSnapshot, err := PrepareStateSnapshotTable(db)
if err != nil {
return err
}
prevEvents, err := PreparePrevEventsTable(db)
if err != nil {
return err
}
roomAliases, err := PrepareRoomAliasesTable(db)
if err != nil {
return err
}
invites, err := PrepareInvitesTable(db)
if err != nil {
return err
}
membership, err := PrepareMembershipTable(db)
if err != nil {
return err
}
published, err := PreparePublishedTable(db)
if err != nil {
return err
}
redactions, err := PrepareRedactionsTable(db)
if err != nil {
return err
}
d.Database = shared.Database{
DB: db,
Cache: cache,
Writer: writer,
EventTypesTable: eventTypes,
EventStateKeysTable: eventStateKeys,
EventJSONTable: eventJSON,
EventsTable: events,
RoomsTable: rooms,
StateBlockTable: stateBlock,
StateSnapshotTable: stateSnapshot,
PrevEventsTable: prevEvents,
RoomAliasesTable: roomAliases,
InvitesTable: invites,
MembershipTable: membership,
PublishedTable: published,
RedactionsTable: redactions,
}
return nil
}