package com.sitech.ismp.check;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Locale;
import java.util.StringTokenizer;
import java.util.Vector;

import org.apache.log4j.Logger;

import com.sitech.ismp.app.coll.RPCTarget;
import com.sitech.ismp.coll.CollBase;
import com.sitech.util.Formater;

public class CheckAIXWithCMD {

    private Logger logger = Logger.getLogger("COLL");

    String PRE_UNITID = "10-20-20"; // aix主机的标识

    RPCTarget rpctarget = null;

    String neat_host_name = "";

    SimpleDateFormat sim = new SimpleDateFormat("MMddHHmmyy");

    String curdate = sim.format(new Date());

    /**
     * 智能巡检错误日志背板冗余模块 包含：rootvg的两块镜像盘hdisk0、hdisk1应该连接到不同的scsi控制器
     */
    public Vector getBackboard(HashMap params) {

        try {
            logger.info("Begin getBackboard");
            init();

            CollBase collResult = new CollBase();

            String backboard_PRE_UNITID = PRE_UNITID + "-01";

            // rootvg的两块镜像盘hdisk0、hdisk1应该连接到不同的scsi控制器
            if (params.get("PM-20-20-001-01") != null
                    && params.get("PM-20-20-001-01").equals("1")) {
                Vector hdiskV = rpctarget
                        .getKPISet("lsdev -C|grep SCSI|awk '{if($1==\"hdisk0\" || $1==\"hdisk1\") print $3}'");
                String isSame = "";
                if (hdiskV.size() >= 2) {
                    String disk0_scsi = (String) hdiskV.elementAt(0);
                    String disk1_scsi = (String) hdiskV.elementAt(1);
                    if (disk0_scsi.equals(disk1_scsi)) {
                        isSame = "hdisk0-->" + disk0_scsi + ",hdisk1-->"
                                + disk1_scsi;
                    } else {
                        isSame = "Y";
                    }
                }
                collResult.addKPI(backboard_PRE_UNITID + ":" + neat_host_name
                        + "-backboard", "PM-20-20-001-01", isSame);
            }
            return collResult.getKPISet();
        } catch (Exception e) {
            logger.error("getBackboard err!!", e);
            e.printStackTrace();
        }
        return null;

    }

	/*
	 * 智能巡检错误日志模块 包含：错误日志中是否有硬件错误，错误日志中是否有 CORE_DUMP 的相关故障记录，错误日志中是否有DELAYED_INT
	 * 相关的故障记录
	 */

    public Vector getErrpt(HashMap params) {

        try {
            logger.info("Begin getErrpt");
            init();

            CollBase collResult = new CollBase();

            String errpt_PRE_UNITID = PRE_UNITID + "-02";

            // 是否有硬件错误 错误日志太多采集不到
            // 2010-10-27 modify by linxc
            // 改为采集错误日志个数
            if (params.get("PM-20-20-001-03") != null
                    && params.get("PM-20-20-001-03").equals("1")) {
                String harderror = rpctarget.getKPIValue(
                        "errpt -d H|grep " + curdate.substring(0, 4) + "...."
                                + curdate.substring(8, 10)
                                + "|sort -u|sed -n '2,$p' | wc -l").trim();
                if (harderror.equals("0"))
                    harderror = "NONE";
                collResult.addKPI(errpt_PRE_UNITID + ":" + neat_host_name
                        + "-errpt", "PM-20-20-001-03", harderror);
            }

            // CORE_DUMP的相关故障记录个数
            if (params.get("PM-20-20-001-04") != null
                    && params.get("PM-20-20-001-04").equals("1")) {
                String coredumpverror = rpctarget
                        .getKPIValue(
                                "errpt | grep CORE|grep "
                                        + curdate.substring(0, 4) + "...."
                                        + curdate.substring(8, 10) + "| wc -l")
                        .trim();
                if (coredumpverror.equals("0"))
                    coredumpverror = "NONE";
                collResult.addKPI(errpt_PRE_UNITID + ":" + neat_host_name
                        + "-errpt", "PM-20-20-001-04", coredumpverror);
            }

            // DELAYED_INT相关的故障记录个数
            if (params.get("PM-20-20-001-05") != null
                    && params.get("PM-20-20-001-05").equals("1")) {
                String delayedinterror = rpctarget.getKPIValue(
                        "errpt | grep DELAYED_INT|grep "
                                + curdate.substring(0, 4) + "...."
                                + curdate.substring(8, 10) + "| wc -l").trim();
                if (delayedinterror.equals("0"))
                    delayedinterror = "NONE";
                collResult.addKPI(errpt_PRE_UNITID + ":" + neat_host_name
                        + "-errpt", "PM-20-20-001-05", delayedinterror);
            }

            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;

    }

	/*
	 * 智能巡检文件系统模块 文件系统、inode使用率是否接近阀值,是否有应该mount，但未mount的文件系统
	 */

    public Vector getFilesys(HashMap params) {
        try {
            logger.info("Begin getFilesys");
            init();

            CollBase collResult = new CollBase();

            String fileSys_PRE_UNITID = PRE_UNITID + "-03";

            // 使用率超过阀值的文件系统
            if (params.get("PM-20-20-001-06") != null
                    && params.get("PM-20-20-001-06").equals("1")) {
                Vector harderror = rpctarget.getKPISet("df -g");
                // 使用率超过阀值的文件系统清单
                String fileSysList = "";
                // 文件系统使用率阀值
                int filesys_used = 85;
                if (params.get("FILESYS_USED") != null
                        && !"".equals(params.get("FILESYS_USED"))) {
                    filesys_used = Integer.parseInt((String) params
                            .get("FILESYS_USED"));
                }

                String fileSysName = "";
                int percent = 0;
                for (int i = 1; i < harderror.size(); i++) {
                    String fileSys = (String) harderror.get(i);
                    fileSysName = split(fileSys, 6).trim();
                    String percentStr = split(fileSys, 3).trim();
                    if (percentStr.equals("-")) {
                        continue;
                    }
                    percent = new Integer(subString(percentStr)).intValue();

                    if (percent > filesys_used) {
                        fileSysList += fileSysName + ":" + percentStr + ",";
                    }
                }

                if (fileSysList.equals("")) {
                    fileSysList = "NONE";
                } else {
                    fileSysList = subString(fileSysList);
                }
                // KPI值太大则截取
                if (fileSysList.length() > 254) {
                    fileSysList = fileSysList.substring(0, 250) + "...";
                }
                collResult.addKPI(fileSys_PRE_UNITID + ":" + neat_host_name
                        + "-filesys", "PM-20-20-001-06", fileSysList);
            }

            // inode使用率超过阀值的文件系统
            if (params.get("PM-20-20-001-02") != null
                    && params.get("PM-20-20-001-02").equals("1")) {
                Vector harderror = rpctarget.getKPISet("df -g");
                // inode使用率超过阀值的文件系统清单
                String fileSysList = "";
                // inode使用率阀值
                int inode_used = 50;
                if (params.get("INODE_USED") != null
                        && !"".equals(params.get("INODE_USED"))) {
                    inode_used = Integer.parseInt((String) params
                            .get("INODE_USED"));
                }

                String fileSysName = "";
                int percent = 0;
                for (int i = 1; i < harderror.size(); i++) {
                    String fileSys = (String) harderror.get(i);
                    fileSysName = split(fileSys, 6).trim();
                    String percentStr = split(fileSys, 5).trim();
                    if (percentStr.equals("-")) {
                        continue;
                    }
                    percent = new Integer(subString(percentStr)).intValue();
                    if (percent > inode_used) {
                        fileSysList += fileSysName + ":" + percentStr + ",";
                    }
                }

                if (fileSysList.equals("")) {
                    fileSysList = "NONE";
                } else {
                    fileSysList = subString(fileSysList);
                }
                // KPI值太大则截取
                if (fileSysList.length() > 254) {
                    fileSysList = fileSysList.substring(0, 250) + "...";
                }
                collResult.addKPI(fileSys_PRE_UNITID + ":" + neat_host_name
                        + "-filesys", "PM-20-20-001-02", fileSysList);
            }

            // closed状态的lv
            if (params.get("PM-20-20-001-07") != null
                    && params.get("PM-20-20-001-07").equals("1")) {
                String closeLvList = "";
                Vector vglist = rpctarget.getKPISet("lsvg");
                Vector lvlist = new Vector();
                for (int i = 0; i < vglist.size(); i++) {
                    String vgname = (String) vglist.elementAt(i);
                    lvlist = rpctarget.getKPISet("lsvg -l " + vgname
                            + " | grep closed | awk '{print $1}'");
                    for (int j = 0; j < lvlist.size(); j++) {
                        String lvinfo = (String) lvlist.elementAt(j);
                        closeLvList += lvinfo.trim() + ",";
                    }
                    lvlist.clear();
                }
                if (closeLvList.length() == 0)
                    closeLvList = "NONE";
                else
                    closeLvList = subString(closeLvList);
                collResult.addKPI(fileSys_PRE_UNITID + ":" + neat_host_name
                        + "-filesys", "PM-20-20-001-07", closeLvList);
            }
            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

	/*
	 * 智能巡检进程模块 包含：进程总数，是否有僵尸进程，是否有父进程为1的非root用户进程存在
	 */

    public Vector getProcess(HashMap params) {

        try {
            logger.info("Begin getProcess");
            init();

            CollBase collResult = new CollBase();

            String process_PRE_UNITID = PRE_UNITID + "-04";

            // root进程总数
            if (params.get("PM-20-20-001-08") != null
                    && params.get("PM-20-20-001-08").equals("1")) {
                Vector totalprocessV = rpctarget
                        .getKPISet("ps -ef | grep root |wc -l");
                String totalprocess = (String) totalprocessV.elementAt(0);
                collResult.addKPI(process_PRE_UNITID + ":" + neat_host_name
                        + "-process", "PM-20-20-001-08", totalprocess.trim());
            }

            // 是否有僵尸进程
            if (params.get("PM-20-20-001-09") != null
                    && params.get("PM-20-20-001-09").equals("1")) {
                Vector zombieprocessV = rpctarget
                        .getKPISet("ps -ef | grep defunct | grep -v grep | wc -l");
                String zombieprocess = (String) zombieprocessV.elementAt(0);
                collResult.addKPI(process_PRE_UNITID + ":" + neat_host_name
                        + "-process", "PM-20-20-001-09", zombieprocess.trim());
            }

            // 是否有父进程为1的非root用户进程存在
            if (params.get("PM-20-20-001-10") != null
                    && params.get("PM-20-20-001-10").equals("1")) {
                Vector fatherprocessis1V = rpctarget
                        .getKPISet("ps -ef|grep -v root|grep -v grep |awk '{if ($3==1) print}'|wc -l");
                String fatherprocessis1 = (String) fatherprocessis1V
                        .elementAt(0);
                collResult.addKPI(process_PRE_UNITID + ":" + neat_host_name
                        + "-process", "PM-20-20-001-10", fatherprocessis1
                        .trim());
            }

            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;

    }

    /*
     * 智能巡检内核模块 包含：系统运行哪种内核环境下
     */
    public Vector getKernel(HashMap params) {

        try {
            logger.info("Begin getKernel");
            init();

            CollBase collResult = new CollBase();

            String kernel_PRE_UNITID = PRE_UNITID + "-05:" + neat_host_name
                    + "-kernel";

            // 系统运行哪种内核环境下
            if (params.get("PM-20-20-001-11") != null
                    && params.get("PM-20-20-001-11").equals("1")) {
                Vector whichkernelV = rpctarget.getKPISet("bootinfo -K");
                String whichkernel = (String) whichkernelV.elementAt(0);
                collResult.addKPI(kernel_PRE_UNITID, "PM-20-20-001-11",
                        whichkernel.trim());
            }

            // unix文件是否连接到正确的image文件
            if (params.get("PM-20-20-001-12") != null
                    && params.get("PM-20-20-001-12").equals("1")) {
                Vector imageV = rpctarget
                        .getKPISet("ls -l /unix|awk '{print $11}'");
                String image = (String) imageV.elementAt(0);
                collResult.addKPI(kernel_PRE_UNITID, "PM-20-20-001-12", image
                        .trim());
            }

            // 在boot image 被修改以后，是否AIX 重新启动过
            if (params.get("PM-20-20-001-14") != null
                    && params.get("PM-20-20-001-14").equals("1")) {
                String isRestart = "N";
                String updays = rpctarget
                        .getKPIValue("uptime|awk '{print $3}'").trim();
                String boottime = rpctarget.getKPIValue(
                        "ls -l /unix|awk '{print $6\" \"$7\" \"$8}'").trim();
                SimpleDateFormat dateFormat = new SimpleDateFormat(
                        "MMM dd yyyy", Locale.ENGLISH);
                long imageChangeDays = (new Date().getTime() - dateFormat
                        .parse(boottime).getTime())
                        / (24 * 60 * 60 * 1000);
                if (imageChangeDays >= Long.parseLong(updays)) {
                    isRestart = "Y";
                }
                collResult.addKPI(kernel_PRE_UNITID, "PM-20-20-001-14",
                        isRestart);
            }

            // 检查镜像盘的镜像文件
            if (params.get("PM-20-20-001-15") != null
                    && params.get("PM-20-20-001-15").equals("1")) {
                String str = "";
                Vector result = rpctarget
                        .getKPISet("cat /home/maint/errpt/bootlist.log");
                if (result != null && result.size() > 0) {
                    for (int i = 0; i < result.size(); i++) {
                        str += ((String) result.get(i)).trim() + "#";
                    }
                } else {
                    str = "无/home/maint/errpt/bootlist.log文件";
                }
                if (str.endsWith("#")) {
                    str = subString(str);
                }

                collResult.addKPI(kernel_PRE_UNITID, "PM-20-20-001-15", str);
            }

            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 智能巡检安装模块 包含：主机Firmware Version微码版本、XCOFF 文件是否和SWVPD保持一致、 /, /usr,
     * /usr/share 是否一致
     */
    public Vector getInstall(HashMap params) {
        try {
            logger.info("Begin getInstalll");
            init();
            CollBase collResult = new CollBase();

            // 主机微码版本 prtconf | grep -i 'Firmware Version' |awk -F ':' '{print
            // $2}'
            if (params.get("PM-20-20-001-16") != null
                    && params.get("PM-20-20-001-16").equals("1")) {
                String install_PRE_UNITID = PRE_UNITID + "-06:"
                        + neat_host_name + "-install";
                String fireware = rpctarget
                        .getKPIValue(
                                "lsmcode|grep 'temporary system firmware'|awk '{print$8}'")
                        .trim();
                collResult.addKPI(install_PRE_UNITID, "PM-20-20-001-16",
                        fireware);
            }

            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 智能巡检Dumps模块 包含：dump 设备是否足够大,dump 数据压缩选项状态,系统是否可以通过强制方式产生dump 文件
     */
    public Vector getDumps(HashMap params) {

        try {
            logger.info("Begin getDumps");
            init();

            CollBase collResult = new CollBase();

            String dumps_PRE_UNITID = PRE_UNITID + "-07";

            // dump设备空间是否大于内存大小
            if (params.get("PM-20-20-001-19") != null
                    && params.get("PM-20-20-001-19").equals("1")) {
                Vector dumpssizeV = rpctarget
                        .getKPISet("sysdumpdev -e|awk -F':' '{print $2}'"); // dump
                String dumpssize = (String) dumpssizeV.elementAt(0);
                float dums_size = Float.parseFloat(dumpssize) / 1024 / 1024;

                Vector mem_num = rpctarget
                        .getKPISet("prtconf |grep 'Good Memory Size:'");
                String mem = (String) mem_num.elementAt(0);
                collResult.addKPI(dumps_PRE_UNITID + ":" + neat_host_name
                        + "-dumps", "PM-20-20-001-19", "dump大小："
                        + String.valueOf(dums_size) + ",内存大小：" + split(mem, 3));
            }

            // dump数据压缩选项状态
            if (params.get("PM-20-20-001-20") != null
                    && params.get("PM-20-20-001-20").equals("1")) {
                Vector stateV = rpctarget
                        .getKPISet("sysdumpdev -l|grep 'dump compression'|awk '{print $3}'");
                String state = (String) stateV.elementAt(0);
                collResult.addKPI(dumps_PRE_UNITID + ":" + neat_host_name
                        + "-dumps", "PM-20-20-001-20", state.trim());
            }

            // 系统是否可以通过强制方式产生dump文件
            if (params.get("PM-20-20-001-21") != null
                    && params.get("PM-20-20-001-21").equals("1")) {
                Vector forcedumpsV = rpctarget
                        .getKPISet("sysdumpdev -l|grep 'forced copy flag'|awk '{print $4}'");
                String forcedumps = (String) forcedumpsV.elementAt(0);
                collResult.addKPI(dumps_PRE_UNITID + ":" + neat_host_name
                        + "-dumps", "PM-20-20-001-21", forcedumps.trim());
            }

            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;

    }

    /*
     * 智能巡检交换空间模块 包含：交换空间使用率，错误日志中是否有 PGSP相关的错误记录
     */
    public Vector getInterspace(HashMap params) {

        try {
            logger.info("Begin getInterspace");
            init();

            CollBase collResult = new CollBase();

            String interspace_PRE_UNITID = PRE_UNITID + "-08";

            // 交换空间使用率
            if (params.get("PM-20-20-001-22") != null
                    && params.get("PM-20-20-001-22").equals("1")) {
                Vector interspaceusedV = rpctarget
                        .getKPISet("lsps -s|tail -n 1|awk '{print $2}'");
                String interspaceused = (String) interspaceusedV.elementAt(0);
                collResult.addKPI(interspace_PRE_UNITID + ":" + neat_host_name
                                + "-interspace", "PM-20-20-001-22",
                        subString(interspaceused.trim()));
            }

            // 错误日志中是否有PGSP相关的错误记录
            if (params.get("PM-20-20-001-23") != null
                    && params.get("PM-20-20-001-23").equals("1")) {
                String pagspaceerror = rpctarget
                        .getKPIValue("errpt | grep -i pagspace | grep "
                                + curdate.substring(0, 4) + "...."
                                + curdate.substring(8, 10) + "|grep -v grep");
                if (pagspaceerror.equals(""))
                    pagspaceerror = "NONE";
                collResult.addKPI(interspace_PRE_UNITID + ":" + neat_host_name
                        + "-interspace", "PM-20-20-001-23", pagspaceerror
                        .trim());
            }

            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;

    }

    /*
     * 智能巡检网络模块 包含：SRC Master 进程是否运行,网络是否有传输错误,loopback/localhost 是否可以解析
     */
    public Vector getNetwork(HashMap params) {

        try {
            logger.info("Begin getNetwork");
            init();

            CollBase collResult = new CollBase();

            String network_PRE_UNITID = PRE_UNITID + "-09:" + neat_host_name
                    + "-network";

            // SRCMster进程是否运行
            if (params.get("PM-20-20-001-27") != null
                    && params.get("PM-20-20-001-27").equals("1")) {
                Vector srcprocessV = rpctarget
                        .getKPISet("ps -ef|grep -i /usr/sbin/srcmster|grep -v grep|wc -l");
                String srcprocess = ((String) srcprocessV.elementAt(0)).trim();

                String srcupornot = "up";
                if (srcprocess.equals("0"))
                    srcupornot = "down";
                else
                    srcupornot = "up";
                collResult.addKPI(network_PRE_UNITID, "PM-20-20-001-27",
                        srcupornot);
            }

            // 网卡工作模式
            String netcard = rpctarget
                    .getKPIValue("lsattr -El ent0|grep media_speed");
            if (params.get("PM-20-20-001-24") != null
                    && params.get("PM-20-20-001-24").equals("1")) {
                String card_mode = split(netcard, 1).trim();
                collResult.addKPI(network_PRE_UNITID, "PM-20-20-001-24",
                        card_mode);
            }

            // 网卡当前速率
            if (params.get("PM-20-20-001-25") != null
                    && params.get("PM-20-20-001-25").equals("1")) {
                String card_speed = split(netcard, 2).toLowerCase().trim();
                if (card_speed.indexOf("media") > -1)
                    card_speed = "--";
                collResult.addKPI(network_PRE_UNITID, "PM-20-20-001-25",
                        card_speed);
            }

            // 缺省网关是否能ping通
            if (params.get("PM-20-20-001-26") != null
                    && params.get("PM-20-20-001-26").equals("1")) {
                String gateway = rpctarget.getKPIValue(
                        "netstat -rn | grep default|awk '{print $2}'").trim();
                String pinggateway = rpctarget
                        .getKPIValue(
                                "ping -c 3 " + gateway
                                        + " |grep loss|awk '{print $7}'")
                        .trim();
                String pinggatewayornot = "Y";
                if (pinggateway.equals("0%"))
                    pinggatewayornot = "Y";
                else
                    pinggatewayornot = "N";
                collResult.addKPI(network_PRE_UNITID, "PM-20-20-001-26",
                        pinggatewayornot);
            }

            // 网络是否有传输错误(次数)
            if (params.get("PM-20-20-001-28") != null
                    && params.get("PM-20-20-001-28").equals("1")) {
                String errorsum = rpctarget
                        .getKPIValue1("netstat -ni|grep -v Name|awk '{if($(NF-1)>1000) print $1\":\"$(NF-1)}'");
                if (errorsum.trim().length() == 0)
                    errorsum = "N";
                collResult.addKPI(network_PRE_UNITID, "PM-20-20-001-28",
                        errorsum);
            }

            // localhost是否可以解析
            if (params.get("PM-20-20-001-29") != null
                    && params.get("PM-20-20-001-29").equals("1")) {
                Vector pinglocalhostV = rpctarget
                        .getKPISet("ping -c 3 localhost|grep loss|awk '{print $7}'");
                String pinglocalhost = ((String) pinglocalhostV.elementAt(0))
                        .trim();
                String pinghostornot = "Y";
                if (pinglocalhost.equals("0%"))
                    pinghostornot = "Y";
                else
                    pinghostornot = "N";
                collResult.addKPI(network_PRE_UNITID, "PM-20-20-001-29",
                        pinghostornot);
            }

            // 收集网络连接总数、各种状态的连接数量
            if (params.get("PM-20-20-001-30") != null
                    && params.get("PM-20-20-001-30").equals("1")) {
                String listencount = rpctarget.getKPIValue(
                        "netstat -an|grep 'LISTEN'|wc -l").trim();
                String estcount = rpctarget.getKPIValue(
                        "netstat -an|grep 'ESTABLISHED'|wc -l").trim();
                String waitcount = rpctarget.getKPIValue(
                        "netstat -an|grep 'TIME_WAIT'|wc -l").trim();
                String closecount = rpctarget.getKPIValue(
                        "netstat -an|grep 'CLOSE_WAIT'|wc -l").trim();
                collResult.addKPI(network_PRE_UNITID, "PM-20-20-001-30",
                        "LISTEN:" + listencount + "#" + "ESTABLISHED:"
                                + estcount + "#" + "TIME_WAIT:" + waitcount
                                + "#" + "CLOSE_WAIT:" + closecount);
            }

            // 网络端口队列监控
            if (params.get("PM-20-20-001-31") != null
                    && params.get("PM-20-20-001-31").equals("1")) {
                String netqueue = rpctarget
                        .getKPIValue(
                                "netstat -n | grep -E 'tcp|udp'|awk '{if($2!=0 || $3!=0) print}'|wc -l")
                        .trim();
                collResult.addKPI(network_PRE_UNITID, "PM-20-20-001-31",
                        netqueue);
            }

            // hostname是否可以解析
            if (params.get("PM-20-20-001-32") != null
                    && params.get("PM-20-20-001-32").equals("1")) {
                Vector hostnameV = rpctarget.getKPISet("hostname");

                String hostname = (String) hostnameV.elementAt(0);

                Vector pinghostnameV = rpctarget.getKPISet("  " + hostname
                        + " |grep loss|awk '{print $7}'");
                String pinghostname = ((String) pinghostnameV.elementAt(0))
                        .trim();

                String pinghostnameornot = "Y";
                if (pinghostname.equals("0%"))
                    pinghostnameornot = "Y";
                else
                    pinghostnameornot = "N";
                collResult.addKPI(network_PRE_UNITID, "PM-20-20-001-32",
                        pinghostnameornot);
            }

            return collResult.getKPISet();

        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 智能巡检Rootvg模块 包含：RootVG 是否被正确地镜像、rootvg 的启动顺序、rootvg剩余空间检查、是否有stale的pp存在
     */
    public Vector getRootvg(HashMap params) {
        try {
            logger.info("Begin getRootvg");
            init();
            String rootvg_PRE_UNITID = PRE_UNITID + "-10:" + neat_host_name
                    + "-rootvg";
            CollBase collResult = new CollBase();

            // rootvg是否被正确镜像
            if (params.get("PM-20-20-001-34") != null
                    && params.get("PM-20-20-001-34").equals("1")) {
                // String QUORUM = rpctarget.getKPIValue("lsvg rootvg|grep
                // QUORUM|awk -F \":\" '{print $3}'").trim();
                String lvNames = rpctarget
                        .getKPIValue1("lsvg -l rootvg | grep -v \"LV NAME\" |grep -v \"rootvg:\"|grep -v \"sysdump\"|awk '{if($4!=$3*2) print $1}'");

                if (lvNames.equals("")) {
                    lvNames = "Y";
                }
                collResult
                        .addKPI(rootvg_PRE_UNITID, "PM-20-20-001-34", lvNames);
            }

            // rootvg启动顺序
            if (params.get("PM-20-20-001-35") != null
                    && params.get("PM-20-20-001-35").equals("1")) {
                Vector startorderV = rpctarget
                        .getKPISet("bootlist -m normal -o|awk '{print $1}'");
                String startorder = "";
                for (int i = 0; i < startorderV.size(); i++) {
                    startorder += (String) startorderV.elementAt(i) + "->";
                }
                if (startorder.endsWith("->"))
                    startorder = startorder.substring(0,
                            startorder.length() - 2);
                collResult.addKPI(rootvg_PRE_UNITID, "PM-20-20-001-35",
                        startorder);
            }

            // rootvg剩余空间 单位：G
            if (params.get("PM-20-20-001-36") != null
                    && params.get("PM-20-20-001-36").equals("1")) {
                String freeroot = rpctarget
                        .getKPIValue(
                                "lsvg rootvg|grep -i free|awk -F \"(\" '{print $2}'|awk '{print $1}'")
                        .trim();
                float free_root = Float.parseFloat(freeroot) * 1000000 / 1024
                        / 1024 / 1024;
                collResult.addKPI(rootvg_PRE_UNITID, "PM-20-20-001-36", String
                        .valueOf(free_root));
            }

            // rootvg的磁盘状态是否有非active的
            if (params.get("PM-20-20-001-37") != null
                    && params.get("PM-20-20-001-37").equals("1")) {
                Vector diskList = rpctarget
                        .getKPISet("lsvg -p rootvg|sed -n '3,$p'");
                String disknames = "";
                for (int i = 0; i < diskList.size(); i++) {
                    String diskinfo = (String) diskList.elementAt(i);
                    String diskname = split(diskinfo, 0);
                    String diskstate = split(diskinfo, 1);
                    if (!diskstate.equals("active"))
                        disknames += diskname + ",";
                }
                if (disknames.length() > 0)
                    disknames = subString(disknames);
                else
                    disknames = "NONE";
                collResult.addKPI(rootvg_PRE_UNITID, "PM-20-20-001-37",
                        disknames);
            }

            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 智能巡检Fullcore模块 包含：fullcore 选项是否被激活
     */
    public Vector getFullcore(HashMap params) {
        try {
            logger.info("Begin getFullcore");
            init();
            CollBase collResult = new CollBase();
            String fullcore_PRE_UNITID = PRE_UNITID + "-11:" + neat_host_name
                    + "-fullcore";

            // fullcore是否处于激活状态
            if (params.get("PM-20-20-001-38") != null
                    && params.get("PM-20-20-001-38").equals("1")) {
                String fullinfo = rpctarget.getKPIValue(
                        "lsattr -El sys0|grep -i full|awk '{print $7}'").trim();
                collResult.addKPI(fullcore_PRE_UNITID, "PM-20-20-001-38",
                        fullinfo);
            }

            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 智能巡检资源限制模块 包含：用户限制是否被正确设置
     */
    public Vector getResastrict(HashMap params) {
        try {
            logger.info("Begin getResastrict");
            init();
            CollBase collResult = new CollBase();

            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 智能巡检hacmp模块 包含：clutils.log
     * 错误检查、hacmp.out（最新HA切换时间）、ha状态、hacmp调用启停脚本权限检查、是正确配置了存储相关的Configure Custom
     * Disk Methods
     */
    public Vector getHacmp(HashMap params) {
        try {
            logger.info("Begin getHacmp");
            init();
            CollBase collResult = new CollBase();
            String hacmp_PRE_UNITID = PRE_UNITID + "-13:" + neat_host_name
                    + "-hacmp";

            // /var/hacmp/log/clutils.log 错误检查
            if (params.get("PM-20-20-001-40") != null
                    && params.get("PM-20-20-001-40").equals("1")) {
                String curdate = new Date().toString().substring(0, 10);
                String errorlog = rpctarget
                        .getKPIValue("cat /var/hacmp/log/clutils.log|grep '"
                                + curdate
                                + "'|grep error|grep -v 'with 0 errors'");
                if (errorlog.equals("")) {
                    errorlog = "NONE";
                } else if (errorlog.length() > 254) {
                    errorlog = errorlog.substring(0, 250) + "...";
                }
                collResult
                        .addKPI(hacmp_PRE_UNITID, "PM-20-20-001-40", errorlog)
                        .trim();
            }

            // hacmp.out日志更新时间
            if (params.get("PM-20-20-001-41") != null
                    && params.get("PM-20-20-001-41").equals("1")) {
                String upgradetime = rpctarget
                        .getKPIValue(
                                "ls -l /tmp/hacmp.out|awk '{print $6 \" \" $7 \" \" $8}'")
                        .trim();
                if (upgradetime.trim().equals("")) {
                    upgradetime = "本主机不存在hacmp.out文件";
                }
                collResult.addKPI(hacmp_PRE_UNITID, "PM-20-20-001-41",
                        upgradetime).trim();
            }

            // ha状态
            if (params.get("PM-20-20-001-42") != null
                    && params.get("PM-20-20-001-42").equals("1")) {
                String hastatus = rpctarget
                        .getKPIValue("lsdev -C|grep tty|awk '{print $2}'");
                if (hastatus.trim().equals("")) {
                    hastatus = "该主机不存在ha设备";
                }
                collResult
                        .addKPI(hacmp_PRE_UNITID, "PM-20-20-001-42", hastatus)
                        .trim();
            }

            // hacmp调用启停脚本权限检查
            if (params.get("PM-20-20-001-44") != null
                    && params.get("PM-20-20-001-44").equals("1")) {
                // Vector hsshells = rpctarget.getKPISet("ls -l
                // /usr/es/sbin/app");
                String shell_right = "";
                shell_right = rpctarget.getKPIValue("ls -l /usr/es/sbin/app");
				/*
				 * for (int i = 0; i < hsshells.size(); i++) { String shell_info =
				 * ((String) hsshells.elementAt(i)).trim(); if
				 * (shell_info.indexOf("does not exist") > -1) { shell_info =
				 * "无启停脚本"; break; } String right = split(shell_info, 0); String
				 * shell = split(shell_info, 8); shell_right += shell + ":" +
				 * right + "#"; } if (shell_right.endsWith("#")) shell_right =
				 * subString(shell_right);
				 */
                if (shell_right.equals("")) {
                    shell_right = "无启停脚本";
                }
                collResult.addKPI(hacmp_PRE_UNITID, "PM-20-20-001-44",
                        shell_right).trim();
            }

            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 智能巡检存储模块 包含：链路状态是否正常、Pv状态、卷组状态
     */
    public Vector getStore(HashMap params) {
        try {
            logger.info("Begin getStore");
            init();
            CollBase collResult = new CollBase();
            String store_PRE_UNITID = PRE_UNITID + "-14:" + neat_host_name
                    + "-store";

            // 链路状态是否正常
            // 2010-10-28 modify by linxc
            if (params.get("PM-20-20-001-46") != null
                    && params.get("PM-20-20-001-46").equals("1")) {
                String linkstatus = "";
                Vector linkList = rpctarget.getKPISet("lspath|grep -v Enabled");
                if (linkList.size() > 0) {
                    for (int i = 0; i < linkList.size(); i++) {
                        String linkInfo = (String) linkList.get(i);
                        String status = split(linkInfo, 0);
                        String name = split(linkInfo, 1);
                        String parent = split(linkInfo, 2);
                        linkstatus += parent + ":" + name + ":" + status + "#";
                    }
                    if (linkstatus.endsWith("#")) {
                        linkstatus = subString(linkstatus);
                    }
                } else {
                    linkstatus = "Y";
                }
                if (linkstatus.length() >= 255) {
                    linkstatus = linkstatus.substring(0, 254);
                }
                collResult.addKPI(store_PRE_UNITID, "PM-20-20-001-46",
                        linkstatus);
            }

            // pv状态不为active的清单
            // 2010-10-28 modify by linxc
            if (params.get("PM-20-20-001-49") != null
                    && params.get("PM-20-20-001-49").equals("1")) {
                String unavailablePvCount = rpctarget
                        .getKPIValue1(
                                "lsvg -o|lsvg -ip|grep -v PV_NAME|awk '{if($2!=\"active\"&&$2!=\"\") print $1\":\"$2}'")
                        .trim();
                if (unavailablePvCount.equals("")) {
                    unavailablePvCount = "NONE";
                }
                if (unavailablePvCount.length() >= 255) {
                    unavailablePvCount = unavailablePvCount.substring(0, 250)
                            + "...";
                }
                collResult.addKPI(store_PRE_UNITID, "PM-20-20-001-49",
                        unavailablePvCount);
            }

            // 卷组状态
            if (params.get("PM-20-20-001-50") != null
                    && params.get("PM-20-20-001-50").equals("1")) {
                String vgstates = "";
                Vector vglist = rpctarget
                        .getKPISet("lsvg -o|lsvg -i|egrep \"VOLUME GROUP|VG STATE\"|awk '{print $3}'");
                for (int i = 0; i < vglist.size(); i++) {
                    if (i % 2 == 0) {
                        vgstates += ((String) vglist.get(i)).trim() + ":";
                    } else {
                        vgstates += ((String) vglist.get(i)).trim() + "#";
                    }
                }

                if (vgstates.endsWith("#")) {
                    vgstates = subString(vgstates);
                }
                if (vgstates.length() >= 255) {
                    vgstates = vgstates.substring(0, 250) + "...";
                }
                collResult
                        .addKPI(store_PRE_UNITID, "PM-20-20-001-50", vgstates);
            }

            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 智能巡检mksysb模块 包含：mksysb备份记录检查（最新备份时间）
     */
    public Vector getMksysb(HashMap params) {
        try {
            logger.info("Begin getMksysb");
            init();
            CollBase collResult = new CollBase();
            String mksysb_PRE_UNITID = PRE_UNITID + "-15:" + neat_host_name
                    + "-mksysb";
            // mksysb最近备份时间
            if (params.get("PM-20-20-001-51") != null
                    && params.get("PM-20-20-001-51").equals("1")) {
                String bktime = rpctarget
                        .getKPIValue(
                                "ls -l /var/adm/ras/vgbackuplog|awk '{print $6\" \"$7\" \"$8}'")
                        .trim();
                collResult.addKPI(mksysb_PRE_UNITID, "PM-20-20-001-51", bktime)
                        .trim();
            }

            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 智能巡检uptime模块 包含：检查系统多久没有重新启动了
     */
    public Vector getUptime(HashMap params) {
        try {
            logger.info("Begin getUptime");
            init();
            CollBase collResult = new CollBase();

            // 检查系统多久没有重新启动了
            if (params.get("PM-20-20-001-52") != null
                    && params.get("PM-20-20-001-52").equals("1")) {
                String uptime_PRE_UNITID = PRE_UNITID + "-16:" + neat_host_name
                        + "-uptime";
                String updays = rpctarget
                        .getKPIValue("uptime|awk '{print $3}'").trim();
                collResult.addKPI(uptime_PRE_UNITID, "PM-20-20-001-52", updays)
                        .trim();
            }

            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 智能巡检系统配置模块
     */
    public Vector getCfgparam(HashMap params) {
        try {
            logger.info("Begin getCfgparam");
            init();
            String syscfg_PRE_UNITID = PRE_UNITID + "-17:" + neat_host_name
                    + "-cfgparam";
            CollBase collResult = new CollBase();

            // 检查系统参数
            if (params.get("PM-20-20-001-80") != null
                    && params.get("PM-20-20-001-80").equals("1")) {
                String sysParams = rpctarget.getKPIValue1(
                        ". ../bin/shell/getAixSysParams.sh").trim();
                if (sysParams.equals("")) {
                    sysParams = "Y";
                }
                if (sysParams.length() >= 255) {
                    sysParams = sysParams.substring(0, 250) + "...";
                }
                collResult.addKPI(syscfg_PRE_UNITID, "PM-20-20-001-80",
                        sysParams).trim();
            }

            // 检查系统关键配置文件与前一天的是否发生变化
            if (params.get("PM-20-20-001-81") != null
                    && params.get("PM-20-20-001-81").equals("1")) {
                String sysCfg = rpctarget.getKPIValue1(
                        ". ../bin/shell/getAixInetdConf.sh").trim();

                if (sysCfg.equals("")) {
                    sysCfg = "Y";
                } else {
                    sysCfg = "N";
                }

                collResult.addKPI(syscfg_PRE_UNITID, "PM-20-20-001-81", sysCfg)
                        .trim();
            }
            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 智能巡检账号模块 包含：用户账号设置、用户组设置、Root用户远程登录限制、系统用户登录限制
     */
    public Vector getAccount(HashMap params) {
        try {
            logger.info("Begin getFullcore");
            init();
            String account_PRE_UNITID = PRE_UNITID + "-20:" + neat_host_name
                    + "-account";
            CollBase collResult = new CollBase();

            // 是否能列出所有用户
            if (params.get("PM-20-20-001-64") != null
                    && params.get("PM-20-20-001-64").equals("1")) {
                String lsusercount = rpctarget.getKPIValue(
                        "lsuser -a home ALL|wc -l").trim();
                String passwdcount = rpctarget.getKPIValue1(
                        "cat /etc/passwd|wc -l").trim();
                String isAccord = "Y";
                if (Integer.parseInt(lsusercount) != Integer
                        .parseInt(passwdcount))
                    isAccord = "实际用户数：" + passwdcount + ",列出用户数：" + lsusercount;

                collResult.addKPI(account_PRE_UNITID, "PM-20-20-001-64",
                        isAccord);
            }
            // 是否有无用用户组
            if (params.get("PM-20-20-001-65") != null
                    && params.get("PM-20-20-001-65").equals("1")) {
                String unusegroups = rpctarget
                        .getKPIValue1("cat /etc/group|grep -vE 'uucp|printq'|awk -F \":\" '{if($4==\"\") print $1}'");
                if (unusegroups.length() == 0)
                    unusegroups = "N";
                collResult.addKPI(account_PRE_UNITID, "PM-20-20-001-65",
                        unusegroups);
            }

            // 是否限制root用户远程登录
            if (params.get("PM-20-20-001-66") != null
                    && params.get("PM-20-20-001-66").equals("1")) {
                String rootRlogin = rpctarget
                        .getKPIValue1("cat /etc/ssh/sshd_config|grep PermitRootLogin|grep -v just|grep -v '#'|awk '{print $2}'");
                if (rootRlogin.trim().equals("no"))
                    rootRlogin = "Y";
                else
                    rootRlogin = "N";

                collResult.addKPI(account_PRE_UNITID, "PM-20-20-001-66",
                        rootRlogin);
            }

            // 是否限制系统用户登录
            if (params.get("PM-20-20-001-67") != null
                    && params.get("PM-20-20-001-67").equals("1")) {
                String sysuserLogin = rpctarget
                        .getKPIValue1("lsuser -a login ALL|grep -E \"daemon|bin|sys|adm|uucp|nuucp|printq|guest|nobody|lpd|sshd\"|awk '$0 ~ /true/ {print $1}'");
                if (sysuserLogin.trim().length() == 0)
                    sysuserLogin = "Y";

                collResult.addKPI(account_PRE_UNITID, "PM-20-20-001-67",
                        sysuserLogin);
            }

            // 用户umask值设置是否合规
            if (params.get("PM-20-20-001-68") != null
                    && params.get("PM-20-20-001-68").equals("1")) {
                String umaskRoot = rpctarget
                        .getKPIValue("lsuser -a umask root|awk '$0 !~ /27/ {print $1}'");
                String umaskElse = rpctarget
                        .getKPIValue1("lsuser -a umask ALL|grep -v root|awk '$0 !~ /22/ {print $1}'");
                String umaskSet = umaskRoot + umaskElse;
                if (umaskSet.trim().length() == 0)
                    umaskSet = "Y";
                collResult.addKPI(account_PRE_UNITID, "PM-20-20-001-68",
                        umaskSet);
            }
            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 智能巡检口令模块 包含：空口令账号、口令生存期安全、口令历史安全、口令锁定策略、口令到期安全、访问权限安全、FTP访问安全
     */
    public Vector getPassword(HashMap params) {
        try {
            logger.info("Begin getFullcore");
            init();
            String password_PRE_UNITID = PRE_UNITID + "-21:" + neat_host_name
                    + "-password";
            CollBase collResult = new CollBase();

            // 用户口令设置是否合规
            if (params.get("PM-20-20-001-70") != null
                    && params.get("PM-20-20-001-70").equals("1")) {
                String secChk = rpctarget
                        .getKPIValue1(". ../bin/shell/getAixPwdCfg.sh ");
                if (secChk.equals("")) {
                    secChk = "Y";
                }
                collResult.addKPI(password_PRE_UNITID, "PM-20-20-001-70",
                        secChk);
            }

            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 智能巡检服务模块 包含：远程维护安全、禁用服务
     */
    public Vector getService(HashMap params) {
        try {
            logger.info("Begin getFullcore");
            init();
            String service_PRE_UNITID = PRE_UNITID + "-22:" + neat_host_name
                    + "-service";
            CollBase collResult = new CollBase();
            // telnet是否禁用
            if (params.get("PM-20-20-001-75") != null
                    && params.get("PM-20-20-001-75").equals("1")) {
                String isTelnet = "";
                String telnetSer = rpctarget
                        .getKPIValue("lssrc -t telnet|grep -v Status|awk '{print $5}'");

                if (telnetSer != null && telnetSer.trim().equals("active")) {
                    isTelnet = "N";
                } else {
                    isTelnet = "Y";
                }
                collResult.addKPI(service_PRE_UNITID, "PM-20-20-001-75",
                        isTelnet);
            }

            // 无用服务是否已禁用
            if (params.get("PM-20-20-001-76") != null
                    && params.get("PM-20-20-001-76").equals("1")) {
                String sysService = rpctarget
                        .getKPIValue1(". ../bin/shell/sysService.sh");

                collResult.addKPI(service_PRE_UNITID, "PM-20-20-001-76",
                        sysService);
            }
            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 智能巡检日志审计模块 包含：安全事件审计
     */
    public Vector getLogaudit(HashMap params) {
        try {
            logger.info("Begin getFullcore");
            init();
            String logaudit_PRE_UNITID = PRE_UNITID + "-23:" + neat_host_name
                    + "-logaudit";
            CollBase collResult = new CollBase();

            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 智能巡检设备模块 包含：屏幕保护
     */
    public Vector getDevice(HashMap params) {
        try {
            logger.info("Begin getFullcore");
            init();
            String device_PRE_UNITID = PRE_UNITID + "-24:" + neat_host_name
                    + "-device";
            CollBase collResult = new CollBase();

            // 屏幕保护设置
            if (params.get("PM-20-20-001-79") != null
                    && params.get("PM-20-20-001-79").equals("1")) {
                String screenset = rpctarget
                        .getKPIValue("cat /etc/profile /etc/environment /etc/security/.profile|grep TMOUT|grep -v '#'|wc -l");
                if (screenset.trim().equals("0"))
                    screenset = "N";
                else
                    screenset = "Y";

                collResult.addKPI(device_PRE_UNITID, "PM-20-20-001-79",
                        screenset);
            }
            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 智能巡检缓冲区模块 包含：缓冲区溢出
     */
    public Vector getCushion(HashMap params) {
        try {
            logger.info("Begin getCushion");
            init();

            CollBase collResult = new CollBase();
            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 智能巡检补丁模块 包含：操作系统的补丁更新检查、操作系统补丁更新及时性检查
     */
    public Vector getMend(HashMap params) {
        try {
            logger.info("Begin getMend");
            init();

            CollBase collResult = new CollBase();
            return collResult.getKPISet();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public void init() {
        rpctarget = new RPCTarget();
        rpctarget.setRpcCmd("sh RPCTarget_suport.sh");
        // 获取主机名称
        String host_name = this.getHostName();

        // 得到unit_id中使用的主机名称
        neat_host_name = Formater.neatenunitid(host_name);
    }

    private String getHostName() {
        Vector host = rpctarget.getKPISet("uname -a");
        String host_name = (String) host.elementAt(0);
        host_name = split(host_name, 1);
        return host_name;
    }

    /**
     * 如果超出了返回,返回 空串
     */
    private String split(String str, int pos) {
        StringTokenizer st = new StringTokenizer(str);
        Vector values = new Vector();
        while (st.hasMoreTokens()) {
            values.add(st.nextToken());
        }
        if (pos >= 0 && pos < values.size()) {
            return (String) values.elementAt(pos);
        }
        return "";
    }

    public String subString(String str) {
        if (str != null && str.length() > 0)
            str = str.substring(0, str.length() - 1);
        return str;
    }

    public static void main(String[] args) {
        // CheckAIXWithCMD cmd = new CheckAIXWithCMD();
        // HashMap params = new HashMap();
        // params.put("PM-20-20-001-02", "1");
        // params.put("PM-20-20-001-06", "1");
        //
        // Vector vector = cmd.getFilesys(params);

        // CheckAIXWithCMD cmd = new CheckAIXWithCMD();
        // System.out.println(cmd.curdate);
        // System.out.println("errpt -d H|grep "
        // + cmd.curdate.substring(0, 4) + "...."
        // + cmd.curdate.substring(8, 10)+ "|sort -u|sed -n '2,$p' | wc -l");
        //

    }
}