#! /bin/bash

# ********************************************** ***************************** #
# File Name: inspect.sh
# Description: Ѳ칤. 
# Input: 
# Output: 
# Author: 
# Created: 2011-07-21
# Function List
# History
# 1.Date:
#   Author:
#   Modification:
# **************************************************************************** #

source /OSM/bin/script/os_source.sh

#******************************************************************************#
#***************                ȫֱ                    *******************#
#******************************************************************************#
#Ʒͺ S8000 VIS
G_PRODUCT_TYPE=
#ǰִѲĽűļ
G_CUR_INSPECT_FILE=`basename $0`
#űǰ·ڴʱļ
G_INSPECT_DIR="/var/log/inspect"
[ -d $G_INSPECT_DIR ] && rm -fr $G_INSPECT_DIR
mkdir -p $G_INSPECT_DIR
cd $G_INSPECT_DIR

#űڶתڵ
G_CMD_ARGS="$*"
#ļڱѲ
G_CHECK_RESULT_FILE=$G_INSPECT_DIR/result_inspect.xml
#ǰڵѲֻcommonvalueerrorvalueֶ
G_CHECK_RESULT_TMP_FILE=$G_INSPECT_DIR/result_inspect_tmp
#űַڵ·
G_INSPECT_FILE_PATH=/OSM/bin/script
#澯ļCLI澯ʱʹ
G_ALARM_TMP_TAR_FILE=/var/alarm/export/export_*.tar
#澯ļıʽ
G_ALARM_TMP_TXT_FILE=$G_INSPECT_DIR/local_alm_file.txt
#ļڽűִлʱʹã֤ͬһʱֻһűִ
G_INSPECT_LCK_FILE=/tmp/INSPECT.lck

#Ѳʱѡ澯ѲҪ澯ѹļ·
G_CMD_OTHER=

#ڵбϢ0:xxx.xxx.xx.xxx:xxx.xxx.xx.xxx,ڵ
G_NODE_LIST=
    
#Ѳбֶ֧Ѳͬʱ·
G_CMD_LIST=

#ҪشļĿ·
G_CMD_DST_DIR=
#ҪشļĿIP
G_CMD_DST_IP=
#ǰѲѲ
G_CUR_JUDGE_VALUE=0

#ǷҪѼڵĻش,ĬϲҪڵѼ
# 0 Ҫַ 1 ַڵ㣬֮ҪѼѲ 2 շַ֮ش 
G_NEED_COLLECT_DATA=0 

#******************************************************************************#
#********жǷC10SPC400ǰİ汾ҴһЩ***********#
#******************************************************************************#
#жǷC10SPC300ǰİ汾
G_OLD_VER_BF_C10SPC400="V200R003C10SPC100
V200R003C10SPC200
V200R003C10SPC300
"
#ǷĳЩMML(tc pvtgt map showscsi getall)ִУ0-ԣ1-
G_SKIP_MML=0

# **************************************************************************** #
# Function Name: IS_OLD_VER
# Description: жǷC10SPC400ǰİ汾
# Parameter: 
# Return: 
# **************************************************************************** #
IS_OLD_VER()
{
    l_cur_ver=`cat /OSM/ver/versions.conf |grep SpcVersion | awk -F= '{print $2}' 2>/dev/null`
    if [ -n "`echo $l_cur_ver |grep "V200R003C00"`" ];then
        return 1
    fi

    if [ "$l_cur_ver" = "V200R003C10" ];then
        return 1
    fi

    if [ -n "`echo $G_OLD_VER_BF_C10SPC400 |grep "$l_cur_ver"`" ];then
        return 1
    else
        return 0
    fi
}
# **************************************************************************** #
# Function Name: CHECK_NEED_SKIP_MML
# Description: C10SPC400ǰİ汾жǷҪĳЩ
# Parameter: 
# Return: 
# **************************************************************************** #
CHECK_NEED_SKIP_MML()
{
    IS_OLD_VER
    if [ 0 = $? ];then
       return
    fi
	
    G_SKIP_MML=1
    OS_ECHO "vxinspect need skip MML;"
}
#******************************************************************************#
#***************           ڿXMLļĸ    *******************#
#******************************************************************************#
# **************************************************************************** #
# Function Name: WRITE_XML_HEADER
# Description: xmlļͷϢ
# Parameter: 
# Return: 
# **************************************************************************** #
WRITE_XML_HEADER()
{
    echo "<?xml version=\""1.0"\" encoding=\""UTF-8"\"?>" >>$G_CHECK_RESULT_FILE
    echo "<device>" >>$G_CHECK_RESULT_FILE
} 

# **************************************************************************** #
# Function Name: WRITE_XML_TAIL
# Description: xmlļβϢ
# Parameter: 
# Return: 
# **************************************************************************** #
WRITE_XML_TAIL()
{
    echo "</device>" >>$G_CHECK_RESULT_FILE   
} 

# **************************************************************************** #
# Function Name: WRITE_XML_CMD_HEADER
# Description: xmlļͷֶ
# Parameter: $1 ID
# Return: 
# **************************************************************************** #
WRITE_XML_CMD_HEADER()
{
    echo "  <cmditem id=\"$1\">" >>$G_CHECK_RESULT_FILE
}

# **************************************************************************** #
# Function Name: WRITE_XML_CMD_TAIL
# Description: xmlļֶ
# Parameter: 
# Return: 
# **************************************************************************** #
WRITE_XML_CMD_TAIL()
{
    echo "  </cmditem>" >>$G_CHECK_RESULT_FILE
} 

# **************************************************************************** #
# Function Name: WRITE_XML_SUBCMD_HEADER
# Description: ͷxmlļ
# Parameter: $1 ID
# Return: 
# **************************************************************************** #
WRITE_XML_SUBCMD_HEADER()
{   
   echo "    <item id=\"$1\">" >>$G_CHECK_RESULT_FILE
}

# **************************************************************************** #
# Function Name: WRITE_XML_SUBCMD_TAIL
# Description: βxmlļ
# Parameter: $1 ID
# Return: 
# **************************************************************************** #
WRITE_XML_SUBCMD_TAIL()
{
    echo "    </item>" >>$G_CHECK_RESULT_FILE
}
# **************************************************************************** #
# Function Name: CONVERT_MSG
# Description: תеţֹxml
# ַ	ʵֵַ
#   &	        &amp;
#   <	        &lt;
#   >       	&gt;
#   "	        &quot;
#   '	        &apos;
# Parameter: $1 
# Return: 
# **************************************************************************** #
CONVERT_MSG ( )
{
    echo -e "$*" | sed -r "s/&/\&amp;/g; s/>/\&gt;/g; s/</\&lt;/g; s/\"/\&quot;/g; s/'/\&apos;/g"
}

# **************************************************************************** #
# Function Name: WRITE_XML_COMMON
# Description: xmlļ
# Parameter: 
#            $1 ʾ
#            $2 
# Return: 
# **************************************************************************** #
WRITE_XML_COMMON()
{  
    content="$*" 
    content="${content#* }" 
    if [ "$G_NEED_COLLECT_DATA" == "0" ]; then
        TMPFILE=$G_CHECK_RESULT_FILE
    else
        TMPFILE=$G_CHECK_RESULT_TMP_FILE
    fi
    echo -e "      <commonvalue type=\"$1\">`CONVERT_MSG "$content"`</commonvalue>" >>$TMPFILE
}

# **************************************************************************** #
# Function Name: WRITE_XML_ERROR
# Description: xmlļ
# Parameter: 
#            $1 ʾ
#            $2 
# ʽerrorNO||param0||param1:....
# Return: 
# **************************************************************************** #
WRITE_XML_ERROR()
{ 
    content=$* 
    content="${content#* }"  
    if [ "$G_NEED_COLLECT_DATA" == "0" ]; then
        TMPFILE=$G_CHECK_RESULT_FILE
    else
        TMPFILE=$G_CHECK_RESULT_TMP_FILE
    fi 
    echo -e "      <errorvalue type=\"$1\">`CONVERT_MSG $content`</errorvalue>" >>$TMPFILE   
} 

# **************************************************************************** #
# Function Name: WRITE_XML_JUDGE
# Description: xmlļ
# Parameter: 
#            $1 ,0/1ʧ
# Return: 
# **************************************************************************** #
WRITE_XML_JUDGE()
{       
    #鿴ǰʱļһǲcommonerrorֵûûϢ  
    if [ -z "`tail -n 1 $G_CHECK_RESULT_FILE| grep -E "(errorvalue>)|(commonvalue>)" `" ]; then    
       WRITE_XML_COMMON 0 "No Information"
    fi
    echo "      <judge>$1</judge>" >>$G_CHECK_RESULT_FILE
}  

#******************************************************************************#
#***************           ûִѲʵֵĸ   *******************#
#******************************************************************************#


# **************************************************************************** #
# Function Name: FILE_TOO_BIG_RESULT
# Description:   Ѳļ󣬲ܴ䣬쳣¼
# Parameter:
# Return:
# **************************************************************************** # 
FILE_TOO_BIG_RESULT()
{
    head4line="`head -n 4 $G_CHECK_RESULT_FILE`"
    tail4line="`tail -n 4 $G_CHECK_RESULT_FILE`"
    
    echo -e "$head4line" >$G_CHECK_RESULT_FILE
    WRITE_XML_COMMON 0 "The result of inspect is so much that can not display"
    echo -e "$tail4line" >>$G_CHECK_RESULT_FILE
}

# **************************************************************************** #
# Function Name: EXECUTE_LOCAL_DEBUG
# Description:   ڱڵִdebug
# Parameter:
#               1 
# Return:
# **************************************************************************** # 
EXECUTE_LOCAL_DEBUG()
{
    resCont="`eval $* 2>/dev/null`"
    
    #VIS_8346_0:/home/amos/inspect/tmp # 

    WRITE_XML_COMMON 0 "$HOSTNAME:/OSM # $*\n$resCont"
    echo -e "$resCont"
}

# **************************************************************************** #
# Function Name: EXECUTE_REMOTE_DEBUG
# Description: ָڵִdebug,ҪԶִѲ
# Parameter:
#               1 Զ̽ڵIP(IP)
#               2 
# Return:
# **************************************************************************** # 
EXECUTE_REMOTE_DEBUG()
{    
    TMPFILE="expect_$$.tmp" 
        
    #ִ 
    vxrsh $1 "$2" > $TMPFILE
    
    #ȡ
    dos2unix $TMPFILE  >/dev/null 2>&1
    cat $TMPFILE    
    rm -fr $TMPFILE
}

# **************************************************************************** #
# Function Name: EXECUTE_SCP_FILE
# Description: ļڵ
# Parameter:
# Return:
# **************************************************************************** # 
EXECUTE_SCP_FILE()
{
    vxrsh scp "$1" $2 "$3"
}


# **************************************************************************** #
# Function Name: EXECUTE_REMOTE_INSPECT
# Description: ڵִеǰѲ
# Parameter:
# Return:
# **************************************************************************** # 
EXECUTE_REMOTE_INSPECT ( )
{
    #ȴµѲʱļ
    [ -f "$G_CHECK_RESULT_TMP_FILE" ] && rm -f $G_CHECK_RESULT_TMP_FILE >/dev/null 2>&1    
    touch $G_CHECK_RESULT_TMP_FILE >/dev/null 2>&1
    
    #ļҪشĿ¼ҪĿ¼Ȩ޿
    chmod 777 $G_INSPECT_DIR  >/dev/null 2>&1
    
    #Ϊ2ѾշַԼַ
    [ "$G_NEED_COLLECT_DATA" == "2" ] && return 1

    for nodeIdx in $G_NODE_LIST 
    do        
        nodeInfo=(`echo -e "$nodeIdx" | sed -r 's/\:/ /g'`)       
        
        #ڵ       
        [ "${nodeInfo[0]}" == "${G_LOCAL_NODE[0]}" ] && continue
        
        strCmd="$G_INSPECT_FILE_PATH/$G_CUR_INSPECT_FILE $G_CMD_ARGS -d $G_INSPECT_DIR"

        #ԶִѲ
        vxrsh ${nodeInfo[1]} "$strCmd -i ${G_LOCAL_NODE[1]} 1>/dev/null 2>&1"  >/dev/null 2>&1
        
        #ִгɹڱشڸýڵѲļ
        # ִнжϡֱӸѲļ
    done 
    
    #ִַҪñ־λ֪ҪѼشĽ
    G_NEED_COLLECT_DATA=1    
}

# **************************************************************************** #
# Function Name: COLLECT_INSPECT_RESULT
# Description: нڵѲ
# Parameter:
# Return:
# **************************************************************************** # 
COLLECT_INSPECT_RESULT ( )
{
    errorNodeList=
    totalJudge=0
    
    #ûر־λʾηַ
    G_NEED_COLLECT_DATA=0   
    
    #ȽصʱļΪ׼ʽĽļ
    mv "$G_CHECK_RESULT_TMP_FILE" "${G_CHECK_RESULT_TMP_FILE}_${G_LOCAL_NODE[0]}_${G_CUR_JUDGE_VALUE}" >/dev/null 2>&1 
    
    #rm -fr ${G_CHECK_RESULT_TMP_FILE}_1_*  >/dev/null 2>&1 
    #touch ${G_CHECK_RESULT_TMP_FILE}_1_0 >/dev/null 2>&1
    
    inspectFileList=`du -ab "$G_INSPECT_DIR"/ | grep -E "$G_CHECK_RESULT_TMP_FILE"`
    #ļ
    for nodeIdx in `echo -e "$G_NODE_LIST" | awk -F: '{print $1}'`
    do     
        tmpInspectFile="`echo -e "$inspectFileList" | \
            grep -E "${G_CHECK_RESULT_TMP_FILE}_${nodeIdx}_[0-9]$"`"
        if [ -z "$tmpInspectFile" ]; then
            #ûѼļҪ¼
            errorNodeList="$errorNodeList $nodeIdx:1:unknown"
            continue       
        fi
        
        #ȡǰļѲ
        tmpJudge=`echo -e "$tmpInspectFile" | awk -F\_ '{print $NF}'`
        tmpInfo=(`echo $tmpInspectFile | awk '{print $1, $2}'`)
        if [ "${tmpInfo[0]}" == "0" ]; then
            #ļΪ
            errorNodeList="$errorNodeList $nodeIdx:$tmpJudge:null"
            rm  ${tmpInfo[1]} >/dev/null 2>&1 
            continue        
        fi
        
        [ $totalJudge -lt $tmpJudge ] && totalJudge=$tmpJudge 
     
        cat ${tmpInfo[1]} >>$G_CHECK_RESULT_FILE
        rm  ${tmpInfo[1]} >/dev/null 2>&1 
    done 
    
    #ǴûѲ쵽Ľڵ㣬unknown¼
    if [ -z "$errorNodeList" ]; then
        G_CUR_JUDGE_VALUE=$totalJudge
        return 0
    fi
    
    for nodeIdx in $errorNodeList
    do
        nodeInfo=(`echo -e "$nodeIdx" | sed -r 's/:/ /g'`)        
        
        [ $totalJudge -lt ${nodeInfo[1]} ] && totalJudge=${nodeInfo[1]}
        if [ "${nodeInfo[1]}" != "0" ]; then            
            WRITE_XML_ERROR 0 "nodeerr||CTRL ID:${nodeInfo[0]}||CONTENT:${nodeInfo[2]}" 
        else
            WRITE_XML_COMMON 0 "The result of NODE ${nodeInfo[0]} is ${nodeInfo[2]}" 
        fi
    done
    
    G_CUR_JUDGE_VALUE=$totalJudge
}

# **************************************************************************** #
# Function Name: RETURN_INSPECT_RESULT
# Description: شڵ㣨ַIP
# Parameter:
# Return:       شļʽresult_inspect_tmp_ڵID_judgeֵ
# **************************************************************************** # 
RETURN_INSPECT_RESULT ( )
{     
    EXECUTE_SCP_FILE "$G_CHECK_RESULT_TMP_FILE" $G_CMD_DST_IP \
        "$G_CMD_DST_DIR/`basename ${G_CHECK_RESULT_TMP_FILE}`_${G_LOCAL_NODE[0]}_${G_CUR_JUDGE_VALUE}" >/dev/null 2>&1
    rm -f $G_CHECK_RESULT_TMP_FILE >/dev/null 2>&1
}

#******************************************************************************#
#***************                ȡϵͳ״̬            *******************#
#******************************************************************************#

# **************************************************************************** #
# Function Name: CHECK_HUNG
# Description: 鴫Ƿ
# Parameter: $1 
# Return:
# **************************************************************************** #
CHECK_HUNG()
{
    pid=`ps -e | awk '/'$1'/ {print $1}' | sed -n '1p'`
    if [ "$pid" == "" ]; then
        return 1
    fi

    hungstr=`awk '/SigBlk/ {print $2}' /proc/$pid/status `
    if [ "$hungstr" == "ffffffffffffffff" ]; then
        return 1
    else
        return 0
    fi
}
# **************************************************************************** #
# Function Name: CHECK_PREPARE
# Description: Ѳǰڹַűڵ
# Parameter:
# Return:
# **************************************************************************** #
CHECK_PREPARE()
{
    errorCount=0
     
    #Ϊ2ѾշַԼַ
    if [ "$G_NEED_COLLECT_DATA" != "2" ]; then  
        for nodeIdx in $G_NODE_LIST 
        do        
            nodeInfo=(`echo -e "$nodeIdx" | sed -r 's/\:/ /g'`)
            
            #ڵ       
            [ "${nodeInfo[0]}" == "${G_LOCAL_NODE[0]}" ] && continue
            #Զ˴Ŀ¼
            vxrsh ${nodeInfo[1]} "mkdir -p $G_INSPECT_FILE_PATH && \
                chmod 777 $G_INSPECT_FILE_PATH 2>&1"            
            
            #ϴļԶָĿ¼
            EXECUTE_SCP_FILE "$G_INSPECT_FILE_PATH/$G_CUR_INSPECT_FILE" \
                ${nodeInfo[1]} "$G_INSPECT_FILE_PATH/$G_CUR_INSPECT_FILE" >/dev/null 2>&1
            [ "$?" != "0" ] && return 1  
            
            vxrsh ${nodeInfo[1]} "chmod 777 $G_INSPECT_FILE_PATH/$G_CUR_INSPECT_FILE"
        
        done
    fi
    
    EXECUTE_REMOTE_INSPECT
    
    CHECK_HUNG vxconfigd
    if [ $? != 0 ]; then
        WRITE_XML_ERROR 0 "vxconfigderr||CTRL ID:${G_LOCAL_NODE[0]}"
        errorCount=1
    fi 
    
    [ "$errorCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1 
                
}


# **************************************************************************** #
# Function Name: CHECK_POST
# Description: Ѳڹ豸ʱĿ¼
#              ÿѲһļҪϴpythonȡļͳһɾ
# Parameter:
# Return:
# **************************************************************************** #
CHECK_POST()
{ 
    errorCount=0
    
    EXECUTE_REMOTE_INSPECT
    
    CHECK_HUNG vxconfigd
    if [ $? != 0 ]; then
        WRITE_XML_ERROR 0 "vxconfigderr||CTRL ID:${G_LOCAL_NODE[0]}"
        errorCount=1
    fi 
    
    [ "$errorCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1 
}

#******************************************************************************#
#***************                ϵͳ״̬                *******************#
#******************************************************************************#

# **************************************************************************** #
# Function Name: CHECK_CTRL_ONLINE_TIME
# Description: ʱ 103
# Parameter:
# Return:

# **************************************************************************** # 
CHECK_CTRL_ONLINE_TIME()
{ 
    #ַѲ
    EXECUTE_REMOTE_INSPECT
    
    EXECUTE_LOCAL_DEBUG uptime 1>/dev/null 2>&1 
 
}


# **************************************************************************** #
# Function Name: CHECK_SYSTEM_INFO
# Description: ϵͳϢ
# Parameter:
# Return:

# **************************************************************************** #   
CHECK_SYSTEM_INFO()
{
    case "${1:1}" in                    
        "03")            # 02 ʱ
            CHECK_CTRL_ONLINE_TIME $1
            ;;                
                                                                                   
        *)
            return 1 
            ;;
    esac
}


#******************************************************************************#
#***************              ҵ״̬              *******************#
#******************************************************************************#



# **************************************************************************** #
# Function Name: CHECK_VOLUMECONSISTENCY_STATUS
# Description: һ 202
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_VOLUMECONSISTENCY_STATUS ( )
{
    errorCount=0
    
    if [ $G_SKIP_MML -eq 1 ];then
        OS_ECHO "vxinspect skip CHECK_VOLUMECONSISTENCY_STATUS"
        return
    fi
	
    #ַѲ
    EXECUTE_REMOTE_INSPECT

    resCont="`EXECUTE_LOCAL_DEBUG auto_mml.sh tc pv`"  
    #ֻоӳ䣬жϹ͹Ƿһ $7ΪǷ򿪣$8ΪǷӳ
    resCont=`echo -e "$resCont" | grep -E "^[0-9]" |awk '{if ($1>=256 && $7!=0 && $8!=0) printf("%s\n",$0);}' | \
                    awk 'BEGIN{OFS=":"}{if ($2 == $3) printf("Yes:"); else printf("No:"); print $1, $11,$12}'`
    for recIdx in `echo -e "$resCont"`
    do
        res=`echo $recIdx | awk -F: '{print $1}'`
        dgname=`echo $recIdx | awk -F: '{print $3}'`
        volname=`echo $recIdx | awk -F: '{print $4}'`
        
        if [ "$res" == "No" ]; then
            let errorCount+=1
            chkCont="nonconsistency||CTRL ID:${G_LOCAL_NODE[0]}||DGNAME:${dgname}||VOLUME NAME${volname}"
            WRITE_XML_ERROR 0 "$chkCont"          
        fi    
    done
   
    [ "$errorCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1    
}

# **************************************************************************** #
# Function Name: CHECK_TGT_STATUS
# Description: TGT״̬ 206
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_TGT_STATUS ( )
{
    errorCount=0   

    if [ $G_SKIP_MML -eq 1 ];then
        OS_ECHO "vxinspect skip check TGT status"
        return 0 
    fi	
 
    #ַѲ
    EXECUTE_REMOTE_INSPECT  

    resCont="`EXECUTE_LOCAL_DEBUG auto_mml.sh tgt status`"

    #״̬м    
    allStatus=(`echo -e "$resCont"| awk -F: '/\.$/ {print $2}' | sed '$!N; s/\n//; s/\.//g'`)
    if [ "${allStatus[0]}" != "enable" -o "${allStatus[1]}" != "unhang" ]; then
        chkCont="Target Status:${allStatus[0]},All Lun Status:${allStatus[1]}" 

        WRITE_XML_ERROR 0 "total||CTRL ID:${G_LOCAL_NODE[0]}||CONTEN:${chkCont}" 
        G_CUR_JUDGE_VALUE=1  
        return 1
    fi

    #ԸLUNз    
    volid=(`echo -e "$resCont" | grep -E "^[0-9]" | awk '{printf("%s\n", $1);}'`)
    status=(`echo -e "$resCont" | grep -E "^[0-9]" | awk '{printf("%s,%s\n", $2, $3);}'`)
    volumes=(`/OSM/bin/script/auto_mml.sh tc pv | grep -E "^[0-9]" | awk '{if(NF >= 12) print $12}'`)
    
    volCnt=${#status[*]}
    volIdx=0
    while [ "$volIdx" -lt "$volCnt" ]
    do
        chkCont="Ctrl ID:${G_LOCAL_NODE[0]}||LunID:${volid[$volIdx]}||Volume:${volumes[$volIdx]}||Status:${status[$volIdx]}"
        if [ "${status[$volIdx]}" != "start,unhang" ]; then
            WRITE_XML_ERROR 0 "lunerr||${chkCont}"
            let errCount+=1
        fi
        let volIdx+=1
    done
    
    if [ -n "$errCount" ]; then
        [ "$errCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
    else
        G_CUR_JUDGE_VALUE=0
    fi        
}

# **************************************************************************** #
# Function Name: CHECK_HEARTBEAT_STATUS
# Description: ״̬ 207 
# Parameter:
# Return:

# **************************************************************************** # 
CHECK_HEARTBEAT_STATUS()
{
    errorCount=0 
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT 
    
    resCont="`EXECUTE_LOCAL_DEBUG /sbin/lltstat -nvv | grep -A 2 "OPEN" | sed 's/\*/ /g' | awk '{printf("%s ", $0);if (NR%3 == 0) printf("\n")}' | awk '{print $1, $5, $8}'`"
            
    if [ -n "`echo -e "$resCont" | grep "DOWN"`" ]
    then       
       let errorCount+=1
    fi 
        
    [ "$errorCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
    echo -e "$resCont" | while read nodeID heart0Stat heart1Stat
    do        
        if [ "$heart0Stat" != "UP" -o "$heart1Stat" != "UP" ]; then
            WRITE_XML_ERROR 0 "hearterr||CTRL ID:$nodeID||HEART0:$heart0Stat||HEART1:$heart1Stat"            
        fi
    done
}

# **************************************************************************** #
# Function Name: CHECK_SYSTEM_DISK_USAGE_RATE
# Description: ϵͳ̷ʹ 208
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_SYSTEM_DISK_USAGE_RATE ()
{
    EXECUTE_REMOTE_INSPECT
	#ϵͳdiskǷзռʳ90%

	L_DF_CONT="`EXECUTE_LOCAL_DEBUG df -h`"
    
    L_ERR_PARTITION="`echo -e "$L_DF_CONT" |awk '{if(NR > 1) {gsub(/%/, "", $5); if ($5 >90) {printf("Directory:%s||UsageRate:%s%%\n", $6, $5)}}}'`"

    [ -z "$L_ERR_PARTITION" ] && return 0
    
	for L_IDX in $L_ERR_PARTITION
    do 
        let errorCount+=1
        WRITE_XML_ERROR 0 "diskusageerr||$L_IDX" 
    done
    
    [ "$errorCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1  
}
# **************************************************************************** #
# Function Name: CHECK_SYSTEM_RUNNING_STATUS
# Description: ״̬ 209
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_SYSTEM_RUNNING_STATUS ( )
{
    #ӵdebugµ
    global_cmd_list="/bin/date
/sbin/lsmod
/usr/bin/free
ps axjf
/sbin/vxfenadm -s all -f /etc/vxfentab"
    
    global_cmd_list2="/usr/bin/top -n 1 -b -c | head -n 20"
    #ַѲ
    EXECUTE_REMOTE_INSPECT
	
    #ռTOPǰ20
    CountIdx=0
    while [ $CountIdx -lt 6 ]
    do
	EXECUTE_LOCAL_DEBUG "`echo -e "$global_cmd_list2"`" >/dev/null
        let CountIdx+=1
        sleep 2
    done

    lineNum=`echo -e "$global_cmd_list" | wc -l`
    for ((idx=1;idx<=$lineNum;idx++))
    do
        EXECUTE_LOCAL_DEBUG "`echo -e "$global_cmd_list" | sed -n "${idx}p"`" >/dev/null
    done
  
    G_CUR_JUDGE_VALUE=0    
}

# **************************************************************************** #
# Function Name: CHECK_KEY_INFO_STATUS
# Description: ؼϢ״̬ 210
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_KEY_INFO_STATUS ( )
{
    #ӵdebugµ
    global_cmd_list="/sbin/ifconfig -a
/sbin/route
/bin/cat /etc/iscsi.conf
/bin/cat /etc/initiatorname.iscsi
/bin/cat /var/lib/iscsi/bindings
iscsi status
/sbin/vxdctl -c mode
/sbin/vxdg free
/sbin/vxfenadm -d
/sbin/vxfenconfig -l
/sbin/gabconfig -a
auto_mml.sh sys admin
auto_mml.sh fc allinfo
auto_mml.sh scan fc pl
auto_mml.sh tc pv
auto_mml.sh vd status
auto_mml.sh tgt tgtswitch 2
cat /etc/vxfenmode
vxfenconfig -c
vxfenconfig -l 
vxfenadm -d
vxdmpadm listenclosure all"
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT
	
    #versions.confļ
    verCont="`/bin/grep -E -v "^[;]" /OSM/ver/versions.conf`"
    WRITE_XML_COMMON 0 "$HOSTNAME:/OSM # cat /OSM/ver/versions.conf\n$verCont"
    
    lineNum=`echo -e "$global_cmd_list" | wc -l`
    for ((idx=1;idx<=$lineNum;idx++))
    do
        local_cmd="`echo -e "$global_cmd_list" | sed -n "${idx}p"`"
        if [ -n "`echo $local_cmd |grep "auto_mml"`" ];then
            if [ $G_SKIP_MML -eq 1 ];then
                OS_ECHO "vxinspect skip $local_cmd"
                continue
            fi
        fi

        EXECUTE_LOCAL_DEBUG "`echo -e "$global_cmd_list" | sed -n "${idx}p"`" >/dev/null
    done

    G_CUR_JUDGE_VALUE=0    
}

# **************************************************************************** #
# Function Name: CHECK_ACTIVE_ACTIVE_STATUS
# Description: 洢˫״̬ 211
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_ACTIVE_ACTIVE_STATUS ( )
{    
    #ַѲ
    EXECUTE_REMOTE_INSPECT
	
	tmir_show="`EXECUTE_LOCAL_DEBUG auto_mml.sh tmir show`"
	
	#Ƿ˫վIDƥ
    if [ -z "`echo -e "$tmir_show" |head -n 2 |grep "START"`" ];then
	    OS_ECHO "vxinspect a-a does not start" 
	    WRITE_XML_COMMON 0 "Active-active mode do not start"
		G_CUR_JUDGE_VALUE=0 
		return 0
	fi
	
    tmir_show_ret="`echo -e "$tmir_show" |head -n 7`"
    curr_site_id="`echo -e "$tmir_show_ret" |grep "Current node"|awk '{print $5}'|awk -F, '{print $1}'`"
    curr_node_id="`echo -e $HOSTNAME |awk -F_ '{print $3}'`"

	site_A_node="`echo -e "$tmir_show_ret" |grep -w "^A"`"
	site_id_name="`echo -e "$site_A_node" |awk '{print $1}'`"
	if [ -n "`echo -e "$site_A_node" |awk '{print $2}' |grep "$curr_node_id"`" ];then
        if [ $curr_site_id != "1" ];then
            OS_ECHO  "vxinspect active-active site does not match local node ($site_id_name $curr_site_id)" 
            WRITE_XML_ERROR 0 "aaerr||SiteName:$site_id_name||SiteID:$curr_site_id"	
            G_CUR_JUDGE_VALUE=1
            return 1			
        fi                
    fi
	
	site_B_node="`echo -e "$tmir_show_ret" |grep -w "^B"`"
	site_id_name="`echo -e "$site_B_node" |awk '{print $1}'`"
	if [ -n "`echo -e "$site_B_node" |awk '{print $2}' |grep "$curr_node_id"`" ];then
        if [ $curr_site_id != "2" ];then                          
            OS_ECHO  "vxinspect active-active site does not match local node ($site_id_name $curr_site_id)" 
            WRITE_XML_ERROR 0 "aaerr||SiteName:$site_id_name||SiteID:$curr_site_id"	
            G_CUR_JUDGE_VALUE=1
            return 1				
        fi                                                          
    fi

    EXECUTE_LOCAL_DEBUG "cat /dev/tmir_dev"
    if [ ! -f /OSM/sf_config/sf_cluster_file ]; then
	    OS_ECHO "vxinspect not AP cluster" 
        WRITE_XML_COMMON 0 "Not Active-active AP cluster"
		return 0
	fi
    
	EXECUTE_LOCAL_DEBUG "/OSM/sf_config/sf_cluster_file"
    EXECUTE_LOCAL_DEBUG "cat /OSM/sf_config/clstsync.conf"
	EXECUTE_LOCAL_DEBUG "cat /OSM/sf_config/local_clstsync.conf"
	EXECUTE_LOCAL_DEBUG "cat /OSM/sf_config/diskgroup_controller.conf"
	EXECUTE_LOCAL_DEBUG "cat /OSM/sf_config/failedgroupmap.conf"
	EXECUTE_LOCAL_DEBUG "cat /OSM/sf_config/groupdisk.conf"

    G_CUR_JUDGE_VALUE=0    
}

# **************************************************************************** #
# Function Name: CHECK_BASIC_AFFAIR_INFO
# Description: ҵ״̬
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_BASIC_AFFAIR_INFO()
{
    case "${1:1}" in           
        "02")              # 02 һ
            CHECK_VOLUMECONSISTENCY_STATUS $1
            ;;  

        "06")              # 06 TGT״̬
            CHECK_TGT_STATUS $1 
            ;;
            
        "07")              # 07 
            CHECK_HEARTBEAT_STATUS $1 
            ;;

        "08")              # 08 ϵͳ̷ʹ
            CHECK_SYSTEM_DISK_USAGE_RATE $1 
            ;;

        "09")              # 07 ϵͳ״̬
            CHECK_SYSTEM_RUNNING_STATUS $1 
            ;;			
             
        "10")              # 08 ؼϢ״̬
            CHECK_KEY_INFO_STATUS $1 
            ;; 

        "11")              # 07 洢˫״̬
            CHECK_ACTIVE_ACTIVE_STATUS $1 
            ;;
			
         *)
            return 1 
            ;;
    esac
}


#******************************************************************************#
#***************              SFҵ״̬                *******************#
#******************************************************************************#

# **************************************************************************** #
# Function Name: CHECK_CVM_STATUS
# Description: CVM״̬ 300
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_CVM_STATUS ( )
{
    errCount=0
    outFlag=0    

    #ַѲ
    EXECUTE_REMOTE_INSPECT

    cvmStatus=`EXECUTE_LOCAL_DEBUG /opt/VRTS/bin/hastatus -sum | awk '{if(0 != index($0, "GROUP STATE")) flag=1; if(0 != index($0, "RESOURCES NOT PROBED")) flag=2; \
               if(flag == 1) print $0}'| grep -E -i "cvm" | awk '{printf("System:%s||State:%s\n", $3, $6)}'`

    clusterName="`hostname`"
    clusterName=${clusterName:0:${#clusterName}-1}
    nodeList=`echo -e "$G_NODE_LIST" | awk -F: '{printf("'$clusterName'%s\n", $1);}'`

    for nodeIdx in `echo -e "$nodeList"`
    do
        cvmIdx="`echo "$cvmStatus" | grep -E "$nodeIdx"`"
       
        if [[ -z "$cvmIdx" || "${cvmIdx##*:}" != "ONLINE" ]]; then
            [ -z "$cvmIdx" ] && cvmIdx="System:$nodeIdx||State:UNKNOWN"
            WRITE_XML_ERROR 0 "cvmerr||Ctrl ID:${G_LOCAL_NODE[0]}||$cvmIdx"
            let errCount+=1
        fi          
    done
    
    [ "$errCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1   
}

# **************************************************************************** #
# Function Name: GET_SYSTEM_DISK
# Description: ȡϵͳ
# Parameter:
# Return:
# **************************************************************************** # 
GET_SYSTEM_DISK ( )
{
    diskList=
    
    for diskIdx in `lsscsi | awk '/\[[1-3]:/ {gsub(/\/.*\//, "", $NF); print $NF}'`
    do         
        [ -n "$diskList" ] && diskList="$diskList|"
        diskList="$diskList$diskIdx"
    done
    echo "$diskList"
}

# **************************************************************************** #
# Function Name: CHECK_DMP_STATUS
# Description: DMP·״̬ 301
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_DMP_STATUS ( )
{
    errCount=0
    dmpNodeIdx=
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT   
    
    sysdiskList=`GET_SYSTEM_DISK`    
    resCont="`EXECUTE_LOCAL_DEBUG vxdisk path | grep -E -v "($sysdiskList)[ ]+"`"
    if [ -n "$resCont" ]; then
        pathCont="`echo -e "$resCont" | sed 1d | awk '{printf("DANAME:%s||INDEX:||SUBPATH:%s||STATE:%s\n", $2,$1,$5)}'`" 
        for diskIdx in `echo -e "$resCont" |  sed 1d | grep -v "ENABLED" | awk '{print $2}' | sort -u`  #`echo -e "$pathCont"`  
        do
            diskinfo="`echo -e "$pathCont" | grep -E "${diskIdx}\|\|"`"         
            pathNum=`echo -e "$diskinfo" | wc -l`
            pathIdxNum=1
            for pathIdx in `echo -e "$diskinfo"`
            do
                chkCont="CTRL ID:${G_LOCAL_NODE[0]}||`echo -e "$pathIdx" | sed "s/INDEX:/&"$pathIdxNum"/g"`"                
                WRITE_XML_ERROR 0 "patherr||$chkCont" 
                let errCount+=1 
                let pathIdxNum+=1
            done      
        done 
    fi 
    EXECUTE_LOCAL_DEBUG "/usr/bin/lsscsi -l" 1>/dev/null 2>&1
    [ "$errCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
}

# **************************************************************************** #
# Function Name: CHECK_LUN_STATUS
# Description: LUN״̬ 302
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_LUN_STATUS ( )
{    
    judgeValue=0
    errCount=0
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT 

    resCont="`EXECUTE_LOCAL_DEBUG vxdisk list | sed 1d | awk '{printf("%s,%s,%s", $1,$2,$4);\
            for(i=5;i<=NF;i++) printf(",%s",$i); printf("\n");}'`"

    #ȥϵͳϢ
    sysdiskList=`GET_SYSTEM_DISK`
    resCont="`echo "$resCont" | grep -v -E "($sysdiskList)[ ]+"`" 
   
    for lunIdx in `echo -e "$resCont"`
    do
        deviceName="${lunIdx%%,*}"
        groupName="`echo -e "$lunIdx" | awk -F\, '{print $3}'`"
        lunStatus="`echo -e "$lunIdx" | awk -F\, '{for(i=4;i<=NF;i++)printf("%s ", $i)}'`"
        chkCont="lunerr||CTRL ID:${G_LOCAL_NODE[0]}||DEVICE:$deviceName||GROUP:$groupName||STATUS:$lunStatus"
        
        lunErrFlag=0    #ʼΪ
        if [ -z "`echo -e "$lunIdx" | grep -E "(failed)|(failing)"`" ]; then            
            if [ -z "`echo -e "$lunIdx" | grep -E "(error)|(online,invalid)|(cdsdisk)|(opaque)"`" ]; then
                #(error)|(online invalid)|(cdsdisk)|(opaque)ΪCOMMON             
                resLunCont="`vxdisk list $deviceName`"
                if [ -n "$resLunCont" ]; then
                    #豸в
                    lunErrFlag=1
                    devName=`echo -e "$resLunCont" | grep -E "state=.*" | awk '{print $1}'`
                    for devIdx in `echo -e "$devName"`
                    do                        
                       /usr/bin/sg_turs /dev/${devIdx}
                       if [ $? -eq "0" ]; then
                          lunErrFlag=0
                          break
                       fi 
                    done           
                fi                
            fi
        else
            #(failed)|(failing)|(udid_mismatch)  ERROR
            lunErrFlag=1
        fi
        
        #֤xmlļ
        if [ "$lunErrFlag" -ne "0" ]; then
            let errCount+=1
            WRITE_XML_ERROR 0 "$chkCont"
        fi
           
    done 
    
    [ "$errCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
}

getdglines()
{
        local dg=$1
        local from=0
        local to=0
        local diff=0
        local lines=0
        from=`echo "$printinfor" |grep -n "^Disk group: "|grep -w "${dg}$" -A 1|head -1|awk -F: '{print $1}'`

        lines=`echo "$printinfor" |grep -n "^Disk group: "|grep -w "${dg}$" -A 1|wc -l`

        if [ "$lines" -eq "2" ];then
                to=`echo "$printinfor" |grep -n "^Disk group: "|grep -w "${dg}$" -A 1|tail -1|awk -F: '{print $1}'`
                let "diff=to-from-1"
        else
                to=`echo "$printinfor"|wc -l`
                let "diff=to-from+1"
        fi

        echo $diff
}

# **************************************************************************** #
# Function Name: CHECK_PLEX_STATUS
# Description: ϵͳҵPlex״̬ 303
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_PLEX_STATUS()
{
    errCount=0
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT 

    for dgIdx in `EXECUTE_LOCAL_DEBUG vxprint -G | awk '/^dg/ {print $2}'`
    do
        resCont="`EXECUTE_LOCAL_DEBUG vxprint -g $dgIdx -hvt | awk '/^pl/ {printf("NAME:%s||KSTATE:%s||STATE:%s\n", $2,$4,$5);}'`"
        for plIdx in $resCont
        do
            if [ -n "`echo "$plIdx" | grep -E "(IOFAIL)|(STALE)|(DETACHED)|(DISABLED)"`" ]; then
                #״̬ȷ
                WRITE_XML_ERROR 0 "plexerr||Ctrl ID:${G_LOCAL_NODE[0]}||DiskGroup:$dgIdx||$plIdx"
                let errCount+=1            
            fi
        done
    done

    #plexΪActiveӴΪRELOCATE״̬
    printinfor=`vxprint 2>/dev/null`
    relocate=`echo  "${vxprintHv}" | awk '{if( $7 == "RELOCATE" ) print $3}'`
    autoRecover=`ps -ef |grep -w "/usr/sbin/auto_recover"|grep -v grep`
    if [ -n "${autoRecover}" ] && [ -n "${relocate}" ] ;then
        WRITE_XML_COMMON 0 "Not ready to check relocate status."
		G_CUR_JUDGE_VALUE=0 
		return 0 
    fi
    for eachDg in `echo  "${printinfor}" | grep "^Disk group:" | awk -F": " '{print $2}'`
    do
        dgLine=`getdglines ${eachDg}`
        allVolInfo=`echo  "${printinfor}" |grep -w "^Disk group: ${eachDg}" -A ${dgLine}|sed -n '3,$'p`
        plexName=`echo  "${allVolInfo}" | awk '{if( $7 == "RELOCATE" ) print $3}'`
        if [ -z "${plexName}" ];then
            continue
        fi

        for eachPlex in `echo -e "${plexName}"`
        do
            volume=`echo  "${allVolInfo}" | awk '{if($1=="pl" && ($2=="'${eachPlex}'") && ($7=="ACTIVE")) print $2}'`
            if [ -n $"${volume}" ];then
                OS_ECHO "DiskGroup:$eachDg,PLEX:$eachPlex,STATE:RELOCATE"
                WRITE_XML_ERROR 0 "plexerr||Ctrl ID:${G_LOCAL_NODE[0]}||DiskGroup:$eachDg||NAME:$eachPlex||KSTATE:ENABLED||STATE:RELOCATE"
                let errCount+=1
            fi
        done
    done

    [ "$errCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
}

# **************************************************************************** #
# Function Name: CHECK_VOLUME_STATUS
# Description: ϵͳҵо״̬ 304
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_VOLUME_STATUS()
{
    errCount=0
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT 

    for dgIdx in `EXECUTE_LOCAL_DEBUG vxprint -G | awk '/^dg/ {print $2}'`
    do
        resCont="`EXECUTE_LOCAL_DEBUG vxprint -g $dgIdx -v | awk '/^v/ {printf("%s,%s,%s,%s,%s\n", $2,$3,$4,$7,$8);}'`"
       
        for volIdx in $resCont
        do
            volinfo=(`echo $volIdx | sed 's/\,/ /g'`)

            chkCont="volerr||CTRL ID:${G_LOCAL_NODE[0]}||DISKGROUP:$dgIdx||NAME:${volinfo[0]}||KSTATE:${volinfo[2]}||STATE:${volinfo[3]}||TUTIL0:${volinfo[4]}"
            errFlag=0
            if [ "${volinfo[1]}" != "gen" ]; then
                if [ "${volinfo[2]}" != "ENABLED" -o "${volinfo[3]}" != "ACTIVE" ]; then
                    if [ "${volinfo[3]}" != "INSTSNAPTMP" -a "${volinfo[4]}" != "SNAP_REFRESH" ]; then                    
                        errFlag=1
                    fi 
                fi
            fi
             
            if [ "$errFlag" -ne "0" ]; then
                #״̬ȷ
                WRITE_XML_ERROR 0 "$chkCont"
                let errCount+=1
            fi
        
        done
    done
    [ "$errCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
}

# **************************************************************************** #
# Function Name: CHECK_DISKGROUP_STATUS
# Description: ϵͳҵд״̬ 305
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_DISKGROUP_STATUS()
{
    errCount=0
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT 

    resCont="`EXECUTE_LOCAL_DEBUG vxdg list |sed 1d| awk '{printf("NAME:%s||STATE:%s\n", $1,$2);}'`"

    for dgIdx in $resCont
    do
        if [ -z "`echo "$dgIdx" | grep -E "enabled"`" ]; then
            #ûƥϣ״̬ȷ
            WRITE_XML_ERROR 0 "dgerr||CTRL ID:${G_LOCAL_NODE[0]}||$dgIdx"
            let errCount+=1
        fi
    done
    
    [ "$errCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
}

# **************************************************************************** #
# Function Name: CHECK_DISKGROUP_EXPORT_STATUS
# Description: 鵼״̬ 306
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_DISKGROUP_EXPORT_STATUS ( )
{
    errCount=0
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT 
 
    resCont="`EXECUTE_LOCAL_DEBUG vxdisk list -o alldgs | awk '/^[a-zA-Z0-9]/ {if (0 != index($4, "("))\
        {printf("DEVICE:%s||GROUP:%s||STATUS:%s", $1,$4,$5);if (NF > 5) printf(",%s",$6); printf("\n");}}'`"
    
    peer_cluster_dg="`awk -F";" '/^\[DGINFO\]/ {sub(/\[DGINFO\]/, "", $1); print $1}' /OSM/sf_config/clstsync.conf 2>/dev/null`"
    for lunIdx in `echo -e "$resCont"`
    do        
        dgname="`echo -e "$lunIdx" | grep -E -o "\(.*\)" | sed 's/[()]//g'`"
        if [[ -z "`echo -e "$dgname" | grep -E "(fendg)|(fencingdg_[0-9]+)"`" \
           && -z "`echo -e "$peer_cluster_dg" | grep -w "$dgname"`" ]]; then
            WRITE_XML_ERROR 0 "exportdgerr||CTRL ID:${G_LOCAL_NODE[0]}||$lunIdx"
            let errCount+=1 
        fi
    done 
    
    [ "$errCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
}

# **************************************************************************** #
# Function Name: CHECK_CTRL_LICENSE
# Description: ϵͳlicense 307 
# Parameter:
# Return:

# **************************************************************************** # 
CHECK_CTRL_LICENSE()
{
    errorCount=0

    #ַѲ
    EXECUTE_REMOTE_INSPECT 

    resCont=`/OSM/bin/script/auto_mml.sh sys lic | sed 's/\r//g'`
    if [ -n "$resCont" ]; then
        WRITE_XML_COMMON 0 "$resCont"
    fi
}


# **************************************************************************** #
# Function Name: CHECK_RLINK_STATUS
# Description: RLINK״̬ 309
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_RLINK_STATUS ( )
{
    errCount=0
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT

    for dgIdx in `vxprint -G | awk '/^dg/ {print $2}'`
    do
        resCont="`EXECUTE_LOCAL_DEBUG vxprint -P -g $dgIdx | awk '/^rl/ {printf("NAME:%s||KSTATE:%s||STATE:%s\n", $2,$4,$7);}'`"
        if [ -z "${resCont}" ];then
            continue
        fi
		
        l_protocol="`vxprint -Pl -g $dgIdx |grep "^protocol:" |awk '{print $2}'`"
        l_check_line="${resCont}||PROTOCOL:${l_protocol}"       

        if [ -z "`echo "$resCont" | grep -E "(CONNECT|ENABLED).*(ACTIVE|PAUSING|RESUMING)"`" ]; then     
			 WRITE_XML_ERROR 0 "rlinkerr||CTRL ID:${G_LOCAL_NODE[0]}||$l_check_line"
             let errCount+=1
        fi
        if [ -z "`echo "$l_check_line" | grep "TCP"`" ]; then                                            
             WRITE_XML_ERROR 0 "rlinkerr||CTRL ID:${G_LOCAL_NODE[0]}||$l_check_line"
            let errCount+=1
        fi

    done
	
    [ "$errCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1   
}

# **************************************************************************** #
# Function Name: CHECK_SRL_STATUS
# Description: SRL 310
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_SRL_STATUS ( )
{
    errCount=0
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT
 
    resCont="`EXECUTE_LOCAL_DEBUG vxprint -v | awk '/^v/ {if($6=="SRL") printf("NAME:%s||KSTATE:%s||STATE:%s\n", $2,$4,$7);}'`"

    for srlIdx in $resCont
    do
        if [ -z "`echo "$srlIdx" | grep -E "ENABLED.*ACTIVE"`" ]; then
            #ûƥϣ״̬ȷ
            WRITE_XML_ERROR 0 "srlerr||CTRL ID:${G_LOCAL_NODE[0]}||$srlIdx"
            let errCount+=1
        fi
    done
    
    [ "$errCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
}


# **************************************************************************** #
# Function Name: CHECK_VVRPARAMETER_STATUS
# Description: VVRƲ 311
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_VVRPARAMETER_STATUS ( )
{
    errCount=0
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT
  
    for rlIdx in `EXECUTE_LOCAL_DEBUG vxprint  | awk '/^rl/ {print $2}'`
    do
        EXECUTE_LOCAL_DEBUG vxprint -l $rlIdx 1>/dev/null 2>&1
    done
}

# **************************************************************************** #
# Function Name: CHECK_SF_PROCESS_STATUS
# Description: SF 312
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_SF_PROCESS_STATUS ( )
{
    errorCount=0

    sfprolist="(vxconfigd.*syslog)|(/OSM/bin/sf_agent)|(/opt/VRTSvcs/bin/had)|(/usr/lib/vxvm/bin/vxcached)"
    sfprolist_nocache="(vxconfigd.*syslog)|(/OSM/bin/sf_agent)|(/opt/VRTSvcs/bin/had)"
    #ַѲ
    EXECUTE_REMOTE_INSPECT   
    resCont_raw="`EXECUTE_LOCAL_DEBUG ps -efw`"
            
    if [ -n "$resCont_raw" ]; then
      
        #ûcache򲻼ý
        #vxprint -c |grep  -E "^sp"
        #ÿʱżǷ
        if [ -z "`echo "$resCont_raw" |grep /usr/lib/vxvm/bin/vxcached`"  -a  -n  "`EXECUTE_LOCAL_DEBUG vxprint -c |grep -E "^sp"`" ]
        then  
            resCont=`echo "$resCont_raw"|grep -E "$sfprolist"`
            sfproNum=`echo "$resCont"|grep -E -o "$sfprolist" | sort -u | wc -l`
            #4ͬĽ 
            [ "$sfproNum" -ne "4" ] && let errorCount+=1            
        else
            resCont=`echo "$resCont_raw"|grep -E "$sfprolist_nocache"`
            sfproNum=`echo "$resCont"|grep -E -o "$sfprolist_nocache" | sort -u | wc -l`
            #3ͬĽ
            [ "$sfproNum" -ne "3" ] &&  let errorCount+=1    
        fi
               
        prolist="`echo -e "$resCont" |grep -E -o "$sfprolist_nocache" | sort -u | \
            awk 'BEGIN{ORS=","}{print $0}'`"
        chkCont="proerr||CTRL ID:${G_LOCAL_NODE[0]}||PROCESS:${prolist}" 
        WRITE_XML_ERROR  0 $chkCont 
    else
        let errorCount+=1
    fi
        
    [ "$errorCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
}
                      
# **************************************************************************** #
# Function Name: CHECK_QUORUM_DISK_STATUS
# Description: ٲ 313
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_QUORUM_DISK_STATUS ( )
{
    errorCount=0
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT

    resCont="`EXECUTE_LOCAL_DEBUG vxappend shwfendsk`"

    diskNum=`echo -e "$resCont" | grep -E "cdsdisk[ ]+Normal" |wc -l`
    if [ "$diskNum" -ne "3" ]; then   
       errorCount=1 
    fi   
    
    #гǰڵٲ 
    echo -e "$resCont" |awk '{if(flag == 1) print $0; if($1=="DEVICE") flag=1;}' |\
    while read diskInfo
    do
        diskInfof=(`echo $diskInfo`)
        chkCont="querumerr||CTRL ID:${G_LOCAL_NODE[0]}||DEVICE:${diskInfof[0]}||TYPE:${diskInfof[1]}||STATUS:${diskInfof[2]}"
        if [ "$errorCount" -ne "0" ]; then
            WRITE_XML_ERROR 0 $chkCont                    
        fi
    done
    [ "$errorCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
}

# **************************************************************************** #
# Function Name: CHECK_SNAP_SYN_PRO_STATUS
# Description: ͬ 314
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_SNAP_SYN_PRO_STATUS ( )
{
    errCount=0
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT

    inspectSnapDIR=$G_INSPECT_DIR/snap      
    [ -d "$inspectSnapDIR" ] || mkdir -p $inspectSnapDIR
    progressScript=$inspectSnapDIR/vxismprocessms.sh

    
    #vvrsync dg002 rvg001 xxx.xxx.xx.xxx 10485760 5051648
    cp -af /usr/sbin/vxismprocessms.sh  $progressScript >/dev/null 2>&1
    chmod 777  $progressScript >/dev/null 2>&1
    sed -i "s#/tmp/#$inspectSnapDIR/#g;s#/etc/#$inspectSnapDIR/#g" $progressScript
    
    #Vx..صı׼Ҫһ
    WRITE_XML_COMMON 0 "$HOSTNAME:/OSM # /usr/sbin/vxismprocessms.sh\n`$progressScript`"
    
    rm -fr $inspectSnapDIR    
    [ "$errCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
}

# **************************************************************************** #
# Function Name: CHECK_VVR_SYN_PRO_STATUS
# Description: ⸴ͬ 315
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_VVR_SYN_PRO_STATUS ( )
{
    errCount=0
    inspectVVRDIR=$G_INSPECT_DIR/vvr
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT

    [ -d "$inspectVVRDIR" ] || mkdir -p $inspectVVRDIR
    vvrScript=$inspectVVRDIR/vxismprocessvvr.sh
    vvrScriptRes=$inspectVVRDIR/deal_showproc_vvr
    
    #vvrsync dg002 rvg001 xxx.xxx.xxx.xxx 10485760 5051648
    cp -af /usr/sbin/vxismprocessvvr.sh  $vvrScript >/dev/null 2>&1
    chmod 777  $vvrScript >/dev/null 2>&1
    sed -i "s#\${AGENTTMP}#$inspectVVRDIR/#g" $vvrScript

    WRITE_XML_COMMON 0 "$HOSTNAME:/OSM # /usr/sbin/vxismprocessvvr.sh\n`$vvrScript`" 
           
    rm -fr $inspectVVRDIR  >/dev/null 2>&1  
}

# **************************************************************************** #
# Function Name: CHECK_MIRROR_SYN_PRO_STATUS
# Description: ⾵ͬ 316
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_MIRROR_SYN_PRO_STATUS ( )
{
    errCount=0
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT

    inspectSnapDIR=$G_INSPECT_DIR/snap      
    [ -d "$inspectSnapDIR" ] || mkdir -p $inspectSnapDIR
    progressScript=$inspectSnapDIR/vxismprocessms.sh

    
    #vvrsync dg002 rvg001 xxx.xxx.xxx.xxx 10485760 5051648
    cp -af /usr/sbin/vxismprocessms.sh  $progressScript >/dev/null 2>&1
    chmod 777  $progressScript >/dev/null 2>&1
    sed -i "s#/tmp/#$inspectSnapDIR/#g;s#/etc/#$inspectSnapDIR/#g" $progressScript
    
    #Vx..صı׼Ҫһ
    WRITE_XML_COMMON 0 "$HOSTNAME:/OSM # /usr/sbin/vxismprocessms.sh\n`$progressScript`"
  
    rm -fr $inspectSnapDIR    
    [ "$errCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
}

# **************************************************************************** #
# Function Name: CHECK_SNAP_CACHE_SPACE_STATUS
# Description: Cacheռ 317
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_SNAP_CACHE_SPACE_STATUS ( )
{
    errorCount=0
    
    inspectSnapDIR=$G_INSPECT_DIR/snap
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT

    [ -d "$inspectSnapDIR" ] || mkdir -p $inspectSnapDIR
    vvrScript=$inspectSnapDIR/vxalarm_ccache.sh
    
    #vvrsync dg002 rvg001 xxx.xxx.xxx.xxx 10485760 5051648
    cp -af /usr/sbin/vxalarm_ccache.sh  $vvrScript >/dev/null 2>&1
    chmod 777  $vvrScript >/dev/null 2>&1
    sed -i " s#/tmp#$inspectSnapDIR#g; s#/etc#$inspectSnapDIR#g" $vvrScript
    
    #Vx..صı׼Ҫһ
    resCont=`$vvrScript 2>/dev/null`
    WRITE_XML_COMMON 0 "$HOSTNAME:/OSM # /usr/sbin/vxalarm_ccache.sh\n${resCont}" 
    resCont="`echo -e "$resCont" | grep -E "cachenm.*percent"`"

    #dg=Application001;cachenm=vol001-JBODEDACSAC;percent=4
    #percentֵ70ʱҪ
    resCont=`echo -e "$resCont"| sed -r 's/=/:/g; s/\;/\|\|/g'`
    for cacheIdx in `echo -e "$resCont"`
    do
        if [ "${cacheIdx##*:}" -ge "70" ];then
            let errorCount+=1
            WRITE_XML_ERROR 0 "cacheerr||Ctrl ID:${G_LOCAL_NODE[0]}||$cacheIdx"
        fi    
        
    done
    
    rm -fr $inspectSnapDIR
    [ "$errorCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
}

# **************************************************************************** #
# Function Name: CHECK_DCO_STATUS
# Description: DCO״̬ 318
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_DCO_STATUS ( )
{
    errorCount=0
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT
    
    for dgIdx in `EXECUTE_LOCAL_DEBUG vxprint -G | awk '/^dg/ {print $2}'`
    do 
        plexInfo="`vxprint -g $dgIdx -p`"
        for volInfo in `vxprint -g $dgIdx -v|awk '{if($3=="gen" || $3=="fsgen") printf("%s,%s\n", $2, $3)}'`
        do  
            volName=${volInfo%%,*}
            volType=${volInfo##*,}
            
            errFlag=0
            volDetail="`EXECUTE_LOCAL_DEBUG vxprint -g $dgIdx $volName`"
            if [ $volType == "gen" ]; then 
                resCont="`echo -e "$volDetail" | \
                    awk '/^v/ { if ( ($4!="ENABLED" || $7!="ACTIVE") && ($7!="INSTSNAPTMP") && ($8!="SNAP_REFRESH") ) print $2 }'`" 
                [ -n "$resCont" ] && errFlag=1
    
                resCont="`echo -e "$volDetail" | awk '/^pl/ {print $4,$7}'| \
                         grep -i -E "(DETACHED)|(DISABLED)|(IOFAIL)|(STALE)"`" 
                [ -n "$resCont" ] && errFlag=1

            else #DCO״̬ 2012-07-09 add
                volPlexNum="`echo -e "$plexInfo" | awk '{if ($3 == "'$volName'") print $3}' | wc -l`"
                if [ "$volPlexNum" -ne "1" ]; then
                   #DCOȡӦdcl,ַͨƴ
                   dcoName="`echo -e "$volDetail" | awk '/^dc/ {print $2}'`"                   
                   dclName="`EXECUTE_LOCAL_DEBUG vxprint -g $dgIdx -l $dcoName | awk '/^assoc.*log_vol/ {gsub(/^.*log_vol=/, "", $0); print $0}'`"                   
                 
                   if [[ -z "$dclName" || -z "`echo -e "$plexInfo"|awk '{if ($3 == "'$dclName'") print $3}'`" ]];then                      
                      errFlag=1
                   fi 
                fi 
            fi 
            
            [ "$errFlag" -ne "0" ] && let errorCount+=1

            echo -e "$volDetail" | grep -E "(^pl)|(^v)"| while read infoIdx
            do
                onevolinfo=(`echo $infoIdx`)
                chkCont="DISKGROUP:$dgIdx||NAME:${onevolinfo[1]}||ASSOC:${onevolinfo[2]}"

                if [ "$errFlag" -ne "0" ]; then
                    WRITE_XML_ERROR 0 "dcoerr||CTRL ID:${G_LOCAL_NODE[0]}||$chkCont"                    
                fi   
            done 
        done 
        
    done
    
    [ "$errorCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
}

# **************************************************************************** #
# Function Name: CHECK_DCM_STATUS
# Description: DCM״̬ 319
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_DCM_STATUS ( )
{
    errCount=0
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT


    for dgIdx in `EXECUTE_LOCAL_DEBUG vxprint -G | awk '/^dg/ {print $2}'`
    do        
        resCont="`EXECUTE_LOCAL_DEBUG vxprint -g $dgIdx -p | awk '/^pl/ {if ($5=="LOGONLY") printf("NAME:%s||ASSOC:%s||KSTATE:%s||STATE:%s\n", $2,$3,$4,$7);}'`"
        for plIdx in $resCont
        do
            if [ -n "`echo "$plIdx" | grep -E "(IOFAIL)|(STALE)|(DETACHED)|(DISABLED)"`" ]; then
                #״̬ȷ
                WRITE_XML_ERROR 0 "dcmerr||CTRL ID:${G_LOCAL_NODE[0]}||DiskGroup:$dgIdx||$plIdx"
                let errCount+=1
            fi
        done  
    done   
    
    [ "$errCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
}

# **************************************************************************** #
# Function Name: CHECK_RVG_STATUS
# Description: RVG״̬ 320
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_RVG_STATUS ( )
{
    errCount=0
    
    #ַѲ
    EXECUTE_REMOTE_INSPECT


    for dgIdx in `EXECUTE_LOCAL_DEBUG vxprint -G | awk '/^dg/ {print $2}'`
    do  
        #·ʱvxlistvolʮֺʱάͬ⣬ɾռϢ
        #EXECUTE_LOCAL_DEBUG vxlistvol $dgIdx 1>/dev/null 2>&1
        resCont="`EXECUTE_LOCAL_DEBUG vxprint -g $dgIdx -V | awk '/^rv/ {print $2}'`"
        for rvgIdx in $resCont
        do
            rvgCont="`EXECUTE_LOCAL_DEBUG vradmin -g $dgIdx -l repstatus $rvgIdx`"
            if [ -z "`echo "$rvgCont" | grep -E " RVG state:[ ]*enabled"`" ]; then
                #״̬ȷ
                WRITE_XML_ERROR 0 "rvgerr||CTRL ID:${G_LOCAL_NODE[0]}||DiskGroup:$dgIdx||Name:$rvgIdx"
                let errCount+=1
            fi
        done  
    done   
    
    [ "$errCount" -gt "0" ] && G_CUR_JUDGE_VALUE=1
}

# **************************************************************************** #
# Function Name: CHECK_SF_AFFAIR_INFO
# Description: SFҵ״̬
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_SF_AFFAIR_INFO()
{
    case "${1:1}" in
            
        "00")              # 00 CVM״̬
            CHECK_CVM_STATUS $1
            ;;
            
        "01")              # 01 DMP·״̬
            CHECK_DMP_STATUS $1            
            ;;
            
        "02")              # 02 LUN״̬
            CHECK_LUN_STATUS $1     
            ;;     
            
        "03")              # 03 Plex״̬
            CHECK_PLEX_STATUS $1
            ;;
                        
        "04")              # 04 Volume״̬
            CHECK_VOLUME_STATUS $1
            ;; 
                        
        "05")              # 05 DiskGroup״̬
            CHECK_DISKGROUP_STATUS $1
            ;;
            
        "06")              # 06 DiskGroup״̬
            CHECK_DISKGROUP_EXPORT_STATUS $1
            ;;            
            
        "07")              # 07 License״̬
            CHECK_CTRL_LICENSE $1
            ;;    

        "09")              # 09 RLINK״̬
            CHECK_RLINK_STATUS $1
            ;;            
                               
        "10")              # 10 SRL
            CHECK_SRL_STATUS $1
            ;;             
                                                     
        "11")              # 11 VVRƲ
            CHECK_VVRPARAMETER_STATUS $1
            ;;            

        "12")              # 12 SF
            CHECK_SF_PROCESS_STATUS $1
            ;;                        
           
          
        "13")              # 13 ٲ
            CHECK_QUORUM_DISK_STATUS $1
            ;;
                        
        "14")              # 14 ͬ
            CHECK_SNAP_SYN_PRO_STATUS $1
            ;;              
            
        "15")              # 15 ⸴ͬ
            CHECK_VVR_SYN_PRO_STATUS $1
            ;;
                        
        "16")              # 16 ⾵ͬ
            CHECK_MIRROR_SYN_PRO_STATUS $1
            ;;              
            
        "17")              # 17 Cacheռ
            CHECK_SNAP_CACHE_SPACE_STATUS $1
            ;;                    
           
        "18")              # 18 DCO״̬
            CHECK_DCO_STATUS $1
            ;;     
                    
        "19")              # 19 DCM״̬
            CHECK_DCM_STATUS $1
            ;; 

        "20")              # 20 RVG״̬
            CHECK_RVG_STATUS $1
            ;;             
                                                                                       
         *)
            echo "`basename $0` cmd is wrong $1" 
            ;;
    esac
}

#******************************************************************************#
#***************              澯Ϣ                  *******************#
#******************************************************************************#

# **************************************************************************** #
# Function Name: CHECK_CRITICAL_INFO
# Description: 澯Ϣ 400
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_CRITICAL_INFO ( )
{
    resCont=
    resCont="`FILTER_WARNING_INFO 0`"
    if [ -n "$resCont" ]; then
        G_CUR_JUDGE_VALUE=1
        WRITE_XML_COMMON 0 "$resCont"        
    fi 
}

# **************************************************************************** #
# Function Name: CHECK_MAJOR_INFO
# Description: Ҫ澯Ϣ 401
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_MAJOR_INFO ( )
{    
    resCont=  
    resCont="`FILTER_WARNING_INFO 1`"
    if [ -n "$resCont" ]; then
        G_CUR_JUDGE_VALUE=1
        WRITE_XML_COMMON 0 "$resCont"        
    fi  
}

# **************************************************************************** #
# Function Name: CHECK_WARNING_INFO
# Description: ⾯漶澯Ϣ 402
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_WARNING_INFO ( )
{
    resCont=    
    resCont="`FILTER_WARNING_INFO 2`"
    if [ -n "$resCont" ]; then
        G_CUR_JUDGE_VALUE=1
        WRITE_XML_COMMON 0 "$resCont"        
    fi 
}

# **************************************************************************** #
# Function Name: FILTER_WARNING_INFO
# Description: ˳ûлָĸ澯Ϣ
# Parameter:    $1 澯 0 Critical, 1 Major, 2 Warning
# Return:
# **************************************************************************** # 
FILTER_WARNING_INFO ( )
{
    #Ѿļֱӷ
    G_ALARM_TMP_TAR_FILE="$G_CMD_OTHER"
    tar -xvf $G_ALARM_TMP_TAR_FILE -C $G_INSPECT_DIR >/dev/null 2>&1   
    rm -fr $G_ALARM_TMP_TAR_FILE >/dev/null 2>&1
    [ ! -f "$G_ALARM_TMP_TXT_FILE" ]  && return 1

    dos2unix $G_ALARM_TMP_TXT_FILE >/dev/null 2>&1
    filter_warning_info $1 $G_ALARM_TMP_TXT_FILE | sed -r 's/^|;[ ]+/\n/g' | \
      awk -F: '{if (NF > 1) {printf("%-16s", $1); sub(/[^:]+:/, "", $0); printf("%s\n", $0)} else printf("%16s%s\n", "", $0)}'
    rm -fr $G_ALARM_TMP_TXT_FILE >/dev/null 2>&1
}

# **************************************************************************** #
# Function Name: CHECK_ALARM_INFO
# Description: ϵͳ澯Ϣ
# Parameter:
# Return:
# **************************************************************************** # 
CHECK_ALARM_INFO()
{

    #澯
    case "${1:1}" in
        "00")              # 00 澯Ϣ
            CHECK_CRITICAL_INFO $1
            ;;

        "01")              # 01 Ҫ澯Ϣ
            CHECK_MAJOR_INFO $1
            ;;  
            
        "02")              # 02 ⾯漶澯Ϣ
            CHECK_WARNING_INFO $1
            ;;              
                                       
         *)
            echo "`basename $0` cmd is wrong $1" 
            ;;
    esac
}

# --------------------------  main  ------------------------------------------ #
#
#жǷSPC400ǰİ汾ǷҪĳЩ
CHECK_NEED_SKIP_MML

# 
# 1 ,Ӧһںִ
# 
while getopts ":c:d:i:o:x:" Option
do
    case $Option in
        x)
            OS_ECHO "vxinspect -x"
            /OSM/bin/script/os_distribute_file.sh /OSM/bin/script/os_data_collect.sh
            exit 0
            ;;
        c) # Ѳ
            G_CMD_LIST="$OPTARG"
            ;;
          
        d) # ļش·
            G_CMD_DST_DIR="$OPTARG"
            ;;  
            
        i) # ļشIP
            G_CMD_DST_IP="$OPTARG"
            ;;  

        o) # ѡ
            G_CMD_OTHER="$OPTARG"
            ;;                                                      
        *)             
            ;;
    esac
done

if [ -z "$G_CMD_LIST" ]; then
    #
    echo "error, you must input -c "
    exit 1
fi

if [ -n "$G_CMD_DST_IP" -o -n "$G_CMD_DST_DIR"  ]; then
    #ͬʱ,޷شļ
    if [ -n "$G_CMD_DST_IP" -a -n "$G_CMD_DST_DIR"  ]; then
        G_NEED_COLLECT_DATA=2
    else
        echo "error, you must input -i -d option"
        exit 1
    fi
fi

# 
# ɾеʱļ
#
[ -f "$G_CHECK_RESULT_FILE" ] && rm -f $G_CHECK_RESULT_FILE
#֤űֻһʵ,120Σÿμ5ӣܹʱ6
lockfile -5 -r 120 $G_INSPECT_LCK_FILE

# 
# ȡǰȺеĽڵ㣬ڵб
#
G_NODE_LIST="`auto_mml.sh sys admin | grep -E "^[0-9][ ]+[0-9]" | awk 'BEGIN{OFS=":"}{print $1,$3,$4}'`"
G_LOCAL_NODE=(`echo -e "$G_NODE_LIST" | grep -E "^${HOSTNAME##*_}:" | sed 's/:/ /g'`)

#
# ȡƷͺ VIS
#
G_PRODUCT_TYPE="VIS"



[ "$G_NEED_COLLECT_DATA" != "2" ] && WRITE_XML_HEADER 



for cmdIdx in ${G_CMD_LIST//,/ }
do
    #XMLͷϢ
    if [ "$G_NEED_COLLECT_DATA" != "2" ]; then
        WRITE_XML_CMD_HEADER $cmdIdx
        WRITE_XML_SUBCMD_HEADER 0
    fi
    
    case "$cmdIdx" in 
        900)
            CHECK_PREPARE
            ;;
                        
        901) 
            CHECK_POST
            ;;
                              
        1*)
            CHECK_SYSTEM_INFO $cmdIdx
            ;;
            
        2*)
            CHECK_BASIC_AFFAIR_INFO $cmdIdx
            ;;
            
        3*)
            CHECK_SF_AFFAIR_INFO $cmdIdx
            ;;
            
        4*)
            CHECK_ALARM_INFO $cmdIdx
            ;;
            
        *)
            echo "`basename $0` cmd is wrong $2" 
            ;;
    esac

    #зַȥҪнڵִн

    if [ "$G_NEED_COLLECT_DATA" == "2" ]; then
        #ҪشϢڵ
        RETURN_INSPECT_RESULT
    else
        if [ "$G_NEED_COLLECT_DATA" == "1" ]; then
            #ҪѼشϢ
            COLLECT_INSPECT_RESULT
        fi
        #XMLβϢ
        WRITE_XML_JUDGE $G_CUR_JUDGE_VALUE
        WRITE_XML_SUBCMD_TAIL   
        WRITE_XML_CMD_TAIL 

    fi     
done

if [ "$G_NEED_COLLECT_DATA" != "2" ]; then
    WRITE_XML_TAIL 
    
    #ļ900K=921600ϴ쳣
    filesize="`du -ab $G_CHECK_RESULT_FILE | awk '{print $1}'`"
    if [[ -n "$filesize" && $filesize -gt 921600 ]]; then
        FILE_TOO_BIG_RESULT
    fi
    cat -v $G_CHECK_RESULT_FILE    
fi

rm -fr $G_INSPECT_LCK_FILE 
