droboticflow/internal/api/acceptance_import.go
2026-06-23 20:43:00 +08:00

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})
}