forked from longtao.wu/droboticflow
404 lines
10 KiB
Go
404 lines
10 KiB
Go
package domain
|
|
|
|
import (
|
|
"sort"
|
|
"strings"
|
|
)
|
|
|
|
func IsScanSourceNode(node WorkflowNode) bool {
|
|
label := strings.TrimSpace(node.Data.Label)
|
|
return node.ID == "scan-source" || label == "BOS 增量扫描"
|
|
}
|
|
|
|
func FindScanSourceNode(nodes []WorkflowNode) *WorkflowNode {
|
|
for index := range nodes {
|
|
if IsScanSourceNode(nodes[index]) {
|
|
return &nodes[index]
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func GetNodeByID(nodes []WorkflowNode, nodeID string) *WorkflowNode {
|
|
for index := range nodes {
|
|
if nodes[index].ID == nodeID {
|
|
return &nodes[index]
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func GetIncomingEdges(edges []WorkflowEdge, nodeID string) []WorkflowEdge {
|
|
items := make([]WorkflowEdge, 0)
|
|
for _, edge := range edges {
|
|
if edge.Target == nodeID {
|
|
items = append(items, edge)
|
|
}
|
|
}
|
|
return items
|
|
}
|
|
|
|
func GetOutgoingEdges(edges []WorkflowEdge, nodeID string) []WorkflowEdge {
|
|
items := make([]WorkflowEdge, 0)
|
|
for _, edge := range edges {
|
|
if edge.Source == nodeID {
|
|
items = append(items, edge)
|
|
}
|
|
}
|
|
return items
|
|
}
|
|
|
|
func GetStartNodeIDs(nodes []WorkflowNode, edges []WorkflowEdge) []string {
|
|
items := make([]string, 0)
|
|
for _, node := range nodes {
|
|
hasIncoming := false
|
|
for _, edge := range edges {
|
|
if edge.Target == node.ID {
|
|
hasIncoming = true
|
|
break
|
|
}
|
|
}
|
|
if !hasIncoming {
|
|
items = append(items, node.ID)
|
|
}
|
|
}
|
|
return items
|
|
}
|
|
|
|
type InputPortConflict struct {
|
|
TargetNodeID string `json:"targetNodeId"`
|
|
TargetNodeLabel string `json:"targetNodeLabel,omitempty"`
|
|
TargetHandle string `json:"targetHandle,omitempty"`
|
|
TargetPortName string `json:"targetPortName,omitempty"`
|
|
EdgeIDs []string `json:"edgeIds"`
|
|
}
|
|
|
|
type WorkflowGraphIssueCode string
|
|
|
|
const (
|
|
WorkflowGraphIssueDisconnected WorkflowGraphIssueCode = "workflow_graph_disconnected"
|
|
WorkflowGraphIssueIsolatedNode WorkflowGraphIssueCode = "workflow_graph_isolated_node"
|
|
WorkflowGraphIssueCycle WorkflowGraphIssueCode = "workflow_graph_cycle"
|
|
)
|
|
|
|
type WorkflowGraphIssue struct {
|
|
Code WorkflowGraphIssueCode `json:"code"`
|
|
NodeIDs []string `json:"nodeIds,omitempty"`
|
|
Component []string `json:"component,omitempty"`
|
|
Message string `json:"message"`
|
|
}
|
|
|
|
func normalizeWorkflowHandle(value string) string {
|
|
return strings.TrimSpace(value)
|
|
}
|
|
|
|
func findInputPortName(node *WorkflowNode, handle string) string {
|
|
if node == nil {
|
|
if handle == "" {
|
|
return "默认输入"
|
|
}
|
|
return handle
|
|
}
|
|
normalizedHandle := normalizeWorkflowHandle(handle)
|
|
if normalizedHandle == "" {
|
|
return "默认输入"
|
|
}
|
|
for _, port := range node.Data.Inputs {
|
|
if normalizeWorkflowHandle(port.ID) == normalizedHandle {
|
|
if name := strings.TrimSpace(port.Name); name != "" {
|
|
return name
|
|
}
|
|
break
|
|
}
|
|
}
|
|
return normalizedHandle
|
|
}
|
|
|
|
func FindInputPortConflicts(nodes []WorkflowNode, edges []WorkflowEdge) []InputPortConflict {
|
|
type key struct {
|
|
target string
|
|
handle string
|
|
}
|
|
|
|
nodeByID := make(map[string]*WorkflowNode, len(nodes))
|
|
for index := range nodes {
|
|
nodeByID[nodes[index].ID] = &nodes[index]
|
|
}
|
|
|
|
grouped := make(map[key]*InputPortConflict)
|
|
for _, edge := range edges {
|
|
if strings.TrimSpace(edge.Target) == "" {
|
|
continue
|
|
}
|
|
conflictKey := key{
|
|
target: strings.TrimSpace(edge.Target),
|
|
handle: normalizeWorkflowHandle(edge.TargetHandle),
|
|
}
|
|
conflict := grouped[conflictKey]
|
|
if conflict == nil {
|
|
targetNode := nodeByID[conflictKey.target]
|
|
conflict = &InputPortConflict{
|
|
TargetNodeID: conflictKey.target,
|
|
TargetHandle: conflictKey.handle,
|
|
TargetPortName: findInputPortName(targetNode, conflictKey.handle),
|
|
}
|
|
if targetNode != nil {
|
|
conflict.TargetNodeLabel = strings.TrimSpace(targetNode.Data.Label)
|
|
}
|
|
grouped[conflictKey] = conflict
|
|
}
|
|
edgeID := strings.TrimSpace(edge.ID)
|
|
if edgeID == "" {
|
|
edgeID = edge.Source + "->" + edge.Target
|
|
}
|
|
conflict.EdgeIDs = append(conflict.EdgeIDs, edgeID)
|
|
}
|
|
|
|
conflicts := make([]InputPortConflict, 0)
|
|
for _, conflict := range grouped {
|
|
if len(conflict.EdgeIDs) <= 1 {
|
|
continue
|
|
}
|
|
sort.Strings(conflict.EdgeIDs)
|
|
conflicts = append(conflicts, *conflict)
|
|
}
|
|
|
|
sort.Slice(conflicts, func(i, j int) bool {
|
|
if conflicts[i].TargetNodeID != conflicts[j].TargetNodeID {
|
|
return conflicts[i].TargetNodeID < conflicts[j].TargetNodeID
|
|
}
|
|
return conflicts[i].TargetHandle < conflicts[j].TargetHandle
|
|
})
|
|
return conflicts
|
|
}
|
|
|
|
func ValidateSingleConnectedWorkflowGraph(nodes []WorkflowNode, edges []WorkflowEdge) []WorkflowGraphIssue {
|
|
if len(nodes) <= 1 {
|
|
return nil
|
|
}
|
|
nodeByID := make(map[string]WorkflowNode, len(nodes))
|
|
for _, node := range nodes {
|
|
trimmedID := strings.TrimSpace(node.ID)
|
|
if trimmedID == "" {
|
|
continue
|
|
}
|
|
nodeByID[trimmedID] = node
|
|
}
|
|
if len(nodeByID) <= 1 {
|
|
return nil
|
|
}
|
|
|
|
adjacent := make(map[string]map[string]struct{}, len(nodeByID))
|
|
degree := make(map[string]int, len(nodeByID))
|
|
for nodeID := range nodeByID {
|
|
adjacent[nodeID] = map[string]struct{}{}
|
|
}
|
|
for _, edge := range edges {
|
|
source := strings.TrimSpace(edge.Source)
|
|
target := strings.TrimSpace(edge.Target)
|
|
if source == "" || target == "" {
|
|
continue
|
|
}
|
|
if _, ok := nodeByID[source]; !ok {
|
|
continue
|
|
}
|
|
if _, ok := nodeByID[target]; !ok {
|
|
continue
|
|
}
|
|
if _, ok := adjacent[source][target]; !ok {
|
|
adjacent[source][target] = struct{}{}
|
|
adjacent[target][source] = struct{}{}
|
|
degree[source]++
|
|
degree[target]++
|
|
}
|
|
}
|
|
|
|
issues := make([]WorkflowGraphIssue, 0)
|
|
isolated := make([]string, 0)
|
|
for nodeID := range nodeByID {
|
|
if degree[nodeID] == 0 {
|
|
isolated = append(isolated, nodeID)
|
|
}
|
|
}
|
|
if len(isolated) > 0 {
|
|
sort.Strings(isolated)
|
|
issues = append(issues, WorkflowGraphIssue{
|
|
Code: WorkflowGraphIssueIsolatedNode,
|
|
NodeIDs: isolated,
|
|
Message: "workflow contains isolated nodes",
|
|
})
|
|
}
|
|
|
|
visited := make(map[string]struct{}, len(nodeByID))
|
|
components := make([][]string, 0)
|
|
for nodeID := range nodeByID {
|
|
if _, ok := visited[nodeID]; ok {
|
|
continue
|
|
}
|
|
queue := []string{nodeID}
|
|
visited[nodeID] = struct{}{}
|
|
component := make([]string, 0)
|
|
for len(queue) > 0 {
|
|
current := queue[0]
|
|
queue = queue[1:]
|
|
component = append(component, current)
|
|
for next := range adjacent[current] {
|
|
if _, ok := visited[next]; ok {
|
|
continue
|
|
}
|
|
visited[next] = struct{}{}
|
|
queue = append(queue, next)
|
|
}
|
|
}
|
|
sort.Strings(component)
|
|
components = append(components, component)
|
|
}
|
|
if len(components) > 1 {
|
|
sort.Slice(components, func(i, j int) bool {
|
|
if len(components[i]) != len(components[j]) {
|
|
return len(components[i]) > len(components[j])
|
|
}
|
|
return strings.Join(components[i], "\x00") < strings.Join(components[j], "\x00")
|
|
})
|
|
for _, component := range components[1:] {
|
|
issues = append(issues, WorkflowGraphIssue{
|
|
Code: WorkflowGraphIssueDisconnected,
|
|
Component: component,
|
|
Message: "workflow contains multiple disconnected chains",
|
|
})
|
|
}
|
|
}
|
|
|
|
indegree := make(map[string]int, len(nodeByID))
|
|
directed := make(map[string][]string, len(nodeByID))
|
|
for nodeID := range nodeByID {
|
|
indegree[nodeID] = 0
|
|
}
|
|
for _, edge := range edges {
|
|
source := strings.TrimSpace(edge.Source)
|
|
target := strings.TrimSpace(edge.Target)
|
|
if _, ok := nodeByID[source]; !ok {
|
|
continue
|
|
}
|
|
if _, ok := nodeByID[target]; !ok {
|
|
continue
|
|
}
|
|
directed[source] = append(directed[source], target)
|
|
indegree[target]++
|
|
}
|
|
queue := make([]string, 0, len(nodeByID))
|
|
for nodeID, degree := range indegree {
|
|
if degree == 0 {
|
|
queue = append(queue, nodeID)
|
|
}
|
|
}
|
|
processed := 0
|
|
for len(queue) > 0 {
|
|
current := queue[0]
|
|
queue = queue[1:]
|
|
processed++
|
|
for _, target := range directed[current] {
|
|
indegree[target]--
|
|
if indegree[target] == 0 {
|
|
queue = append(queue, target)
|
|
}
|
|
}
|
|
}
|
|
if processed != len(nodeByID) {
|
|
cycleNodes := directedCycleNodes(nodeByID, directed)
|
|
sort.Strings(cycleNodes)
|
|
issues = append(issues, WorkflowGraphIssue{
|
|
Code: WorkflowGraphIssueCycle,
|
|
NodeIDs: cycleNodes,
|
|
Message: "workflow contains a directed cycle",
|
|
})
|
|
}
|
|
return issues
|
|
}
|
|
|
|
func directedCycleNodes(nodeByID map[string]WorkflowNode, directed map[string][]string) []string {
|
|
color := make(map[string]uint8, len(nodeByID))
|
|
stack := make([]string, 0, len(nodeByID))
|
|
stackIndex := make(map[string]int, len(nodeByID))
|
|
cycleSet := make(map[string]struct{})
|
|
var visit func(string)
|
|
visit = func(nodeID string) {
|
|
color[nodeID] = 1
|
|
stackIndex[nodeID] = len(stack)
|
|
stack = append(stack, nodeID)
|
|
for _, target := range directed[nodeID] {
|
|
switch color[target] {
|
|
case 0:
|
|
visit(target)
|
|
case 1:
|
|
start := stackIndex[target]
|
|
for _, cycleNode := range stack[start:] {
|
|
cycleSet[cycleNode] = struct{}{}
|
|
}
|
|
}
|
|
}
|
|
stack = stack[:len(stack)-1]
|
|
delete(stackIndex, nodeID)
|
|
color[nodeID] = 2
|
|
}
|
|
for nodeID := range nodeByID {
|
|
if color[nodeID] == 0 {
|
|
visit(nodeID)
|
|
}
|
|
}
|
|
items := make([]string, 0, len(cycleSet))
|
|
for nodeID := range cycleSet {
|
|
items = append(items, nodeID)
|
|
}
|
|
return items
|
|
}
|
|
|
|
func auditDecisionMatchesHandle(handle string, decision AuditStatus) bool {
|
|
if handle == "" {
|
|
return decision == AuditStatusApproved
|
|
}
|
|
normalized := strings.ToLower(handle)
|
|
switch decision {
|
|
case AuditStatusApproved:
|
|
return strings.Contains(normalized, "approved") || strings.Contains(normalized, "通过")
|
|
case AuditStatusRejected:
|
|
return strings.Contains(normalized, "rejected") || strings.Contains(normalized, "拒绝")
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func GetDecisionOutgoingEdges(edges []WorkflowEdge, nodeID string, decision AuditStatus) []WorkflowEdge {
|
|
outgoing := GetOutgoingEdges(edges, nodeID)
|
|
filtered := make([]WorkflowEdge, 0)
|
|
for _, edge := range outgoing {
|
|
if auditDecisionMatchesHandle(edge.SourceHandle, decision) {
|
|
filtered = append(filtered, edge)
|
|
}
|
|
}
|
|
if len(filtered) > 0 {
|
|
return filtered
|
|
}
|
|
return outgoing
|
|
}
|
|
|
|
func NodeRequiresAnnotation(node WorkflowNode) bool {
|
|
if strings.EqualFold(strings.TrimSpace(node.Data.OperatorID), "operator-builtin-annotation-gate") {
|
|
return true
|
|
}
|
|
for _, item := range node.Data.Hyperparams {
|
|
if strings.EqualFold(strings.TrimSpace(item.Key), "REVIEW_MODE") && strings.EqualFold(strings.TrimSpace(item.Value), "annotation") {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func NodeRequiresAudit(node WorkflowNode) bool {
|
|
if NodeRequiresAnnotation(node) {
|
|
return false
|
|
}
|
|
label := strings.ToLower(node.Data.Label)
|
|
return node.Data.Category == "HUMAN" || strings.Contains(label, "human review") || strings.Contains(node.Data.Label, "人工审核")
|
|
}
|