File size: 3,427 Bytes
1e92f2d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 |
package swosync
import (
"context"
"fmt"
"github.com/jackc/pgx/v5"
"github.com/target/goalert/util/log"
"github.com/target/goalert/util/sqlutil"
)
// LogicalSync will sync the source database to the destination database as fast as possible.
func (l *LogicalReplicator) LogicalSync(ctx context.Context) error { return l.doSync(ctx, false) }
// FinalSync will sync the source database to the destination database, using the stop-the-world lock
// and updating switchover_state to use_next_db.
func (l *LogicalReplicator) FinalSync(ctx context.Context) error { return l.doSync(ctx, true) }
func (l *LogicalReplicator) doSync(ctx context.Context, final bool) error {
b := new(pgx.Batch)
if final {
b.Queue(`begin`)
} else {
b.Queue(`begin isolation level serializable read only deferrable`)
}
b.Queue(txInProgressLock)
if final {
// stop-the-world lock before reads
b.Queue(txStopTheWorld)
}
seqSync := NewSequenceSync(l.seqNames)
seqSync.AddBatchReads(b)
tblSync := NewTableSync(l.tables)
tblSync.AddBatchChangeRead(b)
res := l.srcConn.SendBatch(ctx, b)
_, err := res.Exec() // begin tx
if err != nil {
return fmt.Errorf("read changes: begin tx: %w", err)
}
defer func(srcConn *pgx.Conn) { _, _ = srcConn.Exec(ctx, `rollback`) }(l.srcConn)
// in-progress lock & check
_, err = res.Exec()
if err != nil {
return fmt.Errorf("read changes: set tx timeout: %w", err)
}
if final {
// stop-the-world lock before reads
_, err = res.Exec()
if err != nil {
return fmt.Errorf("read changes: stop-the-world lock: %w", err)
}
}
err = seqSync.ScanBatchReads(res)
if err != nil {
return fmt.Errorf("read changes: scan seqs: %w", err)
}
err = tblSync.ScanBatchChangeRead(res)
if err != nil {
return fmt.Errorf("read changes: scan changes: %w", err)
}
err = res.Close()
if err != nil {
return fmt.Errorf("read changes: close batch: %w", err)
}
var readRows pgx.Batch
tblSync.AddBatchRowReads(&readRows)
if readRows.Len() > 0 {
res = l.srcConn.SendBatch(ctx, &readRows)
err = tblSync.ScanBatchRowReads(res)
if err != nil {
return fmt.Errorf("read changes: scan rows: %w", err)
}
err = res.Close()
if err != nil {
return fmt.Errorf("read changes: close batch: %w", err)
}
}
var applyChanges pgx.Batch
applyChanges.Queue("begin")
applyChanges.Queue("set constraints all deferred")
seqSync.AddBatchWrites(&applyChanges)
tblSync.AddBatchWrites(&applyChanges)
applyChanges.Queue("commit")
if final {
// re-enable triggers in destination DB
for _, t := range l.tables {
applyChanges.Queue(fmt.Sprintf(`alter table %s enable trigger user`, sqlutil.QuoteID(t.Name())))
}
}
err = l.dstConn.SendBatch(ctx, &applyChanges).Close()
if err != nil {
_, _ = l.dstConn.Exec(ctx, `rollback`)
return fmt.Errorf("apply changes: %w", err)
}
var finish pgx.Batch
if final {
// world is stopped, changes in new DB, triggers enabled, so we can safely update switchover_state
finish.Queue("update switchover_state set current_state = 'use_next_db' where current_state = 'in_progress'")
}
finish.Queue("commit")
err = l.srcConn.SendBatch(ctx, &finish).Close()
if err != nil {
return fmt.Errorf("commit sync read: %w", err)
}
_, err = tblSync.ExecDeleteChanges(ctx, l.srcConn)
if !final {
return err
}
if err != nil {
// log but don't return error in final since switchover is complete
log.Log(ctx, err)
}
return nil
}
|