forked from longtao.wu/droboticflow
582 lines
25 KiB
Go
582 lines
25 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"droboticflow/internal/domain"
|
|
pluginregistry "droboticflow/internal/plugins"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
)
|
|
|
|
type workflowPublishRequest struct {
|
|
ReleaseNotes string `json:"releaseNotes"`
|
|
}
|
|
|
|
type projectWorkflowInstanceRequest struct {
|
|
ReleaseID string `json:"releaseId"`
|
|
SupplierID string `json:"supplierId,omitempty"`
|
|
}
|
|
|
|
var productionHumanRoles = []domain.AnnotationAssignmentRole{
|
|
domain.AnnotationRoleAnnotator,
|
|
domain.AnnotationRoleQualityReviewer,
|
|
domain.AnnotationRoleAcceptanceReviewer,
|
|
}
|
|
|
|
func releaseUsesAnnotationGate(release domain.WorkflowReleaseRecord) bool {
|
|
for _, node := range release.Nodes {
|
|
if strings.TrimSpace(node.Data.OperatorID) == "operator-builtin-annotation-gate" {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (server *server) releaseUsesFanyuSupplierPool(ctx context.Context, release domain.WorkflowReleaseRecord) (bool, error) {
|
|
if domain.WorkflowProcessingProfile(release.Nodes) != domain.ProcessingProfileRawHuman {
|
|
return false, nil
|
|
}
|
|
for _, node := range release.Nodes {
|
|
if strings.TrimSpace(node.Data.OperatorID) != "operator-builtin-annotation-gate" {
|
|
continue
|
|
}
|
|
for _, param := range node.Data.Hyperparams {
|
|
if param.Key != "ANNOTATION_TEMPLATE_ID" || strings.TrimSpace(param.Value) == "" {
|
|
continue
|
|
}
|
|
template, err := server.store.GetAnnotationTemplate(ctx, strings.TrimSpace(param.Value))
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
return template != nil && domain.IsFanyuV58ThreeRoleHumanLoop(template.HumanStages), nil
|
|
}
|
|
}
|
|
return false, nil
|
|
}
|
|
|
|
func supplierHasProductionHumanRoles(members []domain.ProjectMemberRecord, supplierID string) bool {
|
|
covered := map[domain.AnnotationAssignmentRole]bool{}
|
|
for _, member := range members {
|
|
if strings.TrimSpace(member.SupplierID) != supplierID {
|
|
continue
|
|
}
|
|
for _, role := range member.Roles {
|
|
covered[role] = true
|
|
}
|
|
}
|
|
for _, role := range productionHumanRoles {
|
|
if !covered[role] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func bindAnnotationSupplier(nodes []domain.WorkflowNode, supplierID string) []domain.WorkflowNode {
|
|
cloned := make([]domain.WorkflowNode, len(nodes))
|
|
copy(cloned, nodes)
|
|
for index := range cloned {
|
|
cloned[index].Data.Hyperparams = append([]domain.HyperParam(nil), cloned[index].Data.Hyperparams...)
|
|
if strings.TrimSpace(cloned[index].Data.OperatorID) != "operator-builtin-annotation-gate" {
|
|
continue
|
|
}
|
|
bound := false
|
|
for paramIndex := range cloned[index].Data.Hyperparams {
|
|
if strings.TrimSpace(cloned[index].Data.Hyperparams[paramIndex].Key) != "ANNOTATION_SUPPLIER_ID" {
|
|
continue
|
|
}
|
|
cloned[index].Data.Hyperparams[paramIndex].Value = supplierID
|
|
cloned[index].Data.Hyperparams[paramIndex].Type = "string"
|
|
cloned[index].Data.Hyperparams[paramIndex].Description = "当前项目绑定的供应商 ID"
|
|
bound = true
|
|
}
|
|
if !bound {
|
|
cloned[index].Data.Hyperparams = append(cloned[index].Data.Hyperparams, domain.HyperParam{
|
|
Key: "ANNOTATION_SUPPLIER_ID", Value: supplierID, Type: "string", Description: "当前项目绑定的供应商 ID",
|
|
})
|
|
}
|
|
}
|
|
return cloned
|
|
}
|
|
|
|
func (server *server) resolveProjectWorkflowSupplier(ctx context.Context, project domain.ProjectRecord, release domain.WorkflowReleaseRecord, requested string) (string, []validationIssue, error) {
|
|
if !releaseUsesAnnotationGate(release) {
|
|
return "", nil, nil
|
|
}
|
|
publicPool, err := server.releaseUsesFanyuSupplierPool(ctx, release)
|
|
if err != nil {
|
|
return "", nil, err
|
|
}
|
|
if publicPool {
|
|
return "", nil, nil
|
|
}
|
|
members, err := server.store.ListProjectMembers(ctx, project.OrganizationID, project.ID)
|
|
if err != nil {
|
|
return "", nil, err
|
|
}
|
|
ids := []string{}
|
|
for _, member := range members {
|
|
ids = append(ids, member.UserID)
|
|
}
|
|
users, e := server.store.ListProjectMemberUsers(ctx, project.OrganizationID, ids)
|
|
if e != nil {
|
|
return "", nil, e
|
|
}
|
|
directory := map[string]domain.UserRecord{}
|
|
for _, user := range users {
|
|
directory[user.ID] = user
|
|
}
|
|
for i := range members {
|
|
user, ok := directory[members[i].UserID]
|
|
members[i].Roles = nil
|
|
if ok && user.Status != domain.UserStatusDisabled && user.SupplierID == members[i].SupplierID {
|
|
members[i].Roles = domain.AccountProductionRoles(user)
|
|
}
|
|
}
|
|
requested = strings.TrimSpace(requested)
|
|
if requested != "" {
|
|
supplier, supplierErr := server.store.GetSupplier(ctx, requested)
|
|
if supplierErr != nil {
|
|
return "", nil, supplierErr
|
|
}
|
|
if supplier == nil || normalizedOrganizationID(supplier.OrganizationID) != normalizedOrganizationID(project.OrganizationID) || !strings.EqualFold(strings.TrimSpace(supplier.Status), "active") {
|
|
return "", []validationIssue{{Field: "supplierId", Message: "an active supplier in the same organization is required"}}, nil
|
|
}
|
|
if !supplierHasProductionHumanRoles(members, requested) {
|
|
return "", []validationIssue{{Field: "supplierId", Message: "supplier project members must cover annotator, quality reviewer and acceptance reviewer"}}, nil
|
|
}
|
|
return requested, nil, nil
|
|
}
|
|
candidates := map[string]struct{}{}
|
|
for _, member := range members {
|
|
supplierID := strings.TrimSpace(member.SupplierID)
|
|
if supplierID != "" && supplierHasProductionHumanRoles(members, supplierID) {
|
|
candidates[supplierID] = struct{}{}
|
|
}
|
|
}
|
|
if len(candidates) != 1 {
|
|
return "", []validationIssue{{Field: "supplierId", Message: "select exactly one supplier whose project members cover all three production roles"}}, nil
|
|
}
|
|
for supplierID := range candidates {
|
|
return server.resolveProjectWorkflowSupplier(ctx, project, release, supplierID)
|
|
}
|
|
return "", []validationIssue{{Field: "supplierId", Message: "supplier is required"}}, nil
|
|
}
|
|
|
|
func templateSnapshotFromWorkflow(item domain.WorkflowRecord) domain.TemplateRecord {
|
|
return domain.TemplateRecord{ID: "legacy-workflow:" + item.ID, OrganizationID: item.OrganizationID, Name: item.Name, Description: item.Description, Type: item.Type, Kind: item.Kind, ExecutionScope: item.ExecutionScope, ScanConfig: item.ScanConfig, Hyperparams: item.Hyperparams, MaxConcurrentRuns: item.MaxConcurrentRuns, NodeTimeoutSeconds: item.NodeTimeoutSeconds, RunTimeoutSeconds: item.RunTimeoutSeconds, MaxRetryAttempts: item.MaxRetryAttempts, RetryBackoffSeconds: item.RetryBackoffSeconds, Schedule: item.Schedule, Nodes: item.Nodes, Edges: item.Edges}
|
|
}
|
|
|
|
func (server *server) migrateLegacyProjectWorkflowInstances(ctx context.Context, project *domain.ProjectRecord) error {
|
|
if project == nil {
|
|
return nil
|
|
}
|
|
workflows, err := server.store.ListWorkflowsByProject(ctx, project.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
instances, err := server.store.ListProjectWorkflowInstances(ctx, project.OrganizationID, domain.ProjectWorkflowInstanceQuery{ProjectID: project.ID})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
byWorkflow := map[string]struct{}{}
|
|
for _, instance := range instances {
|
|
byWorkflow[instance.WorkflowID] = struct{}{}
|
|
}
|
|
for _, workflow := range workflows {
|
|
if _, exists := byWorkflow[workflow.ID]; exists {
|
|
continue
|
|
}
|
|
template := templateSnapshotFromWorkflow(workflow)
|
|
capabilities, requiredPlugins := workflowReleaseRequirements(template)
|
|
now := nowISO()
|
|
release := domain.WorkflowReleaseRecord{ID: "workflow-release-legacy-" + workflow.ID, OrganizationID: project.OrganizationID, TemplateID: template.ID, Version: 1, Name: workflow.Name, Description: workflow.Description, Type: workflow.Type, Kind: workflow.Kind, ExecutionScope: workflow.ExecutionScope, ScanConfig: workflow.ScanConfig, Hyperparams: workflow.Hyperparams, MaxConcurrentRuns: workflow.MaxConcurrentRuns, NodeTimeoutSeconds: workflow.NodeTimeoutSeconds, RunTimeoutSeconds: workflow.RunTimeoutSeconds, MaxRetryAttempts: workflow.MaxRetryAttempts, RetryBackoffSeconds: workflow.RetryBackoffSeconds, Schedule: workflow.Schedule, Nodes: workflow.Nodes, Edges: workflow.Edges, Capabilities: capabilities, RequiredPluginIDs: requiredPlugins, ContentDigest: workflowReleaseDigest(template), ReleaseNotes: "Historical workflow migration", PublishedByUserID: "system-migration", PublishedAt: now, CreatedAt: now}
|
|
if err := server.store.UpsertWorkflowRelease(ctx, release); err != nil {
|
|
return err
|
|
}
|
|
instance := domain.ProjectWorkflowInstanceRecord{ID: "project-workflow-instance-legacy-" + workflow.ID, OrganizationID: project.OrganizationID, ProjectID: project.ID, ReleaseID: release.ID, ReleaseVersion: 1, SourceTemplateID: release.TemplateID, WorkflowID: workflow.ID, Status: domain.ProjectWorkflowInstanceActive, CreatedByUserID: "system-migration", CreatedAt: now, UpdatedAt: now}
|
|
if err := server.store.UpsertProjectWorkflowInstance(ctx, instance); err != nil {
|
|
return err
|
|
}
|
|
if project.WorkflowInstanceID == "" {
|
|
project.WorkflowInstanceID = instance.ID
|
|
project.UpdatedAt = now
|
|
}
|
|
}
|
|
if project.WorkflowInstanceID != "" {
|
|
return server.store.UpsertProject(ctx, *project)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func workflowReleaseDigest(item domain.TemplateRecord) string {
|
|
item.CreatedAt = ""
|
|
item.UpdatedAt = ""
|
|
payload, _ := json.Marshal(item)
|
|
digest := sha256.Sum256(payload)
|
|
return hex.EncodeToString(digest[:])
|
|
}
|
|
|
|
func workflowReleaseRequirements(item domain.TemplateRecord) ([]string, []string) {
|
|
workflow := domain.WorkflowRecord{ID: item.ID, Nodes: item.Nodes, Edges: item.Edges}
|
|
if !pluginregistry.RequiredByWorkflow(workflow, pluginregistry.AnnotationQAID) {
|
|
return nil, nil
|
|
}
|
|
return []string{"human_annotation", "human_quality_review", "human_acceptance"}, []string{pluginregistry.HumanLoopCoreID, pluginregistry.AnnotationQAID}
|
|
}
|
|
|
|
func (server *server) handleTemplateReleasesList(writer http.ResponseWriter, request *http.Request) {
|
|
template, err := server.store.GetTemplate(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if template == nil {
|
|
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Template not found"})
|
|
return
|
|
}
|
|
if !server.ensureTenantAccess(writer, request, template.OrganizationID, "Template") {
|
|
return
|
|
}
|
|
items, err := server.store.ListWorkflowReleases(request.Context(), template.OrganizationID, domain.WorkflowReleaseQuery{TemplateID: template.ID})
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if len(items) == 0 && len(template.Nodes) > 0 && len(validateWorkflowTopology(template.Nodes, template.Edges)) == 0 {
|
|
capabilities, requiredPlugins := workflowReleaseRequirements(*template)
|
|
now := nowISO()
|
|
release := domain.WorkflowReleaseRecord{ID: "workflow-release-legacy-template-" + template.ID, OrganizationID: template.OrganizationID, TemplateID: template.ID, Version: 1, Name: template.Name, Description: template.Description, Type: template.Type, Kind: template.Kind, ExecutionScope: template.ExecutionScope, ScanConfig: template.ScanConfig, Hyperparams: template.Hyperparams, MaxConcurrentRuns: template.MaxConcurrentRuns, NodeTimeoutSeconds: template.NodeTimeoutSeconds, RunTimeoutSeconds: template.RunTimeoutSeconds, MaxRetryAttempts: template.MaxRetryAttempts, RetryBackoffSeconds: template.RetryBackoffSeconds, Schedule: template.Schedule, WorkflowInputs: template.WorkflowInputs, ArtifactStorage: template.ArtifactStorage, Nodes: template.Nodes, Edges: template.Edges, Capabilities: capabilities, RequiredPluginIDs: requiredPlugins, ContentDigest: workflowReleaseDigest(*template), ReleaseNotes: "Historical template migration", PublishedByUserID: "system-migration", PublishedAt: now, CreatedAt: now}
|
|
if err := server.store.UpsertWorkflowRelease(request.Context(), release); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
items = []domain.WorkflowReleaseRecord{release}
|
|
}
|
|
for index := range items {
|
|
publicPool, err := server.releaseUsesFanyuSupplierPool(request.Context(), items[index])
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
items[index].UsesPublicSupplierPool = publicPool
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func (server *server) handleTemplatePublish(writer http.ResponseWriter, request *http.Request) {
|
|
template, err := server.store.GetTemplate(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if template == nil {
|
|
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Template not found"})
|
|
return
|
|
}
|
|
if !server.ensureTenantAccess(writer, request, template.OrganizationID, "Template") {
|
|
return
|
|
}
|
|
if template.Type != domain.WorkflowTypeStreaming || template.ExecutionScope == domain.WorkflowExecutionScopeSandbox || domain.WorkflowScheduleEnabled(template.Schedule) {
|
|
renderValidationError(writer, validationIssue{Field: "type", Code: "continuous_capture_only", Message: "仅支持发布持续 Capture 正式处理模板"})
|
|
return
|
|
}
|
|
var payload workflowPublishRequest
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if issues := validateWorkflowTopology(template.Nodes, template.Edges); len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
if issues := server.validateWorkflowOperatorPublication(request.Context(), template.Nodes, template.ExecutionScope); len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
capabilities, requiredPlugins := workflowReleaseRequirements(*template)
|
|
if workflowReleaseContainsString(requiredPlugins, pluginregistry.AnnotationQAID) {
|
|
enabled, pluginErr := server.annotationPluginEnabled(request.Context(), template.OrganizationID)
|
|
if pluginErr != nil {
|
|
renderError(writer, http.StatusInternalServerError, pluginErr)
|
|
return
|
|
}
|
|
if !enabled {
|
|
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Annotation QA plugin is disabled", "code": "plugin_disabled"})
|
|
return
|
|
}
|
|
}
|
|
digest := workflowReleaseDigest(*template)
|
|
existing, err := server.store.ListWorkflowReleases(request.Context(), template.OrganizationID, domain.WorkflowReleaseQuery{TemplateID: template.ID})
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if len(existing) > 0 && existing[0].ContentDigest == digest {
|
|
renderJSON(writer, http.StatusOK, existing[0])
|
|
return
|
|
}
|
|
version := 1
|
|
if len(existing) > 0 {
|
|
version = existing[0].Version + 1
|
|
}
|
|
principal, _ := currentPrincipal(request)
|
|
now := nowISO()
|
|
release := domain.WorkflowReleaseRecord{
|
|
ID: domain.NewID("workflow-release"), OrganizationID: template.OrganizationID, TemplateID: template.ID, Version: version,
|
|
Name: template.Name, Description: template.Description, Type: template.Type, Kind: template.Kind,
|
|
ExecutionScope: template.ExecutionScope, ScanConfig: template.ScanConfig, Hyperparams: template.Hyperparams,
|
|
MaxConcurrentRuns: template.MaxConcurrentRuns, NodeTimeoutSeconds: template.NodeTimeoutSeconds,
|
|
RunTimeoutSeconds: template.RunTimeoutSeconds, MaxRetryAttempts: template.MaxRetryAttempts,
|
|
RetryBackoffSeconds: template.RetryBackoffSeconds, Schedule: template.Schedule, Nodes: template.Nodes, Edges: template.Edges,
|
|
WorkflowInputs: template.WorkflowInputs, ArtifactStorage: template.ArtifactStorage,
|
|
Capabilities: capabilities, RequiredPluginIDs: requiredPlugins, ContentDigest: digest,
|
|
ReleaseNotes: strings.TrimSpace(payload.ReleaseNotes), PublishedByUserID: principal.User.ID, PublishedAt: now, CreatedAt: now,
|
|
}
|
|
if err := server.store.UpsertWorkflowRelease(request.Context(), release); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusCreated, release)
|
|
}
|
|
|
|
func workflowReleaseContainsString(items []string, target string) bool {
|
|
for _, item := range items {
|
|
if item == target {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (server *server) handleWorkflowReleaseGet(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.store.GetWorkflowRelease(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if item == nil {
|
|
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Workflow release not found"})
|
|
return
|
|
}
|
|
if !server.ensureTenantAccess(writer, request, item.OrganizationID, "Workflow release") {
|
|
return
|
|
}
|
|
publicPool, err := server.releaseUsesFanyuSupplierPool(request.Context(), *item)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
item.UsesPublicSupplierPool = publicPool
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func (server *server) handleProjectWorkflowInstancesList(writer http.ResponseWriter, request *http.Request) {
|
|
project, err := server.store.GetProject(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if project == nil {
|
|
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Project not found"})
|
|
return
|
|
}
|
|
if !server.ensureTenantAccess(writer, request, project.OrganizationID, "Project") {
|
|
return
|
|
}
|
|
items, err := server.store.ListProjectWorkflowInstances(request.Context(), project.OrganizationID, domain.ProjectWorkflowInstanceQuery{ProjectID: project.ID})
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func (server *server) handleProjectWorkflowInstanceCreate(writer http.ResponseWriter, request *http.Request) {
|
|
project, err := server.store.GetProject(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if project == nil {
|
|
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Project not found"})
|
|
return
|
|
}
|
|
if !server.ensureTenantAccess(writer, request, project.OrganizationID, "Project") {
|
|
return
|
|
}
|
|
var payload projectWorkflowInstanceRequest
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
release, err := server.store.GetWorkflowRelease(request.Context(), strings.TrimSpace(payload.ReleaseID))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if release == nil || normalizedOrganizationID(release.OrganizationID) != normalizedOrganizationID(project.OrganizationID) {
|
|
renderValidationError(writer, validationIssue{Field: "releaseId", Message: "published workflow release is required"})
|
|
return
|
|
}
|
|
if release.Type != domain.WorkflowTypeStreaming || release.ExecutionScope == domain.WorkflowExecutionScopeSandbox || domain.WorkflowScheduleEnabled(release.Schedule) {
|
|
renderValidationError(writer, validationIssue{Field: "releaseId", Code: "continuous_capture_only", Message: "仅支持引用持续 Capture 正式处理模板,历史单次模板只读"})
|
|
return
|
|
}
|
|
supplierID, supplierIssues, supplierErr := server.resolveProjectWorkflowSupplier(request.Context(), *project, *release, payload.SupplierID)
|
|
if supplierErr != nil {
|
|
renderError(writer, http.StatusInternalServerError, supplierErr)
|
|
return
|
|
}
|
|
if len(supplierIssues) > 0 {
|
|
renderValidationError(writer, supplierIssues[0])
|
|
return
|
|
}
|
|
for _, pluginID := range release.RequiredPluginIDs {
|
|
if pluginID != pluginregistry.AnnotationQAID {
|
|
continue
|
|
}
|
|
enabled, pluginErr := server.annotationPluginEnabled(request.Context(), project.OrganizationID)
|
|
if pluginErr != nil {
|
|
renderError(writer, http.StatusInternalServerError, pluginErr)
|
|
return
|
|
}
|
|
if !enabled {
|
|
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Annotation QA plugin is disabled", "code": "plugin_disabled"})
|
|
return
|
|
}
|
|
}
|
|
instanceStorage := release.ArtifactStorage
|
|
if domain.InitialCaptureAutomation(release.Type, release.Schedule) != nil {
|
|
instanceStorage = nil
|
|
if issues := applyProjectWorkflowArtifactStorage(project, &instanceStorage); len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
}
|
|
workflow, err := server.store.CreateWorkflow(request.Context(), domain.CreateWorkflowInput{
|
|
OrganizationID: project.OrganizationID, ProjectID: project.ID, Name: release.Name, Description: release.Description,
|
|
Type: release.Type, Kind: release.Kind, ExecutionScope: release.ExecutionScope, ScanConfig: release.ScanConfig,
|
|
CaptureAutomation: domain.InitialCaptureAutomation(release.Type, release.Schedule),
|
|
Hyperparams: release.Hyperparams, MaxConcurrentRuns: release.MaxConcurrentRuns, NodeTimeoutSeconds: release.NodeTimeoutSeconds,
|
|
RunTimeoutSeconds: release.RunTimeoutSeconds, MaxRetryAttempts: release.MaxRetryAttempts,
|
|
RetryBackoffSeconds: release.RetryBackoffSeconds, Schedule: release.Schedule, Nodes: bindAnnotationSupplier(release.Nodes, supplierID), Edges: release.Edges,
|
|
WorkflowInputs: release.WorkflowInputs, ArtifactStorage: instanceStorage,
|
|
})
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
// A project workflow instance is an immutable release binding, not a new
|
|
// editable draft. Persist that distinction on the backing workflow so the
|
|
// normal project workflow run endpoint keeps project/workgroup isolation.
|
|
workflow.DefinitionState = domain.WorkflowDefinitionStateReleased
|
|
workflow.DefinitionVersion = release.Version
|
|
workflow.DefinitionFamilyID = release.TemplateID
|
|
workflow.UpdatedAt = nowISO()
|
|
if err := server.store.UpsertWorkflow(request.Context(), *workflow); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
existing, err := server.store.ListProjectWorkflowInstances(request.Context(), project.OrganizationID, domain.ProjectWorkflowInstanceQuery{ProjectID: project.ID, Status: domain.ProjectWorkflowInstanceActive})
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
var supersedes string
|
|
for index := range existing {
|
|
existing[index].Status = domain.ProjectWorkflowInstanceSuperseded
|
|
existing[index].UpdatedAt = nowISO()
|
|
if supersedes == "" {
|
|
supersedes = existing[index].ID
|
|
}
|
|
if err := server.store.UpsertProjectWorkflowInstance(request.Context(), existing[index]); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
}
|
|
principal, _ := currentPrincipal(request)
|
|
now := nowISO()
|
|
instance := domain.ProjectWorkflowInstanceRecord{
|
|
ID: domain.NewID("project-workflow-instance"), OrganizationID: project.OrganizationID, ProjectID: project.ID,
|
|
ReleaseID: release.ID, ReleaseVersion: release.Version, SourceTemplateID: release.TemplateID, WorkflowID: workflow.ID,
|
|
SupplierID: supplierID,
|
|
Status: domain.ProjectWorkflowInstanceActive, SupersedesInstanceID: supersedes, CreatedByUserID: principal.User.ID,
|
|
CreatedAt: now, UpdatedAt: now,
|
|
}
|
|
if err := server.store.UpsertProjectWorkflowInstance(request.Context(), instance); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
project.WorkflowInstanceID = instance.ID
|
|
project.UpdatedAt = now
|
|
if err := server.store.UpsertProject(request.Context(), *project); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusCreated, map[string]any{"instance": instance, "workflow": workflow})
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Production Run Request & Security Gate Types
|
|
// ----------------------------------------------------------------------------
|
|
|
|
const maxInlinePayloadBytes = 65536
|
|
|
|
type productionRunRequest struct {
|
|
Trigger domain.RunTrigger `json:"trigger"`
|
|
Inputs map[string]domain.ArtifactPayload `json:"inputs,omitempty"`
|
|
NodeOverrides map[string]any `json:"nodeOverrides,omitempty"`
|
|
DebugTarget any `json:"debugTarget,omitempty"`
|
|
Nodes any `json:"nodes,omitempty"`
|
|
Edges any `json:"edges,omitempty"`
|
|
}
|
|
|
|
func renderProductionSecurityGateError(writer http.ResponseWriter, code string, message string, issues ...validationIssue) {
|
|
resp := map[string]any{
|
|
"error": message,
|
|
"code": code,
|
|
}
|
|
if len(issues) > 0 {
|
|
resp["issues"] = issues
|
|
}
|
|
renderJSON(writer, http.StatusUnprocessableEntity, resp)
|
|
}
|
|
|
|
func workflowSnapshotFromRelease(release domain.WorkflowReleaseRecord) domain.WorkflowRecord {
|
|
return domain.WorkflowRecord{
|
|
ID: release.ID,
|
|
OrganizationID: release.OrganizationID,
|
|
Name: release.Name,
|
|
Description: release.Description,
|
|
Type: release.Type,
|
|
Kind: release.Kind,
|
|
ExecutionScope: release.ExecutionScope,
|
|
ScanConfig: release.ScanConfig,
|
|
Hyperparams: release.Hyperparams,
|
|
MaxConcurrentRuns: release.MaxConcurrentRuns,
|
|
NodeTimeoutSeconds: release.NodeTimeoutSeconds,
|
|
RunTimeoutSeconds: release.RunTimeoutSeconds,
|
|
MaxRetryAttempts: release.MaxRetryAttempts,
|
|
RetryBackoffSeconds: release.RetryBackoffSeconds,
|
|
Schedule: release.Schedule,
|
|
DefinitionState: domain.WorkflowDefinitionStateReleased,
|
|
DefinitionVersion: release.Version,
|
|
DefinitionFamilyID: release.TemplateID,
|
|
WorkflowInputs: release.WorkflowInputs,
|
|
ArtifactStorage: release.ArtifactStorage,
|
|
Nodes: release.Nodes,
|
|
Edges: release.Edges,
|
|
CreatedAt: release.CreatedAt,
|
|
UpdatedAt: release.PublishedAt,
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// POST /api/workflow-releases/{id}/runs Handler
|
|
// ----------------------------------------------------------------------------
|