基于业务规则的XSLT 1.0分组过滤：多服务器失败步骤汇总

需要生成汇总多执行服务器失败步骤的XML，失败判定规则如下：

• <ERROR_CRITERIA>ALL</ERROR_CRITERIA>：仅当该步骤在所有服务器均失败时，判定为失败
• <ERROR_CRITERIA>1</ERROR_CRITERIA>：只要该步骤在任意一台服务器失败，即判定为失败

以下提供XSLT 1.0和Python两种实现方案，均支持任意数量的步骤和服务器。

XSLT 1.0 实现方案 #

XSLT 1.0可以通过Muenchian分组实现该逻辑，核心是按<STEP>和<ERROR_CRITERIA>组合分组，再针对每组应用失败判定规则，最后生成汇总结果。

XSLT 代码 #

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="xml" indent="yes" encoding="UTF-8"/>
    
    <!-- 定义分组键：STEP + ERROR_CRITERIA -->
    <xsl:key name="validation-group" match="VALIDATION" use="concat(STEP, '|', ERROR_CRITERIA)"/>
    
    <xsl:template match="/ERROR">
        <ERROR>
            <!-- 遍历所有唯一的分组 -->
            <xsl:for-each select="SERVER/VALIDATION[generate-id() = generate-id(key('validation-group', concat(STEP, '|', ERROR_CRITERIA))[1])]">
                <xsl:variable name="current-step" select="STEP"/>
                <xsl:variable name="current-criteria" select="ERROR_CRITERIA"/>
                <!-- 获取该分组下的所有VALIDATION节点 -->
                <xsl:variable name="group-items" select="key('validation-group', concat($current-step, '|', $current-criteria))"/>
                
                <!-- 根据规则判断是否标记为失败 -->
                <xsl:variable name="is-failure">
                    <xsl:choose>
                        <!-- ALL规则：所有STATUS都是FAILURE -->
                        <xsl:when test="$current-criteria = 'ALL'">
                            <xsl:value-of select="count($group-items[STATUS != 'FAILURE']) = 0"/>
                        </xsl:when>
                        <!-- 1规则：至少有一个STATUS是FAILURE -->
                        <xsl:when test="$current-criteria = '1'">
                            <xsl:value-of select="count($group-items[STATUS = 'FAILURE']) > 0"/>
                        </xsl:when>
                        <xsl:otherwise>false</xsl:otherwise>
                    </xsl:choose>
                </xsl:variable>
                
                <!-- 如果判定为失败，生成汇总节点 -->
                <xsl:if test="$is-failure = 'true'">
                    <VALIDATION>
                        <STEP><xsl:value-of select="$current-step"/></STEP>
                        <ERROR_CRITERIA><xsl:value-of select="$current-criteria"/></ERROR_CRITERIA>
                        <STATUS>FAILURE</STATUS>
                        <MESSAGE>
                            <!-- 拼接所有服务器的执行信息 -->
                            <xsl:for-each select="$group-items">
                                <xsl:variable name="server-id" select="../SERVERID"/>
                                <xsl:value-of select="concat('SERVERID_', $server-id, ':', MESSAGE)"/>
                                <!-- 最后一个节点不加分隔符 -->
                                <xsl:if test="position() != last()">
                                    <xsl:text>.</xsl:text>
                                </xsl:if>
                            </xsl:for-each>
                        </MESSAGE>
                    </VALIDATION>
                </xsl:if>
            </xsl:for-each>
        </ERROR>
    </xsl:template>
</xsl:stylesheet>

逻辑说明 #

1. 分组：通过concat(STEP, '|', ERROR_CRITERIA)作为键，将相同步骤和判定规则的<VALIDATION>节点归为一组。
2. 失败判定：
   • 对于ALL规则，检查组内所有节点的<STATUS>是否全为FAILURE；
   • 对于1规则，检查组内是否存在至少一个<STATUS>为FAILURE的节点。
3. 汇总信息：将组内每个服务器的ID和执行消息拼接成<MESSAGE>内容，仅输出判定为失败的分组。

Python 实现方案 #

如果对XSLT语法不太熟悉，用Python的标准XML库也能快速实现，逻辑和XSLT一致：分组、规则判定、生成输出。

Python 代码 #

import xml.etree.ElementTree as ET

def generate_summary_xml(input_xml_path, output_xml_path):
    # 解析输入XML
    tree = ET.parse(input_xml_path)
    root = tree.getroot()
    
    # 分组存储：键为(STEP, ERROR_CRITERIA)，值为列表[(SERVERID, STATUS, MESSAGE)]
    validation_groups = {}
    
    # 遍历所有SERVER下的VALIDATION节点
    for server in root.findall('SERVER'):
        server_id = server.find('SERVERID').text
        for validation in server.findall('VALIDATION'):
            step = validation.find('STEP').text
            criteria = validation.find('ERROR_CRITERIA').text
            status = validation.find('STATUS').text
            message = validation.find('MESSAGE').text
            
            key = (step, criteria)
            if key not in validation_groups:
                validation_groups[key] = []
            validation_groups[key].append((server_id, status, message))
    
    # 构建输出XML
    output_root = ET.Element('ERROR')
    
    for (step, criteria), items in validation_groups.items():
        is_failure = False
        # 应用判定规则
        if criteria == 'ALL':
            # 所有都是FAILURE才判定失败
            is_failure = all(status == 'FAILURE' for (_, status, _) in items)
        elif criteria == '1':
            # 只要有一个FAILURE就判定失败
            is_failure = any(status == 'FAILURE' for (_, status, _) in items)
        
        if is_failure:
            validation_elem = ET.SubElement(output_root, 'VALIDATION')
            ET.SubElement(validation_elem, 'STEP').text = step
            ET.SubElement(validation_elem, 'ERROR_CRITERIA').text = criteria
            ET.SubElement(validation_elem, 'STATUS').text = 'FAILURE'
            
            # 拼接MESSAGE内容
            message_parts = []
            for server_id, _, msg in items:
                message_parts.append(f"SERVERID_{server_id}:{msg}")
            ET.SubElement(validation_elem, 'MESSAGE').text = '.'.join(message_parts)
    
    # 生成格式化的XML输出
    ET.indent(output_root, space="    ")
    output_tree = ET.ElementTree(output_root)
    output_tree.write(output_xml_path, encoding='utf-8', xml_declaration=True)

# 示例调用
generate_summary_xml('input.xml', 'output.xml')

逻辑说明 #

1. 数据分组：遍历输入XML的所有节点，按(步骤ID, 判定规则)分组，存储每个服务器的执行信息。
2. 规则校验：对每组分别应用ALL或1的失败判定逻辑。
3. 生成输出：仅将判定为失败的分组转化为<VALIDATION>节点，拼接所有服务器的消息后写入输出XML。

内容的提问来源于stack exchange，提问作者baati