Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

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.go
index 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.IssueCommen
return 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) *v1p
EndPosition: 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.go
index 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.sql
new file mode 100644
index 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.sql
index 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 unique
resource_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.go
index 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.go
index 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 string
diff --git a/backend/runner/plancheck/derive.go b/backend/runner/plancheck/derive.go
index 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.go
index 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.go
index 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.go
index 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 *Chec
enablePriorBackup := target.EnablePriorBackup
enableGhost := 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.go
index 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.go
index 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.go
index 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.go
index 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.go
new file mode 100644
index 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.go
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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.Claimed
slog.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_DONE
payload := &storepb.ReviewRunPayload{}
if execErr != nil {
status = storepb.ReviewRun_FAILED
payload.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.Clai
panicErr = errors.Errorf("%v", r)
}
slog.Error("Review run executor PANIC RECOVER", log.BBError(panicErr), log.BBStack("panic-stack"))
+ results = nil
err = errors.Errorf("review run executor panic: %v", panicErr)
}
}()
diff --git a/backend/server/server.go b/backend/server/server.go
index 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.go
index 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 *FindIssueCommentMess
Payload: &storepb.IssueCommentPayload{},
}
var p []byte
- var parentID, threadState sql.NullString
+ var creator, parentID, threadState sql.NullString
if 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.String
if parentID.Valid {
ic.ParentID = &parentID.String
}
diff --git a/backend/store/review_run.go b/backend/store/review_run.go
index 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 *ClaimedReviewRun
if 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 *ClaimedReviewRun
return 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 *ClaimedReviewRun
if 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 no
diff --git a/backend/store/review_run_lock_order_test.go b/backend/store/review_run_lock_order_test.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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.go
index 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.mod
index 3f3d91df5b..0178100c3f 100644
--- a/go.mod
+++ b/go.mod
@@ -36,7 +36,7 @@ require (
github.com/bmatcuk/doublestar/v4 v4.10.0
github.com/bytebase/gomongo v0.0.0-20260730033313-67ba6e249735
github.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-3165d7e5a683
github.com/caarlos0/env/v11 v11.4.1
github.com/cenkalti/backoff/v7 v7.0.0
github.com/cockroachdb/cockroach-go/v2 v2.4.3
diff --git a/go.sum b/go.sum
index c3878265dc..e49af43d3e 100644
--- a/go.sum
+++ b/go.sum
@@ -252,8 +252,8 @@ github.com/bytebase/gomongo v0.0.0-20260730033313-67ba6e249735 h1:v8y6mXeHmYVsdM
github.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=