feat(waf): complete composable rule orchestration

Add the React Flow rule editor, ordered graph APIs and runtime DAG execution.\n\nPublish rules only on OpenResty reload and reconcile checksum-driven IP group snapshots in bounded shared memory.

internal/apps/openflare/waf/graph_validate.go

@@ -26,7 +26,33 @@ var (
 	regionCodePattern  = regexp.MustCompile(`^[A-Z]{2}-[A-Z0-9]{1,3}$`)
 )
 
+// ValidateRuleGraph validates graph structure, node configuration, references,
+// reachability, and termination before compilation.
 func ValidateRuleGraph(ctx context.Context, graph RuleGraph, ipGroupExists func(context.Context, uint) (bool, error)) error {
+	if err := validateRuleGraphLimits(graph); err != nil {
+		return err
+	}
+	nodes, startID, err := validateRuleGraphNodes(ctx, graph.Nodes, ipGroupExists)
+	if err != nil {
+		return err
+	}
+	outgoing, incoming, handleTargets, err := validateRuleGraphEdges(nodes, graph.Edges)
+	if err != nil {
+		return err
+	}
+	if hasRuleGraphCycle(nodes, outgoing, incoming) {
+		return errors.New("规则图不能包含循环")
+	}
+	if err := validateRequiredHandles(graph.Nodes, handleTargets); err != nil {
+		return err
+	}
+	if err := validateRuleGraphConnectivity(graph.Nodes, startID, outgoing, incoming); err != nil {
+		return err
+	}
+	return validateTerminalPaths(graph.Nodes, outgoing)
+}
+
+func validateRuleGraphLimits(graph RuleGraph) error {
 	if graph.SchemaVersion != RuleGraphSchemaVersion {
 		return fmt.Errorf("规则图 schema_version 必须为 %d", RuleGraphSchemaVersion)
 	}
@@ -41,15 +67,18 @@ func ValidateRuleGraph(ctx context.Context, graph RuleGraph, ipGroupExists func(
 	} else if len(raw) > maxRuleGraphBytes {
 		return fmt.Errorf("规则图大小不能超过 256 KiB")
 	}
+	return nil
+}
 
-	nodes := make(map[string]RuleNode, len(graph.Nodes))
+func validateRuleGraphNodes(ctx context.Context, graphNodes []RuleNode, ipGroupExists func(context.Context, uint) (bool, error)) (map[string]RuleNode, string, error) {
+	nodes := make(map[string]RuleNode, len(graphNodes))
 	startCount, allowCount, startID := 0, 0, ""
-	for _, node := range graph.Nodes {
+	for _, node := range graphNodes {
 		if strings.TrimSpace(node.ID) == "" {
-			return errors.New("节点 ID 不能为空")
+			return nil, "", errors.New("节点 ID 不能为空")
 		}
 		if _, exists := nodes[node.ID]; exists {
-			return fmt.Errorf("节点 ID %s 重复", node.ID)
+			return nil, "", fmt.Errorf("节点 ID %s 重复", node.ID)
 		}
 		nodes[node.ID] = node
 		switch node.Type {
@@ -60,67 +89,74 @@ func ValidateRuleGraph(ctx context.Context, graph RuleGraph, ipGroupExists func(
 			allowCount++
 		case RuleNodeBlock, RuleNodeIPMatch, RuleNodeGeoMatch, RuleNodePoW:
 		default:
-			return fmt.Errorf("节点 %s 的类型 %s 未知", node.ID, node.Type)
+			return nil, "", fmt.Errorf("节点 %s 的类型 %s 未知", node.ID, node.Type)
 		}
 		if err := validateRuleNodeConfig(ctx, node, ipGroupExists); err != nil {
-			return err
+			return nil, "", err
 		}
 	}
 	if startCount != 1 {
-		return errors.New("规则图必须恰好包含一个开始节点")
+		return nil, "", errors.New("规则图必须恰好包含一个开始节点")
 	}
 	if allowCount != 1 {
-		return errors.New("规则图必须恰好包含一个通过节点")
+		return nil, "", errors.New("规则图必须恰好包含一个通过节点")
 	}
+	return nodes, startID, nil
+}
 
-	edgeIDs := make(map[string]struct{}, len(graph.Edges))
+func validateRuleGraphEdges(nodes map[string]RuleNode, graphEdges []RuleEdge) (map[string][]RuleEdge, map[string]int, map[string]int, error) {
+	edgeIDs := make(map[string]struct{}, len(graphEdges))
 	outgoing := make(map[string][]RuleEdge)
 	incoming := make(map[string]int)
 	handleTargets := make(map[string]int)
-	for _, edge := range graph.Edges {
+	for _, edge := range graphEdges {
 		if strings.TrimSpace(edge.ID) == "" {
-			return errors.New("边 ID 不能为空")
+			return nil, nil, nil, errors.New("边 ID 不能为空")
 		}
 		if _, exists := edgeIDs[edge.ID]; exists {
-			return fmt.Errorf("边 ID %s 重复", edge.ID)
+			return nil, nil, nil, fmt.Errorf("边 ID %s 重复", edge.ID)
 		}
 		edgeIDs[edge.ID] = struct{}{}
 		source, ok := nodes[edge.Source]
 		if !ok {
-			return fmt.Errorf("边 %s 的源节点 %s 不存在", edge.ID, edge.Source)
+			return nil, nil, nil, fmt.Errorf("边 %s 的源节点 %s 不存在", edge.ID, edge.Source)
 		}
 		if _, ok := nodes[edge.Target]; !ok {
-			return fmt.Errorf("边 %s 的目标节点 %s 不存在", edge.ID, edge.Target)
+			return nil, nil, nil, fmt.Errorf("边 %s 的目标节点 %s 不存在", edge.ID, edge.Target)
 		}
 		if !validSourceHandle(source.Type, edge.SourceHandle) {
-			return fmt.Errorf("边 %s 的源端口 %s 不适用于节点 %s", edge.ID, edge.SourceHandle, edge.Source)
+			return nil, nil, nil, fmt.Errorf("边 %s 的源端口 %s 不适用于节点 %s", edge.ID, edge.SourceHandle, edge.Source)
 		}
 		key := edge.Source + "\x00" + edge.SourceHandle
 		handleTargets[key]++
 		if handleTargets[key] > 1 {
-			return fmt.Errorf("节点 %s 的 %s 出口连接了多个目标", edge.Source, edge.SourceHandle)
+			return nil, nil, nil, fmt.Errorf("节点 %s 的 %s 出口连接了多个目标", edge.Source, edge.SourceHandle)
 		}
 		outgoing[edge.Source] = append(outgoing[edge.Source], edge)
 		incoming[edge.Target]++
 	}
-	if hasRuleGraphCycle(nodes, outgoing, incoming) {
-		return errors.New("规则图不能包含循环")
-	}
-	for _, node := range graph.Nodes {
+	return outgoing, incoming, handleTargets, nil
+}
+
+func validateRequiredHandles(nodes []RuleNode, handleTargets map[string]int) error {
+	for _, node := range nodes {
 		for _, handle := range requiredHandles(node.Type) {
 			if handleTargets[node.ID+"\x00"+handle] == 0 {
 				return fmt.Errorf("节点 %s 的 %s 出口未连接", node.ID, handle)
 			}
 		}
 	}
+	return nil
+}
 
+func validateRuleGraphConnectivity(nodes []RuleNode, startID string, outgoing map[string][]RuleEdge, incoming map[string]int) error {
 	reachable := walkRuleGraph(startID, outgoing)
-	for _, node := range graph.Nodes {
+	for _, node := range nodes {
 		if !reachable[node.ID] {
 			return fmt.Errorf("节点 %s 无法从开始节点到达", node.ID)
 		}
 	}
-	for _, node := range graph.Nodes {
+	for _, node := range nodes {
 		if node.Type == RuleNodeStart && incoming[node.ID] != 0 {
 			return fmt.Errorf("开始节点 %s 不能有入边", node.ID)
 		}
@@ -131,96 +167,129 @@ func ValidateRuleGraph(ctx context.Context, graph RuleGraph, ipGroupExists func(
 			return fmt.Errorf("终止节点 %s 不能有出口", node.ID)
 		}
 	}
-	if err := validateTerminalPaths(graph.Nodes, outgoing); err != nil {
-		return err
-	}
 	return nil
 }
 
 func validateRuleNodeConfig(ctx context.Context, node RuleNode, exists func(context.Context, uint) (bool, error)) error {
 	switch node.Type {
 	case RuleNodeStart, RuleNodeAllow:
-		var cfg struct{}
-		if err := decodeStrictConfig(node.Config, &cfg); err != nil {
-			return fmt.Errorf("节点 %s 的配置无效: %w", node.ID, err)
-		}
+		return validateEmptyNodeConfig(node)
 	case RuleNodeIPMatch:
-		var cfg IPMatchConfig
-		if err := decodeStrictConfig(node.Config, &cfg); err != nil {
-			return fmt.Errorf("节点 %s 的配置无效: %w", node.ID, err)
-		}
-		for _, raw := range cfg.IPs {
-			if _, err := netip.ParseAddr(raw); err != nil {
-				return fmt.Errorf("节点 %s 的 IP %s 无效", node.ID, raw)
-			}
-		}
-		for _, raw := range cfg.CIDRs {
-			if _, err := netip.ParsePrefix(raw); err != nil {
-				return fmt.Errorf("节点 %s 的 CIDR %s 无效", node.ID, raw)
-			}
-		}
-		for _, id := range cfg.IPGroupIDs {
-			if id == 0 {
-				return fmt.Errorf("节点 %s 引用的 IP 组 ID 无效", node.ID)
-			}
-			if exists == nil {
-				return fmt.Errorf("节点 %s 无法校验 IP 组 %d", node.ID, id)
-			}
-			ok, err := exists(ctx, id)
-			if err != nil {
-				return fmt.Errorf("节点 %s 校验 IP 组 %d 失败: %w", node.ID, id, err)
-			}
-			if !ok {
-				return fmt.Errorf("节点 %s 引用的 IP 组 %d 不存在", node.ID, id)
-			}
-		}
+		return validateIPMatchNodeConfig(ctx, node, exists)
 	case RuleNodeGeoMatch:
-		var cfg GeoMatchConfig
-		if err := decodeStrictConfig(node.Config, &cfg); err != nil {
-			return fmt.Errorf("节点 %s 的配置无效: %w", node.ID, err)
-		}
-		for _, code := range cfg.Countries {
-			if !countryCodePattern.MatchString(code) {
-				return fmt.Errorf("节点 %s 的国家代码 %s 无效", node.ID, code)
-			}
-		}
-		for _, code := range cfg.Regions {
-			if !regionCodePattern.MatchString(code) {
-				return fmt.Errorf("节点 %s 的地区代码 %s 无效", node.ID, code)
-			}
-		}
+		return validateGeoMatchNodeConfig(node)
 	case RuleNodePoW:
-		var cfg PoWNodeConfig
-		if err := decodeStrictConfig(node.Config, &cfg); err != nil {
-			return fmt.Errorf("节点 %s 的配置无效: %w", node.ID, err)
-		}
-		if cfg.Difficulty < 1 || cfg.Difficulty > 16 {
-			return fmt.Errorf("节点 %s 的 PoW 难度必须在 1-16 之间", node.ID)
-		}
-		if cfg.Algorithm != "fast" && cfg.Algorithm != "slow" {
-			return fmt.Errorf("节点 %s 的 PoW 算法必须为 fast 或 slow", node.ID)
-		}
-		if cfg.SessionTTL < 60 {
-			return fmt.Errorf("节点 %s 的 PoW 会话 TTL 不能小于 60 秒", node.ID)
-		}
-		if cfg.ChallengeTTL < 30 {
-			return fmt.Errorf("节点 %s 的 PoW 挑战 TTL 不能小于 30 秒", node.ID)
-		}
+		return validatePoWNodeConfig(node)
 	case RuleNodeBlock:
-		var cfg BlockNodeConfig
-		if err := decodeStrictConfig(node.Config, &cfg); err != nil {
-			return fmt.Errorf("节点 %s 的配置无效: %w", node.ID, err)
+		return validateBlockNodeConfig(node)
+	}
+	return nil
+}
+
+func validateEmptyNodeConfig(node RuleNode) error {
+	var cfg struct{}
+	return decodeNodeConfig(node, &cfg)
+}
+
+func validateIPMatchNodeConfig(ctx context.Context, node RuleNode, exists func(context.Context, uint) (bool, error)) error {
+	var cfg IPMatchConfig
+	if err := decodeNodeConfig(node, &cfg); err != nil {
+		return err
+	}
+	for _, raw := range cfg.IPs {
+		if _, err := netip.ParseAddr(raw); err != nil {
+			return fmt.Errorf("节点 %s 的 IP %s 无效", node.ID, raw)
 		}
-		if cfg.StatusCode < 400 || cfg.StatusCode > 599 {
-			return fmt.Errorf("节点 %s 的阻止状态码必须在 400-599 之间", node.ID)
+	}
+	for _, raw := range cfg.CIDRs {
+		if _, err := netip.ParsePrefix(raw); err != nil {
+			return fmt.Errorf("节点 %s 的 CIDR %s 无效", node.ID, raw)
 		}
-		if len([]byte(cfg.ResponseBody)) > maxWAFBlockBodyBytes {
-			return fmt.Errorf("节点 %s 的阻止响应体不能超过 %d 字节", node.ID, maxWAFBlockBodyBytes)
+	}
+	for _, id := range cfg.IPGroupIDs {
+		if err := validateIPGroupReference(ctx, node.ID, id, exists); err != nil {
+			return err
 		}
 	}
 	return nil
 }
 
+func validateIPGroupReference(ctx context.Context, nodeID string, id uint, exists func(context.Context, uint) (bool, error)) error {
+	if id == 0 {
+		return fmt.Errorf("节点 %s 引用的 IP 组 ID 无效", nodeID)
+	}
+	if exists == nil {
+		return fmt.Errorf("节点 %s 无法校验 IP 组 %d", nodeID, id)
+	}
+	ok, err := exists(ctx, id)
+	if err != nil {
+		return fmt.Errorf("节点 %s 校验 IP 组 %d 失败: %w", nodeID, id, err)
+	}
+	if !ok {
+		return fmt.Errorf("节点 %s 引用的 IP 组 %d 不存在", nodeID, id)
+	}
+	return nil
+}
+
+func validateGeoMatchNodeConfig(node RuleNode) error {
+	var cfg GeoMatchConfig
+	if err := decodeNodeConfig(node, &cfg); err != nil {
+		return err
+	}
+	for _, code := range cfg.Countries {
+		if !countryCodePattern.MatchString(code) {
+			return fmt.Errorf("节点 %s 的国家代码 %s 无效", node.ID, code)
+		}
+	}
+	for _, code := range cfg.Regions {
+		if !regionCodePattern.MatchString(code) {
+			return fmt.Errorf("节点 %s 的地区代码 %s 无效", node.ID, code)
+		}
+	}
+	return nil
+}
+
+func validatePoWNodeConfig(node RuleNode) error {
+	var cfg PoWNodeConfig
+	if err := decodeNodeConfig(node, &cfg); err != nil {
+		return err
+	}
+	if cfg.Difficulty < 1 || cfg.Difficulty > 16 {
+		return fmt.Errorf("节点 %s 的 PoW 难度必须在 1-16 之间", node.ID)
+	}
+	if cfg.Algorithm != powAlgorithmFast && cfg.Algorithm != powAlgorithmSlow {
+		return fmt.Errorf("节点 %s 的 PoW 算法必须为 fast 或 slow", node.ID)
+	}
+	if cfg.SessionTTL < minPoWSessionTTLSeconds {
+		return fmt.Errorf("节点 %s 的 PoW 会话 TTL 不能小于 60 秒", node.ID)
+	}
+	if cfg.ChallengeTTL < minPoWChallengeTTLSeconds {
+		return fmt.Errorf("节点 %s 的 PoW 挑战 TTL 不能小于 30 秒", node.ID)
+	}
+	return nil
+}
+
+func validateBlockNodeConfig(node RuleNode) error {
+	var cfg BlockNodeConfig
+	if err := decodeNodeConfig(node, &cfg); err != nil {
+		return err
+	}
+	if cfg.StatusCode < 400 || cfg.StatusCode > 599 {
+		return fmt.Errorf("节点 %s 的阻止状态码必须在 400-599 之间", node.ID)
+	}
+	if len([]byte(cfg.ResponseBody)) > maxWAFBlockBodyBytes {
+		return fmt.Errorf("节点 %s 的阻止响应体不能超过 %d 字节", node.ID, maxWAFBlockBodyBytes)
+	}
+	return nil
+}
+
+func decodeNodeConfig(node RuleNode, dst any) error {
+	if err := decodeStrictConfig(node.Config, dst); err != nil {
+		return fmt.Errorf("节点 %s 的配置无效: %w", node.ID, err)
+	}
+	return nil
+}
+
 func decodeStrictConfig(raw json.RawMessage, dst any) error {
 	trimmed := bytes.TrimSpace(raw)
 	if bytes.Equal(trimmed, []byte("null")) {