Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat(review): call omni's SQL Review V2 contract from the rule review run
rebelice1f32d207da1a
diff --git a/backend/api/v1/issue_service_converter.go b/backend/api/v1/issue_service_converter.goindex d8dbe0941e..8147bbe25e 100644--- a/backend/api/v1/issue_service_converter.go+++ b/backend/api/v1/issue_service_converter.go@@ -183,13 +183,27 @@ func convertToIssueComments(issueName string, issueComments []*store.IssueCommenreturn res}+// convertToIssueCommentReviewMetadata casts across the mirrored store and v1+// enums; TestReviewRuleTypeEnumsMirror holds the rule numbering together.+func convertToIssueCommentReviewMetadata(metadata *storepb.IssueCommentPayload_ReviewMetadata) *v1pb.IssueComment_ReviewMetadata {+ return &v1pb.IssueComment_ReviewMetadata{+ RunType: convertToReviewRunType(metadata.RunType.String()),+ RuleType: v1pb.ReviewRuleType(metadata.RuleType),+ Priority: v1pb.IssueComment_ReviewMetadata_Priority(metadata.Priority),+ Targets: metadata.Targets,+ }+}+func convertToIssueComment(issueName string, ic *store.IssueCommentMessage) *v1pb.IssueComment {r := &v1pb.IssueComment{Comment: ic.Payload.Comment,CreateTime: timestamppb.New(ic.CreatedAt),UpdateTime: timestamppb.New(ic.UpdatedAt),Name: common.FormatIssueComment(issueName, ic.ResourceID),- Creator: common.FormatUserEmail(ic.CreatorEmail),+ }+ // A review result has no creator; its review_metadata names the reviewer.+ if ic.CreatorEmail != "" {+ r.Creator = common.FormatUserEmail(ic.CreatorEmail)}if ic.ParentID != nil {@@ -211,6 +225,9 @@ func convertToIssueComment(issueName string, ic *store.IssueCommentMessage) *v1pEndPosition: convertToPosition(anchor.EndPosition),}}+ if metadata := ic.Payload.GetReviewMetadata(); metadata != nil {+ r.ReviewMetadata = convertToIssueCommentReviewMetadata(metadata)+ }switch e := ic.Payload.Event.(type) {case *storepb.IssueCommentPayload_Approval_:diff --git a/backend/api/v1/org_policy_service_review_rule_test.go b/backend/api/v1/org_policy_service_review_rule_test.goindex 227a2c7966..6982bbf9ac 100644--- a/backend/api/v1/org_policy_service_review_rule_test.go+++ b/backend/api/v1/org_policy_service_review_rule_test.go@@ -26,6 +26,47 @@ func TestReviewRuleTypeEnumsMirror(t *testing.T) {}}+// TestReviewMetadataPriorityEnumsMirror holds the v1 and store review result+// priorities to the same numbering for convertToIssueCommentReviewMetadata.+func TestReviewMetadataPriorityEnumsMirror(t *testing.T) {+ t.Parallel()+ require.Equal(t, len(v1pb.IssueComment_ReviewMetadata_Priority_name), len(storepb.IssueCommentPayload_ReviewMetadata_Priority_name))+ for number, name := range v1pb.IssueComment_ReviewMetadata_Priority_name {+ require.Equal(t, name, storepb.IssueCommentPayload_ReviewMetadata_Priority_name[number], "value %d", number)+ }+}++func TestConvertToIssueCommentReviewResult(t *testing.T) {+ t.Parallel()+ got := convertToIssueComment("projects/p/issues/101", &store.IssueCommentMessage{+ ResourceID: "c1",+ Payload: &storepb.IssueCommentPayload{+ Comment: "UPDATE without WHERE",+ ReviewMetadata: &storepb.IssueCommentPayload_ReviewMetadata{+ RunType: storepb.ReviewRun_RULE,+ RuleType: storepb.ReviewRuleType_REQUIRE_WHERE,+ Priority: storepb.IssueCommentPayload_ReviewMetadata_P1,+ Targets: []string{"instances/i/databases/a", "instances/i/databases/b"},+ },+ },+ })+ require.Empty(t, got.Creator, "a review result has no creator")+ require.Equal(t, &v1pb.IssueComment_ReviewMetadata{+ RunType: v1pb.ReviewRun_RULE,+ RuleType: v1pb.ReviewRuleType_REQUIRE_WHERE,+ Priority: v1pb.IssueComment_ReviewMetadata_P1,+ Targets: []string{"instances/i/databases/a", "instances/i/databases/b"},+ }, got.ReviewMetadata)++ person := convertToIssueComment("projects/p/issues/101", &store.IssueCommentMessage{+ ResourceID: "c2",+ CreatorEmail: "[email protected]",+ Payload: &storepb.IssueCommentPayload{Comment: "looks fine"},+ })+ require.Equal(t, "users/[email protected]", person.Creator)+ require.Nil(t, person.ReviewMetadata)+}+func TestReviewRulePolicyConverterRoundTrip(t *testing.T) {t.Parallel()in := &v1pb.ReviewRulePolicy{Rules: []v1pb.ReviewRuleType{diff --git a/backend/migrator/migration/3.23/0005##issue_comment_creator_nullable.sql b/backend/migrator/migration/3.23/0005##issue_comment_creator_nullable.sqlnew file mode 100644index 0000000000..eb005caf49--- /dev/null+++ b/backend/migrator/migration/3.23/0005##issue_comment_creator_nullable.sql@@ -0,0 +1,4 @@+-- A review result is posted by a reviewer, not a person: its creator is NULL+-- and review_metadata names the reviewer, as task_run.creator is NULL for+-- system-generated runs.+ALTER TABLE issue_comment ALTER COLUMN creator DROP NOT NULL;diff --git a/backend/migrator/migration/LATEST.sql b/backend/migrator/migration/LATEST.sqlindex 799a7ad28c..57e85302a8 100644--- a/backend/migrator/migration/LATEST.sql+++ b/backend/migrator/migration/LATEST.sql@@ -360,7 +360,9 @@ CREATE INDEX idx_issue_ts_vector ON issue USING GIN(ts_vector);CREATE TABLE issue_comment (-- global uniqueresource_id text NOT NULL DEFAULT gen_random_uuid()::text,- creator text NOT NULL,+ -- NULL on review results, which a reviewer posts (payload.review_metadata+ -- names it), never a person.+ creator text,created_at timestamptz NOT NULL DEFAULT now(),updated_at timestamptz NOT NULL DEFAULT now(),project text NOT NULL REFERENCES project(resource_id),diff --git a/backend/migrator/migrator_test.go b/backend/migrator/migrator_test.goindex 86c25d2a54..947a13f7b4 100644--- a/backend/migrator/migrator_test.go+++ b/backend/migrator/migrator_test.go@@ -10,8 +10,8 @@ import (func TestLatestVersion(t *testing.T) {files, err := getSortedVersionedFiles()require.NoError(t, err)- require.Equal(t, semver.MustParse("3.23.4"), *files[len(files)-1].version)- require.Equal(t, "migration/3.23/0004##workload_identity_audiences.sql", files[len(files)-1].path)+ require.Equal(t, semver.MustParse("3.23.5"), *files[len(files)-1].version)+ require.Equal(t, "migration/3.23/0005##issue_comment_creator_nullable.sql", files[len(files)-1].path)}func TestVersionUnique(t *testing.T) {diff --git a/backend/runner/plancheck/check_target.go b/backend/runner/plancheck/check_target.goindex 07cc8a4944..7af1c7d3f9 100644--- a/backend/runner/plancheck/check_target.go+++ b/backend/runner/plancheck/check_target.go@@ -5,6 +5,8 @@ import storepb "github.com/bytebase/bytebase/backend/generated-go/store"// CheckTarget represents a derived check target from a plan.// This is computed at runtime from the plan's specs, not stored.type CheckTarget struct {+ // SpecID is the plan spec (PlanConfig.Spec.id) the target comes from.+ SpecID string// Target is the canonical database resource name: instances/{instance}/databases/{database}// or projects/{project}/instances/{instance}/databases/{database}.Target stringdiff --git a/backend/runner/plancheck/derive.go b/backend/runner/plancheck/derive.goindex a7b02547f2..f99969b250 100644--- a/backend/runner/plancheck/derive.go+++ b/backend/runner/plancheck/derive.go@@ -83,6 +83,7 @@ func deriveTargets(ctx context.Context, s *store.Store, project *store.ProjectMe}targets = append(targets, &CheckTarget{+ SpecID: spec.Id,Target: target,SheetSha256: config.ChangeDatabaseConfig.SheetSha256,EnablePriorBackup: config.ChangeDatabaseConfig.EnablePriorBackup,diff --git a/backend/runner/plancheck/derive_test.go b/backend/runner/plancheck/derive_test.goindex 60230d3629..3b151a2888 100644--- a/backend/runner/plancheck/derive_test.go+++ b/backend/runner/plancheck/derive_test.go@@ -22,6 +22,7 @@ func TestDeriveReviewTargetsSkipsCISampling(t *testing.T) {plan := &store.PlanMessage{Config: &storepb.PlanConfig{Specs: []*storepb.PlanConfig_Spec{{+ Id: "spec-1",Config: &storepb.PlanConfig_Spec_ChangeDatabaseConfig{ChangeDatabaseConfig: &storepb.PlanConfig_ChangeDatabaseConfig{Targets: []string{@@ -42,4 +43,7 @@ func TestDeriveReviewTargetsSkipsCISampling(t *testing.T) {full, err := DeriveReviewTargets(ctx, nil, project, plan, nil)require.NoError(t, err)require.Len(t, full, 3, "review must evaluate every target regardless of CI sampling")+ for _, target := range full {+ require.Equal(t, "spec-1", target.SpecID, "a review result anchors on its spec")+ }}diff --git a/backend/runner/plancheck/ghost_sync_executor.go b/backend/runner/plancheck/ghost_sync_executor.goindex eb447831e4..a8c7f5fd08 100644--- a/backend/runner/plancheck/ghost_sync_executor.go+++ b/backend/runner/plancheck/ghost_sync_executor.go@@ -63,7 +63,7 @@ func (e *GhostSyncExecutor) RunForTarget(ctx context.Context, target *CheckTarge}}()- instance, database, err := resolveDatabaseTarget(ctx, e.store, target.Target)+ instance, database, err := ResolveDatabaseTarget(ctx, e.store, target.Target)if err != nil {return nil, err}diff --git a/backend/runner/plancheck/statement_advise_executor.go b/backend/runner/plancheck/statement_advise_executor.goindex 3e039c1ca0..7d5da4ee98 100644--- a/backend/runner/plancheck/statement_advise_executor.go+++ b/backend/runner/plancheck/statement_advise_executor.go@@ -52,7 +52,7 @@ func (e *StatementAdviseExecutor) RunForTarget(ctx context.Context, target *ChecenablePriorBackup := target.EnablePriorBackupenableGhost := target.EnableGhost- instance, database, err := resolveDatabaseTarget(ctx, e.store, target.Target)+ instance, database, err := ResolveDatabaseTarget(ctx, e.store, target.Target)if err != nil {return nil, err}diff --git a/backend/runner/plancheck/statement_report_executor.go b/backend/runner/plancheck/statement_report_executor.goindex 041b8ad260..ddf07d6823 100644--- a/backend/runner/plancheck/statement_report_executor.go+++ b/backend/runner/plancheck/statement_report_executor.go@@ -63,7 +63,7 @@ func (e *StatementReportExecutor) RunForTarget(ctx context.Context, target *Chec}, nil}- instance, database, err := resolveDatabaseTarget(ctx, e.store, target.Target)+ instance, database, err := ResolveDatabaseTarget(ctx, e.store, target.Target)if err != nil {return nil, err}diff --git a/backend/runner/plancheck/target.go b/backend/runner/plancheck/target.goindex fa06e1d6db..bf6e59aaf2 100644--- a/backend/runner/plancheck/target.go+++ b/backend/runner/plancheck/target.go@@ -9,8 +9,8 @@ import ("github.com/bytebase/bytebase/backend/store")-// resolveDatabaseTarget resolves a workspace- or project-scoped database resource name.-func resolveDatabaseTarget(ctx context.Context, stores *store.Store, target string) (*store.InstanceMessage, *store.DatabaseMessage, error) {+// ResolveDatabaseTarget resolves a workspace- or project-scoped database resource name.+func ResolveDatabaseTarget(ctx context.Context, stores *store.Store, target string) (*store.InstanceMessage, *store.DatabaseMessage, error) {projectID, instanceID, databaseName, err := common.GetDatabaseResourceName(target)if err != nil {return nil, nil, errors.Wrapf(err, "failed to parse target %s", target)diff --git a/backend/runner/plancheck/target_test.go b/backend/runner/plancheck/target_test.goindex d05c9a9273..3572d6e44a 100644--- a/backend/runner/plancheck/target_test.go+++ b/backend/runner/plancheck/target_test.go@@ -78,7 +78,7 @@ func TestResolveDatabaseTarget(t *testing.T) {for _, tt := range tests {t.Run(tt.name, func(t *testing.T) {- instance, database, err := resolveDatabaseTarget(ctx, stores, tt.target)+ instance, database, err := ResolveDatabaseTarget(ctx, stores, tt.target)if tt.wantErr != "" {require.ErrorContains(t, err, tt.wantErr)require.Nil(t, instance)diff --git a/backend/runner/reviewrun/guideline_executor.go b/backend/runner/reviewrun/guideline_executor.goindex 6d0dce88f0..4f1468957e 100644--- a/backend/runner/reviewrun/guideline_executor.go+++ b/backend/runner/reviewrun/guideline_executor.go@@ -4,6 +4,8 @@ import ("context""github.com/pkg/errors"++ "github.com/bytebase/bytebase/backend/store")// GuidelineExecutor is the natural-language guideline reviewer, performed by@@ -21,6 +23,6 @@ func NewGuidelineExecutor() *GuidelineExecutor {}// RunOnce implements Executor.-func (*GuidelineExecutor) RunOnce(_ context.Context, _ string, _ int64) error {- return errors.New("guideline review is not implemented yet")+func (*GuidelineExecutor) RunOnce(_ context.Context, _ string, _ int64) ([]*store.IssueCommentMessage, error) {+ return nil, errors.New("guideline review is not implemented yet")}diff --git a/backend/runner/reviewrun/reviewers.go b/backend/runner/reviewrun/reviewers.gonew file mode 100644index 0000000000..7cc4e0679c--- /dev/null+++ b/backend/runner/reviewrun/reviewers.go@@ -0,0 +1,13 @@+package reviewrun++import (+ "github.com/bytebase/omni/review"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+)++// reviewers maps an engine to its omni review entry point. An engine absent+// here has no standard rule review, and a run touching it fails. The map+// fills in as omni ships engine review packages (pg/review, mysql/review,+// ...): each one is a line here and nothing else.+var reviewers = map[storepb.Engine]review.ReviewFunc{}diff --git a/backend/runner/reviewrun/rule_executor.go b/backend/runner/reviewrun/rule_executor.goindex 38685b1806..6827753215 100644--- a/backend/runner/reviewrun/rule_executor.go+++ b/backend/runner/reviewrun/rule_executor.go@@ -5,88 +5,206 @@ import ("fmt""strings"+ "github.com/bytebase/omni/review""github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/component/dbfactory"- "github.com/bytebase/bytebase/backend/component/sheet"+ "github.com/bytebase/bytebase/backend/common"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/runner/plancheck""github.com/bytebase/bytebase/backend/store"+ "github.com/bytebase/bytebase/backend/utils")+// maxBackupSize is the largest SQL text prior backup can handle, the same+// bound the task executor enforces.+const maxBackupSize = common.MaxSheetCheckSize+// RuleExecutor evaluates the standard rules against every (spec, target)-// unit of the issue's plan.-//-// Findings are not persisted yet: review results become issue comments, and-// the comment integration lands with the comment-thread design. The executor-// still evaluates every unit for real so the run lifecycle, fencing, and-// failure aggregation exercise the true path; computed advices are-// discarded.+// unit of the issue's plan through omni's SQL Review V2 contract: one Review+// call per (spec, engine), the caller resolving every input that needs the+// store and the engine deriving the findings.type RuleExecutor struct {- store *store.Store- sheetManager *sheet.Manager- dbFactory *dbfactory.DBFactory+ store *store.Store+ reviewers map[storepb.Engine]review.ReviewFunc}// NewRuleExecutor creates the standard-rule review executor.-func NewRuleExecutor(s *store.Store, sheetManager *sheet.Manager, dbFactory *dbfactory.DBFactory) *RuleExecutor {- return &RuleExecutor{- store: s,- sheetManager: sheetManager,- dbFactory: dbFactory,- }+func NewRuleExecutor(s *store.Store) *RuleExecutor {+ return &RuleExecutor{store: s, reviewers: reviewers}}-// RunOnce implements Executor.-func (e *RuleExecutor) RunOnce(ctx context.Context, projectID string, issueUID int64) error {+// RunOnce implements Executor. Collect-all, no fail-fast: every unit is+// attempted, failures aggregate into one message, and the findings are+// returned only when every unit was evaluated.+func (e *RuleExecutor) RunOnce(ctx context.Context, projectID string, issueUID int64) ([]*store.IssueCommentMessage, error) {issue, err := e.store.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{projectID}, UID: &issueUID})if err != nil {- return errors.Wrapf(err, "failed to get issue")+ return nil, errors.Wrapf(err, "failed to get issue")}if issue == nil {- return errors.Errorf("issue %d not found in project %s", issueUID, projectID)+ return nil, errors.Errorf("issue %d not found in project %s", issueUID, projectID)}if issue.PlanUID == nil {- return errors.Errorf("issue %d has no plan", issueUID)+ return nil, errors.Errorf("issue %d has no plan", issueUID)}plan, err := e.store.GetPlan(ctx, &store.FindPlanMessage{ProjectID: projectID, UID: issue.PlanUID})if err != nil {- return errors.Wrapf(err, "failed to get plan")+ return nil, errors.Wrapf(err, "failed to get plan")}if plan == nil {- return errors.Errorf("plan %d not found in project %s", *issue.PlanUID, projectID)+ return nil, errors.Errorf("plan %d not found in project %s", *issue.PlanUID, projectID)}project, err := e.store.GetProjectByResourceID(ctx, projectID)if err != nil {- return errors.Wrapf(err, "failed to get project")+ return nil, errors.Wrapf(err, "failed to get project")}if project == nil {- return errors.Errorf("project %s not found", projectID)+ return nil, errors.Errorf("project %s not found", projectID)+ }+ policy, err := e.store.GetEffectiveReviewRulePolicy(ctx, project.Workspace, projectID)+ if err != nil {+ return nil, errors.Wrapf(err, "failed to get review rule policy")}databaseGroup, err := plancheck.GetDatabaseGroupForPlan(ctx, e.store, plan, nil)if err != nil {- return errors.Wrapf(err, "failed to get database group for plan")+ return nil, errors.Wrapf(err, "failed to get database group for plan")}// DeriveReviewTargets, not DeriveCheckTargets: review must evaluate every// (spec, target) unit, so the CI sampling limit does not apply.- targets, err := plancheck.DeriveReviewTargets(ctx, e.store, project, plan, databaseGroup)+ checkTargets, err := plancheck.DeriveReviewTargets(ctx, e.store, project, plan, databaseGroup)if err != nil {- return errors.Wrapf(err, "failed to derive review targets")+ return nil, errors.Wrapf(err, "failed to derive review targets")}- adviseExecutor := plancheck.NewStatementAdviseExecutor(e.store, e.sheetManager, e.dbFactory)var unitErrs []error- for _, target := range targets {+ var targets []*reviewTarget+ for _, checkTarget := range checkTargets {+ if err := ctx.Err(); err != nil {+ return nil, err+ }+ target, err := e.resolveReviewTarget(ctx, project, checkTarget)+ if err != nil {+ unitErrs = append(unitErrs, errors.Wrapf(err, "%s", checkTarget.Target))+ continue+ }+ targets = append(targets, target)+ }++ var comments []*store.IssueCommentMessage+ sheets := make(map[string]string)+ for _, unit := range groupReviewUnits(reviewRules(policy), targets) {if err := ctx.Err(); err != nil {- return err+ return nil, err+ }+ reviewer, ok := e.reviewers[unit.Engine]+ if !ok {+ unitErrs = append(unitErrs, unit.failures(errors.Errorf("engine %s has no standard rule reviewer", unit.Engine))...)+ continue+ }+ sql, ok := sheets[unit.SheetSha256]+ if !ok {+ sheet, err := e.store.GetSheetFull(ctx, unit.SheetSha256)+ if err != nil {+ unitErrs = append(unitErrs, unit.failures(errors.Wrapf(err, "failed to get sheet"))...)+ continue+ }+ if sheet == nil {+ unitErrs = append(unitErrs, unit.failures(errors.Errorf("sheet %s not found", unit.SheetSha256))...)+ continue+ }+ sql = sheet.Statement+ sheets[unit.SheetSha256] = sql+ }+ inputs := make([]review.Target, 0, len(unit.Targets))+ for _, target := range unit.Targets {+ inputs = append(inputs, target.Input)}- // Collect-all, no fail-fast: every unit is attempted, and failures- // aggregate into one message.- if _, err := adviseExecutor.RunForTarget(ctx, target); err != nil {- unitErrs = append(unitErrs, errors.Wrapf(err, "%s", target.Target))+ result, err := reviewer(ctx, sql, unit.Options, inputs)+ if err != nil {+ unitErrs = append(unitErrs, unit.failures(err)...)+ continue}+ for _, failure := range result.Failures {+ if failure.Target < 0 || failure.Target >= len(unit.Targets) {+ unitErrs = append(unitErrs, errors.Wrapf(failure.Err, "target %d of spec %s", failure.Target, unit.SpecID))+ continue+ }+ unitErrs = append(unitErrs, errors.Wrapf(failure.Err, "%s", unit.Targets[failure.Target].Check.Target))+ }+ comments = append(comments, reviewResultComments(projectID, issueUID, unit, sql, result)...)+ }+ if err := aggregateUnitErrors(len(checkTargets), unitErrs); err != nil {+ return nil, err+ }+ return comments, nil+}++// failures reports one error per target of the unit, so the aggregate counts+// every database the failure kept from being reviewed.+func (u *reviewUnit) failures(err error) []error {+ errs := make([]error, 0, len(u.Targets))+ for _, target := range u.Targets {+ errs = append(errs, errors.Wrapf(err, "%s", target.Check.Target))+ }+ return errs+}++// resolveReviewTarget gathers the inputs the engine cannot derive from the+// SQL: the synced schema, and the instance facts the review contract lists.+// A database whose schema is not synced cannot be reviewed.+func (e *RuleExecutor) resolveReviewTarget(ctx context.Context, project *store.ProjectMessage, checkTarget *plancheck.CheckTarget) (*reviewTarget, error) {+ instance, database, err := plancheck.ResolveDatabaseTarget(ctx, e.store, checkTarget.Target)+ if err != nil {+ return nil, err+ }+ engine := instance.Metadata.GetEngine()+ dbSchema, err := e.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{+ Workspace: instance.Workspace,+ InstanceID: database.InstanceID,+ DatabaseName: database.DatabaseName,+ })+ if err != nil {+ return nil, errors.Wrapf(err, "failed to get database schema")+ }+ if dbSchema == nil || dbSchema.GetProto() == nil {+ return nil, errors.New("metadata not synced")+ }+ schema := dbSchema.GetProto()++ backupDatabaseName := common.BackupDatabaseNameOfEngine(engine)+ backupDatabase, err := e.store.GetDatabase(ctx, &store.FindDatabaseMessage{+ Workspace: instance.Workspace,+ InstanceID: &instance.ResourceID,+ DatabaseName: &backupDatabaseName,+ })+ if err != nil {+ return nil, errors.Wrapf(err, "failed to look up backup database %q", backupDatabaseName)+ }++ return &reviewTarget{+ Check: checkTarget,+ Engine: engine,+ Input: review.Target{+ Schema: schema,+ BackupDatabaseExists: backupDatabase != nil,+ SessionUser: sessionUser(project, instance, schema.GetOwner()),+ LowerCaseTableNames: int(instance.Metadata.GetMysqlLowerCaseTableNames()),+ },+ }, nil+}++// sessionUser is the role the change runs as: the database owner when the+// project's PostgreSQL tenant mode switches to it, else the admin data+// source's login user. Empty opts out of the engine's ownership checks.+func sessionUser(project *store.ProjectMessage, instance *store.InstanceMessage, owner string) string {+ if instance.Metadata.GetEngine() != storepb.Engine_POSTGRES {+ return ""+ }+ if project.Setting.GetPostgresDatabaseTenantMode() {+ return owner}- return aggregateUnitErrors(len(targets), unitErrs)+ return utils.DataSourceFromInstanceWithType(instance, storepb.DataSourceType_ADMIN).GetUsername()}// aggregateUnitErrors folds per-unit failures into one message, e.g.diff --git a/backend/runner/reviewrun/rule_review.go b/backend/runner/reviewrun/rule_review.gonew file mode 100644index 0000000000..901b61dee6--- /dev/null+++ b/backend/runner/reviewrun/rule_review.go@@ -0,0 +1,165 @@+package reviewrun++import (+ "slices"++ "github.com/bytebase/omni/review"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/runner/plancheck"+ "github.com/bytebase/bytebase/backend/store"+)++// reviewTarget is one database of the plan with the inputs its engine's+// Review needs, resolved by the executor.+type reviewTarget struct {+ Check *plancheck.CheckTarget+ Engine storepb.Engine+ Input review.Target+}++// reviewUnit is one call to an engine's Review: a spec's SQL against every+// database of one engine the spec addresses. Findings refer to Targets by+// index, in the order they are passed to Review.+type reviewUnit struct {+ SpecID string+ SheetSha256 string+ Engine storepb.Engine+ Options review.Options+ Targets []*reviewTarget+}++// reviewRules names the rules a policy switches on, by the enum name the+// omni contract maps on.+func reviewRules(policy *storepb.ReviewRulePolicy) []review.Rule {+ rules := make([]review.Rule, 0, len(policy.GetRules()))+ for _, rule := range policy.GetRules() {+ rules = append(rules, review.Rule(rule.String()))+ }+ return rules+}++// groupReviewUnits folds the targets into one unit per (spec, engine), in+// first-seen order. The change's requested behaviors are read from the first+// target: they come from the spec and its sheet, so every target of a spec+// agrees.+func groupReviewUnits(rules []review.Rule, targets []*reviewTarget) []*reviewUnit {+ type key struct {+ specID string+ engine storepb.Engine+ }+ units := make(map[key]*reviewUnit)+ var ordered []*reviewUnit+ for _, target := range targets {+ k := key{specID: target.Check.SpecID, engine: target.Engine}+ unit, ok := units[k]+ if !ok {+ unit = &reviewUnit{+ SpecID: target.Check.SpecID,+ SheetSha256: target.Check.SheetSha256,+ Engine: target.Engine,+ Options: review.Options{+ Rules: rules,+ Change: review.Change{+ OnlineMigration: target.Check.EnableGhost,+ PriorBackup: target.Check.EnablePriorBackup,+ MaxBackupSize: maxBackupSize,+ },+ },+ }+ units[k] = unit+ ordered = append(ordered, unit)+ }+ unit.Targets = append(unit.Targets, target)+ }+ return ordered+}++// rulePriority is what resolving a finding's thread means: P0 rules report+// SQL that is wrong, P1 rules report operations a person must accept. Every+// ReviewRuleType has a line here; TestRulePriorityCoversEveryRule holds it.+func rulePriority(rule storepb.ReviewRuleType) storepb.IssueCommentPayload_ReviewMetadata_Priority {+ switch rule {+ case storepb.ReviewRuleType_SYNTAX,+ storepb.ReviewRuleType_WALK_THROUGH,+ storepb.ReviewRuleType_ONLINE_MIGRATION,+ storepb.ReviewRuleType_PRIOR_BACKUP,+ storepb.ReviewRuleType_REQUIRE_IS_NULL:+ return storepb.IssueCommentPayload_ReviewMetadata_P0+ case storepb.ReviewRuleType_REQUIRE_WHERE,+ storepb.ReviewRuleType_DISALLOW_DROP_OBJECT,+ storepb.ReviewRuleType_DISALLOW_TRUNCATE,+ storepb.ReviewRuleType_DISALLOW_DROP_CONSTRAINT,+ storepb.ReviewRuleType_DISALLOW_RENAME,+ storepb.ReviewRuleType_REQUIRE_PRIMARY_KEY:+ return storepb.IssueCommentPayload_ReviewMetadata_P1+ default:+ return storepb.IssueCommentPayload_ReviewMetadata_PRIORITY_UNSPECIFIED+ }+}++// reviewResultComments converts a unit's findings into the review result+// comments to post: one OPEN root per finding, anchored to the finding's+// range on the spec's sheet, naming the rule, its priority, and every target+// the finding applies to. A finding for a rule this server does not know is+// dropped, as the contract says.+func reviewResultComments(projectID string, issueUID int64, unit *reviewUnit, sql string, result *review.Result) []*store.IssueCommentMessage {+ text := review.Index(sql)+ comments := make([]*store.IssueCommentMessage, 0, len(result.Findings))+ for _, finding := range result.Findings {+ rule := storepb.ReviewRuleType(storepb.ReviewRuleType_value[string(finding.Rule)])+ if rule == storepb.ReviewRuleType_REVIEW_RULE_TYPE_UNSPECIFIED {+ continue+ }+ targets := make([]string, 0, len(finding.Targets))+ for _, i := range finding.Targets {+ if i < 0 || i >= len(unit.Targets) {+ continue+ }+ targets = append(targets, unit.Targets[i].Check.Target)+ }+ slices.Sort(targets)+ comments = append(comments, &store.IssueCommentMessage{+ ProjectID: projectID,+ IssueUID: issueUID,+ Payload: &storepb.IssueCommentPayload{+ Comment: finding.Message,+ StatementAnchor: findingAnchor(text, unit, result, finding),+ ReviewMetadata: &storepb.IssueCommentPayload_ReviewMetadata{+ RunType: storepb.ReviewRun_RULE,+ RuleType: rule,+ Priority: rulePriority(rule),+ Targets: targets,+ },+ },+ })+ }+ return comments+}++// findingAnchor anchors a finding on the spec's sheet: its own range, else+// its statement's range, else nothing for a finding that addresses the whole+// change. An empty range anchors the whole line it starts on.+func findingAnchor(text *review.Text, unit *reviewUnit, result *review.Result, finding review.Finding) *storepb.IssueCommentPayload_StatementAnchor {+ if finding.Statement < 0 {+ return nil+ }+ r := finding.Range+ if r == (review.Range{}) && finding.Statement < len(result.Statements) {+ r = result.Statements[finding.Statement]+ }+ startLine, startColumn := text.Position(r.Start)+ endLine, endColumn := text.Position(r.End)+ anchor := &storepb.IssueCommentPayload_StatementAnchor{+ SpecId: unit.SpecID,+ SheetSha256: unit.SheetSha256,+ }+ if endLine < startLine || (endLine == startLine && endColumn <= startColumn) {+ anchor.StartPosition = &storepb.Position{Line: int32(startLine)}+ anchor.EndPosition = &storepb.Position{Line: int32(startLine)}+ return anchor+ }+ anchor.StartPosition = &storepb.Position{Line: int32(startLine), Column: int32(startColumn)}+ anchor.EndPosition = &storepb.Position{Line: int32(endLine), Column: int32(endColumn)}+ return anchor+}diff --git a/backend/runner/reviewrun/rule_review_test.go b/backend/runner/reviewrun/rule_review_test.gonew file mode 100644index 0000000000..254ca764d4--- /dev/null+++ b/backend/runner/reviewrun/rule_review_test.go@@ -0,0 +1,175 @@+package reviewrun++import (+ "errors"+ "testing"++ "github.com/bytebase/omni/review"+ "github.com/stretchr/testify/require"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/runner/plancheck"+ "github.com/bytebase/bytebase/backend/store"+)++const testSheet = "0be1f01d6ee8e6f6c6a2ce9b418ba10ea9d16c9b9bfae5548b8fa0e26c04a5e0"++func TestReviewRules(t *testing.T) {+ t.Parallel()+ require.Equal(t, []review.Rule{review.Syntax, review.RequireWhere}, reviewRules(&storepb.ReviewRulePolicy{+ Rules: []storepb.ReviewRuleType{storepb.ReviewRuleType_SYNTAX, storepb.ReviewRuleType_REQUIRE_WHERE},+ }))+ require.Empty(t, reviewRules(nil))++ // Every default rule is one the omni contract names.+ known := map[review.Rule]bool{}+ for _, rule := range []review.Rule{+ review.Syntax, review.WalkThrough, review.OnlineMigration, review.PriorBackup, review.RequireIsNull,+ review.RequireWhere, review.DisallowDropObject, review.DisallowTruncate, review.DisallowDropConstraint,+ review.DisallowRename, review.RequirePrimaryKey,+ } {+ known[rule] = true+ }+ for _, rule := range reviewRules(store.GetDefaultReviewRulePolicy()) {+ require.True(t, known[rule], "rule %s is not in the omni contract", rule)+ }+}++// TestRulePriorityCoversEveryRule fails when a rule is added to+// ReviewRuleType without a priority.+func TestRulePriorityCoversEveryRule(t *testing.T) {+ t.Parallel()+ for number, name := range storepb.ReviewRuleType_name {+ rule := storepb.ReviewRuleType(number)+ if rule == storepb.ReviewRuleType_REVIEW_RULE_TYPE_UNSPECIFIED {+ require.Equal(t, storepb.IssueCommentPayload_ReviewMetadata_PRIORITY_UNSPECIFIED, rulePriority(rule))+ continue+ }+ require.NotEqual(t, storepb.IssueCommentPayload_ReviewMetadata_PRIORITY_UNSPECIFIED, rulePriority(rule), name)+ }+ require.Equal(t, storepb.IssueCommentPayload_ReviewMetadata_P0, rulePriority(storepb.ReviewRuleType_SYNTAX))+ require.Equal(t, storepb.IssueCommentPayload_ReviewMetadata_P1, rulePriority(storepb.ReviewRuleType_DISALLOW_DROP_OBJECT))+}++func target(specID, name string, engine storepb.Engine, ghost bool) *reviewTarget {+ return &reviewTarget{+ Check: &plancheck.CheckTarget{SpecID: specID, Target: name, SheetSha256: testSheet, EnableGhost: ghost, EnablePriorBackup: !ghost},+ Engine: engine,+ Input: review.Target{SessionUser: name},+ }+}++func TestGroupReviewUnits(t *testing.T) {+ t.Parallel()+ rules := []review.Rule{review.Syntax}+ units := groupReviewUnits(rules, []*reviewTarget{+ target("spec-1", "instances/pg/databases/a", storepb.Engine_POSTGRES, true),+ target("spec-1", "instances/my/databases/b", storepb.Engine_MYSQL, true),+ target("spec-2", "instances/pg/databases/c", storepb.Engine_POSTGRES, false),+ target("spec-1", "instances/pg/databases/d", storepb.Engine_POSTGRES, true),+ })+ require.Len(t, units, 3, "one unit per (spec, engine), in first-seen order")++ require.Equal(t, "spec-1", units[0].SpecID)+ require.Equal(t, storepb.Engine_POSTGRES, units[0].Engine)+ require.Equal(t, testSheet, units[0].SheetSha256)+ require.Equal(t, review.Options{Rules: rules, Change: review.Change{OnlineMigration: true, MaxBackupSize: maxBackupSize}}, units[0].Options)+ require.Equal(t, []string{"instances/pg/databases/a", "instances/pg/databases/d"}, targetNames(units[0]))++ require.Equal(t, storepb.Engine_MYSQL, units[1].Engine)+ require.Equal(t, []string{"instances/my/databases/b"}, targetNames(units[1]))++ require.Equal(t, "spec-2", units[2].SpecID)+ require.Equal(t, review.Change{PriorBackup: true, MaxBackupSize: maxBackupSize}, units[2].Options.Change)+ require.Equal(t, []string{"instances/pg/databases/c"}, targetNames(units[2]))+}++func targetNames(unit *reviewUnit) []string {+ var names []string+ for _, target := range unit.Targets {+ names = append(names, target.Check.Target)+ }+ return names+}++func TestReviewResultComments(t *testing.T) {+ t.Parallel()+ const sql = "UPDATE t SET a = 1;\nDROP TABLE 你好;\nSELECT 1"+ unit := groupReviewUnits(nil, []*reviewTarget{+ target("spec-1", "instances/pg/databases/b", storepb.Engine_POSTGRES, false),+ target("spec-1", "instances/pg/databases/a", storepb.Engine_POSTGRES, false),+ })[0]+ result := &review.Result{+ Statements: []review.Range{{Start: 0, End: 19}, {Start: 20, End: 38}, {Start: 39, End: 47}},+ Findings: []review.Finding{+ {Rule: review.RequireWhere, Statement: 0, Message: "UPDATE without WHERE", Targets: []int{0, 1}},+ {Rule: review.DisallowDropObject, Statement: 1, Range: review.Range{Start: 31, End: 37}, Message: "DROP TABLE 你好", Targets: []int{1}},+ {Rule: review.PriorBackup, Statement: -1, Message: "backup database missing", Targets: []int{0}},+ {Rule: "FUTURE_RULE", Statement: 2, Message: "dropped: unknown to this server", Targets: []int{0}},+ {Rule: review.Syntax, Statement: 2, Range: review.Range{Start: 40, End: 40}, Message: "empty range anchors the line", Targets: []int{0, 7}},+ },+ }++ comments := reviewResultComments("p", 101, unit, sql, result)+ require.Len(t, comments, 4, "the unknown rule's finding is dropped")+ for _, c := range comments {+ require.Equal(t, "p", c.ProjectID)+ require.Equal(t, int64(101), c.IssueUID)+ require.Empty(t, c.CreatorEmail)+ require.Equal(t, storepb.ReviewRun_RULE, c.Payload.ReviewMetadata.RunType)+ }++ whole := comments[0]+ require.Equal(t, "UPDATE without WHERE", whole.Payload.Comment)+ require.Equal(t, storepb.ReviewRuleType_REQUIRE_WHERE, whole.Payload.ReviewMetadata.RuleType)+ require.Equal(t, storepb.IssueCommentPayload_ReviewMetadata_P1, whole.Payload.ReviewMetadata.Priority)+ require.Equal(t, []string{"instances/pg/databases/a", "instances/pg/databases/b"}, whole.Payload.ReviewMetadata.Targets, "targets sorted")+ require.Equal(t, &storepb.IssueCommentPayload_StatementAnchor{+ SpecId: "spec-1", SheetSha256: testSheet,+ StartPosition: &storepb.Position{Line: 1, Column: 1},+ EndPosition: &storepb.Position{Line: 1, Column: 20},+ }, whole.Payload.StatementAnchor, "a zero range anchors the whole statement")++ ranged := comments[1]+ require.Equal(t, []string{"instances/pg/databases/a"}, ranged.Payload.ReviewMetadata.Targets)+ require.Equal(t, &storepb.Position{Line: 2, Column: 12}, ranged.Payload.StatementAnchor.StartPosition, "columns count code points")+ require.Equal(t, &storepb.Position{Line: 2, Column: 14}, ranged.Payload.StatementAnchor.EndPosition)++ change := comments[2]+ require.Nil(t, change.Payload.StatementAnchor, "a whole-change finding has no anchor")+ require.Equal(t, storepb.IssueCommentPayload_ReviewMetadata_P0, change.Payload.ReviewMetadata.Priority)++ line := comments[3]+ require.Equal(t, []string{"instances/pg/databases/b"}, line.Payload.ReviewMetadata.Targets, "an out-of-range target index is dropped")+ require.Equal(t, &storepb.Position{Line: 3}, line.Payload.StatementAnchor.StartPosition)+ require.Equal(t, &storepb.Position{Line: 3}, line.Payload.StatementAnchor.EndPosition)+}++func TestSessionUser(t *testing.T) {+ t.Parallel()+ pg := &store.InstanceMessage{Metadata: &storepb.Instance{+ Engine: storepb.Engine_POSTGRES,+ DataSources: []*storepb.DataSource{{Type: storepb.DataSourceType_READ_ONLY, Username: "ro"}, {Type: storepb.DataSourceType_ADMIN, Username: "admin"}},+ }}+ mysql := &store.InstanceMessage{Metadata: &storepb.Instance{Engine: storepb.Engine_MYSQL, DataSources: pg.Metadata.DataSources}}+ plain := &store.ProjectMessage{Setting: &storepb.Project{}}+ tenant := &store.ProjectMessage{Setting: &storepb.Project{PostgresDatabaseTenantMode: true}}++ require.Equal(t, "admin", sessionUser(plain, pg, "owner"))+ require.Equal(t, "owner", sessionUser(tenant, pg, "owner"), "tenant mode runs the change as the database owner")+ require.Empty(t, sessionUser(plain, mysql, "owner"), "only PostgreSQL has ownership checks")+}++func TestAggregateUnitErrors(t *testing.T) {+ t.Parallel()+ require.NoError(t, aggregateUnitErrors(3, nil))+ err := aggregateUnitErrors(5, []error{errors.New("a"), errors.New("b"), errors.New("c"), errors.New("d")})+ require.EqualError(t, err, "4 of 5 review units failed: a; b; c (+1 more)")++ unit := groupReviewUnits(nil, []*reviewTarget{+ target("spec-1", "instances/pg/databases/a", storepb.Engine_POSTGRES, false),+ target("spec-1", "instances/pg/databases/b", storepb.Engine_POSTGRES, false),+ })[0]+ err = aggregateUnitErrors(2, unit.failures(errors.New("engine POSTGRES has no standard rule reviewer")))+ require.EqualError(t, err, "2 of 2 review units failed: instances/pg/databases/a: engine POSTGRES has no standard rule reviewer; instances/pg/databases/b: engine POSTGRES has no standard rule reviewer")+}diff --git a/backend/runner/reviewrun/scheduler.go b/backend/runner/reviewrun/scheduler.goindex 297b8500f3..35dcdcd548 100644--- a/backend/runner/reviewrun/scheduler.go+++ b/backend/runner/reviewrun/scheduler.go@@ -32,11 +32,11 @@ const reviewRunSchedulerInterval = 5 * time.Second// Executor executes one review run for one reviewer type.type Executor interface {// RunOnce evaluates every (spec, target) unit of the issue's plan- // (collect-all, no fail-fast). A nil error marks the run DONE; a non-nil- // error marks it FAILED with the aggregated message. Findings will- // surface as issue comments once the comment integration lands; until- // then executors only report status.- RunOnce(ctx context.Context, projectID string, issueUID int64) error+ // (collect-all, no fail-fast) and returns the results to post as issue+ // comments. A nil error marks the run DONE and posts the results; a+ // non-nil error marks it FAILED with the aggregated message and posts+ // nothing.+ RunOnce(ctx context.Context, projectID string, issueUID int64) ([]*store.IssueCommentMessage, error)}// NewScheduler creates a new review run scheduler.@@ -138,7 +138,7 @@ func (s *Scheduler) scheduleReviewRuns(ctx context.Context) (retErr error) {func (s *Scheduler) dispatchReviewRun(ctx context.Context, claimed *store.ClaimedReviewRun) {executor, ok := s.executorMap[claimed.Type]if !ok {- s.completeReviewRun(ctx, claimed, errors.Errorf("no executor registered for reviewer type %q", claimed.Type))+ s.completeReviewRun(ctx, claimed, nil, errors.Errorf("no executor registered for reviewer type %q", claimed.Type))return}s.runs.Go(func() { s.runReviewRunOnce(ctx, claimed, executor) })@@ -155,7 +155,7 @@ func (s *Scheduler) runReviewRunOnce(ctx context.Context, claimed *store.Claimed}}()- err := runExecutorOnce(ctx, executor, claimed)+ results, err := runExecutorOnce(ctx, executor, claimed)if err != nil && errors.Is(err, context.Canceled) {// Shutdown: the completion write would fail on the same canceled// context. The replica's heartbeat stops with the process, so the@@ -166,20 +166,22 @@ func (s *Scheduler) runReviewRunOnce(ctx context.Context, claimed *store.Claimedslog.String("type", claimed.Type))return}- s.completeReviewRun(ctx, claimed, err)+ s.completeReviewRun(ctx, claimed, results, err)}-// completeReviewRun writes the terminal status: DONE on a nil error, FAILED-// with the aggregated message otherwise. Zero rows means the run was-// superseded or reaped since the claim; the result is discarded.-func (s *Scheduler) completeReviewRun(ctx context.Context, claimed *store.ClaimedReviewRun, execErr error) {+// completeReviewRun writes the terminal status: DONE with the results posted+// on a nil error, FAILED with the aggregated message otherwise. Zero rows+// means the run was superseded or reaped since the claim; the results are+// discarded.+func (s *Scheduler) completeReviewRun(ctx context.Context, claimed *store.ClaimedReviewRun, results []*store.IssueCommentMessage, execErr error) {status := storepb.ReviewRun_DONEpayload := &storepb.ReviewRunPayload{}if execErr != nil {status = storepb.ReviewRun_FAILEDpayload.Error = execErr.Error()+ results = nil}- updated, err := s.store.CompleteReviewRun(ctx, claimed, s.profile.ReplicaID, status, payload)+ updated, err := s.store.CompleteReviewRun(ctx, claimed, s.profile.ReplicaID, status, payload, results)if err != nil {slog.Error("failed to complete review run",slog.String("project", claimed.ProjectID),@@ -199,7 +201,7 @@ func (s *Scheduler) completeReviewRun(ctx context.Context, claimed *store.Claime// runExecutorOnce wraps Executor.RunOnce with panic recovery so a panicking// executor fails its run instead of crashing the process.-func runExecutorOnce(ctx context.Context, executor Executor, claimed *store.ClaimedReviewRun) (err error) {+func runExecutorOnce(ctx context.Context, executor Executor, claimed *store.ClaimedReviewRun) (results []*store.IssueCommentMessage, err error) {defer func() {if r := recover(); r != nil {panicErr, ok := r.(error)@@ -207,6 +209,7 @@ func runExecutorOnce(ctx context.Context, executor Executor, claimed *store.ClaipanicErr = errors.Errorf("%v", r)}slog.Error("Review run executor PANIC RECOVER", log.BBError(panicErr), log.BBStack("panic-stack"))+ results = nilerr = errors.Errorf("review run executor panic: %v", panicErr)}}()diff --git a/backend/server/server.go b/backend/server/server.goindex 4d6035fc0f..948b99c73d 100644--- a/backend/server/server.go+++ b/backend/server/server.go@@ -245,7 +245,7 @@ func NewServer(ctx context.Context, profile *config.Profile) (*Server, error) {s.planCheckScheduler = plancheck.NewScheduler(stores, s.bus, combinedExecutor, s.licenseService, productMetrics)s.reviewRunScheduler = reviewrun.NewScheduler(stores, s.bus, profile, s.licenseService, productMetrics)- s.reviewRunScheduler.Register(store.ReviewRunTypeRule, reviewrun.NewRuleExecutor(stores, sheetManager, s.dbFactory))+ s.reviewRunScheduler.Register(store.ReviewRunTypeRule, reviewrun.NewRuleExecutor(stores))s.reviewRunScheduler.Register(store.ReviewRunTypeGuideline, reviewrun.NewGuidelineExecutor())s.notifyListener = notifylistener.NewListener(stores.GetDB(), s.bus)diff --git a/backend/store/issue_comment.go b/backend/store/issue_comment.goindex efaeb8410b..26bd39faf2 100644--- a/backend/store/issue_comment.go+++ b/backend/store/issue_comment.go@@ -27,12 +27,14 @@ const ()type IssueCommentMessage struct {- ProjectID string- ResourceID string- CreatedAt time.Time- UpdatedAt time.Time- IssueUID int64- Payload *storepb.IssueCommentPayload+ ProjectID string+ ResourceID string+ CreatedAt time.Time+ UpdatedAt time.Time+ IssueUID int64+ Payload *storepb.IssueCommentPayload+ // CreatorEmail is empty on a review result, which a reviewer posts;+ // Payload.ReviewMetadata names it.CreatorEmail string// ParentID names the thread's root comment on a reply; nil on root// comments and events.@@ -202,11 +204,11 @@ func (s *Store) ListIssueComment(ctx context.Context, find *FindIssueCommentMessPayload: &storepb.IssueCommentPayload{},}var p []byte- var parentID, threadState sql.NullString+ var creator, parentID, threadState sql.NullStringif err := rows.Scan(&ic.ProjectID,&ic.ResourceID,- &ic.CreatorEmail,+ &creator,&ic.CreatedAt,&ic.UpdatedAt,&ic.IssueUID,@@ -216,6 +218,7 @@ func (s *Store) ListIssueComment(ctx context.Context, find *FindIssueCommentMess); err != nil {return nil, errors.Wrapf(err, "failed to scan")}+ ic.CreatorEmail = creator.Stringif parentID.Valid {ic.ParentID = &parentID.String}diff --git a/backend/store/review_run.go b/backend/store/review_run.goindex 8ba003779b..eb212ffd88 100644--- a/backend/store/review_run.go+++ b/backend/store/review_run.go@@ -149,10 +149,23 @@ func (s *Store) ClaimAvailableReviewRuns(ctx context.Context, replicaID string)}// CompleteReviewRun moves a RUNNING run this replica owns to a terminal-// status, fenced on the claim's attempt. False means superseded: the slot was-// reset or reaped since the claim, and the caller must discard its work.-func (s *Store) CompleteReviewRun(ctx context.Context, claimed *ClaimedReviewRun, replicaID string, status storepb.ReviewRun_Status, payload *storepb.ReviewRunPayload) (bool, error) {- if status != storepb.ReviewRun_DONE && status != storepb.ReviewRun_FAILED {+// status, fenced on the claim's attempt. On DONE it posts the run's results in+// the same transaction: every OPEN root the same reviewer posted on the issue+// is resolved, then the results are inserted as OPEN roots with no creator. A+// FAILED run leaves the comments alone and takes no results. False means+// superseded: the slot was reset or reaped since the claim, and nothing was+// written.+//+// Lock order: the issue's review comments, then the run slot, the order the+// project purge deletes them in.+func (s *Store) CompleteReviewRun(ctx context.Context, claimed *ClaimedReviewRun, replicaID string, status storepb.ReviewRun_Status, payload *storepb.ReviewRunPayload, results []*IssueCommentMessage) (bool, error) {+ switch status {+ case storepb.ReviewRun_DONE:+ case storepb.ReviewRun_FAILED:+ if len(results) > 0 {+ return false, errors.New("a failed review run posts no results")+ }+ default:return false, errors.Errorf("invalid terminal review run status %v", status)}if payload == nil {@@ -162,6 +175,51 @@ func (s *Store) CompleteReviewRun(ctx context.Context, claimed *ClaimedReviewRunif err != nil {return false, errors.Wrapf(err, "failed to marshal review run payload")}+ resultPayloads, err := marshalReviewResults(claimed, results)+ if err != nil {+ return false, err+ }++ tx, err := s.GetDB().BeginTx(ctx, nil)+ if err != nil {+ return false, errors.Wrapf(err, "failed to begin tx")+ }+ defer tx.Rollback()++ if status == storepb.ReviewRun_DONE {+ // The literal 'OPEN' lets the planner use idx_issue_comment_open_thread.+ q := qb.Q().Space(`+ UPDATE issue_comment+ SET thread_state = ?+ WHERE project = ? AND issue_id = ?+ AND parent_id IS NULL AND thread_state = 'OPEN'+ AND payload->'reviewMetadata'->>'runType' = ?+ `, string(ThreadStateResolved), claimed.ProjectID, claimed.IssueUID, claimed.Type)+ query, args, err := q.ToSQL()+ if err != nil {+ return false, errors.Wrapf(err, "failed to build sql")+ }+ if _, err := tx.ExecContext(ctx, query, args...); err != nil {+ return false, errors.Wrapf(err, "failed to resolve previous review results")+ }+ if len(resultPayloads) > 0 {+ // created_at is offset by the ordinal for the same reason as in+ // CreateIssueComments: the batch keeps its order.+ q := qb.Q().Space(`+ INSERT INTO issue_comment (creator, project, issue_id, payload, thread_state, created_at, updated_at)+ SELECT NULL, ?, ?, c.payload, 'OPEN', t.at, t.at+ FROM unnest(?::JSONB[]) WITH ORDINALITY AS c(payload, ordinality),+ LATERAL (SELECT now() + ((c.ordinality - 1) * interval '1 microsecond')) AS t(at)+ `, claimed.ProjectID, claimed.IssueUID, resultPayloads)+ query, args, err := q.ToSQL()+ if err != nil {+ return false, errors.Wrapf(err, "failed to build sql")+ }+ if _, err := tx.ExecContext(ctx, query, args...); err != nil {+ return false, errors.Wrapf(err, "failed to post review results")+ }+ }+ }q := qb.Q().Space(`UPDATE review_run@@ -177,7 +235,7 @@ func (s *Store) CompleteReviewRun(ctx context.Context, claimed *ClaimedReviewRunreturn false, errors.Wrapf(err, "failed to build sql")}- result, err := s.GetDB().ExecContext(ctx, query, args...)+ result, err := tx.ExecContext(ctx, query, args...)if err != nil {return false, errors.Wrapf(err, "failed to complete review run")}@@ -185,7 +243,47 @@ func (s *Store) CompleteReviewRun(ctx context.Context, claimed *ClaimedReviewRunif err != nil {return false, errors.Wrapf(err, "failed to get rows affected")}- return rowsAffected > 0, nil+ if rowsAffected == 0 {+ // Superseded: the rollback discards the results.+ return false, nil+ }+ if err := tx.Commit(); err != nil {+ return false, errors.Wrapf(err, "failed to commit tx")+ }+ return true, nil+}++// marshalReviewResults checks that every result is a root comment the+// claimed reviewer posted, with no event and no creator, and returns the+// payloads to insert.+func marshalReviewResults(claimed *ClaimedReviewRun, results []*IssueCommentMessage) ([][]byte, error) {+ payloads := make([][]byte, 0, len(results))+ for _, result := range results {+ if result.ProjectID != claimed.ProjectID || result.IssueUID != claimed.IssueUID {+ return nil, errors.Errorf("review result for issue %d in project %s does not belong to the run on issue %d in project %s", result.IssueUID, result.ProjectID, claimed.IssueUID, claimed.ProjectID)+ }+ if result.ParentID != nil || result.CreatorEmail != "" {+ return nil, errors.New("a review result is a root comment with no creator")+ }+ if result.ThreadState != nil && *result.ThreadState != ThreadStateOpen {+ return nil, errors.New("a review result starts its thread OPEN")+ }+ if result.Payload.GetEvent() != nil {+ return nil, errors.New("a review result cannot carry an event")+ }+ if result.Payload.GetReviewMetadata().GetRunType().String() != claimed.Type {+ return nil, errors.Errorf("review result names reviewer %q; the run is %q", result.Payload.GetReviewMetadata().GetRunType(), claimed.Type)+ }+ if err := validateIssueCommentPayload(result.Payload); err != nil {+ return nil, err+ }+ payload, err := protojson.Marshal(result.Payload)+ if err != nil {+ return nil, errors.Wrapf(err, "failed to marshal review result")+ }+ payloads = append(payloads, payload)+ }+ return payloads, nil}// FailStaleReviewRuns fails RUNNING review runs whose owning replica has nodiff --git a/backend/store/review_run_lock_order_test.go b/backend/store/review_run_lock_order_test.gonew file mode 100644index 0000000000..3decc004d3--- /dev/null+++ b/backend/store/review_run_lock_order_test.go@@ -0,0 +1,137 @@+package store_test++import (+ "fmt"+ "testing"+ "time"++ "github.com/stretchr/testify/require"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/store"+)++// A prior OPEN rule result gives the completion's resolve UPDATE a row to+// lock, and the barrier trigger parks the completion right after it, before+// the run slot is touched.+const reviewRunLockOrderSeed = `+ INSERT INTO issue (id, creator, project, name, status, type)+ VALUES (301, '[email protected]', '%[1]s', 'Issue', 'OPEN', 'DATABASE_CHANGE');+ INSERT INTO issue_comment (project, issue_id, payload, thread_state)+ VALUES ('%[1]s', 301, '{"comment":"prior","reviewMetadata":{"runType":"RULE","ruleType":"SYNTAX","priority":"P0"}}', 'OPEN');+ INSERT INTO review_run (project, issue_id, type, attempt, status, replica_id)+ VALUES ('%[1]s', 301, 'RULE', 0, 'RUNNING', 'replica-1');+`++func reviewRunLockOrderCompletion(fixture *storePostgresFixture, projectID string) (bool, error) {+ claimed := &store.ClaimedReviewRun{ProjectID: projectID, IssueUID: reviewResultIssue, Type: store.ReviewRunTypeRule, Attempt: 0}+ return fixture.store.CompleteReviewRun(fixture.ctx, claimed, "replica-1", storepb.ReviewRun_DONE, nil,+ []*store.IssueCommentMessage{reviewResult(projectID, "new", storepb.ReviewRuleType_REQUIRE_WHERE)})+}++// TestCompleteReviewRunLockOrder parks a DONE completion between its comment+// writes and its slot fence and races the two writers that share those rows:+// a re-run, which must win and leave the completion with nothing written, and+// a project purge, which must wait for the completion rather than deadlock+// with it.+func TestCompleteReviewRunLockOrder(t *testing.T) {+ t.Parallel()++ t.Run("re-run lands mid-completion", func(t *testing.T) {+ t.Parallel()+ fixture := newStorePostgresFixture(t, fmt.Sprintf(reviewRunLockOrderSeed, "default"))+ const barrierID = 9971+ barrier := newMaintenanceLockBarrier(fixture.ctx, t, fixture.db, barrierID)+ installMaintenanceLockBarrier(t, fixture.db, barrierID, "AFTER UPDATE ON issue_comment FOR EACH STATEMENT")++ type completion struct {+ updated bool+ err error+ }+ completed := make(chan completion, 1)+ go func() {+ updated, err := reviewRunLockOrderCompletion(fixture, "default")+ completed <- completion{updated: updated, err: err}+ }()+ waitForMaintenanceBarrier(fixture.ctx, t, fixture.db, barrierID)++ // The re-run touches only the slot, so it lands while the completion+ // holds the comment locks.+ run, err := fixture.store.CreateReviewRun(fixture.ctx, "default", reviewResultIssue, store.ReviewRunTypeRule)+ require.NoError(t, err)+ require.Equal(t, int64(1), run.Attempt)+ barrier.release(t)++ select {+ case c := <-completed:+ require.NoError(t, c.err)+ require.False(t, c.updated, "the superseded completion must match zero rows")+ case <-time.After(maintenanceLockWait):+ t.Fatal("timed out waiting for the completion")+ }+ require.Equal(t, []reviewComment{{Comment: "prior", ThreadState: "OPEN"}},+ listReviewComments(t, fixture, "default"), "a superseded completion writes nothing")+ var status string+ var attempt int64+ require.NoError(t, fixture.db.QueryRowContext(fixture.ctx,+ `SELECT status, attempt FROM review_run WHERE project = 'default' AND issue_id = $1 AND type = 'RULE'`,+ reviewResultIssue).Scan(&status, &attempt))+ require.Equal(t, "AVAILABLE", status)+ require.Equal(t, int64(1), attempt)+ })++ t.Run("purge waits for the completion", func(t *testing.T) {+ t.Parallel()+ fixture := newStorePostgresFixture(t, fmt.Sprintf(reviewRunLockOrderSeed, "project-a"))+ const barrierID = 9972+ barrier := newMaintenanceLockBarrier(fixture.ctx, t, fixture.db, barrierID)+ installMaintenanceLockBarrier(t, fixture.db, barrierID, "AFTER UPDATE ON issue_comment FOR EACH STATEMENT")++ type completion struct {+ updated bool+ err error+ }+ completed := make(chan completion, 1)+ go func() {+ updated, err := reviewRunLockOrderCompletion(fixture, "project-a")+ completed <- completion{updated: updated, err: err}+ }()+ waitForMaintenanceBarrier(fixture.ctx, t, fixture.db, barrierID)+ completionPID := maintenanceBarrierWaitingPID(fixture.ctx, t, fixture.db, barrierID)++ purged := make(chan error, 1)+ go func() {+ purged <- fixture.store.DeleteProjects(fixture.ctx, "default", "project-a")+ }()+ // The purge deletes issue_comment first and waits on the row the+ // completion resolved; the completion never waits on the purge.+ waitForBackendBlockedByPID(fixture.ctx, t, fixture.db, completionPID)+ barrier.release(t)++ select {+ case c := <-completed:+ require.NoError(t, c.err)+ require.True(t, c.updated, "the completion commits while the purge waits")+ case <-time.After(maintenanceLockWait):+ t.Fatal("timed out waiting for the completion")+ }+ // The result the completion inserted is invisible to the purge's+ // comment DELETE, so its issue DELETE fails the foreign key: the+ // accepted best-effort outcome for a writer racing a purge, which a+ // retry then completes.+ select {+ case err := <-purged:+ require.ErrorContains(t, err, "issue_comment_project_issue_id_fkey")+ case <-time.After(maintenanceLockWait):+ t.Fatal("timed out waiting for the purge")+ }+ require.Equal(t, []reviewComment{{Comment: "prior", ThreadState: "RESOLVED"}, {Comment: "new", ThreadState: "OPEN"}},+ listReviewComments(t, fixture, "project-a"), "the failed purge rolled back; the completion's writes stand")+ require.NoError(t, fixture.store.DeleteProjects(fixture.ctx, "default", "project-a"))+ require.Empty(t, listReviewComments(t, fixture, "project-a"))+ var runs int+ require.NoError(t, fixture.db.QueryRowContext(fixture.ctx,+ `SELECT COUNT(*) FROM review_run WHERE project = 'project-a'`).Scan(&runs))+ require.Zero(t, runs)+ })+}diff --git a/backend/store/review_run_results_test.go b/backend/store/review_run_results_test.gonew file mode 100644index 0000000000..debd25f870--- /dev/null+++ b/backend/store/review_run_results_test.go@@ -0,0 +1,230 @@+package store_test++import (+ "testing"++ "github.com/stretchr/testify/require"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/store"+)++const (+ reviewResultSheet = "0be1f01d6ee8e6f6c6a2ce9b418ba10ea9d16c9b9bfae5548b8fa0e26c04a5e0"+ // reviewResultIssue is the issue id both projects hold, so the keys collide.+ reviewResultIssue = int64(301)+)++func reviewResult(projectID string, message string, rule storepb.ReviewRuleType) *store.IssueCommentMessage {+ return &store.IssueCommentMessage{+ ProjectID: projectID,+ IssueUID: reviewResultIssue,+ Payload: &storepb.IssueCommentPayload{+ Comment: message,+ StatementAnchor: &storepb.IssueCommentPayload_StatementAnchor{+ SpecId: "spec-1",+ SheetSha256: reviewResultSheet,+ StartPosition: &storepb.Position{Line: 1},+ EndPosition: &storepb.Position{Line: 1},+ },+ ReviewMetadata: &storepb.IssueCommentPayload_ReviewMetadata{+ RunType: storepb.ReviewRun_RULE,+ RuleType: rule,+ Priority: storepb.IssueCommentPayload_ReviewMetadata_P1,+ Targets: []string{"instances/i/databases/db"},+ },+ },+ }+}++type reviewComment struct {+ Comment string+ ThreadState string+ Creator *string+}++func listReviewComments(t *testing.T, fixture *storePostgresFixture, projectID string) []reviewComment {+ t.Helper()+ rows, err := fixture.db.QueryContext(fixture.ctx, `+ SELECT payload->>'comment', thread_state, creator+ FROM issue_comment+ WHERE project = $1 AND issue_id = $2 AND payload ? 'reviewMetadata'+ ORDER BY created_at, resource_id+ `, projectID, reviewResultIssue)+ require.NoError(t, err)+ defer rows.Close()+ var out []reviewComment+ for rows.Next() {+ var c reviewComment+ require.NoError(t, rows.Scan(&c.Comment, &c.ThreadState, &c.Creator))+ out = append(out, c)+ }+ require.NoError(t, rows.Err())+ return out+}++// TestCompleteReviewRunPostsResults completes runs on two projects whose issue+// ids collide: a DONE completion posts its results as creatorless OPEN roots+// and resolves only the same reviewer's earlier results on its own issue; a+// superseded or FAILED completion writes nothing.+func TestCompleteReviewRunPostsResults(t *testing.T) {+ t.Parallel()+ fixture := newStorePostgresFixture(t, `+ INSERT INTO project (resource_id, workspace, name) VALUES ('other', 'default', 'Other');+ INSERT INTO issue (id, creator, project, name, status, type)+ VALUES (301, '[email protected]', 'default', 'Issue Default', 'OPEN', 'DATABASE_CHANGE');+ INSERT INTO issue (id, creator, project, name, status, type)+ VALUES (301, '[email protected]', 'other', 'Issue Other', 'OPEN', 'DATABASE_CHANGE');+ `)+ ctx, s := fixture.ctx, fixture.store+ const issueUID = reviewResultIssue++ // A person's anchored thread and a guideline result on the same issue+ // must survive every rule completion below.+ open := store.ThreadStateOpen+ _, err := s.CreateIssueComments(ctx, "[email protected]", &store.IssueCommentMessage{+ ProjectID: "default", IssueUID: issueUID,+ Payload: &storepb.IssueCommentPayload{+ Comment: "person",+ StatementAnchor: reviewResult("default", "", storepb.ReviewRuleType_SYNTAX).Payload.StatementAnchor,+ },+ })+ require.NoError(t, err)+ guideline := reviewResult("default", "guideline", storepb.ReviewRuleType_REVIEW_RULE_TYPE_UNSPECIFIED)+ guideline.Payload.ReviewMetadata.RunType = storepb.ReviewRun_GUIDELINE+ guideline.ThreadState = &open++ // Colliding rule runs on both projects.+ for _, projectID := range []string{"default", "other"} {+ _, err := s.CreateReviewRun(ctx, projectID, issueUID, store.ReviewRunTypeRule)+ require.NoError(t, err)+ }+ _, err = s.CreateReviewRun(ctx, "default", issueUID, store.ReviewRunTypeGuideline)+ require.NoError(t, err)+ claimed, err := s.ClaimAvailableReviewRuns(ctx, "replica-1")+ require.NoError(t, err)+ require.Len(t, claimed, 3)+ byKey := make(map[[2]string]*store.ClaimedReviewRun)+ for _, c := range claimed {+ byKey[[2]string{c.ProjectID, c.Type}] = c+ }+ ruleDefault := byKey[[2]string{"default", store.ReviewRunTypeRule}]+ ruleOther := byKey[[2]string{"other", store.ReviewRunTypeRule}]+ guidelineDefault := byKey[[2]string{"default", store.ReviewRunTypeGuideline}]++ updated, err := s.CompleteReviewRun(ctx, guidelineDefault, "replica-1", storepb.ReviewRun_DONE, nil, []*store.IssueCommentMessage{guideline})+ require.NoError(t, err)+ require.True(t, updated)++ // Results must belong to the claimed run and name its reviewer.+ _, err = s.CompleteReviewRun(ctx, ruleDefault, "replica-1", storepb.ReviewRun_DONE, nil,+ []*store.IssueCommentMessage{reviewResult("other", "wrong project", storepb.ReviewRuleType_SYNTAX)})+ require.Error(t, err)+ wrongReviewer := reviewResult("default", "wrong reviewer", storepb.ReviewRuleType_SYNTAX)+ wrongReviewer.Payload.ReviewMetadata.RunType = storepb.ReviewRun_GUIDELINE+ _, err = s.CompleteReviewRun(ctx, ruleDefault, "replica-1", storepb.ReviewRun_DONE, nil, []*store.IssueCommentMessage{wrongReviewer})+ require.Error(t, err)+ _, err = s.CompleteReviewRun(ctx, ruleDefault, "replica-1", storepb.ReviewRun_FAILED, nil,+ []*store.IssueCommentMessage{reviewResult("default", "failed with results", storepb.ReviewRuleType_SYNTAX)})+ require.Error(t, err)+ require.Len(t, listReviewComments(t, fixture, "default"), 1, "a rejected completion writes nothing")++ // The first rule completion on each project posts its results.+ updated, err = s.CompleteReviewRun(ctx, ruleDefault, "replica-1", storepb.ReviewRun_DONE, nil, []*store.IssueCommentMessage{+ reviewResult("default", "default first", storepb.ReviewRuleType_REQUIRE_WHERE),+ reviewResult("default", "default second", storepb.ReviewRuleType_DISALLOW_TRUNCATE),+ })+ require.NoError(t, err)+ require.True(t, updated)+ updated, err = s.CompleteReviewRun(ctx, ruleOther, "replica-1", storepb.ReviewRun_DONE, nil, []*store.IssueCommentMessage{+ reviewResult("other", "other first", storepb.ReviewRuleType_REQUIRE_WHERE),+ })+ require.NoError(t, err)+ require.True(t, updated)++ got := listReviewComments(t, fixture, "default")+ require.Equal(t, []reviewComment{+ {Comment: "guideline", ThreadState: "OPEN"},+ {Comment: "default first", ThreadState: "OPEN"},+ {Comment: "default second", ThreadState: "OPEN"},+ }, got, "results post in order as OPEN roots with no creator")+ otherBefore := listReviewComments(t, fixture, "other")+ require.Equal(t, []reviewComment{{Comment: "other first", ThreadState: "OPEN"}}, otherBefore)++ // A re-run supersedes the RUNNING execution: its completion posts nothing+ // and resolves nothing.+ _, err = s.CreateReviewRun(ctx, "default", issueUID, store.ReviewRunTypeRule)+ require.NoError(t, err)+ claimed, err = s.ClaimAvailableReviewRuns(ctx, "replica-1")+ require.NoError(t, err)+ require.Len(t, claimed, 1)+ current := claimed[0]+ _, err = s.CreateReviewRun(ctx, "default", issueUID, store.ReviewRunTypeRule)+ require.NoError(t, err)+ updated, err = s.CompleteReviewRun(ctx, current, "replica-1", storepb.ReviewRun_DONE, nil, []*store.IssueCommentMessage{+ reviewResult("default", "superseded", storepb.ReviewRuleType_SYNTAX),+ })+ require.NoError(t, err)+ require.False(t, updated)+ require.Equal(t, got, listReviewComments(t, fixture, "default"), "a superseded completion writes nothing")++ // A FAILED completion keeps the earlier results open.+ claimed, err = s.ClaimAvailableReviewRuns(ctx, "replica-1")+ require.NoError(t, err)+ require.Len(t, claimed, 1)+ updated, err = s.CompleteReviewRun(ctx, claimed[0], "replica-1", storepb.ReviewRun_FAILED, &storepb.ReviewRunPayload{Error: "boom"}, nil)+ require.NoError(t, err)+ require.True(t, updated)+ require.Equal(t, got, listReviewComments(t, fixture, "default"), "a failed run leaves the comments alone")++ // The next DONE resolves the same reviewer's earlier results on this+ // issue, and only those: the guideline result, the person's thread, and+ // the colliding issue in the other project stay open.+ _, err = s.CreateReviewRun(ctx, "default", issueUID, store.ReviewRunTypeRule)+ require.NoError(t, err)+ claimed, err = s.ClaimAvailableReviewRuns(ctx, "replica-1")+ require.NoError(t, err)+ require.Len(t, claimed, 1)+ updated, err = s.CompleteReviewRun(ctx, claimed[0], "replica-1", storepb.ReviewRun_DONE, nil, []*store.IssueCommentMessage{+ reviewResult("default", "default third", storepb.ReviewRuleType_REQUIRE_WHERE),+ })+ require.NoError(t, err)+ require.True(t, updated)+ require.Equal(t, []reviewComment{+ {Comment: "guideline", ThreadState: "OPEN"},+ {Comment: "default first", ThreadState: "RESOLVED"},+ {Comment: "default second", ThreadState: "RESOLVED"},+ {Comment: "default third", ThreadState: "OPEN"},+ }, listReviewComments(t, fixture, "default"))+ require.Equal(t, otherBefore, listReviewComments(t, fixture, "other"), "the colliding issue in the other project is untouched")++ openThreads, err := s.ListIssueComment(ctx, &store.FindIssueCommentMessage{ProjectID: "default", IssueUID: &[]int64{issueUID}[0], ThreadState: &open})+ require.NoError(t, err)+ var comments []string+ for _, c := range openThreads {+ comments = append(comments, c.Payload.Comment)+ if c.Payload.ReviewMetadata != nil {+ require.Empty(t, c.CreatorEmail, "a review result reads back with no creator")+ } else {+ require.Equal(t, "[email protected]", c.CreatorEmail)+ }+ }+ require.ElementsMatch(t, []string{"person", "guideline", "default third"}, comments)++ // A clean DONE with no results still resolves the previous ones.+ _, err = s.CreateReviewRun(ctx, "default", issueUID, store.ReviewRunTypeRule)+ require.NoError(t, err)+ claimed, err = s.ClaimAvailableReviewRuns(ctx, "replica-1")+ require.NoError(t, err)+ require.Len(t, claimed, 1)+ updated, err = s.CompleteReviewRun(ctx, claimed[0], "replica-1", storepb.ReviewRun_DONE, nil, nil)+ require.NoError(t, err)+ require.True(t, updated)+ for _, c := range listReviewComments(t, fixture, "default") {+ if c.Comment == "guideline" {+ require.Equal(t, "OPEN", c.ThreadState)+ continue+ }+ require.Equal(t, "RESOLVED", c.ThreadState, c.Comment)+ }+}diff --git a/backend/store/review_run_test.go b/backend/store/review_run_test.goindex 3dfa6ccc4c..6d69fdb719 100644--- a/backend/store/review_run_test.go+++ b/backend/store/review_run_test.go@@ -53,12 +53,12 @@ func TestReviewRunStoreLifecycle(t *testing.T) {require.Equal(t, storepb.ReviewRun_AVAILABLE, run.Status)// The superseded execution's completion is fenced off.- updated, err := s.CompleteReviewRun(ctx, claimed[0], "replica-1", storepb.ReviewRun_DONE, nil)+ updated, err := s.CompleteReviewRun(ctx, claimed[0], "replica-1", storepb.ReviewRun_DONE, nil, nil)require.NoError(t, err)require.False(t, updated, "a superseded completion must match zero rows")// Only terminal statuses complete a run.- _, err = s.CompleteReviewRun(ctx, claimed[0], "replica-1", storepb.ReviewRun_AVAILABLE, nil)+ _, err = s.CompleteReviewRun(ctx, claimed[0], "replica-1", storepb.ReviewRun_AVAILABLE, nil, nil)require.Error(t, err)// Claim the new attempt and complete it for real.@@ -66,7 +66,7 @@ func TestReviewRunStoreLifecycle(t *testing.T) {require.NoError(t, err)require.Len(t, claimed, 1)require.Equal(t, int64(1), claimed[0].Attempt)- updated, err = s.CompleteReviewRun(ctx, claimed[0], "replica-1", storepb.ReviewRun_FAILED, &storepb.ReviewRunPayload{Error: "boom"})+ updated, err = s.CompleteReviewRun(ctx, claimed[0], "replica-1", storepb.ReviewRun_FAILED, &storepb.ReviewRunPayload{Error: "boom"}, nil)require.NoError(t, err)require.True(t, updated)@@ -79,7 +79,7 @@ func TestReviewRunStoreLifecycle(t *testing.T) {require.Equal(t, "boom", payloadError)// A terminal row never completes again.- updated, err = s.CompleteReviewRun(ctx, claimed[0], "replica-1", storepb.ReviewRun_DONE, nil)+ updated, err = s.CompleteReviewRun(ctx, claimed[0], "replica-1", storepb.ReviewRun_DONE, nil, nil)require.NoError(t, err)require.False(t, updated)diff --git a/backend/tests/review_run_lifecycle_test.go b/backend/tests/review_run_lifecycle_test.goindex c8c60db63c..1faa5f9030 100644--- a/backend/tests/review_run_lifecycle_test.go+++ b/backend/tests/review_run_lifecycle_test.go@@ -90,13 +90,16 @@ func TestCollision_RunReviewLifecycle(t *testing.T) {a.NoError(err)a.Equal(v1pb.ReviewRun_AVAILABLE, runB.Status)- // The scheduler claims and executes both; the rule engine evaluates the- // real test databases and the runs reach DONE.+ // The scheduler claims and executes both. The rule executor evaluates+ // the real test databases through omni's SQL Review V2 contract; until+ // omni ships this engine's review package, the run fails honestly rather+ // than reporting a vacuous DONE. Flip these to DONE when it registers.rowA := waitReviewRunTerminal(ctx, t, ctl, projectAID, issueAUID, "RULE")- a.Equal("DONE", rowA.Status, "rule review on project A should succeed, got payload %s", rowA.Payload)+ a.Equal("FAILED", rowA.Status, "rule review on project A, got payload %s", rowA.Payload)+ a.Contains(rowA.Payload, "has no standard rule reviewer")a.Equal(int64(0), rowA.Attempt)rowB := waitReviewRunTerminal(ctx, t, ctl, projectBID, issueBUID, "RULE")- a.Equal("DONE", rowB.Status, "rule review on project B should succeed, got payload %s", rowB.Payload)+ a.Equal("FAILED", rowB.Status, "rule review on project B, got payload %s", rowB.Payload)a.Equal(int64(0), rowB.Attempt)// Re-running A bumps only A's attempt; B's colliding slot is untouched.@@ -107,7 +110,7 @@ func TestCollision_RunReviewLifecycle(t *testing.T) {a.Equal(v1pb.ReviewRun_AVAILABLE, runA2.Status)rowA2 := waitReviewRunTerminal(ctx, t, ctl, projectAID, issueAUID, "RULE")a.Equal(int64(1), rowA2.Attempt)- a.Equal("DONE", rowA2.Status)+ a.Equal("FAILED", rowA2.Status)afterB := listReviewRuns(ctx, t, ctl, projectBID)a.Equal(beforeB, afterB, "project B review_run rows must be untouched by A's re-run")@@ -143,5 +146,5 @@ func TestCollision_RunReviewLifecycle(t *testing.T) {// The failed guideline run left A's rule slot alone.rowA3 := waitReviewRunTerminal(ctx, t, ctl, projectAID, issueAUID, "RULE")a.Equal(int64(1), rowA3.Attempt)- a.Equal("DONE", rowA3.Status)+ a.Equal("FAILED", rowA3.Status)}diff --git a/go.mod b/go.modindex 3f3d91df5b..0178100c3f 100644--- a/go.mod+++ b/go.mod@@ -36,7 +36,7 @@ require (github.com/bmatcuk/doublestar/v4 v4.10.0github.com/bytebase/gomongo v0.0.0-20260730033313-67ba6e249735github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0- github.com/bytebase/omni v0.0.0-20260917062119-96fc86c5cfd8+ github.com/bytebase/omni v0.0.0-20260920103048-3165d7e5a683github.com/caarlos0/env/v11 v11.4.1github.com/cenkalti/backoff/v7 v7.0.0github.com/cockroachdb/cockroach-go/v2 v2.4.3diff --git a/go.sum b/go.sumindex c3878265dc..e49af43d3e 100644--- a/go.sum+++ b/go.sum@@ -252,8 +252,8 @@ github.com/bytebase/gomongo v0.0.0-20260730033313-67ba6e249735 h1:v8y6mXeHmYVsdMgithub.com/bytebase/gomongo v0.0.0-20260730033313-67ba6e249735/go.mod h1:vTHjcvfn8Pmf65WjnV1ytTCYyC7xNhFjrniv4YWvtA8=github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0 h1:bJ8NSf2K+pccl5m/wuu97fiYjDwpJH6IzURAq/3XA2U=github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0/go.mod h1:BEWMfiZtqshdmulKJcIsWb45MUaEvDO4CROcgi8dfFg=-github.com/bytebase/omni v0.0.0-20260917062119-96fc86c5cfd8 h1:4NJaveqYKUlCH8BDJLAEgYGOjF/Hx9wUaLZrVq87P+c=-github.com/bytebase/omni v0.0.0-20260917062119-96fc86c5cfd8/go.mod h1:9XZE1hqtvr09Oc+DdLu1/yCb8MDcoy/EPdA4AONDHlE=+github.com/bytebase/omni v0.0.0-20260920103048-3165d7e5a683 h1:qPDr0tbTRnhhWbmwlDf0yfVLAtWGyh9KT5YzT5ZLCJ4=+github.com/bytebase/omni v0.0.0-20260920103048-3165d7e5a683/go.mod h1:9XZE1hqtvr09Oc+DdLu1/yCb8MDcoy/EPdA4AONDHlE=github.com/bytebase/pgx/v5 v5.0.0-20250212161523-96ff8aed8767 h1:YuR5G3LcxpO5ScSTA+Kdirxg9RW4TRc/v1t7N2Hfmbw=github.com/bytebase/pgx/v5 v5.0.0-20250212161523-96ff8aed8767/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ=github.com/bytebase/pkcs8 v0.0.0-20240612095628-fcd0a7484c94 h1:6PNsuNmSqCuR8Z616uQLzDIvujWCFsKzeVc3ECmVubk=