forked from longtao.wu/droboticflow
671 lines
29 KiB
Go
671 lines
29 KiB
Go
package api
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"regexp"
|
|
"strings"
|
|
|
|
"droboticflow/internal/domain"
|
|
)
|
|
|
|
const (
|
|
pocAcceptanceProjectID = "project-poc-operator-acceptance"
|
|
pocAcceptanceWorkflowID = "workflow-poc-operator-acceptance"
|
|
pocAcceptanceNodeID = "poc-operator-acceptance"
|
|
pocAcceptanceProjectName = "POC 算子验收"
|
|
pocAcceptanceWorkflow = "POC 内置算子验收"
|
|
)
|
|
|
|
var (
|
|
acceptanceIDSegmentPattern = regexp.MustCompile(`[^a-zA-Z0-9_-]+`)
|
|
containerImageIDPattern = regexp.MustCompile(`^\S+@sha256:[a-fA-F0-9]{64}$`)
|
|
)
|
|
|
|
var requiredPocAcceptanceFixtureSourceNames = []string{"csv", "json", "lerobot", "model", "rosbag", "xplatform"}
|
|
|
|
type pocAcceptanceImportRequest struct {
|
|
Result map[string]any `json:"result"`
|
|
Source struct {
|
|
Environment string `json:"environment,omitempty"`
|
|
Namespace string `json:"namespace,omitempty"`
|
|
JobName string `json:"jobName,omitempty"`
|
|
Image string `json:"image,omitempty"`
|
|
ImageID string `json:"imageId,omitempty"`
|
|
} `json:"source,omitempty"`
|
|
}
|
|
|
|
func sanitizeAcceptanceIDSegment(value string) string {
|
|
trimmed := strings.Trim(acceptanceIDSegmentPattern.ReplaceAllString(strings.TrimSpace(value), "-"), "-_")
|
|
if trimmed == "" {
|
|
return "unknown"
|
|
}
|
|
if len(trimmed) > 96 {
|
|
return trimmed[:96]
|
|
}
|
|
return trimmed
|
|
}
|
|
|
|
func boolField(payload map[string]any, key string) bool {
|
|
value, _ := payload[key].(bool)
|
|
return value
|
|
}
|
|
|
|
func stringField(payload map[string]any, key string) string {
|
|
value, _ := payload[key].(string)
|
|
return strings.TrimSpace(value)
|
|
}
|
|
|
|
func numberField(payload map[string]any, key string) int {
|
|
value, ok := payload[key].(float64)
|
|
if !ok || value < 0 {
|
|
return 0
|
|
}
|
|
return int(value)
|
|
}
|
|
|
|
func stringSliceField(payload map[string]any, key string) []string {
|
|
raw, ok := payload[key].([]any)
|
|
if !ok {
|
|
return []string{}
|
|
}
|
|
items := make([]string, 0, len(raw))
|
|
for _, item := range raw {
|
|
if text := strings.TrimSpace(fmt.Sprint(item)); text != "" {
|
|
items = append(items, text)
|
|
}
|
|
}
|
|
return items
|
|
}
|
|
|
|
func stringSetContains(items []string, value string) bool {
|
|
for _, item := range items {
|
|
if item == value {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func imageRepositoryName(reference string) string {
|
|
trimmed := strings.TrimSpace(reference)
|
|
if at := strings.Index(trimmed, "@"); at >= 0 {
|
|
trimmed = trimmed[:at]
|
|
}
|
|
lastSlash := strings.LastIndex(trimmed, "/")
|
|
lastColon := strings.LastIndex(trimmed, ":")
|
|
if lastColon > lastSlash {
|
|
trimmed = trimmed[:lastColon]
|
|
}
|
|
return trimmed
|
|
}
|
|
|
|
func boolFieldPresent(payload map[string]any, key string) (bool, bool) {
|
|
value, ok := payload[key].(bool)
|
|
return value, ok
|
|
}
|
|
|
|
func numericFieldPresent(payload map[string]any, key string) (int, bool) {
|
|
value, ok := payload[key].(float64)
|
|
if !ok || value < 0 || value != float64(int(value)) {
|
|
return 0, false
|
|
}
|
|
return int(value), true
|
|
}
|
|
|
|
type fixtureSourceEvidence struct {
|
|
generated int
|
|
real int
|
|
present bool
|
|
issues []validationIssue
|
|
}
|
|
|
|
func fixtureSourceEvidenceField(payload map[string]any) fixtureSourceEvidence {
|
|
evidence := fixtureSourceEvidence{issues: make([]validationIssue, 0)}
|
|
fixtureSources, ok := payload["fixtureSources"].(map[string]any)
|
|
if !ok {
|
|
evidence.issues = append(evidence.issues, validationIssue{Field: "result.fixtureSources", Message: "fixtureSources must be present when fullExternalAcceptance is true"})
|
|
return evidence
|
|
}
|
|
allowGenerated, ok := fixtureSources["allowGeneratedFixtures"].(bool)
|
|
if !ok {
|
|
evidence.issues = append(evidence.issues, validationIssue{Field: "result.fixtureSources.allowGeneratedFixtures", Message: "fixtureSources.allowGeneratedFixtures must be boolean false when fullExternalAcceptance is true"})
|
|
} else if allowGenerated {
|
|
evidence.issues = append(evidence.issues, validationIssue{Field: "result.fixtureSources.allowGeneratedFixtures", Message: "fixtureSources.allowGeneratedFixtures must be false when fullExternalAcceptance is true"})
|
|
}
|
|
items, ok := fixtureSources["items"].(map[string]any)
|
|
if !ok || len(items) == 0 {
|
|
evidence.issues = append(evidence.issues, validationIssue{Field: "result.fixtureSources.items", Message: "fixtureSources.items must include real fixture path evidence when fullExternalAcceptance is true"})
|
|
return evidence
|
|
}
|
|
evidence.present = true
|
|
for _, name := range requiredPocAcceptanceFixtureSourceNames {
|
|
if _, ok := items[name]; !ok {
|
|
evidence.issues = append(evidence.issues, validationIssue{Field: "result.fixtureSources.items." + name, Message: "fixtureSources.items must include " + name + " when fullExternalAcceptance is true"})
|
|
}
|
|
}
|
|
for name, raw := range items {
|
|
fieldPrefix := "result.fixtureSources.items." + name
|
|
item, ok := raw.(map[string]any)
|
|
if !ok {
|
|
evidence.issues = append(evidence.issues, validationIssue{Field: fieldPrefix, Message: "fixture source must be an object when fullExternalAcceptance is true"})
|
|
continue
|
|
}
|
|
path, _ := item["path"].(string)
|
|
path = strings.TrimSpace(path)
|
|
if path == "" {
|
|
evidence.issues = append(evidence.issues, validationIssue{Field: fieldPrefix + ".path", Message: "fixture source path is required when fullExternalAcceptance is true"})
|
|
} else if !strings.HasPrefix(path, "/") {
|
|
evidence.issues = append(evidence.issues, validationIssue{Field: fieldPrefix + ".path", Message: "fixture source path must be absolute when fullExternalAcceptance is true"})
|
|
}
|
|
generated, ok := item["generated"].(bool)
|
|
if !ok {
|
|
evidence.issues = append(evidence.issues, validationIssue{Field: fieldPrefix + ".generated", Message: "fixture source generated flag must be boolean false when fullExternalAcceptance is true"})
|
|
continue
|
|
}
|
|
if generated {
|
|
evidence.generated++
|
|
} else {
|
|
evidence.real++
|
|
}
|
|
}
|
|
return evidence
|
|
}
|
|
|
|
func anySliceLen(payload map[string]any, key string) (int, bool) {
|
|
raw, ok := payload[key].([]any)
|
|
if !ok {
|
|
return 0, false
|
|
}
|
|
return len(raw), true
|
|
}
|
|
|
|
func validatePocAcceptanceRepositoryEvidence(payload map[string]any) []validationIssue {
|
|
issues := make([]validationIssue, 0)
|
|
staticPayload, ok := payload["static"].(map[string]any)
|
|
if !ok {
|
|
return []validationIssue{{Field: "result.static", Message: "static operator repository evidence must be present when fullExternalAcceptance is true"}}
|
|
}
|
|
|
|
operatorFileCount, ok := numericFieldPresent(staticPayload, "operatorFileCount")
|
|
if !ok || operatorFileCount <= 0 {
|
|
issues = append(issues, validationIssue{Field: "result.static.operatorFileCount", Message: "static.operatorFileCount must be a positive integer when fullExternalAcceptance is true"})
|
|
}
|
|
repositoryManifestCount, ok := numericFieldPresent(staticPayload, "repositoryManifestCount")
|
|
if !ok {
|
|
issues = append(issues, validationIssue{Field: "result.static.repositoryManifestCount", Message: "static.repositoryManifestCount must be present when fullExternalAcceptance is true"})
|
|
}
|
|
if operatorFileCount > 0 && repositoryManifestCount != operatorFileCount {
|
|
issues = append(issues, validationIssue{Field: "result.static.repositoryManifestCount", Message: "static.repositoryManifestCount must equal static.operatorFileCount when fullExternalAcceptance is true"})
|
|
}
|
|
if runtimeSources, ok := anySliceLen(staticPayload, "runtimeSources"); ok && operatorFileCount > 0 && runtimeSources != operatorFileCount {
|
|
issues = append(issues, validationIssue{Field: "result.static.runtimeSources", Message: "static.runtimeSources must include every builtin operator source when fullExternalAcceptance is true"})
|
|
}
|
|
if repositoryManifests, ok := anySliceLen(staticPayload, "repositoryManifests"); ok && operatorFileCount > 0 && repositoryManifests != operatorFileCount {
|
|
issues = append(issues, validationIssue{Field: "result.static.repositoryManifests", Message: "static.repositoryManifests must include every builtin operator repository when fullExternalAcceptance is true"})
|
|
}
|
|
for _, item := range []struct {
|
|
key string
|
|
field string
|
|
message string
|
|
}{
|
|
{"repositoryManifestErrors", "result.static.repositoryManifestErrors", "static.repositoryManifestErrors must be empty when fullExternalAcceptance is true"},
|
|
{"duplicateOperatorIds", "result.static.duplicateOperatorIds", "static.duplicateOperatorIds must be empty when fullExternalAcceptance is true"},
|
|
{"duplicateOperatorNames", "result.static.duplicateOperatorNames", "static.duplicateOperatorNames must be empty when fullExternalAcceptance is true"},
|
|
{"legacyOperators", "result.static.legacyOperators", "static.legacyOperators must be empty when fullExternalAcceptance is true"},
|
|
{"builtinHelperCallOperators", "result.static.builtinHelperCallOperators", "static.builtinHelperCallOperators must be empty when fullExternalAcceptance is true"},
|
|
{"hardcodedExternalApiSources", "result.static.hardcodedExternalApiSources", "static.hardcodedExternalApiSources must be empty when fullExternalAcceptance is true"},
|
|
{"helperBuiltinKeys", "result.static.helperBuiltinKeys", "static.helperBuiltinKeys must be empty when fullExternalAcceptance is true"},
|
|
} {
|
|
if values := stringSliceField(staticPayload, item.key); len(values) > 0 {
|
|
issues = append(issues, validationIssue{Field: item.field, Message: item.message})
|
|
}
|
|
}
|
|
if count, ok := numericFieldPresent(payload, "operatorRepositoryRequiredCount"); !ok || count != operatorFileCount {
|
|
issues = append(issues, validationIssue{Field: "result.operatorRepositoryRequiredCount", Message: "operatorRepositoryRequiredCount must match static.operatorFileCount when fullExternalAcceptance is true"})
|
|
}
|
|
if count, ok := numericFieldPresent(payload, "operatorRepositoryCount"); !ok || count != repositoryManifestCount {
|
|
issues = append(issues, validationIssue{Field: "result.operatorRepositoryCount", Message: "operatorRepositoryCount must match static.repositoryManifestCount when fullExternalAcceptance is true"})
|
|
}
|
|
if complete, ok := boolFieldPresent(payload, "operatorRepositoryCoverageComplete"); !ok || !complete {
|
|
issues = append(issues, validationIssue{Field: "result.operatorRepositoryCoverageComplete", Message: "operatorRepositoryCoverageComplete must be true when fullExternalAcceptance is true"})
|
|
}
|
|
if clean, ok := boolFieldPresent(payload, "operatorRepositoryPolicyClean"); !ok || !clean {
|
|
issues = append(issues, validationIssue{Field: "result.operatorRepositoryPolicyClean", Message: "operatorRepositoryPolicyClean must be true when fullExternalAcceptance is true"})
|
|
}
|
|
if violations := stringSliceField(payload, "operatorRepositoryPolicyViolations"); len(violations) > 0 {
|
|
issues = append(issues, validationIssue{Field: "result.operatorRepositoryPolicyViolations", Message: "operatorRepositoryPolicyViolations must be empty when fullExternalAcceptance is true"})
|
|
}
|
|
return issues
|
|
}
|
|
|
|
func validatePocAcceptanceFullConsistency(payload map[string]any) []validationIssue {
|
|
issues := make([]validationIssue, 0)
|
|
fullExternalAcceptance, ok := boolFieldPresent(payload, "fullExternalAcceptance")
|
|
if !ok || !fullExternalAcceptance {
|
|
return issues
|
|
}
|
|
|
|
if stringField(payload, "status") != "passed" {
|
|
issues = append(issues, validationIssue{Field: "result.status", Message: "status must be passed when fullExternalAcceptance is true"})
|
|
}
|
|
if stringField(payload, "acceptanceScope") != "full" {
|
|
issues = append(issues, validationIssue{Field: "result.acceptanceScope", Message: "acceptanceScope must be full when fullExternalAcceptance is true"})
|
|
}
|
|
requiredExternals := stringSliceField(payload, "requiredExternals")
|
|
for _, external := range []string{"bos", "dcloud", "mongo"} {
|
|
if !stringSetContains(requiredExternals, external) {
|
|
issues = append(issues, validationIssue{Field: "result.requiredExternals", Message: "requiredExternals must include bos, dcloud, and mongo when fullExternalAcceptance is true"})
|
|
break
|
|
}
|
|
}
|
|
externalVerificationPassed := stringSliceField(payload, "externalVerificationPassed")
|
|
for _, external := range []string{"bos", "dcloud", "mongo"} {
|
|
if !stringSetContains(externalVerificationPassed, external) {
|
|
issues = append(issues, validationIssue{Field: "result.externalVerificationPassed", Message: "externalVerificationPassed must include bos, dcloud, and mongo when fullExternalAcceptance is true"})
|
|
break
|
|
}
|
|
}
|
|
if externalVerificationMissing := stringSliceField(payload, "externalVerificationMissing"); len(externalVerificationMissing) > 0 {
|
|
issues = append(issues, validationIssue{Field: "result.externalVerificationMissing", Message: "externalVerificationMissing must be empty when fullExternalAcceptance is true"})
|
|
}
|
|
externalVerificationPassedCount, ok := numericFieldPresent(payload, "externalVerificationPassedCount")
|
|
if !ok || externalVerificationPassedCount < 3 {
|
|
issues = append(issues, validationIssue{Field: "result.externalVerificationPassedCount", Message: "externalVerificationPassedCount must be at least 3 when fullExternalAcceptance is true"})
|
|
}
|
|
if externalVerificationRequiredCount, ok := numericFieldPresent(payload, "externalVerificationRequiredCount"); !ok || externalVerificationRequiredCount < 3 {
|
|
issues = append(issues, validationIssue{Field: "result.externalVerificationRequiredCount", Message: "externalVerificationRequiredCount must be at least 3 when fullExternalAcceptance is true"})
|
|
}
|
|
operatorCount, ok := numericFieldPresent(payload, "operatorCount")
|
|
if !ok || operatorCount <= 0 {
|
|
issues = append(issues, validationIssue{Field: "result.operatorCount", Message: "operatorCount must be a positive integer"})
|
|
}
|
|
operatorPassedCount, ok := numericFieldPresent(payload, "operatorPassedCount")
|
|
if !ok {
|
|
issues = append(issues, validationIssue{Field: "result.operatorPassedCount", Message: "operatorPassedCount must be a non-negative integer"})
|
|
}
|
|
if operatorCount > 0 && operatorPassedCount != operatorCount {
|
|
issues = append(issues, validationIssue{Field: "result.operatorPassedCount", Message: "operatorPassedCount must equal operatorCount when fullExternalAcceptance is true"})
|
|
}
|
|
if coveredOperatorCount, ok := numericFieldPresent(payload, "coveredOperatorCount"); ok && operatorCount > 0 && coveredOperatorCount != operatorCount {
|
|
issues = append(issues, validationIssue{Field: "result.coveredOperatorCount", Message: "coveredOperatorCount must equal operatorCount when fullExternalAcceptance is true"})
|
|
}
|
|
if failedCount, ok := numericFieldPresent(payload, "failedCount"); ok && failedCount != 0 {
|
|
issues = append(issues, validationIssue{Field: "result.failedCount", Message: "failedCount must be zero when fullExternalAcceptance is true"})
|
|
}
|
|
if requiredSkippedCount, ok := numericFieldPresent(payload, "requiredSkippedCount"); ok && requiredSkippedCount != 0 {
|
|
issues = append(issues, validationIssue{Field: "result.requiredSkippedCount", Message: "requiredSkippedCount must be zero when fullExternalAcceptance is true"})
|
|
}
|
|
if allComplete, ok := boolFieldPresent(payload, "allOperatorCoverageComplete"); !ok || !allComplete {
|
|
issues = append(issues, validationIssue{Field: "result.allOperatorCoverageComplete", Message: "allOperatorCoverageComplete must be true when fullExternalAcceptance is true"})
|
|
}
|
|
if blockingComplete, ok := boolFieldPresent(payload, "blockingOperatorCoverageComplete"); !ok || !blockingComplete {
|
|
issues = append(issues, validationIssue{Field: "result.blockingOperatorCoverageComplete", Message: "blockingOperatorCoverageComplete must be true when fullExternalAcceptance is true"})
|
|
}
|
|
if missing := stringSliceField(payload, "missingCoverage"); len(missing) > 0 {
|
|
issues = append(issues, validationIssue{Field: "result.missingCoverage", Message: "missingCoverage must be empty when fullExternalAcceptance is true"})
|
|
}
|
|
if missing := stringSliceField(payload, "blockingMissingCoverage"); len(missing) > 0 {
|
|
issues = append(issues, validationIssue{Field: "result.blockingMissingCoverage", Message: "blockingMissingCoverage must be empty when fullExternalAcceptance is true"})
|
|
}
|
|
generatedFixtureCount, generatedCountOK := numericFieldPresent(payload, "generatedFixtureCount")
|
|
realFixtureCount, realCountOK := numericFieldPresent(payload, "realFixtureCount")
|
|
fixtureEvidence := fixtureSourceEvidenceField(payload)
|
|
issues = append(issues, fixtureEvidence.issues...)
|
|
derivedGenerated, derivedReal, hasFixtureSources := fixtureEvidence.generated, fixtureEvidence.real, fixtureEvidence.present
|
|
if !generatedCountOK && hasFixtureSources {
|
|
generatedFixtureCount = derivedGenerated
|
|
generatedCountOK = true
|
|
} else if generatedCountOK && hasFixtureSources && generatedFixtureCount != derivedGenerated {
|
|
issues = append(issues, validationIssue{Field: "result.generatedFixtureCount", Message: "generatedFixtureCount must match fixtureSources.items when fullExternalAcceptance is true"})
|
|
}
|
|
if !realCountOK && hasFixtureSources {
|
|
realFixtureCount = derivedReal
|
|
realCountOK = true
|
|
} else if realCountOK && hasFixtureSources && realFixtureCount != derivedReal {
|
|
issues = append(issues, validationIssue{Field: "result.realFixtureCount", Message: "realFixtureCount must match fixtureSources.items when fullExternalAcceptance is true"})
|
|
}
|
|
if !generatedCountOK {
|
|
issues = append(issues, validationIssue{Field: "result.generatedFixtureCount", Message: "generatedFixtureCount must be present when fullExternalAcceptance is true"})
|
|
} else if generatedFixtureCount != 0 {
|
|
issues = append(issues, validationIssue{Field: "result.generatedFixtureCount", Message: "generatedFixtureCount must be zero when fullExternalAcceptance is true"})
|
|
}
|
|
if !realCountOK || realFixtureCount <= 0 {
|
|
issues = append(issues, validationIssue{Field: "result.realFixtureCount", Message: "realFixtureCount must be a positive integer when fullExternalAcceptance is true"})
|
|
}
|
|
if allFixturesReal, ok := boolFieldPresent(payload, "allFixturesReal"); !ok || !allFixturesReal {
|
|
issues = append(issues, validationIssue{Field: "result.allFixturesReal", Message: "allFixturesReal must be true when fullExternalAcceptance is true"})
|
|
}
|
|
if hasFixtureSources && derivedGenerated > 0 {
|
|
issues = append(issues, validationIssue{Field: "result.fixtureSources.items", Message: "fixtureSources.items must not contain generated fixtures when fullExternalAcceptance is true"})
|
|
}
|
|
issues = append(issues, validatePocAcceptanceRepositoryEvidence(payload)...)
|
|
return issues
|
|
}
|
|
|
|
func validatePocAcceptancePayload(payload map[string]any) []validationIssue {
|
|
issues := make([]validationIssue, 0)
|
|
if strings.TrimSpace(stringField(payload, "runId")) == "" {
|
|
issues = append(issues, validationIssue{Field: "result.runId", Message: "runId is required"})
|
|
}
|
|
if strings.TrimSpace(stringField(payload, "status")) == "" {
|
|
issues = append(issues, validationIssue{Field: "result.status", Message: "status is required"})
|
|
}
|
|
if strings.TrimSpace(stringField(payload, "acceptanceScope")) == "" {
|
|
issues = append(issues, validationIssue{Field: "result.acceptanceScope", Message: "acceptanceScope is required"})
|
|
}
|
|
if _, ok := payload["fullExternalAcceptance"].(bool); !ok {
|
|
issues = append(issues, validationIssue{Field: "result.fullExternalAcceptance", Message: "fullExternalAcceptance must be boolean"})
|
|
}
|
|
if _, ok := payload["operatorCount"].(float64); !ok {
|
|
issues = append(issues, validationIssue{Field: "result.operatorCount", Message: "operatorCount is required"})
|
|
}
|
|
if _, ok := payload["operatorPassedCount"].(float64); !ok {
|
|
issues = append(issues, validationIssue{Field: "result.operatorPassedCount", Message: "operatorPassedCount is required"})
|
|
}
|
|
issues = append(issues, validatePocAcceptanceFullConsistency(payload)...)
|
|
return issues
|
|
}
|
|
|
|
func validatePocAcceptanceImportSource(payload pocAcceptanceImportRequest) []validationIssue {
|
|
issues := make([]validationIssue, 0)
|
|
fullExternalAcceptance := boolField(payload.Result, "fullExternalAcceptance")
|
|
imageValid := false
|
|
imageIDValid := false
|
|
if strings.TrimSpace(payload.Source.Namespace) == "" {
|
|
if fullExternalAcceptance {
|
|
issues = append(issues, validationIssue{Field: "source.namespace", Message: "source.namespace is required when fullExternalAcceptance is true"})
|
|
}
|
|
}
|
|
if strings.TrimSpace(payload.Source.JobName) == "" {
|
|
if fullExternalAcceptance {
|
|
issues = append(issues, validationIssue{Field: "source.jobName", Message: "source.jobName is required when fullExternalAcceptance is true"})
|
|
}
|
|
}
|
|
image := strings.TrimSpace(payload.Source.Image)
|
|
if image == "" {
|
|
if fullExternalAcceptance {
|
|
issues = append(issues, validationIssue{Field: "source.image", Message: "source.image is required when fullExternalAcceptance is true"})
|
|
}
|
|
} else if strings.ContainsAny(image, " \t\r\n") {
|
|
issues = append(issues, validationIssue{Field: "source.image", Message: "source.image must not contain whitespace"})
|
|
} else {
|
|
imageValid = true
|
|
}
|
|
imageID := strings.TrimSpace(payload.Source.ImageID)
|
|
if imageID == "" {
|
|
if fullExternalAcceptance {
|
|
issues = append(issues, validationIssue{Field: "source.imageId", Message: "source.imageId is required when fullExternalAcceptance is true"})
|
|
}
|
|
} else if !containerImageIDPattern.MatchString(imageID) {
|
|
issues = append(issues, validationIssue{Field: "source.imageId", Message: "source.imageId must be a sha256 image digest"})
|
|
} else {
|
|
imageIDValid = true
|
|
}
|
|
if imageValid && imageIDValid && imageRepositoryName(image) != imageRepositoryName(imageID) {
|
|
issues = append(issues, validationIssue{Field: "source.imageId", Message: "source.imageId must match source.image repository"})
|
|
}
|
|
return issues
|
|
}
|
|
|
|
func acceptanceRunID(payload map[string]any) string {
|
|
return "run-poc-operator-acceptance-" + sanitizeAcceptanceIDSegment(stringField(payload, "runId"))
|
|
}
|
|
|
|
func acceptanceResultStatus(payload map[string]any) domain.RunStatus {
|
|
if stringField(payload, "status") == "passed" && numberField(payload, "failedCount") == 0 {
|
|
return domain.RunStatusCompleted
|
|
}
|
|
return domain.RunStatusFailed
|
|
}
|
|
|
|
func acceptanceResultLogLevel(runStatus domain.RunStatus) string {
|
|
if runStatus == domain.RunStatusCompleted {
|
|
return "INFO"
|
|
}
|
|
return "ERROR"
|
|
}
|
|
|
|
func acceptanceResultMessage(payload map[string]any) string {
|
|
scope := stringField(payload, "acceptanceScope")
|
|
passed := numberField(payload, "operatorPassedCount")
|
|
total := numberField(payload, "operatorCount")
|
|
full := boolField(payload, "fullExternalAcceptance")
|
|
return fmt.Sprintf("POC operator acceptance imported: scope=%s fullExternalAcceptance=%t operators=%d/%d", scope, full, passed, total)
|
|
}
|
|
|
|
func acceptanceResultError(payload map[string]any) string {
|
|
missing := stringSliceField(payload, "blockingMissingCoverage")
|
|
if len(missing) > 0 {
|
|
return "blocking missing coverage: " + strings.Join(missing, ", ")
|
|
}
|
|
if stringField(payload, "status") != "passed" {
|
|
return "acceptance status is " + stringField(payload, "status")
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func acceptanceResultArtifactData(payload map[string]any, source pocAcceptanceImportRequest) map[string]any {
|
|
data := make(map[string]any, len(payload)+1)
|
|
for key, value := range payload {
|
|
data[key] = value
|
|
}
|
|
sourceData := map[string]any{}
|
|
if source.Source.Environment != "" {
|
|
sourceData["environment"] = source.Source.Environment
|
|
}
|
|
if source.Source.Namespace != "" {
|
|
sourceData["namespace"] = source.Source.Namespace
|
|
}
|
|
if source.Source.JobName != "" {
|
|
sourceData["jobName"] = source.Source.JobName
|
|
}
|
|
if source.Source.Image != "" {
|
|
sourceData["image"] = source.Source.Image
|
|
}
|
|
if source.Source.ImageID != "" {
|
|
sourceData["imageId"] = source.Source.ImageID
|
|
}
|
|
if len(sourceData) > 0 {
|
|
data["importSource"] = sourceData
|
|
}
|
|
return data
|
|
}
|
|
|
|
func artifactSizeLabel(raw []byte) string {
|
|
if len(raw) < 1024 {
|
|
return fmt.Sprintf("%d B", len(raw))
|
|
}
|
|
return fmt.Sprintf("%.1f KB", float64(len(raw))/1024)
|
|
}
|
|
|
|
func (server *server) upsertPocAcceptanceProjectAndWorkflow(request *http.Request, now string) error {
|
|
organizationID := server.requestOrganizationID(request)
|
|
project := domain.ProjectRecord{
|
|
ID: pocAcceptanceProjectID,
|
|
OrganizationID: organizationID,
|
|
Name: pocAcceptanceProjectName,
|
|
Description: "POC 环境内置算子真实验收记录,包含完整外部验收与依赖隔离验收结果。",
|
|
Status: domain.ProjectStatusActive,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
if existing, err := server.store.GetProject(request.Context(), project.ID); err != nil {
|
|
return err
|
|
} else if existing != nil {
|
|
project.CreatedAt = existing.CreatedAt
|
|
}
|
|
if err := server.store.UpsertProject(request.Context(), project); err != nil {
|
|
return err
|
|
}
|
|
|
|
workflow := domain.WorkflowRecord{
|
|
ID: pocAcceptanceWorkflowID,
|
|
OrganizationID: organizationID,
|
|
ProjectID: project.ID,
|
|
Name: pocAcceptanceWorkflow,
|
|
Description: "导入 POC Kubernetes 验收 Job 结果,作为平台可查询的验收运行。",
|
|
Type: domain.WorkflowTypeBatch,
|
|
Kind: domain.WorkflowKindStandard,
|
|
Nodes: []domain.WorkflowNode{
|
|
{
|
|
ID: pocAcceptanceNodeID,
|
|
Type: "operator",
|
|
Data: domain.WorkflowNodeData{
|
|
Label: "POC 算子验收",
|
|
Category: "验收",
|
|
Description: "POC Kubernetes Job 验收结果导入",
|
|
Inputs: []domain.PortDefinition{},
|
|
Outputs: []domain.PortDefinition{
|
|
{ID: "out-acceptance", Name: "验收结果", Type: domain.PortTypeJSON},
|
|
},
|
|
},
|
|
Position: domain.Position{X: 0, Y: 0},
|
|
},
|
|
},
|
|
Edges: []domain.WorkflowEdge{},
|
|
Status: domain.WorkflowStatusReady,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
if existing, err := server.store.GetWorkflow(request.Context(), workflow.ID); err != nil {
|
|
return err
|
|
} else if existing != nil {
|
|
workflow.CreatedAt = existing.CreatedAt
|
|
}
|
|
return server.store.UpsertWorkflow(request.Context(), workflow)
|
|
}
|
|
|
|
func (server *server) handlePocAcceptanceImport(writer http.ResponseWriter, request *http.Request) {
|
|
var payload pocAcceptanceImportRequest
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if len(payload.Result) == 0 {
|
|
renderValidationError(writer, validationIssue{Field: "result", Message: "result is required"})
|
|
return
|
|
}
|
|
if issues := validatePocAcceptancePayload(payload.Result); len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
if issues := validatePocAcceptanceImportSource(payload); len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
|
|
now := nowISO()
|
|
if err := server.upsertPocAcceptanceProjectAndWorkflow(request, now); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
|
|
runStatus := acceptanceResultStatus(payload.Result)
|
|
artifactData := acceptanceResultArtifactData(payload.Result, payload)
|
|
rawArtifact, _ := json.Marshal(artifactData)
|
|
hash := sha256.Sum256(rawArtifact)
|
|
runID := acceptanceRunID(payload.Result)
|
|
startedAt := stringField(payload.Result, "startedAt")
|
|
if startedAt == "" {
|
|
startedAt = now
|
|
}
|
|
endedAt := stringField(payload.Result, "endedAt")
|
|
if endedAt == "" {
|
|
endedAt = now
|
|
}
|
|
artifact := domain.ExecutionArtifact{
|
|
ID: "artifact-" + runID,
|
|
RunID: runID,
|
|
NodeID: pocAcceptanceNodeID,
|
|
PortID: "out-acceptance",
|
|
PortName: "验收结果",
|
|
Name: "poc-operator-full-acceptance-result.json",
|
|
Type: domain.PortTypeJSON,
|
|
Size: artifactSizeLabel(rawArtifact),
|
|
Path: stringField(payload.Result, "workspace") + "/poc-operator-full-acceptance-result.json",
|
|
Metadata: &domain.ArtifactMetadata{
|
|
MimeType: "application/json",
|
|
SHA256: hex.EncodeToString(hash[:]),
|
|
},
|
|
Data: artifactData,
|
|
}
|
|
logEntry := domain.LogEntryRecord{
|
|
Timestamp: now,
|
|
Level: acceptanceResultLogLevel(runStatus),
|
|
Operator: "poc-operator-acceptance",
|
|
Message: acceptanceResultMessage(payload.Result),
|
|
}
|
|
run := domain.RunRecord{
|
|
ID: runID,
|
|
OrganizationID: server.requestOrganizationID(request),
|
|
WorkflowID: pocAcceptanceWorkflowID,
|
|
WorkflowName: pocAcceptanceWorkflow,
|
|
ProjectID: pocAcceptanceProjectID,
|
|
ProjectName: pocAcceptanceProjectName,
|
|
Trigger: domain.RunTriggerManual,
|
|
Attempt: 1,
|
|
AvailableAt: startedAt,
|
|
Status: runStatus,
|
|
StartedAt: startedAt,
|
|
EndedAt: endedAt,
|
|
CurrentRunAt: startedAt,
|
|
CurrentNodeID: pocAcceptanceNodeID,
|
|
NodeExecutions: []domain.NodeExecutionRecord{
|
|
{
|
|
NodeID: pocAcceptanceNodeID,
|
|
NodeLabel: "POC 算子验收",
|
|
Status: func() domain.NodeExecutionStatus {
|
|
if runStatus == domain.RunStatusCompleted {
|
|
return domain.NodeExecutionStatusCompleted
|
|
}
|
|
return domain.NodeExecutionStatusFailed
|
|
}(),
|
|
StartedAt: startedAt,
|
|
EndedAt: endedAt,
|
|
Logs: []domain.LogEntryRecord{logEntry},
|
|
Artifacts: []domain.ExecutionArtifact{artifact},
|
|
ResourceSeries: []domain.ResourceSample{},
|
|
Error: acceptanceResultError(payload.Result),
|
|
},
|
|
},
|
|
Logs: []domain.LogEntryRecord{logEntry},
|
|
ResourceSeries: []domain.ResourceSample{},
|
|
Artifacts: []domain.ExecutionArtifact{artifact},
|
|
K8sRefs: []domain.K8sRef{
|
|
{NodeID: pocAcceptanceNodeID, JobName: payload.Source.JobName, Namespace: payload.Source.Namespace},
|
|
},
|
|
Error: acceptanceResultError(payload.Result),
|
|
CreatedAt: startedAt,
|
|
UpdatedAt: now,
|
|
}
|
|
if err := server.store.UpsertRun(request.Context(), run); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
|
|
workflow, err := server.store.GetWorkflow(request.Context(), pocAcceptanceWorkflowID)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if workflow != nil {
|
|
workflow.LastRunID = run.ID
|
|
workflow.LastRunAt = endedAt
|
|
if runStatus == domain.RunStatusCompleted {
|
|
workflow.Status = domain.WorkflowStatusCompleted
|
|
} else {
|
|
workflow.Status = domain.WorkflowStatusFailed
|
|
}
|
|
workflow.UpdatedAt = now
|
|
if err := server.store.UpsertWorkflow(request.Context(), *workflow); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
}
|
|
|
|
renderJSON(writer, http.StatusCreated, map[string]any{"run": run, "artifact": artifact})
|
|
}
|