diff --git a/internal/api/annotation_operations.go b/internal/api/annotation_operations.go index b3c4d757..9c8493e3 100644 --- a/internal/api/annotation_operations.go +++ b/internal/api/annotation_operations.go @@ -88,16 +88,21 @@ func annotationTaskStatusValid(status domain.AnnotationTaskStatus) bool { } } -func (server *server) annotationMembershipsForUser(ctx context.Context, organizationID string, projectID string, userID string) ([]domain.ProjectAnnotationMembershipRecord, error) { - items, err := server.store.ListProjectAnnotationMemberships(ctx, organizationID, projectID) - if err != nil { - return nil, err - } - filtered := make([]domain.ProjectAnnotationMembershipRecord, 0) - for _, item := range items { - if item.UserID == userID { - filtered = append(filtered, item) - } +type annotationProjectRole struct { + ProjectID string + UserID string + SupplierID string + Role domain.AnnotationAssignmentRole + AccountRole domain.UserRole +} + +func (server *server) annotationMembershipsForUser(ctx context.Context, organizationID string, projectID string, userID string) ([]annotationProjectRole, error) { + filtered := make([]annotationProjectRole, 0) + accountRole := domain.UserRole("") + if user, userErr := server.store.GetUser(ctx, userID); userErr != nil { + return nil, userErr + } else if user != nil { + accountRole = user.Role } projectMembers, err := server.store.ListProjectMembers(ctx, organizationID, projectID) if err != nil { @@ -108,68 +113,61 @@ func (server *server) annotationMembershipsForUser(ctx context.Context, organiza continue } for _, role := range member.Roles { - filtered = append(filtered, domain.ProjectAnnotationMembershipRecord{ - ID: "project-member:" + member.ID + ":" + string(role), - OrganizationID: member.OrganizationID, - ProjectID: member.ProjectID, - UserID: member.UserID, - VendorID: member.SupplierID, - AssignmentRole: role, - CreatedAt: member.CreatedAt, - UpdatedAt: member.UpdatedAt, + filtered = append(filtered, annotationProjectRole{ + ProjectID: member.ProjectID, UserID: member.UserID, SupplierID: member.SupplierID, Role: role, AccountRole: accountRole, }) } } return filtered, nil } -func membershipAllowsTask(memberships []domain.ProjectAnnotationMembershipRecord, task domain.AnnotationTaskRecord) bool { +func membershipAllowsTask(memberships []annotationProjectRole, task domain.AnnotationTaskRecord) bool { for _, membership := range memberships { if membership.ProjectID != task.ProjectID { continue } taskSupplierID := task.SupplierID - if taskSupplierID == "" { - taskSupplierID = task.VendorID - } if taskSupplierID != "" { // Current ProjectMember routing is supplier-scoped. An unscoped member // must never become a wildcard across suppliers. - if strings.TrimSpace(membership.VendorID) != taskSupplierID { + if strings.TrimSpace(membership.SupplierID) != taskSupplierID { continue } } - if membership.WorkgroupID != "" && task.WorkgroupID != "" && membership.WorkgroupID != task.WorkgroupID { - continue - } return true } return false } -func membershipAllowsTaskRead(memberships []domain.ProjectAnnotationMembershipRecord, task domain.AnnotationTaskRecord) bool { +func membershipAllowsTaskRead(memberships []annotationProjectRole, task domain.AnnotationTaskRecord) bool { for _, membership := range memberships { - if membership.AssignmentRole == domain.AnnotationRoleVendorManager { + if membership.Role == domain.AnnotationRoleVendorManager { continue } - if membershipAllowsTask([]domain.ProjectAnnotationMembershipRecord{membership}, task) { + if membershipAllowsTask([]annotationProjectRole{membership}, task) { return true } } return false } -func membershipHasRole(memberships []domain.ProjectAnnotationMembershipRecord, task domain.AnnotationTaskRecord, role domain.AnnotationAssignmentRole) bool { +func membershipHasRole(memberships []annotationProjectRole, task domain.AnnotationTaskRecord, role domain.AnnotationAssignmentRole) bool { for _, membership := range memberships { - compatible := membership.AssignmentRole == role - if compatible && membershipAllowsTask([]domain.ProjectAnnotationMembershipRecord{membership}, task) { + compatible := membership.Role == role + // Historical v5.7 cutter memberships are migrated to the v5.8 annotator + // role. Keep old read-only tasks completable without restoring a separate + // Workgroup or active cutter membership model. + if role == domain.AnnotationRoleCutter && membership.Role == domain.AnnotationRoleAnnotator && membership.AccountRole == domain.UserRoleCutter { + compatible = true + } + if compatible && membershipAllowsTask([]annotationProjectRole{membership}, task) { return true } } return false } -func (server *server) ensureAnnotationTaskAccess(writer http.ResponseWriter, request *http.Request, task domain.AnnotationTaskRecord) (*authenticatedPrincipal, []domain.ProjectAnnotationMembershipRecord, bool) { +func (server *server) ensureAnnotationTaskAccess(writer http.ResponseWriter, request *http.Request, task domain.AnnotationTaskRecord) (*authenticatedPrincipal, []annotationProjectRole, bool) { principal, ok := currentPrincipal(request) if !ok || principal == nil { renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "login is required"}) @@ -214,7 +212,7 @@ func (server *server) handleAnnotationWorkgroupsList(writer http.ResponseWriter, } allowed := map[string]struct{}{} for _, membership := range memberships { - allowed[membership.WorkgroupID] = struct{}{} + allowed[membership.SupplierID] = struct{}{} } filtered := items[:0] for _, item := range items { @@ -709,12 +707,7 @@ func annotationTaskProgress(sliceRevision *domain.SliceRevisionRecord, annotatio func (server *server) handleAnnotationTasksList(writer http.ResponseWriter, request *http.Request) { projectID := strings.TrimSpace(request.URL.Query().Get("projectId")) status := domain.AnnotationTaskStatus(strings.TrimSpace(request.URL.Query().Get("status"))) - workgroupID := strings.TrimSpace(request.URL.Query().Get("workgroupId")) - vendorID := strings.TrimSpace(request.URL.Query().Get("vendorId")) supplierID := strings.TrimSpace(request.URL.Query().Get("supplierId")) - if supplierID == "" { - supplierID = vendorID - } workflowID := strings.TrimSpace(request.URL.Query().Get("workflowId")) runID := strings.TrimSpace(request.URL.Query().Get("runId")) nodeID := strings.TrimSpace(request.URL.Query().Get("nodeId")) @@ -736,7 +729,7 @@ func (server *server) handleAnnotationTasksList(writer http.ResponseWriter, requ } } principal, _ := currentPrincipal(request) - var memberships []domain.ProjectAnnotationMembershipRecord + var memberships []annotationProjectRole if !annotationManager(principal) && principal != nil { memberships, err = server.annotationMembershipsForUser(request.Context(), server.requestOrganizationID(request), projectID, principal.User.ID) if err != nil { @@ -753,13 +746,7 @@ func (server *server) handleAnnotationTasksList(writer http.ResponseWriter, requ if status != "" && item.Status != status { continue } - if workgroupID != "" && item.WorkgroupID != workgroupID { - continue - } itemSupplierID := strings.TrimSpace(item.SupplierID) - if itemSupplierID == "" { - itemSupplierID = strings.TrimSpace(item.VendorID) - } if supplierID != "" && itemSupplierID != supplierID { continue } @@ -2453,16 +2440,13 @@ func (server *server) handleAnnotationWorkloadSummary(writer http.ResponseWriter } allowedSuppliers := map[string]struct{}{} for _, membership := range memberships { - if supplierID := strings.TrimSpace(membership.VendorID); supplierID != "" { + if supplierID := strings.TrimSpace(membership.SupplierID); supplierID != "" { allowedSuppliers[supplierID] = struct{}{} } } filtered := events[:0] for _, event := range events { supplierID := strings.TrimSpace(event.SupplierID) - if supplierID == "" { - supplierID = strings.TrimSpace(event.VendorID) - } if _, ok := allowedSuppliers[supplierID]; !ok { continue } @@ -2499,9 +2483,6 @@ func (server *server) handleAnnotationWorkloadSummary(writer http.ResponseWriter aggregates := map[key]*domain.AnnotationWorkloadAggregate{} for _, event := range events { supplierID := strings.TrimSpace(event.SupplierID) - if supplierID == "" { - supplierID = strings.TrimSpace(event.VendorID) - } groupKey := key{event.UserID, supplierID, event.TemplateVersion} item := aggregates[groupKey] if item == nil { diff --git a/internal/api/annotation_operations_test.go b/internal/api/annotation_operations_test.go index 1a8c0adc..d9d59551 100644 --- a/internal/api/annotation_operations_test.go +++ b/internal/api/annotation_operations_test.go @@ -150,17 +150,17 @@ func TestClearCombinedAnnotationDraftPreservesOtherSubjectPayload(t *testing.T) } } -func TestMembershipRequiresMatchingProjectWorkgroupAndVendor(t *testing.T) { - task := domain.AnnotationTaskRecord{ProjectID: "project-a", WorkgroupID: "group-a", VendorID: "vendor-a"} - memberships := []domain.ProjectAnnotationMembershipRecord{ - {ProjectID: "project-a", WorkgroupID: "group-a", VendorID: "vendor-a", AssignmentRole: domain.AnnotationRoleAnnotator}, +func TestMembershipRequiresMatchingProjectAndSupplier(t *testing.T) { + task := domain.AnnotationTaskRecord{ProjectID: "project-a", SupplierID: "supplier-a"} + memberships := []annotationProjectRole{ + {ProjectID: "project-a", SupplierID: "supplier-a", Role: domain.AnnotationRoleAnnotator}, } if !membershipAllowsTask(memberships, task) { t.Fatal("expected matching membership to allow task") } - task.VendorID = "vendor-b" + task.SupplierID = "supplier-b" if membershipAllowsTask(memberships, task) { - t.Fatal("vendor mismatch must not allow task") + t.Fatal("supplier mismatch must not allow task") } } @@ -187,15 +187,14 @@ func TestAnnotationProductionRolesMatchTheThreePoolModel(t *testing.T) { } func TestQualityReviewerMembershipDoesNotCoverIndependentAcceptanceRole(t *testing.T) { - task := domain.AnnotationTaskRecord{ProjectID: "project-a", WorkgroupID: "group-a", VendorID: "vendor-a"} - memberships := []domain.ProjectAnnotationMembershipRecord{{ - ProjectID: task.ProjectID, WorkgroupID: task.WorkgroupID, VendorID: task.VendorID, - AssignmentRole: domain.AnnotationRoleQualityReviewer, + task := domain.AnnotationTaskRecord{ProjectID: "project-a", SupplierID: "supplier-a"} + memberships := []annotationProjectRole{{ + ProjectID: task.ProjectID, SupplierID: task.SupplierID, Role: domain.AnnotationRoleQualityReviewer, }} if membershipHasRole(memberships, task, domain.AnnotationRoleAcceptanceReviewer) { t.Fatal("quality reviewer must not cover independent final-acceptance membership checks") } - memberships = append(memberships, domain.ProjectAnnotationMembershipRecord{ProjectID: task.ProjectID, WorkgroupID: task.WorkgroupID, VendorID: task.VendorID, AssignmentRole: domain.AnnotationRoleAcceptanceReviewer}) + memberships = append(memberships, annotationProjectRole{ProjectID: task.ProjectID, SupplierID: task.SupplierID, Role: domain.AnnotationRoleAcceptanceReviewer}) if !membershipHasRole(memberships, task, domain.AnnotationRoleAcceptanceReviewer) { t.Fatal("explicit acceptance reviewer membership must grant final acceptance") } @@ -227,17 +226,15 @@ func TestFanyuV58FirstHumanSubmissionIgnoresSystemSuggestionRevision(t *testing. } func TestVendorManagerMembershipDoesNotGrantTaskMediaRead(t *testing.T) { - task := domain.AnnotationTaskRecord{ProjectID: "project-a", WorkgroupID: "group-a", VendorID: "vendor-a"} - memberships := []domain.ProjectAnnotationMembershipRecord{{ - ProjectID: task.ProjectID, WorkgroupID: task.WorkgroupID, VendorID: task.VendorID, - AssignmentRole: domain.AnnotationRoleVendorManager, + task := domain.AnnotationTaskRecord{ProjectID: "project-a", SupplierID: "supplier-a"} + memberships := []annotationProjectRole{{ + ProjectID: task.ProjectID, SupplierID: task.SupplierID, Role: domain.AnnotationRoleVendorManager, }} if membershipAllowsTaskRead(memberships, task) { t.Fatal("vendor manager aggregation membership must not grant task media read") } - memberships = append(memberships, domain.ProjectAnnotationMembershipRecord{ - ProjectID: task.ProjectID, WorkgroupID: task.WorkgroupID, VendorID: task.VendorID, - AssignmentRole: domain.AnnotationRoleQualityReviewer, + memberships = append(memberships, annotationProjectRole{ + ProjectID: task.ProjectID, SupplierID: task.SupplierID, Role: domain.AnnotationRoleQualityReviewer, }) if !membershipAllowsTaskRead(memberships, task) { t.Fatal("an additional production role should grant scoped task read") diff --git a/internal/api/fanyu_template.go b/internal/api/fanyu_template.go index 30ceab7c..65799ddd 100644 --- a/internal/api/fanyu_template.go +++ b/internal/api/fanyu_template.go @@ -23,8 +23,8 @@ const fanyuDeliveryTemplateV57ID = "template-fanyu-stereo-prelabel-delivery-v5-7 const fanyuDeliveryTemplateV58ID = "template-fanyu-stereo-synchronized-delivery-v5-8" const fanyuV58QwenImage = "ccr-29eug8s3-pub.cnc.bj.baidubce.com/fanyu/droboticflow-operator-qwen-behavior-rough-cut:81b8e0e-fanyu-full-coverage-20260827" const fanyuV58QwenImageID = "ccr-29eug8s3-pub.cnc.bj.baidubce.com/fanyu/droboticflow-operator-qwen-behavior-rough-cut@sha256:f69a53a71121c9a684f36938f4e38dd72aca96cf78b5366d411e87002308879b" -const fanyuV58PackageImage = "ccr-29eug8s3-vpc.cnc.bj.baidubce.com/fanyu/droboticflow-operator-package:48398fc0-fanyu-20260831-capture-v2" -const fanyuV58PackageImageID = "ccr-29eug8s3-vpc.cnc.bj.baidubce.com/fanyu/droboticflow-operator-package@sha256:ff2a1966654b42f646d5c2061f3fd7c6033af8e345872e1bf34dccdda1ffe649" +const fanyuV58PackageImage = "ccr-29eug8s3-vpc.cnc.bj.baidubce.com/fanyu/droboticflow-operator-package:b085e371-fanyu-20260901-capture-v5" +const fanyuV58PackageImageID = "ccr-29eug8s3-vpc.cnc.bj.baidubce.com/fanyu/droboticflow-operator-package@sha256:87965e34785dcc8027934a4291a4d35de0918cf68b681a5ed5cc184e2a4bddf2" func fanyuLegacyPorts(operatorID string, inputs []domain.PortDefinition, outputs []domain.PortDefinition) ([]domain.PortDefinition, []domain.PortDefinition) { legacy := func(id, name string, typ domain.PortType, required bool) domain.PortDefinition { diff --git a/internal/api/server.go b/internal/api/server.go index cfdd5b85..8719e672 100644 --- a/internal/api/server.go +++ b/internal/api/server.go @@ -4641,15 +4641,19 @@ func (server *server) handleWorkflowCreateVersion(writer http.ResponseWriter, re return } created, err := server.store.CreateWorkflow(request.Context(), domain.CreateWorkflowInput{ - OrganizationID: source.OrganizationID, - ProjectID: source.ProjectID, - Name: source.Name, - Description: source.Description, - Type: source.Type, - Kind: source.Kind, - Hidden: source.Hidden, + OrganizationID: source.OrganizationID, + ProjectID: source.ProjectID, + Name: source.Name, + Description: source.Description, + Type: source.Type, + Kind: source.Kind, + // A new version stays inactive until explicitly released and activated. + // This prevents two listeners in the same family from scanning the same + // Capture prefix during the edit/release window. + Hidden: true, ExecutionScope: source.ExecutionScope, ScanConfig: source.ScanConfig, + CaptureAutomation: source.CaptureAutomation, Hyperparams: source.Hyperparams, MaxConcurrentRuns: source.MaxConcurrentRuns, NodeTimeoutSeconds: source.NodeTimeoutSeconds, @@ -4674,6 +4678,39 @@ func (server *server) handleWorkflowCreateVersion(writer http.ResponseWriter, re renderError(writer, http.StatusInternalServerError, err) return } + sourcePolicy, policyErr := server.store.GetWorkflowRuntimePolicy(request.Context(), source.ID) + if policyErr != nil { + renderError(writer, http.StatusInternalServerError, policyErr) + return + } + maxConcurrentCaptures := domain.DefaultMaxConcurrentCaptureRuns + acceptanceProbability := domain.DefaultAcceptanceSampleProbability + if sourcePolicy != nil { + maxConcurrentCaptures = sourcePolicy.MaxConcurrentCaptureRuns + acceptanceProbability = sourcePolicy.AcceptanceSampleProbability + } + actorID := "system" + if principal, ok := currentPrincipal(request); ok && principal != nil && strings.TrimSpace(principal.User.ID) != "" { + actorID = principal.User.ID + } + policyUpdatedAt := nowISO() + createdPolicy := domain.WorkflowRuntimePolicyRecord{ + ID: "workflow-runtime-policy-" + created.ID, OrganizationID: created.OrganizationID, + ProjectID: created.ProjectID, WorkflowID: created.ID, Revision: 1, + MaxConcurrentCaptureRuns: maxConcurrentCaptures, AcceptanceSampleProbability: acceptanceProbability, + UpdatedByUserID: actorID, UpdatedAt: policyUpdatedAt, + History: []domain.WorkflowRuntimePolicyRevision{{ + Revision: 1, MaxConcurrentCaptureRuns: maxConcurrentCaptures, + AcceptanceSampleProbability: acceptanceProbability, UpdatedByUserID: actorID, UpdatedAt: policyUpdatedAt, + }}, + } + if updated, updateErr := server.store.UpdateWorkflowRuntimePolicyVersioned(request.Context(), createdPolicy, 0); updateErr != nil { + renderError(writer, http.StatusInternalServerError, updateErr) + return + } else if !updated { + renderJSON(writer, http.StatusConflict, map[string]string{"error": "workflow runtime policy version conflict", "code": "runtime_policy_version_conflict"}) + return + } renderJSON(writer, http.StatusCreated, sanitizeWorkflow(created)) } diff --git a/internal/api/server_test.go b/internal/api/server_test.go index 0437d827..0e35733f 100644 --- a/internal/api/server_test.go +++ b/internal/api/server_test.go @@ -11345,6 +11345,14 @@ func TestWorkflowDefinitionReleaseLocksUpdatesAndCreatesNewVersion(t *testing.T) if err != nil { t.Fatalf("create workflow: %v", err) } + workflow.CaptureAutomation = &domain.CaptureAutomationConfig{Enabled: true, Bucket: "robot-data", Prefix: "incoming", WorkflowInputID: "config"} + if err := dataStore.UpsertWorkflow(ctx, *workflow); err != nil { + t.Fatal(err) + } + policy := domain.WorkflowRuntimePolicyRecord{ID: "workflow-runtime-policy-" + workflow.ID, OrganizationID: workflow.OrganizationID, ProjectID: project.ID, WorkflowID: workflow.ID, Revision: 1, MaxConcurrentCaptureRuns: 4, AcceptanceSampleProbability: 0.25} + if updated, err := dataStore.UpdateWorkflowRuntimePolicyVersioned(ctx, policy, 0); err != nil || !updated { + t.Fatalf("seed workflow runtime policy: updated=%v err=%v", updated, err) + } handler := NewHandler(dataStore, nil) release := httptest.NewRecorder() handler.ServeHTTP(release, httptest.NewRequest(http.MethodPost, "/api/workflows/"+workflow.ID+"/release", nil)) @@ -11361,6 +11369,17 @@ func TestWorkflowDefinitionReleaseLocksUpdatesAndCreatesNewVersion(t *testing.T) if version.Code != http.StatusCreated || !strings.Contains(version.Body.String(), `"definitionVersion":2`) || !strings.Contains(version.Body.String(), `"definitionState":"draft"`) { t.Fatalf("create workflow version: status=%d body=%s", version.Code, version.Body.String()) } + var createdVersion domain.WorkflowRecord + if err := json.Unmarshal(version.Body.Bytes(), &createdVersion); err != nil { + t.Fatal(err) + } + if !createdVersion.Hidden || createdVersion.CaptureAutomation == nil || !createdVersion.CaptureAutomation.Enabled { + t.Fatalf("new listener version must stay hidden and retain Capture policy: %#v", createdVersion) + } + createdPolicy, err := dataStore.GetWorkflowRuntimePolicy(ctx, createdVersion.ID) + if err != nil || createdPolicy == nil || createdPolicy.MaxConcurrentCaptureRuns != 4 || createdPolicy.AcceptanceSampleProbability != 0.25 { + t.Fatalf("new workflow version did not inherit runtime policy: %#v err=%v", createdPolicy, err) + } } func TestWorkflowVersionActivationHidesSiblingsAndKeepsHistoryReadable(t *testing.T) { diff --git a/internal/api/tenant.go b/internal/api/tenant.go index c75a2fab..7dc7e3d8 100644 --- a/internal/api/tenant.go +++ b/internal/api/tenant.go @@ -267,7 +267,7 @@ func (server *server) projectVisibleToRequest(request *http.Request, organizatio // Legacy roles remain organization-scoped for one compatibility cycle. return true } - memberships, err := server.store.ListProjectAnnotationMemberships(request.Context(), organizationID, projectID) + memberships, err := server.store.ListProjectMembers(request.Context(), organizationID, projectID) if err != nil { return false } diff --git a/internal/api/workflow_deletion.go b/internal/api/workflow_deletion.go index dc49fb62..4d99f24b 100644 --- a/internal/api/workflow_deletion.go +++ b/internal/api/workflow_deletion.go @@ -146,7 +146,7 @@ func (server *server) buildWorkflowDeletionPreview(ctx context.Context, workflow return preview, nil, err } preview.CaptureRecordCount = len(captures) - memberships, err := server.store.ListProjectAnnotationMemberships(ctx, workflow.OrganizationID, workflow.ProjectID) + memberships, err := server.store.ListProjectMembers(ctx, workflow.OrganizationID, workflow.ProjectID) if err != nil { return preview, nil, err } diff --git a/internal/k8s/launcher.go b/internal/k8s/launcher.go index 3f04996a..4f3a91ab 100644 --- a/internal/k8s/launcher.go +++ b/internal/k8s/launcher.go @@ -24,6 +24,7 @@ import ( apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/resource" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/client-go/kubernetes" "k8s.io/client-go/kubernetes/scheme" "k8s.io/client-go/rest" @@ -75,6 +76,20 @@ type LaunchInput struct { // for production jobs; keeping it on the launch input makes the pod contract // explicit and easy to test. SharedMemorySize string + InferenceSidecar *InferenceSidecar +} + +type InferenceSidecar struct { + Name string + Image string + Port int32 + HealthPath string + Env map[string]string + CPURequest string + CPULimit string + MemoryRequest string + MemoryLimit string + GPULimit string } type PVCMount struct { @@ -580,6 +595,24 @@ func CreateJobManifest(namespace string, imagePullSecretName string, workspacePV if err != nil { return nil, err } + var sidecarResources corev1.ResourceRequirements + if input.InferenceSidecar != nil { + sidecar := input.InferenceSidecar + if strings.TrimSpace(sidecar.Name) == "" || strings.TrimSpace(sidecar.Image) == "" || strings.ContainsAny(sidecar.Image, " \t\r\n") || sidecar.Port <= 0 || sidecar.Port > 65535 || !strings.HasPrefix(strings.TrimSpace(sidecar.HealthPath), "/") { + return nil, fmt.Errorf("inference sidecar requires a name, image, valid port and absolute health path") + } + if err := ValidateGPURequest(sidecar.GPULimit); err != nil { + return nil, fmt.Errorf("inference sidecar: %w", err) + } + sidecarResources, err = resourceRequirements(LaunchInput{CPURequest: sidecar.CPURequest, CPULimit: sidecar.CPULimit, MemoryRequest: sidecar.MemoryRequest, MemoryLimit: sidecar.MemoryLimit, GPULimit: sidecar.GPULimit}) + if err != nil { + return nil, err + } + if hasPositiveGPU(sidecar.GPULimit) { + delete(resources.Requests, corev1.ResourceName("nvidia.com/gpu")) + delete(resources.Limits, corev1.ResourceName("nvidia.com/gpu")) + } + } sharedMemorySize := strings.TrimSpace(input.SharedMemorySize) if sharedMemorySize != "" { quantity, quantityErr := resource.ParseQuantity(sharedMemorySize) @@ -693,6 +726,29 @@ func CreateJobManifest(namespace string, imagePullSecretName string, workspacePV }, }, } + if input.InferenceSidecar != nil { + sidecar := input.InferenceSidecar + restartAlways := corev1.ContainerRestartPolicyAlways + sidecarEnv := make([]corev1.EnvVar, 0, len(sidecar.Env)) + sidecarKeys := make([]string, 0, len(sidecar.Env)) + for key := range sidecar.Env { + sidecarKeys = append(sidecarKeys, key) + } + sort.Strings(sidecarKeys) + for _, key := range sidecarKeys { + sidecarEnv = append(sidecarEnv, corev1.EnvVar{Name: key, Value: sidecar.Env[key]}) + } + job.Spec.Template.Spec.InitContainers = []corev1.Container{{ + Name: sidecar.Name, Image: sidecar.Image, ImagePullPolicy: corev1.PullAlways, + RestartPolicy: &restartAlways, Env: sidecarEnv, Resources: sidecarResources, + Ports: []corev1.ContainerPort{{Name: "inference-http", ContainerPort: sidecar.Port, Protocol: corev1.ProtocolTCP}}, + StartupProbe: &corev1.Probe{ + ProbeHandler: corev1.ProbeHandler{HTTPGet: &corev1.HTTPGetAction{Path: sidecar.HealthPath, Port: intstr.FromInt32(sidecar.Port)}}, + InitialDelaySeconds: 2, PeriodSeconds: 5, TimeoutSeconds: 3, FailureThreshold: 120, + }, + SecurityContext: &corev1.SecurityContext{RunAsNonRoot: boolPtr(false), RunAsUser: int64Ptr(0), AllowPrivilegeEscalation: boolPtr(false)}, + }} + } if sharedMemorySize != "" { quantity := resource.MustParse(sharedMemorySize) job.Spec.Template.Spec.Volumes = append(job.Spec.Template.Spec.Volumes, corev1.Volume{ @@ -706,6 +762,9 @@ func CreateJobManifest(namespace string, imagePullSecretName string, workspacePV Name: "droboticflow-shm", MountPath: "/dev/shm", }) + if len(job.Spec.Template.Spec.InitContainers) > 0 { + job.Spec.Template.Spec.InitContainers[0].VolumeMounts = append(job.Spec.Template.Spec.InitContainers[0].VolumeMounts, corev1.VolumeMount{Name: "droboticflow-shm", MountPath: "/dev/shm"}) + } } if input.JobTTLSeconds > 0 { job.Spec.TTLSecondsAfterFinished = func() *int32 { @@ -737,6 +796,9 @@ func CreateJobManifest(namespace string, imagePullSecretName string, workspacePV MountPath: workspaceMountPath, ReadOnly: input.CodeReadOnly, }) + if len(job.Spec.Template.Spec.InitContainers) > 0 { + job.Spec.Template.Spec.InitContainers[0].VolumeMounts = append(job.Spec.Template.Spec.InitContainers[0].VolumeMounts, corev1.VolumeMount{Name: "workspace", MountPath: workspaceMountPath}) + } if codeSubPath != "" { runSubPath, err := cleanVolumeSubPath(pathClean("system/runs/" + input.RunID)) if err != nil { diff --git a/internal/k8s/launcher_test.go b/internal/k8s/launcher_test.go index 76807ea6..f5ea1544 100644 --- a/internal/k8s/launcher_test.go +++ b/internal/k8s/launcher_test.go @@ -131,6 +131,37 @@ func TestCreateJobManifest(t *testing.T) { } } +func TestCreateJobManifestRunsGPUInferenceAsNativeSidecar(t *testing.T) { + manifest, err := CreateJobManifest("droboticflow", "registry", "workspace", "/workspace", LaunchInput{ + Image: "runner@sha256:" + strings.Repeat("a", 64), RunID: "run-pose", WorkflowID: "wf", NodeID: "handpose", + CPURequest: "500m", MemoryRequest: "1Gi", GPULimit: "1", SharedMemorySize: "8Gi", + InferenceSidecar: &InferenceSidecar{ + Name: "wilor-inference", Image: "wilor@sha256:" + strings.Repeat("b", 64), Port: 8080, HealthPath: "/api/health", + CPURequest: "2", CPULimit: "4", MemoryRequest: "16Gi", MemoryLimit: "24Gi", GPULimit: "1", + }, + }) + if err != nil { + t.Fatal(err) + } + if len(manifest.Spec.Template.Spec.InitContainers) != 1 { + t.Fatalf("expected one native sidecar: %#v", manifest.Spec.Template.Spec.InitContainers) + } + sidecar := manifest.Spec.Template.Spec.InitContainers[0] + if sidecar.RestartPolicy == nil || *sidecar.RestartPolicy != corev1.ContainerRestartPolicyAlways || sidecar.StartupProbe == nil || sidecar.StartupProbe.HTTPGet == nil || sidecar.StartupProbe.HTTPGet.Path != "/api/health" { + t.Fatalf("invalid native inference sidecar lifecycle: %#v", sidecar) + } + sidecarGPU := sidecar.Resources.Limits[corev1.ResourceName("nvidia.com/gpu")] + if sidecarGPU.String() != "1" { + t.Fatalf("sidecar did not receive GPU: %#v", sidecar.Resources) + } + if _, exists := manifest.Spec.Template.Spec.Containers[0].Resources.Limits[corev1.ResourceName("nvidia.com/gpu")]; exists { + t.Fatalf("operator runner must not reserve a second GPU: %#v", manifest.Spec.Template.Spec.Containers[0].Resources) + } + if len(sidecar.VolumeMounts) < 2 { + t.Fatalf("sidecar must share workspace and shm: %#v", sidecar.VolumeMounts) + } +} + func TestCreateJobManifestUsesValidLongDeterministicName(t *testing.T) { manifest, err := CreateJobManifest("droboticflow", "", "droboticflow-workspace", "/workspace", LaunchInput{ Image: "runner:latest", diff --git a/internal/store/annotation_operations.go b/internal/store/annotation_operations.go index 3794f5a9..aaf638a7 100644 --- a/internal/store/annotation_operations.go +++ b/internal/store/annotation_operations.go @@ -89,6 +89,17 @@ func (store *MemoryStore) UpsertProjectAnnotationMembership(_ context.Context, i } item.UpdatedAt = now store.annotationMemberships[item.ID] = item + // Test and migration compatibility only: active authorization reads + // ProjectMember. Any legacy fixture written through this deprecated method + // is immediately mirrored into the production model. + memberID := "project-member-legacy:" + item.ProjectID + ":" + item.UserID + member := store.projectMembers[memberID] + if member.ID == "" { + member = domain.ProjectMemberRecord{ID: memberID, OrganizationID: item.OrganizationID, ProjectID: item.ProjectID, UserID: item.UserID, SupplierID: item.VendorID, CreatedAt: item.CreatedAt} + } + member.Roles = domain.NormalizeProjectMemberRoles(append(member.Roles, item.AssignmentRole)) + member.UpdatedAt = now + store.projectMembers[member.ID] = clone(member) return nil } diff --git a/internal/worker/annotation_gate.go b/internal/worker/annotation_gate.go index ceffedee..0040629f 100644 --- a/internal/worker/annotation_gate.go +++ b/internal/worker/annotation_gate.go @@ -18,11 +18,8 @@ import ( ) type annotationGateConfig struct { - TemplateID string - SupplierID string - // WorkgroupID is retained only to read pre-v6 workflow definitions during - // migration. New templates must use ANNOTATION_SUPPLIER_ID or project members. - WorkgroupID string + TemplateID string + SupplierID string ReleasePolicy domain.HumanReleasePolicy PartitionMaxItems int PartitionMaxWaitSeconds int @@ -85,7 +82,6 @@ func annotationGateConfigFromNode(node domain.WorkflowNode) annotationGateConfig return annotationGateConfig{ TemplateID: strings.TrimSpace(params["ANNOTATION_TEMPLATE_ID"]), SupplierID: strings.TrimSpace(params["ANNOTATION_SUPPLIER_ID"]), - WorkgroupID: strings.TrimSpace(params["ANNOTATION_WORKGROUP_ID"]), ReleasePolicy: releasePolicy, PartitionMaxItems: positiveAnnotationGateInt(params["PARTITION_MAX_ITEMS"], 32), PartitionMaxWaitSeconds: positiveAnnotationGateInt(params["PARTITION_MAX_WAIT_SECONDS"], 60), @@ -100,15 +96,6 @@ func (runtime *Runtime) annotationGateSupplierID(ctx context.Context, run *domai return "", fmt.Errorf("annotation supplier resolution requires a run and configuration") } requested := strings.TrimSpace(config.SupplierID) - if config.WorkgroupID != "" { - group, err := runtime.store.GetAnnotationWorkgroup(ctx, config.WorkgroupID) - if err != nil { - return "", err - } - if group != nil && requested == "" { - requested = strings.TrimSpace(group.VendorID) - } - } members, err := runtime.store.ListProjectMembers(ctx, run.OrganizationID, run.ProjectID) if err != nil { return "", err diff --git a/internal/worker/executor.go b/internal/worker/executor.go index 5ce25c9c..28ec4083 100644 --- a/internal/worker/executor.go +++ b/internal/worker/executor.go @@ -20,6 +20,8 @@ const resultPrefix = "DROBOTICFLOW_RESULT=" const resultPathPrefix = "DROBOTICFLOW_RESULT_PATH=" const inputArtifactsInlineLimit = 64 * 1024 +var inferenceServiceImagePattern = regexp.MustCompile(`^\S+@sha256:[a-f0-9]{64}$`) + type nodeWorkspace struct { RunRoot string Root string @@ -30,6 +32,52 @@ type nodeWorkspace struct { StageManifestPath string } +func setNodeHyperparamValue(node *domain.WorkflowNode, key, value string) { + if node == nil { + return + } + for index := range node.Data.Hyperparams { + if strings.TrimSpace(node.Data.Hyperparams[index].Key) == key { + node.Data.Hyperparams[index].Value = value + return + } + } + node.Data.Hyperparams = append(node.Data.Hyperparams, domain.HyperParam{Key: key, Value: value, Type: "string"}) +} + +func inferenceSidecarForNode(run *domain.RunRecord, node *domain.WorkflowNode) (*k8s.InferenceSidecar, error) { + if node == nil { + return nil, nil + } + params := nodeHyperparamsMap(*node) + switch strings.TrimSpace(node.Data.OperatorID) { + case "operator-builtin-wilor-hand-pose": + image := strings.TrimSpace(params["WILOR_SERVICE_IMAGE_ID"]) + if !inferenceServiceImagePattern.MatchString(image) { + return nil, fmt.Errorf("WiLoR on-demand service requires digest-pinned WILOR_SERVICE_IMAGE_ID") + } + setNodeHyperparamValue(node, "WILOR_API_BASE_URL", "http://127.0.0.1:8080") + return &k8s.InferenceSidecar{Name: "wilor-inference", Image: image, Port: 8080, HealthPath: "/api/health", CPURequest: "2", CPULimit: "4", MemoryRequest: "16Gi", MemoryLimit: "24Gi", GPULimit: "1"}, nil + case "operator-builtin-head-pose": + image := strings.TrimSpace(params["HEADPOSE_SERVICE_IMAGE_ID"]) + if !inferenceServiceImagePattern.MatchString(image) { + return nil, fmt.Errorf("HeadPose on-demand service requires digest-pinned HEADPOSE_SERVICE_IMAGE_ID") + } + setNodeHyperparamValue(node, "HEADPOSE_API_BASE_URL", "http://127.0.0.1:8080") + outputRoot := "/workspace/system/headpose-service" + if run != nil { + outputRoot = filepath.Join("/workspace/system/runs", run.ID, "nodes", node.ID, "headpose-service") + } + return &k8s.InferenceSidecar{ + Name: "headpose-inference", Image: image, Port: 8080, HealthPath: "/health", + CPURequest: "1", CPULimit: "2", MemoryRequest: "2Gi", MemoryLimit: "4Gi", + Env: map[string]string{"HEADPOSE_MODEL_SHA256": params["HEADPOSE_MODEL_SHA256"], "HEADPOSE_LICENSE_ID": params["HEADPOSE_LICENSE_ID"], "HEADPOSE_OUTPUT_ROOT": outputRoot, "HEADPOSE_GPU_ID": "-1"}, + }, nil + default: + return nil, nil + } +} + type executionResult struct { Logs []domain.LogEntryRecord `json:"logs"` Artifacts []domain.ExecutionArtifact `json:"artifacts"` @@ -985,6 +1033,10 @@ func (runtime *Runtime) executeNode(ctx context.Context, run *domain.RunRecord, return executionResult{}, nil, err } node = runtime.resolveNodeBusinessStage(ctx, run, node) + inferenceSidecar, err := inferenceSidecarForNode(run, &node) + if err != nil { + return executionResult{}, nil, err + } workspace, err := prepareNodeWorkspace(runtime.workspaceRoot, run.ID, node.ID) if err != nil { return executionResult{}, nil, err @@ -1037,6 +1089,10 @@ func (runtime *Runtime) executeNode(ctx context.Context, run *domain.RunRecord, if workflow != nil { nodeTimeoutSeconds = workflow.NodeTimeoutSeconds } + launchGPULimit := resources.GPULimit + if inferenceSidecar != nil && strings.TrimSpace(inferenceSidecar.GPULimit) != "" { + launchGPULimit = inferenceSidecar.GPULimit + } launched, err := runtime.launcher.Launch(ctx, k8s.LaunchInput{ Image: chooseImage(node, runtime.operatorRunnerImage), Command: cloneStringSlice(node.Data.ContainerCommand), @@ -1052,7 +1108,7 @@ func (runtime *Runtime) executeNode(ctx context.Context, run *domain.RunRecord, CPULimit: resources.CPULimit, MemoryRequest: resources.MemoryRequest, MemoryLimit: resources.MemoryLimit, - GPULimit: resources.GPULimit, + GPULimit: launchGPULimit, GPUNodeSelector: gpuNodeSelector, SharedMemorySize: resources.SharedMemorySize, LongRunning: runtimeContractLongRunning(node.Data.RuntimeContract), @@ -1061,6 +1117,7 @@ func (runtime *Runtime) executeNode(ctx context.Context, run *domain.RunRecord, CodeReadOnly: lightweightConfig.CodeReadOnly, PVCMounts: pvcMounts, OperatorRunnerImage: runtime.operatorRunnerImage, + InferenceSidecar: inferenceSidecar, }) if err != nil { return executionResult{}, nil, err diff --git a/internal/worker/inference_sidecar_test.go b/internal/worker/inference_sidecar_test.go new file mode 100644 index 00000000..a43ecb14 --- /dev/null +++ b/internal/worker/inference_sidecar_test.go @@ -0,0 +1,53 @@ +package worker + +import ( + "strings" + "testing" + + "droboticflow/internal/domain" +) + +func poseNode(operatorID string, params map[string]string) domain.WorkflowNode { + hyperparams := make([]domain.HyperParam, 0, len(params)) + for key, value := range params { + hyperparams = append(hyperparams, domain.HyperParam{Key: key, Value: value}) + } + return domain.WorkflowNode{ID: "pose", Data: domain.WorkflowNodeData{OperatorID: operatorID, Hyperparams: hyperparams}} +} + +func TestInferenceSidecarForWiLoRIsPerRunAndGPUScoped(t *testing.T) { + node := poseNode("operator-builtin-wilor-hand-pose", map[string]string{ + "WILOR_API_BASE_URL": "http://droboticflow-wilor:8080", + "WILOR_SERVICE_IMAGE_ID": "registry/wilor@sha256:" + strings.Repeat("a", 64), + }) + sidecar, err := inferenceSidecarForNode(&domain.RunRecord{ID: "run-a"}, &node) + if err != nil || sidecar == nil { + t.Fatalf("sidecar=%#v err=%v", sidecar, err) + } + if sidecar.GPULimit != "1" || sidecar.HealthPath != "/api/health" || nodeHyperparamsMap(node)["WILOR_API_BASE_URL"] != "http://127.0.0.1:8080" { + t.Fatalf("unexpected WiLoR sidecar contract: %#v params=%#v", sidecar, nodeHyperparamsMap(node)) + } +} + +func TestInferenceSidecarForHeadPoseCarriesModelEvidence(t *testing.T) { + node := poseNode("operator-builtin-head-pose", map[string]string{ + "HEADPOSE_API_BASE_URL": "http://droboticflow-headpose:8080", + "HEADPOSE_SERVICE_IMAGE_ID": "registry/headpose@sha256:" + strings.Repeat("b", 64), + "HEADPOSE_MODEL_SHA256": "sha256:" + strings.Repeat("c", 64), + "HEADPOSE_LICENSE_ID": "MIT", + }) + sidecar, err := inferenceSidecarForNode(&domain.RunRecord{ID: "run-head"}, &node) + if err != nil || sidecar == nil { + t.Fatalf("sidecar=%#v err=%v", sidecar, err) + } + if sidecar.Env["HEADPOSE_MODEL_SHA256"] == "" || !strings.Contains(sidecar.Env["HEADPOSE_OUTPUT_ROOT"], "run-head") || nodeHyperparamsMap(node)["HEADPOSE_API_BASE_URL"] != "http://127.0.0.1:8080" { + t.Fatalf("unexpected HeadPose sidecar contract: %#v params=%#v", sidecar, nodeHyperparamsMap(node)) + } +} + +func TestInferenceSidecarRejectsMutableServiceImage(t *testing.T) { + node := poseNode("operator-builtin-wilor-hand-pose", map[string]string{"WILOR_SERVICE_IMAGE_ID": "registry/wilor:latest"}) + if _, err := inferenceSidecarForNode(nil, &node); err == nil { + t.Fatal("mutable WiLoR service image must be rejected") + } +} diff --git a/operator-repos/builtin/package/release.json b/operator-repos/builtin/package/release.json index 937387c8..21a35bab 100644 --- a/operator-repos/builtin/package/release.json +++ b/operator-repos/builtin/package/release.json @@ -1,14 +1,14 @@ { "acceptance": {}, - "builtAt": "2026-08-31T14:30:00Z", - "digest": "sha256:ff2a1966654b42f646d5c2061f3fd7c6033af8e345872e1bf34dccdda1ffe649", + "builtAt": "2026-08-31T19:36:30Z", + "digest": "sha256:87965e34785dcc8027934a4291a4d35de0918cf68b681a5ed5cc184e2a4bddf2", "environmentReleases": { "fanyu": { - "digest": "sha256:ff2a1966654b42f646d5c2061f3fd7c6033af8e345872e1bf34dccdda1ffe649", - "image": "ccr-29eug8s3-vpc.cnc.bj.baidubce.com/fanyu/droboticflow-operator-package:48398fc0-fanyu-20260831-capture-v2", - "imageId": "ccr-29eug8s3-vpc.cnc.bj.baidubce.com/fanyu/droboticflow-operator-package@sha256:ff2a1966654b42f646d5c2061f3fd7c6033af8e345872e1bf34dccdda1ffe649", + "digest": "sha256:87965e34785dcc8027934a4291a4d35de0918cf68b681a5ed5cc184e2a4bddf2", + "image": "ccr-29eug8s3-vpc.cnc.bj.baidubce.com/fanyu/droboticflow-operator-package:b085e371-fanyu-20260901-capture-v5", + "imageId": "ccr-29eug8s3-vpc.cnc.bj.baidubce.com/fanyu/droboticflow-operator-package@sha256:87965e34785dcc8027934a4291a4d35de0918cf68b681a5ed5cc184e2a4bddf2", "registry": "ccr-29eug8s3-vpc.cnc.bj.baidubce.com", - "tag": "48398fc0-fanyu-20260831-capture-v2" + "tag": "b085e371-fanyu-20260901-capture-v5" }, "poc": { "digest": "sha256:fa084bbd0e3b6fedff9582d09c965b460f054ad9e0f5edaf9fc4b9aebcc375cc", @@ -18,14 +18,14 @@ "tag": "feaaf80-poc-handpose-auto-20260825052001" } }, - "image": "ccr-29eug8s3-vpc.cnc.bj.baidubce.com/fanyu/droboticflow-operator-package:48398fc0-fanyu-20260831-capture-v2", - "imageId": "ccr-29eug8s3-vpc.cnc.bj.baidubce.com/fanyu/droboticflow-operator-package@sha256:ff2a1966654b42f646d5c2061f3fd7c6033af8e345872e1bf34dccdda1ffe649", - "kanikoJob": "droboticflow-kaniko-op-package-48398fc0-fanyu-20260831-capture", + "image": "ccr-29eug8s3-vpc.cnc.bj.baidubce.com/fanyu/droboticflow-operator-package:b085e371-fanyu-20260901-capture-v5", + "imageId": "ccr-29eug8s3-vpc.cnc.bj.baidubce.com/fanyu/droboticflow-operator-package@sha256:87965e34785dcc8027934a4291a4d35de0918cf68b681a5ed5cc184e2a4bddf2", + "kanikoJob": "droboticflow-kaniko-op-package-b085e371-fanyu-20260901-capture", "operatorId": "operator-builtin-package", "registry": "ccr-29eug8s3-vpc.cnc.bj.baidubce.com", "schemaVersion": "droboticflow.operator.release/v1", "slug": "package", - "sourceCommit": "48398fc0409c96a04481a60278370ad5e1a2c403", - "sourceTreeSha256": "9c91471144466566083b516e71ac10ae948c1d1490d59708ff9b2068daed759a", - "tag": "48398fc0-fanyu-20260831-capture-v2" + "sourceCommit": "b085e371b230b304fb0446040dee98793dc2e545", + "sourceTreeSha256": "8cb9d11686fa3c44c33117340ee6b115b6880a0e73e1fc0807d9b997a117fe3d", + "tag": "b085e371-fanyu-20260901-capture-v5" } diff --git a/scripts/build-poc-images-kaniko.sh b/scripts/build-poc-images-kaniko.sh index e30e4e6d..1dc7a521 100755 --- a/scripts/build-poc-images-kaniko.sh +++ b/scripts/build-poc-images-kaniko.sh @@ -29,6 +29,8 @@ POC_KANIKO_CLEAN_CONTEXT_TIMEOUT_SECONDS="${POC_KANIKO_CLEAN_CONTEXT_TIMEOUT_SEC POC_KANIKO_WAIT_TIMEOUT="${POC_KANIKO_WAIT_TIMEOUT:-1200s}" POC_KANIKO_GOPROXY="${POC_KANIKO_GOPROXY:-}" POC_KANIKO_CONTEXT_SOURCE="${POC_KANIKO_CONTEXT_SOURCE:-worktree}" +POC_KANIKO_PACKED_CONTEXT="${POC_KANIKO_PACKED_CONTEXT:-true}" +POC_KANIKO_CONTEXT_PREPARE_IMAGE="${POC_KANIKO_CONTEXT_PREPARE_IMAGE:-busybox:1.36.1}" POC_KANIKO_CONTEXT_POD="${POC_KANIKO_CONTEXT_POD:-}" POC_KANIKO_GIT_CONTEXT="${POC_KANIKO_GIT_CONTEXT:-}" POC_KANIKO_NODE_NAME="${POC_KANIKO_NODE_NAME:-}" @@ -97,6 +99,8 @@ validate_boolean POC_KANIKO_BUILD_OPERATORS "$POC_KANIKO_BUILD_OPERATORS" validate_boolean POC_KANIKO_BUILD_OPERATOR_BASES "$POC_KANIKO_BUILD_OPERATOR_BASES" validate_boolean POC_KANIKO_PRECHECK_ONLY "$POC_KANIKO_PRECHECK_ONLY" validate_boolean POC_KANIKO_HEADPOSE_REUSE_BASE_RUNTIME "$POC_KANIKO_HEADPOSE_REUSE_BASE_RUNTIME" +validate_boolean POC_KANIKO_PACKED_CONTEXT "$POC_KANIKO_PACKED_CONTEXT" +validate_image_reference POC_KANIKO_CONTEXT_PREPARE_IMAGE "$POC_KANIKO_CONTEXT_PREPARE_IMAGE" if [[ -n "$POC_KANIKO_HEADPOSE_BASE_IMAGE" ]]; then validate_image_reference POC_KANIKO_HEADPOSE_BASE_IMAGE "$POC_KANIKO_HEADPOSE_BASE_IMAGE" fi @@ -150,6 +154,7 @@ if boolean_true POC_KANIKO_BUILD_OPERATORS "$POC_KANIKO_BUILD_OPERATORS" && [[ ! fi CONTEXT_DIR="${POC_BUILD_CONTEXT_ROOT%/}/droboticflow-${IMAGE_TAG}" +CONTEXT_ARCHIVE="${CONTEXT_DIR}.tar" api_pod="" context_json="" context_uploaded=false @@ -204,6 +209,9 @@ kaniko_args_yaml() { if [[ "$POC_KANIKO_CONTEXT_SOURCE" == "git" ]]; then context_value="$POC_KANIKO_GIT_CONTEXT" dockerfile_value="$dockerfile" + elif boolean_true POC_KANIKO_PACKED_CONTEXT "$POC_KANIKO_PACKED_CONTEXT"; then + context_value="dir:///kaniko-build-context" + dockerfile_value="/kaniko-build-context/${dockerfile}" fi cat <&2 exit 1 fi @@ -564,13 +603,23 @@ elif [[ "$POC_KANIKO_CONTEXT_SOURCE" != "git" ]]; then exit 1 fi - context_json="$(json_string "$CONTEXT_DIR")" - kubectl -n "$K8S_NAMESPACE" exec "$api_pod" -- sh -lc "rm -rf $context_json && mkdir -p $context_json" - context_uploaded=true + if boolean_true POC_KANIKO_PACKED_CONTEXT "$POC_KANIKO_PACKED_CONTEXT"; then + context_json="$(json_string "$CONTEXT_ARCHIVE")" + context_parent_json="$(json_string "$(dirname "$CONTEXT_ARCHIVE")")" + kubectl -n "$K8S_NAMESPACE" exec "$api_pod" -- sh -lc "mkdir -p $context_parent_json && rm -f $context_json" + else + context_json="$(json_string "$CONTEXT_DIR")" + kubectl -n "$K8S_NAMESPACE" exec "$api_pod" -- sh -lc "rm -rf $context_json && mkdir -p $context_json" + fi + context_uploaded=true # Object-backed workspace mounts can reject restoring archived mtimes while # directory entries are still becoming visible. Build contents are immutable # by digest, so preserve bytes and paths while assigning mount-native mtimes. - upload_build_context | kubectl -n "$K8S_NAMESPACE" exec -i "$api_pod" -- tar -m -xf - -C "$CONTEXT_DIR" + if boolean_true POC_KANIKO_PACKED_CONTEXT "$POC_KANIKO_PACKED_CONTEXT"; then + upload_build_context | kubectl -n "$K8S_NAMESPACE" exec -i "$api_pod" -- sh -lc "cat > $context_json" + else + upload_build_context | kubectl -n "$K8S_NAMESPACE" exec -i "$api_pod" -- tar -m -xf - -C "$CONTEXT_DIR" + fi fi operator_components=() diff --git a/tests/backend/build_poc_images_kaniko_script_test.py b/tests/backend/build_poc_images_kaniko_script_test.py index 3fb5506e..37b0d690 100644 --- a/tests/backend/build_poc_images_kaniko_script_test.py +++ b/tests/backend/build_poc_images_kaniko_script_test.py @@ -111,6 +111,8 @@ def run_script( "POC_KANIKO_CLEAN_CONTEXT", "POC_KANIKO_CLEAN_CONTEXT_TIMEOUT_SECONDS", "POC_KANIKO_CONTEXT_SOURCE", + "POC_KANIKO_PACKED_CONTEXT", + "POC_KANIKO_CONTEXT_PREPARE_IMAGE", "POC_KANIKO_BUILD_OPERATORS", "POC_KANIKO_BUILD_TIME", "POC_KANIKO_OPERATOR_MANIFEST", @@ -176,11 +178,14 @@ def test_poc_kaniko_build_creates_five_jobs_with_registry_mirror(tmp_path): assert "OPERATOR_RUNNER_IMAGE=registry.example.com/dataflow-poc/droboticflow-operator-runner:ce9b6a1-poc-20260623135924" in result.stdout calls = calls_path.read_text(encoding="utf-8") - assert "-n droboticflow exec -i droboticflow-api-test -- tar -m -xf - -C /workspace/system/builds/contexts/droboticflow-ce9b6a1-poc-20260623135924" in calls + assert "-n droboticflow exec -i droboticflow-api-test -- sh -lc cat > \"/workspace/system/builds/contexts/droboticflow-ce9b6a1-poc-20260623135924.tar\"" in calls assert calls.count("wait --for=condition=complete") == 5 manifests = "\n---\n".join(path.read_text(encoding="utf-8") for path in sorted(applied_dir.glob("*.yaml"))) assert manifests.count("kind: Job") == 5 + assert manifests.count("name: prepare-context") == 5 + assert "tar -m -xf /workspace/system/builds/contexts/droboticflow-ce9b6a1-poc-20260623135924.tar -C /kaniko-build-context" in manifests + assert "mountPath: /kaniko-build-context" in manifests assert "--build-arg=GOPROXY=https://goproxy.cn,direct" in manifests assert "--build-arg=DROBOTICFLOW_BUILD_COMMIT=0123456789abcdef" in manifests assert "--build-arg=DROBOTICFLOW_BUILD_TIME=2026-07-10T10:30:00Z" in manifests @@ -331,7 +336,7 @@ def test_poc_kaniko_build_cleans_uploaded_context_when_job_fails(tmp_path): assert result.returncode == 1 calls = calls_path.read_text(encoding="utf-8").splitlines() assert ( - '-n droboticflow exec droboticflow-api-test -- sh -lc rm -rf "/workspace/system/builds/contexts/droboticflow-ce9b6a1-poc-20260623135924"' + '-n droboticflow exec droboticflow-api-test -- sh -lc rm -rf "/workspace/system/builds/contexts/droboticflow-ce9b6a1-poc-20260623135924.tar"' in calls ) @@ -354,6 +359,6 @@ def test_poc_kaniko_build_cleanup_timeout_does_not_block_success(tmp_path): assert "warning: timed out after 1s while cleaning Kaniko build context" in result.stderr calls = calls_path.read_text(encoding="utf-8").splitlines() assert ( - '-n droboticflow exec droboticflow-api-test -- sh -lc rm -rf "/workspace/system/builds/contexts/droboticflow-ce9b6a1-poc-20260623135924"' + '-n droboticflow exec droboticflow-api-test -- sh -lc rm -rf "/workspace/system/builds/contexts/droboticflow-ce9b6a1-poc-20260623135924.tar"' in calls )