mirror of
https://github.com/zitadel/zitadel.git
synced 2024-12-16 21:08:00 +00:00
dab5d9e756
# Which Problems Are Solved If many events are written to the same aggregate id it can happen that zitadel [starts to retry the push transaction](48ffc902cc/internal/eventstore/eventstore.go (L101)) because [the locking behaviour](48ffc902cc/internal/eventstore/v3/sequence.go (L25)) during push does compute the wrong sequence because newly committed events are not visible to the transaction. These events impact the current sequence. In cases with high command traffic on a single aggregate id this can have severe impact on general performance of zitadel. Because many connections of the `eventstore pusher` database pool are blocked by each other. # How the Problems Are Solved To improve the performance this locking mechanism was removed and the business logic of push is moved to sql functions which reduce network traffic and can be analyzed by the database before the actual push. For clients of the eventstore framework nothing changed. # Additional Changes - after a connection is established prefetches the newly added database types - `eventstore.BaseEvent` now returns the correct revision of the event # Additional Context - part of https://github.com/zitadel/zitadel/issues/8931 --------- Co-authored-by: Tim Möhlmann <tim+github@zitadel.com> Co-authored-by: Livio Spring <livio.a@gmail.com> Co-authored-by: Max Peintner <max@caos.ch> Co-authored-by: Elio Bischof <elio@zitadel.com> Co-authored-by: Stefan Benz <46600784+stebenz@users.noreply.github.com> Co-authored-by: Miguel Cabrerizo <30386061+doncicuto@users.noreply.github.com> Co-authored-by: Joakim Lodén <Loddan@users.noreply.github.com> Co-authored-by: Yxnt <Yxnt@users.noreply.github.com> Co-authored-by: Stefan Benz <stefan@caos.ch> Co-authored-by: Harsha Reddy <harsha.reddy@klaviyo.com> Co-authored-by: Zach H <zhirschtritt@gmail.com>
483 lines
9.5 KiB
Go
483 lines
9.5 KiB
Go
package eventstore
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/zitadel/zitadel/internal/api/authz"
|
|
"github.com/zitadel/zitadel/internal/eventstore"
|
|
)
|
|
|
|
func Test_commandToEvent(t *testing.T) {
|
|
payload := struct {
|
|
ID string
|
|
}{
|
|
ID: "test",
|
|
}
|
|
payloadMarshalled, err := json.Marshal(payload)
|
|
if err != nil {
|
|
t.Fatalf("marshal of payload failed: %v", err)
|
|
}
|
|
type args struct {
|
|
command eventstore.Command
|
|
}
|
|
type want struct {
|
|
event *event
|
|
err func(t *testing.T, err error)
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want want
|
|
}{
|
|
{
|
|
name: "no payload",
|
|
args: args{
|
|
command: &mockCommand{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
payload: nil,
|
|
},
|
|
},
|
|
want: want{
|
|
event: mockEvent(
|
|
mockAggregate("V3-Red9I"),
|
|
0,
|
|
nil,
|
|
).(*event),
|
|
},
|
|
},
|
|
{
|
|
name: "struct payload",
|
|
args: args{
|
|
command: &mockCommand{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
payload: payload,
|
|
},
|
|
},
|
|
want: want{
|
|
event: mockEvent(
|
|
mockAggregate("V3-Red9I"),
|
|
0,
|
|
payloadMarshalled,
|
|
).(*event),
|
|
},
|
|
},
|
|
{
|
|
name: "pointer payload",
|
|
args: args{
|
|
command: &mockCommand{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
payload: &payload,
|
|
},
|
|
},
|
|
want: want{
|
|
event: mockEvent(
|
|
mockAggregate("V3-Red9I"),
|
|
0,
|
|
payloadMarshalled,
|
|
).(*event),
|
|
},
|
|
},
|
|
{
|
|
name: "invalid payload",
|
|
args: args{
|
|
command: &mockCommand{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
payload: func() {},
|
|
},
|
|
},
|
|
want: want{
|
|
err: func(t *testing.T, err error) {
|
|
assert.Error(t, err)
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
if tt.want.err == nil {
|
|
tt.want.err = func(t *testing.T, err error) {
|
|
require.NoError(t, err)
|
|
}
|
|
}
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := commandToEvent(tt.args.command)
|
|
|
|
tt.want.err(t, err)
|
|
if tt.want.event == nil {
|
|
assert.Nil(t, got)
|
|
return
|
|
}
|
|
assert.Equal(t, tt.want.event, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_commandToEventOld(t *testing.T) {
|
|
payload := struct {
|
|
ID string
|
|
}{
|
|
ID: "test",
|
|
}
|
|
payloadMarshalled, err := json.Marshal(payload)
|
|
if err != nil {
|
|
t.Fatalf("marshal of payload failed: %v", err)
|
|
}
|
|
type args struct {
|
|
sequence *latestSequence
|
|
command eventstore.Command
|
|
}
|
|
type want struct {
|
|
event *event
|
|
err func(t *testing.T, err error)
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want want
|
|
}{
|
|
{
|
|
name: "no payload",
|
|
args: args{
|
|
sequence: &latestSequence{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
sequence: 0,
|
|
},
|
|
command: &mockCommand{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
payload: nil,
|
|
},
|
|
},
|
|
want: want{
|
|
event: mockEvent(
|
|
mockAggregate("V3-Red9I"),
|
|
0,
|
|
nil,
|
|
).(*event),
|
|
},
|
|
},
|
|
{
|
|
name: "struct payload",
|
|
args: args{
|
|
sequence: &latestSequence{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
sequence: 0,
|
|
},
|
|
command: &mockCommand{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
payload: payload,
|
|
},
|
|
},
|
|
want: want{
|
|
event: mockEvent(
|
|
mockAggregate("V3-Red9I"),
|
|
0,
|
|
payloadMarshalled,
|
|
).(*event),
|
|
},
|
|
},
|
|
{
|
|
name: "pointer payload",
|
|
args: args{
|
|
sequence: &latestSequence{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
sequence: 0,
|
|
},
|
|
command: &mockCommand{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
payload: &payload,
|
|
},
|
|
},
|
|
want: want{
|
|
event: mockEvent(
|
|
mockAggregate("V3-Red9I"),
|
|
0,
|
|
payloadMarshalled,
|
|
).(*event),
|
|
},
|
|
},
|
|
{
|
|
name: "invalid payload",
|
|
args: args{
|
|
sequence: &latestSequence{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
sequence: 0,
|
|
},
|
|
command: &mockCommand{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
payload: func() {},
|
|
},
|
|
},
|
|
want: want{
|
|
err: func(t *testing.T, err error) {
|
|
assert.Error(t, err)
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
if tt.want.err == nil {
|
|
tt.want.err = func(t *testing.T, err error) {
|
|
require.NoError(t, err)
|
|
}
|
|
}
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := commandToEventOld(tt.args.sequence, tt.args.command)
|
|
|
|
tt.want.err(t, err)
|
|
assert.Equal(t, tt.want.event, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_commandsToEvents(t *testing.T) {
|
|
ctx := context.Background()
|
|
payload := struct {
|
|
ID string
|
|
}{
|
|
ID: "test",
|
|
}
|
|
payloadMarshalled, err := json.Marshal(payload)
|
|
if err != nil {
|
|
t.Fatalf("marshal of payload failed: %v", err)
|
|
}
|
|
type args struct {
|
|
ctx context.Context
|
|
cmds []eventstore.Command
|
|
}
|
|
type want struct {
|
|
events []eventstore.Event
|
|
commands []*command
|
|
err func(t *testing.T, err error)
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want want
|
|
}{
|
|
{
|
|
name: "no commands",
|
|
args: args{
|
|
ctx: ctx,
|
|
cmds: nil,
|
|
},
|
|
want: want{
|
|
events: []eventstore.Event{},
|
|
commands: []*command{},
|
|
err: func(t *testing.T, err error) {
|
|
require.NoError(t, err)
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "single command no payload",
|
|
args: args{
|
|
ctx: ctx,
|
|
cmds: []eventstore.Command{
|
|
&mockCommand{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
payload: nil,
|
|
},
|
|
},
|
|
},
|
|
want: want{
|
|
events: []eventstore.Event{
|
|
mockEvent(
|
|
mockAggregate("V3-Red9I"),
|
|
0,
|
|
nil,
|
|
),
|
|
},
|
|
commands: []*command{
|
|
{
|
|
InstanceID: "instance",
|
|
AggregateType: "type",
|
|
AggregateID: "V3-Red9I",
|
|
Owner: "ro",
|
|
CommandType: "event.type",
|
|
Revision: 1,
|
|
Payload: nil,
|
|
Creator: "creator",
|
|
},
|
|
},
|
|
err: func(t *testing.T, err error) {
|
|
require.NoError(t, err)
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "single command no instance id",
|
|
args: args{
|
|
ctx: authz.WithInstanceID(ctx, "instance from ctx"),
|
|
cmds: []eventstore.Command{
|
|
&mockCommand{
|
|
aggregate: mockAggregateWithInstance("V3-Red9I", ""),
|
|
payload: nil,
|
|
},
|
|
},
|
|
},
|
|
want: want{
|
|
events: []eventstore.Event{
|
|
mockEvent(
|
|
mockAggregateWithInstance("V3-Red9I", "instance from ctx"),
|
|
0,
|
|
nil,
|
|
),
|
|
},
|
|
commands: []*command{
|
|
{
|
|
InstanceID: "instance from ctx",
|
|
AggregateType: "type",
|
|
AggregateID: "V3-Red9I",
|
|
Owner: "ro",
|
|
CommandType: "event.type",
|
|
Revision: 1,
|
|
Payload: nil,
|
|
Creator: "creator",
|
|
},
|
|
},
|
|
err: func(t *testing.T, err error) {
|
|
require.NoError(t, err)
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "single command with payload",
|
|
args: args{
|
|
ctx: ctx,
|
|
cmds: []eventstore.Command{
|
|
&mockCommand{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
payload: payload,
|
|
},
|
|
},
|
|
},
|
|
want: want{
|
|
events: []eventstore.Event{
|
|
mockEvent(
|
|
mockAggregate("V3-Red9I"),
|
|
0,
|
|
payloadMarshalled,
|
|
),
|
|
},
|
|
commands: []*command{
|
|
{
|
|
InstanceID: "instance",
|
|
AggregateType: "type",
|
|
AggregateID: "V3-Red9I",
|
|
Owner: "ro",
|
|
CommandType: "event.type",
|
|
Revision: 1,
|
|
Payload: payloadMarshalled,
|
|
Creator: "creator",
|
|
},
|
|
},
|
|
err: func(t *testing.T, err error) {
|
|
require.NoError(t, err)
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "multiple commands",
|
|
args: args{
|
|
ctx: ctx,
|
|
cmds: []eventstore.Command{
|
|
&mockCommand{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
payload: payload,
|
|
},
|
|
&mockCommand{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
payload: nil,
|
|
},
|
|
},
|
|
},
|
|
want: want{
|
|
events: []eventstore.Event{
|
|
mockEvent(
|
|
mockAggregate("V3-Red9I"),
|
|
0,
|
|
payloadMarshalled,
|
|
),
|
|
mockEvent(
|
|
mockAggregate("V3-Red9I"),
|
|
0,
|
|
nil,
|
|
),
|
|
},
|
|
commands: []*command{
|
|
{
|
|
InstanceID: "instance",
|
|
AggregateType: "type",
|
|
AggregateID: "V3-Red9I",
|
|
CommandType: "event.type",
|
|
Revision: 1,
|
|
Payload: payloadMarshalled,
|
|
Creator: "creator",
|
|
Owner: "ro",
|
|
},
|
|
{
|
|
InstanceID: "instance",
|
|
AggregateType: "type",
|
|
AggregateID: "V3-Red9I",
|
|
CommandType: "event.type",
|
|
Revision: 1,
|
|
Payload: nil,
|
|
Creator: "creator",
|
|
Owner: "ro",
|
|
},
|
|
},
|
|
err: func(t *testing.T, err error) {
|
|
require.NoError(t, err)
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "invalid command",
|
|
args: args{
|
|
ctx: ctx,
|
|
cmds: []eventstore.Command{
|
|
&mockCommand{
|
|
aggregate: mockAggregate("V3-Red9I"),
|
|
payload: func() {},
|
|
},
|
|
},
|
|
},
|
|
want: want{
|
|
events: nil,
|
|
commands: nil,
|
|
err: func(t *testing.T, err error) {
|
|
assert.Error(t, err)
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
gotEvents, gotCommands, err := commandsToEvents(tt.args.ctx, tt.args.cmds)
|
|
|
|
tt.want.err(t, err)
|
|
assert.Equal(t, tt.want.events, gotEvents)
|
|
require.Len(t, gotCommands, len(tt.want.commands))
|
|
for i, wantCommand := range tt.want.commands {
|
|
assertCommand(t, wantCommand, gotCommands[i])
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func assertCommand(t *testing.T, want, got *command) {
|
|
t.Helper()
|
|
assert.Equal(t, want.CommandType, got.CommandType)
|
|
assert.Equal(t, want.Payload, got.Payload)
|
|
assert.Equal(t, want.Creator, got.Creator)
|
|
assert.Equal(t, want.Owner, got.Owner)
|
|
assert.Equal(t, want.AggregateID, got.AggregateID)
|
|
assert.Equal(t, want.AggregateType, got.AggregateType)
|
|
assert.Equal(t, want.InstanceID, got.InstanceID)
|
|
assert.Equal(t, want.Revision, got.Revision)
|
|
}
|