package com.sitech.ismp.coll.host;

import com.sitech.ismp.coll.CollBase;
import com.sitech.ismp.coll.basic.TblATO_KPIDETAIL;
import com.sitech.util.Formater;
import com.sitech.util.LockFile;
import com.sitech.util.PropertyUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

import java.io.*;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class CollHPWithCMDByCron extends CollBase {

    static final String RESULT_PATH = "../result/";

    static final String SH_COLL_DISK = "getHPDisk.sh";
    static final String RESULT_DISK = "hpDiskResult";

    static final String SH_COLL_CPU = "getHPCpu.sh";
    static final String RESULT_CPU = "hpCpuResult";

    static final String SH_COLL_MEMORY = "getHPMemory.sh";
    static final String RESULT_MEMORY = "hpMemoryResult";

    static final String SH_COLL_CONFIG = "getHPConfig.sh";
    static final String RESULT_CONFIG = "hpConfigResult";

    static final String SH_COLL_FILE_SYSTEM = "getHPFileSystem.sh";
    static final String RESULT_FILE_SYSTEM = "hpFileSystemResult";

    static final String SH_COLL_USERPRONUM = "getHPUserProNum.sh";
    static final String RESULT_USER_PRONUM = "hpUserProNum";

    static final String SH_COLL_TOPPROCESS = "getHPTopProcess";
    static final String RESULT_TOPPROCESS = "hpTopProcess";

    static final String SH_COLL_ALLDISK = "getHPAllDisk.sh";
    static final String RESULT_ALLDISK = "hpAllDisk";

    static final String SH_COLL_ALLPROCESS = "getHPAllProcess.sh";
    static final String RESULT_ALLPROCESS = "hpAllProcess";

    static final String SH_COLL_SYSLOG = "getHPSyslog.sh";
    static final String RESULT_SYSLOG = "hpSyslog";

    static final String SH_COLL_CLOCK = "getHPClockInfo.sh";
    static final String RESULT_CLOCK = "hpClockInfo";

    static final String SH_COLL_FILESIZE = "getHPFileSize.sh";
    static final String RESULT_FILESIZE = "hpFileSizeResult";

    static final String SH_COLL_HARDWARE = "getHPHardware.sh";
    static final String RESULT_HARDWARE = "hpHardwareResult";

    static final String SH_COLL_FILEMOUNT = "getHPFileMount.sh";
    static final String RESULT_FILEMOUNT = "hpFileMountResult";

    static final String SH_COLL_NETLOG = "getHPNetLog.sh";
    static final String RESULT_NETLOG = "hpNetLogResult";

    static final String SH_COLL_RAIDSTATUS = "getHPRAIDStatus.sh";
    static final String RESULT_RAIDSTATUS = "hpRAIDStatusResult";

    static final String SH_COLL_CABINETRACK = "getHPCabinetRack.sh";
    static final String RESULT_CABINETRACK = "hpCabinetRackResult";

    static final String SH_COLL_PROCESS = "getHPProcessTop10.sh";
    static final String RESULT_PROCESS = "hpProcessTop10Result";

    static final String SH_COLL_KEY_PROCESS = "getHPProcess.sh";
    static final String RESULT_KEY_PROCESS = "hpProcessResult";

    static final String SH_COLL_NET = "getHPNet.sh";
    static final String RESULT_NET = "hpNetResult";

    static final String SH_COLL_FILE = "getFile.sh";
    static final String RESULT_FILE = "fileResult";

    String PRE_UNITID = "10-10-21"; // hp主机的标识

    /**
     * 内存已使用情况通过vmstat的fre字段 乘以 4k
     * PM-00-01-002-01 内存的使用率 vmstat 中的memory - free * 4k 为空闲内存，不通过本方法获取，通过SNMP获取
     * PM-00-01-002-02 内存交换请求数 vmstat 中的page - fr
     * PM-00-01-002-03 内存交换页换进率 vmstat 中的page - pi
     * PM-00-01-002-04 内存交换页换出率 vmstat 中的page - po
     * PM-00-01-002-05 内存队列数 等待内存的进程或线程数量vmstat 中的 kthr - r
     * PM-00-01-002-06 系统内存使用率 系统内存占所有物理内存的百分比 无此概念
     * PM-00-01-002-07 用户内存使用率 用户内存占所有物理内存的百分比 无此概念
     * PM-00-01-002-08 文件系统数据缓冲命中率 文件系统数据缓冲命中率 使用sar 2 2 , 平均读写命中率
     */
    public Vector<TblATO_KPIDETAIL> getMemory(HashMap<String, String> params) {
        logger.info("begin getMemory");

        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        
        // 执行脚本
        exec(SH_COLL_MEMORY);
        // 获得脚本执行结果
        List<String> result = getResult(RESULT_MEMORY);
        if(null == result || result.isEmpty()){
        	return collResult.KPISet;
        }
        List<List<String>> list = parseResult(result, 4);

        String deviceId = params.get("DEVICE_ID");
        if(null == deviceId || "".equals(deviceId.trim())){
            // 获取主机名称 : uname -a
            List<String> vHostName = list.get(0);
        	deviceId = split(vHostName.get(0), 1);
        }

        String memUnitId = PRE_UNITID + "-12:" + Formater.neatenunitid(deviceId) + "-memory";
        
        try {
        	// vmstat 2 10
            List<String> vmstat_result = list.get(1);
            if(null == vmstat_result || vmstat_result.size() < 1){
            	throw new Exception("\"vmstat 2 10\": null");
            }
            String vmstat_string = vmstat_result.get(vmstat_result.size() - 1);
            logger.info("vmstat 2 10:\n" + vmstat_string);

            // machinfo|grep Memory
            List<String> mem_num = list.get(2);
            logger.info("-- mem_num:" + mem_num.size());
            String memTotalInfo = mem_num.get(0);
            String memTotalSize = null;
            if (null == memTotalInfo || "".equals(memTotalInfo.trim())) {
                throw new Exception("Can't get memory total size");
            } else if (memTotalInfo.contains(":")) {
                memTotalSize = split(memTotalInfo, 1);
            } else if (memTotalInfo.contains("=")) {
                memTotalSize = split(memTotalInfo, 2);
            }

            logger.info("-- Memory total size:" + memTotalSize);
            
            double memFreeSize = Double.parseDouble(split(vmstat_string, 4)) * 4 / 1024;
            logger.info("-- Memory free size:" + memFreeSize);
            // 内存使用率
            double memUsage = 100.0 - (memFreeSize * 100.0) / Double.parseDouble(memTotalSize);

            collResult.addKPI(memUnitId, "PM-00-01-002-01", Formater.formatDecimalKpivalue(String.valueOf(memUsage)));

			String value = "";
			value = Formater.formatDecimalKpivalue(split(vmstat_string, 9));
			collResult.addKPI(memUnitId, "PM-00-01-002-02", value);

			value = Formater.formatDecimalKpivalue(split(vmstat_string, 7));
			collResult.addKPI(memUnitId, "PM-00-01-002-03", value);

			value = Formater.formatDecimalKpivalue(split(vmstat_string, 8));
			collResult.addKPI(memUnitId, "PM-00-01-002-04", value);

			value = Formater.formatDecimalKpivalue(split(vmstat_string, 0));
			collResult.addKPI(memUnitId, "PM-00-01-002-05", value);
		} catch (Exception e) {
			logger.error("Exception while getMemory!", e);
		}
        String filerate_string="";
		try {
			// sar -b 2 2 | grep Average
			List<String> filerate_result = list.get(3);
			if (null == filerate_result || filerate_result.isEmpty()) {
				throw new Exception("\"sar -b 2 2 | grep Average\": null");
			}
			 filerate_string = filerate_result
					.get(filerate_result.size() - 1);
			logger.info("sar -b 2 2 | grep Average:\n" + filerate_string);

			long r_rate = Long.parseLong(split(filerate_string, 3));
			long w_rate = Long.parseLong(split(filerate_string, 6));
			collResult.addKPI(memUnitId, "PM-00-01-002-08", Formater
					.formatDecimalKpivalue(String
							.valueOf((r_rate + w_rate) / 2)));
		} catch (Exception e) {
			logger.error("sar -b 2 2 | grep Average:\n" + filerate_string);
			logger.error("Exception while get filerate_result", e);
		}
        return collResult.getKPISet();
    }

    /**
     * PM-00-01-004-01 文件系统使用比率 文件系统已使用的空间与总空间的比值
     * PM-00-01-004-02 交换区使用百分比 交换区使用百分比
     * PM-00-01-004-03 逻辑卷(裸设备)文件系统使用率 各逻辑卷上文件系统的使用率
     * PM-00-01-004-01/03 Object=Disk PM-00-01-004-02 Object=System
     *
     * @param params
     * @return
     * @throws Exception
     */
    public Vector<TblATO_KPIDETAIL> getFileSystem(HashMap<String, String> params) {
        logger.info("begin getFileSystem");

        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        exec(SH_COLL_FILE_SYSTEM);
        // 获得脚本执行结果
        List<String> result = getResult(RESULT_FILE_SYSTEM);
        if(result == null || result.size() == 0){
            return collResult.KPISet;
        }
        List<List<String>> list = parseResult(result,4);

		String deviceId = params.get("DEVICE_ID");
		if (null == deviceId || "".equals(deviceId.trim())) {
			// 获取主机名称 : uname -a
			List<String> vHostName = list.get(0);
			deviceId = split(vHostName.get(0), 1);
		}
        // 得到unit_id中使用的主机名称
		deviceId = Formater.neatenunitid(deviceId);

        try{
        	// 采集各文件系统占用率
            long fsTotalSize = 0; // 文件系统总空间 兆
            long fsTotalUsed = 0; // 文件系统总空余空间
            List<String> fileSystemVTmp = list.get(1);
            if(null==fileSystemVTmp || fileSystemVTmp.size()<1){
                throw new Exception("[HP COLL] bdf : null ");
            }
            
            // bdf
            // 因为用命令取得的数据，某些行会一行变两行，因此需要将被拆分开的合为一行，原来想法
            // 直接合，但是发现会有某些行被删掉，因此造了个临时向量，把哪些有问题的行的行号记下来，
            // 先把拼好的放到fileSystemVTmp，然后通过临时向量中记录的序号，将fileSystemVTmp的对应记录删除
            List<String> fileSystemV = new ArrayList<String>();

            String vTmp1, vTmp2;
            for (int m0 = 1; m0 < fileSystemVTmp.size(); m0++) {
                String tmp = fileSystemVTmp.get(m0);

                String Vtmp1 = split(tmp, 1);
                if (!(null == Vtmp1 || Vtmp1.equals(null) || "".equals(Vtmp1) || "" == Vtmp1)) {
                    String Vtmp2 = split(tmp, 5);
                    if (!(null == Vtmp2 || Vtmp2.equals(null) || "".equals(Vtmp2) || "" == Vtmp2)) {
                        fileSystemV.add(tmp);
                    }
                } else {
                    int kkk = m0 + 1;
                    vTmp2 = fileSystemVTmp.get(kkk).trim();
                    vTmp1 = tmp + "    " + vTmp2;
                    fileSystemV.add(vTmp1);
                }
            }

            for (int i = 0; i < fileSystemV.size(); i++) {
                String fsname_info = (String) fileSystemV.get(i);
                String fsSize = split(fsname_info, 1);
                String usedSize = split(fsname_info, 2);
                String freeSize = split(fsname_info, 3);
                String fsUsage = split(fsname_info, 4);

                fsUsage = fsUsage.substring(0, fsUsage.indexOf("%"));
                String fs_name = split(fsname_info, 5);
                float free = Float.parseFloat(freeSize) / 1024;
                String fsFreeSize = Float.toString(free);

                String fsUnitId = PRE_UNITID + "-14:" + deviceId;
                if (fs_name != null && fs_name.equals("/")) {
                	fsUnitId += "-//";
                } else {
                	fsUnitId += "-" + Formater.neatenunitid(fs_name);
                }
                
                collResult.addKPI(fsUnitId, "PM-00-01-004-03", fsUsage);

                // 文件系统可用空间
                collResult.addKPI(fsUnitId, "PM-00-01-004-04", Formater.formatDecimalKpivalue(fsFreeSize));

                fsTotalSize += Long.parseLong(fsSize);
                fsTotalUsed += Long.parseLong(usedSize);
            }

            String totalUnitId = PRE_UNITID + "-10:" + deviceId + "-total";
            // PM-00-01-004-01 文件系统总占用率需要计算
            if (fsTotalSize != 0) {
                collResult.addKPI(totalUnitId,
                        "PM-00-01-004-01", Formater.formatDecimalKpivalue(String.valueOf(fsTotalUsed * 100.0 / fsTotalSize)));
            }

            // "swapinfo -atm | grep dev"
            List<String> swapV = list.get(2);
            if (swapV != null && swapV.size() > 0) {
                long swap_sum_avl = 0;
                long swap_sum_usd = 0;
                long swap_sum_free = 0;
                for (int i = 0; i < swapV.size(); i++) {
                    String swap_info = swapV.get(i);
                    String swap_avl = split(swap_info, 1);
                    String swap_usd = split(swap_info, 2);
                    String swap_free = split(swap_info, 3);
                    swap_sum_avl = swap_sum_avl + Long.parseLong(swap_avl);
                    swap_sum_usd = swap_sum_usd + Long.parseLong(swap_usd);
                    swap_sum_free = swap_sum_free + Long.parseLong(swap_free);
                }

                String swapUsage = Formater.formatDecimalKpivalue(String.valueOf(swap_sum_usd * 100.0 / swap_sum_avl));

				collResult.addKPI(totalUnitId, "PM-00-01-004-02", swapUsage);
                //交换分区大小
				collResult.addKPI(totalUnitId, "CM-00-01-001-13", Long.toString(swap_sum_avl));
                //交换分区已用大小
				collResult.addKPI(totalUnitId, "PM-00-01-004-19", Long.toString(swap_sum_usd));
                //交换分区空闲大小
				collResult.addKPI(totalUnitId, "PM-00-01-004-22", Long.toString(swap_sum_free));
            }

            // 实际打开进程数/允许打开进程数 实际使用inod数/允许使用inod数 实际打开文件数/允许打开文件数
            // sar -v 1 | tail -n 1 | sed 's/\\// /g' | awk '{printf("%0.4f\t%0.4f\t%0.4f\t%d\t%d\t%d\t%d\t%d\t%d\n", $6/$7 *100, $9/$10 *100, $12/$13 *100, $6, $7, $9, $10, $12, $13);}'
            List<String> listUserRate = list.get(3);
            if (listUserRate != null && listUserRate.size() > 0) {
                String strMsg = (String) listUserRate.get(0);

                String strProc = split(strMsg, 0);
                String strInod = split(strMsg, 1);
                String strFile = split(strMsg, 2);

                String strProc_1 = split(strMsg, 3);
                String strProc_2 = split(strMsg, 4);
                String strInod_1 = split(strMsg, 5);
                String strInod_2 = split(strMsg, 6);
                String strFile_1 = split(strMsg, 7);
                String strFile_2 = split(strMsg, 8);

				// 实际打开进程数量与可供打开数比率
				collResult.addKPI(totalUnitId, "PM-00-01-004-05", strProc);
				// 实际使用inod比率
				collResult.addKPI(totalUnitId, "PM-00-01-004-06", strInod);
				// 实际打开文件数比率
				collResult.addKPI(totalUnitId, "PM-00-01-004-07", strFile);
				// 实际打开进程数
				collResult.addKPI(totalUnitId, "PM-00-01-004-08", strProc_1);
				// 允许打开进程数
				collResult.addKPI(totalUnitId, "PM-00-01-004-09", strProc_2);
				// 实际使用inod数
				collResult.addKPI(totalUnitId, "PM-00-01-004-10", strInod_1);
				// 允许使用inod数
				collResult.addKPI(totalUnitId, "PM-00-01-004-11", strInod_2);
				// 实际打开文件数
				collResult.addKPI(totalUnitId, "PM-00-01-004-12", strFile_1);
				// 允许打开文件数
				collResult.addKPI(totalUnitId, "PM-00-01-004-13", strFile_2);
            }
        } catch (Exception e){
            logger.error("[HP COLL]Exception coll HP FileSystem ",e);
        }

        return collResult.getKPISet();
    }

    /**
     * 获取所有用户用户进程数
     *
     * @param params
     * @return
     */
    public Vector<TblATO_KPIDETAIL> getUserProNum(HashMap<String, String> params) {
        logger.info("begin getUserProNum ");

        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();

        // 得到所有用户的列表，该用户名出现多少次，就表明ps出来有多少行，即有多少进程
        Vector<String> userV = new Vector();
//        Vector<String> processV = rpctarget.getKPISet("ps -ef | grep -v UID");

        List<String> result = null;
        List<List<String>> list = null;
        try{
            exec(SH_COLL_USERPRONUM);
            result = getResult(RESULT_USER_PRONUM);
            if(result == null || result.size() == 0){
                return collResult.KPISet;
            }
            list = parseResult(result,2);
        } catch (Exception e){
            logger.error("[HP COLL] Exception while execute "+SH_COLL_USERPRONUM,e);
        }
        List<String> processV = list.get(1);
        // 原来采用以下命令，但在jilin 10.161.1.132 hp主机上有时出现 用户名称为 _3的情况，所以弃用
        // rpctarget.getKPISet("export UNIX95=XPG4;ps -ef -o user | grep -v USER");
        for (int i = 0; i < processV.size(); i++) {
//            String processInfo = (String) processV.elementAt(i);
            String processInfo = (String) processV.get(i);
            userV.add(collResult.split(processInfo, 0));
        }
        processV = null;

        if (userV == null || userV.size() == 0) {
            return new Vector<TblATO_KPIDETAIL>();
        }

        // 计算各个用户的进程数，并保存在这个map中
        // user - user process numer
        Map user_pronum = new HashMap();

        for (int i = 0; i < userV.size(); i++) {
            String userName = ((String) userV.elementAt(i)).trim();
            int pro_number = 1;
            if (user_pronum.get(userName) == null) {
                user_pronum.put(userName, new Integer(pro_number));
            } else {
                pro_number = Integer.parseInt(user_pronum.get(userName) + "") + 1;
                user_pronum.put(userName, new Integer(pro_number));
            }
        }


        // 本方法得到的kpi值的unit_id,均以PRE_UNITID + "-10"开头，代表Total数据
        String pro_PRE_UNITID = PRE_UNITID + "-21"; // total值

        // 获取主机名称
        String deviceId = params.get("DEVICE_ID");
        if(null==deviceId || "".equals(deviceId.trim())){
            // 获取主机名称 : uname -a
            List<String> vHostName = list.get(0);
            deviceId = split(vHostName.get(0), 1);
        }
        // 得到unit_id中使用的主机名称
        String neat_host_name = Formater.neatenunitid(deviceId);

        Set users = user_pronum.keySet();
        // System.out.println("users------------"+users);
        Iterator iter = users.iterator();
        while (iter.hasNext()) {
            String username = (String) iter.next();
            // System.out.println("username------------"+username);
            collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-" + Formater.neatenunitid(username),
                    "PM-00-01-005-06", ((Integer) user_pronum.get(username)).toString());
            collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-" + Formater.neatenunitid(username),
                    "CM-00-01-005-06", Formater.neatenunitid(username));

        }

        return collResult.getKPISet();
    }

    /**
     * 17个指标中 15个ok 1 hp
     * CM-00-01-001-06(cpu频率) 待完成
     * 主机物理内存大小通过SNMP获取 其他待测试
     * 在方法的最后面增加了getAllDisk的指标采集，该方法的采集值比较多，所以放在这里了。
     *
     * @param params
     * @return
     */
    public Vector<TblATO_KPIDETAIL> getConfig(HashMap<String, String> params) {
        logger.info("begin getConfig");

        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        
        // 执行脚本
        exec(SH_COLL_CONFIG);
        // 获得脚本执行结果
        List<String> result = getResult(RESULT_CONFIG);
        if(null == result || result.isEmpty()){
        	logger.warn("Exception while execute " + SH_COLL_CONFIG + ", result is null");
        	return collResult.KPISet;
        }
        
        List<List<String>> list = parseResult(result, 17);
        logger.info("RESULT SIZE:"+list.size());
        // 获取主机名称 : uname -a
        List<String> vHostName = list.get(0);
        logger.info("=========================uname result start=========================");
        String hostname = vHostName.get(0);
        
        String deviceId = params.get("DEVICE_ID");
        if(null == deviceId || "".equals(deviceId.trim())){
        	deviceId = split(hostname, 1);
        }
        
        String unitId = PRE_UNITID + "-10:" + Formater.neatenunitid(deviceId) + "-total";

        // 常用ip,用于告警标题
//        collResult.addKPI(unitId, "CM-00-01-001-50", params.get("IP_ADDR"));

        // 主机名称
        collResult.addKPI(unitId, "CM-00-01-001-01", split(hostname, 1));
        
        // 主机操作系统版本 
        collResult.addKPI(unitId, "CM-00-01-001-08", split(hostname, 2));
        
        // 主机类型
        collResult.addKPI(unitId, "CM-00-01-001-03", "HP");
        logger.info("=========================uname result end=========================");
        // ----cpu信息 ， CM-00-01-001-04(个数)/05(型号)/06(主频)-----
		// ioscan -fnk | grep processor

        List<String> cpunumV = list.get(1);
        logger.info("=========================ioscan -fnk | grep processor start=========================");
        // CPU个数
        String cpuNum = String.valueOf(cpunumV.size());
        collResult.addKPI(unitId, "CM-00-01-001-04", cpuNum);
        logger.info("=========================ioscan -fnk | grep processor end=========================");

        try {
        	// machinfo
            List<String> cputypeV = list.get(2);
            logger.info("=========================machinfo start=========================");
            for (int j = 0; j < cputypeV.size(); j++) {
                String cpu_info = cputypeV.get(j);
                if (cpu_info.indexOf("processor model:") > -1) {
                    String cputype = split(cpu_info, 3) + " " + split(cpu_info, 4) + " " + split(cpu_info, 5) + " " + split(cpu_info, 6) + " " + split(cpu_info, 7);
                    // cpu类型
                    collResult.addKPI(unitId, "CM-00-01-001-05", cputype);
                }
                if (cpu_info.indexOf("Clock speed") > -1) {
                    String cpuHZ = split(cpu_info, 3);
                    // cpu频率 MHz
                    collResult.addKPI(unitId, "CM-00-01-001-06", cpuHZ);
                }

                // CPU info:
                //   Intel(R) Itanium 2 9100 series processor (1.6 GHz, 24 MB)
                if (cpu_info.trim().startsWith("CPU info:")) {
                    String nextLine = cputypeV.get(j + 1);
                    if (nextLine.indexOf("GHz") > 0 && nextLine.indexOf("MB") > 0) {
                        // cpu类型
                        collResult.addKPI(unitId, "CM-00-01-001-05", nextLine.trim().replace("\t", " "));
                    }
                }

                if (cpu_info.trim().startsWith("Memory") && cpu_info.indexOf("=") > 0) {
                    // B.11.23使用
                    String phyMemSize = split(cpu_info, 2);
                    // 物理内存大小
                    collResult.addKPI(unitId, "CM-00-01-001-07", phyMemSize);
                }

                if (cpu_info.trim().startsWith("Memory:")) {
                    // HP-UX B.11.31使用
                    String phyMemSize = split(cpu_info, 1);
                    // 物理内存大小
                    collResult.addKPI(unitId, "CM-00-01-001-07", phyMemSize);
                }
            }
        } catch (Exception e) {
            logger.warn("Exception while coll cpu type and cpu clock", e);
        }
        logger.info("=========================machinfo end=========================");
        // ----CM-00-01-001-09 内置盘大小--------
        // 这里得到的pe size默认认为是megadata
        // 一下两个命令得到的结果行数一致，分别表示物理设备大小，以及该大小的单位（pe size）
		// ioscan -fnkC disk | grep GST
        logger.info("=========================ioscan -fnkC disk | grep GST start=========================");
        List<String> diskVsize = list.get(3);
        float disksize_sum = 0; // 单位PE Size
        for (int i = 0; i < diskVsize.size(); i++) {
            String disksizes = (String) diskVsize.get(i);
            logger.info("disksizes("+i+")======["+disksizes+"]");
            String subds = disksizes.substring(disksizes.indexOf("HP")+3, disksizes.indexOf("GST"));
            float i_disksize = Float.parseFloat(subds.trim());
            disksize_sum = disksize_sum + i_disksize * 1024;
        }
        collResult.addKPI(unitId,
                "CM-00-01-001-09", Formater.formatDecimalKpivalue(String.valueOf(disksize_sum == 0 ? 139898 : disksize_sum)));

        logger.info("=========================ioscan -fnkC disk | grep GST end=========================");
//        // ---------------------------- 网卡配置Begin -------------------------------------------
//        // netstat -in | grep -v Mtu | grep -v 127.0.0.1 | grep -v none
//
//        logger.info("=========================netstat  lanscan start=========================");
//        List<String> netstatV = list.get(4);
//
//        // lanscan | grep -v Hardware | grep -v Path
//        List<String> lanscanV = list.get(5);
//
//        // CM-00-01-001-10 系统网络接口数 , lanscan得出的行数
//        collResult.addKPI(unitId, "CM-00-01-001-10", String.valueOf(lanscanV.size()));
//
//        Map<String, String> ips = new HashMap<String, String>();
//        long lan_ipkts_total = 0;
//        long lan_opkts_total = 0;
//        for (String netstatInfo: netstatV) {
//            String lanName = split(netstatInfo, 0);
//            String ip = split(netstatInfo, 3);
//            lan_ipkts_total = lan_ipkts_total+ Long.parseLong(split(netstatInfo, 4));
//            lan_opkts_total = lan_opkts_total+ Long.parseLong(split(netstatInfo, 6));
//            ips.put(lanName, ip);
//        }
//        //网卡总出包数
//        collResult.addKPI(unitId, "PM-00-01-001-17", String.valueOf(lan_opkts_total));
//        //网卡总入包数
//        collResult.addKPI(unitId, "PM-00-01-001-18", String.valueOf(lan_ipkts_total));
//
//        Map<String, String> phyAddrMap = new HashMap<String, String>();
//        Map<String, String> ifStateMap = new HashMap<String, String>();
//        for (String lancanInfo : lanscanV) {
//            String lanName = split(lancanInfo, 4);
//            String phyAddr = split(lancanInfo, 1);
//            String ifState = split(lancanInfo, 3);
//            phyAddrMap.put(lanName, phyAddr);
//            ifStateMap.put(lanName, ifState);
//        }
//
//        Set<String> ipskeys = ips.keySet();
//        Object[] arrObj = ipskeys.toArray();
//
//        String serviceIp = "";
//        for (String lanName : ips.keySet()) {
//            if (null != phyAddrMap.get(lanName)) {
//            	String ifUnitId = this.PRE_UNITID + "-16:" + deviceId + "-" + Formater.neatenunitid(lanName);
//                // 系统网络接口IP地址
//                collResult.addKPI(ifUnitId, "CM-00-01-001-11", ips.get(lanName));
//
//                // 系统网络接口物理地址
//                collResult.addKPI(ifUnitId, "CM-00-01-001-12", phyAddrMap.get(lanName));
//
//                // 网卡状态
//                collResult.addKPI(ifUnitId, "FM-00-01-001-03", ifStateMap.get(lanName));
//
//                serviceIp = serviceIp + "," + ips.get(lanName);
//            }
//        }
//
//        // 主机（服务）地址 CM-00-01-001-02， 将所有ip地址累加
//        if (serviceIp.length() > 0) {
//            collResult.addKPI(unitId, "CM-00-01-001-02", serviceIp.substring(1));
//        }
//        logger.info("=========================netstat  lanscan end=========================");
//        // ---------------------------- 网卡配置End -------------------------------------------
        
        // 交换分区大小: swapinfo -atm 
        List<String> vSwap = list.get(6);
        logger.info("=========================swap start=========================");
        if(null == vSwap || vSwap.isEmpty()){
        	logger.warn("\"swapinfo -atm\": null");
        }else{
        	try{
        		 String swapSize = vSwap.get(vSwap.size() - 1);
        		 logger.info("swapinfo -atm:\n" + swapSize);
                 // 交换分区大小
                 swapSize = split(swapSize, 1);
                 collResult.addKPI(unitId, "CM-00-01-001-13", swapSize);
        	}catch(Exception e){
        		logger.warn("Exception while parse \"swapinfo -atm\"!", e);
        	}
        }
        logger.info("=========================swap end=========================");
//        // 逻辑卷名称 与 逻辑卷大小
//        // vgdisplay -v |grep 'LV Name'
//        List<String> vLvName = list.get(7);
//
//        // vgdisplay -v |grep 'LV Size'
//        List<String> vLvSize = list.get(8);
//        logger.info("=========================LV start=========================");
//        if (vLvName != null && vLvSize != null
//                && vLvName.size() == vLvSize.size()) {
//            for (int i = 0; i < vLvName.size(); i++) {
//                String lvName = vLvName.get(i);
//                lvName = this.split(lvName, 2);
//
//                String lvUnitId = this.PRE_UNITID + "-17:" + deviceId + Formater.neatenunitid(lvName);
//
//                // 逻辑卷名称
//                collResult.addKPI(lvUnitId, "CM-00-01-001-14", lvName);
//
//                // 逻辑卷大小
//                String lvSize = this.split(vLvSize.get(i), 3);
//                collResult.addKPI(lvUnitId, "CM-00-01-001-15", lvSize);
//            }
//        }
//        logger.info("=========================LV end=========================");
        // ------------------------------- 文件系统信息  Begin------------------------------------------
        // bdf
        List<String> fileSystemVTmp = list.get(9);
        logger.info("=========================bdf start=========================");
        if(null == fileSystemVTmp || fileSystemVTmp.isEmpty()){
        	logger.warn("\"bdf\": null");
        }else{
        	Vector<String> fileSystemV = new Vector<String>();

            String vTmp1, vTmp2;
            for (int m0 = 1; m0 < fileSystemVTmp.size(); m0++) {
                String tmp = fileSystemVTmp.get(m0);
                if(null == tmp || "".equals(tmp.trim())){
                	continue;
                }

                String Vtmp1 = split(tmp, 1);
                if (null != Vtmp1 && !"".equals(Vtmp1.trim())) {
                    String Vtmp2 = split(tmp, 5);
                    if (null != Vtmp2 && !"".equals(Vtmp2.trim())) {
                        fileSystemV.add(tmp);
                    }
                } else {
                    int kkk = m0 + 1;
                    vTmp2 = fileSystemVTmp.get(kkk).trim();
                    vTmp1 = tmp + "    " + vTmp2;
                    fileSystemV.add(vTmp1);
                }
            }

            long fsTotalSize = 0; // 文件系统总空间，兆
            for (int i = 0; i < fileSystemV.size(); i++) {
                try {
                    String fsname_info = fileSystemV.get(i);
                    String fsSize = split(fsname_info, 1).trim();
                    String fsName = split(fsname_info, 5).trim();
                    String fsDiskName = split(fsname_info, 0).trim();
                    
                    logger.info("test oh test :" + fsName + "--" + fsSize + "----" + fsname_info);

                    String fsUnitId = this.PRE_UNITID + "-14:" + deviceId;
                    if (fsName != null && fsName.trim().equals("/")) {
                    	fsUnitId += "-" + Formater.neatenunitid("//");
                    } else {
                    	fsUnitId += "-" + Formater.neatenunitid(fsName);
                    }
                    
                    // 文件系统名称
                    collResult.addKPI(fsUnitId, "CM-00-01-001-16", fsName);

                    // 文件系统挂载磁盘
                    collResult.addKPI(fsUnitId, "CM-00-01-001-42", fsDiskName);
                    fsName = (null == fsName || "".equals(fsName) || "-".equals(fsName)) ? "0" : fsSize.trim();
                    fsTotalSize = fsTotalSize + Long.parseLong(fsSize);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            // 文件系统总大小
            collResult.addKPI(unitId, "CM-00-01-001-17", Formater.formatDecimalKpivalue(String.valueOf(fsTotalSize / 1024)));
        }
        logger.info("=========================bdf end=========================");
        // ------------------------------- 文件系统信息  End------------------------------------------
        
        
        // ------------------------------- 集群  Begin------------------------------------------
        // cluster状态
        try {
            String cluster_PRE_UNITID = this.PRE_UNITID + "-22";
            // cmviewcl -l cluster	
            List<String> clusterInfo = list.get(10);
            logger.info("=========================cluster start=========================");
            if(null == clusterInfo || clusterInfo.isEmpty()){
            	logger.warn("\"cmviewcl -l cluster\": null");
            } else {
                for (String cluster : clusterInfo) {
                	if(null == cluster || "".equals(cluster.trim()) ){
                		continue;
                	}
                	if(cluster.indexOf("CLUSTER") > -1 || cluster.indexOf("STATUS") > -1){
                		continue;
                	}
                   
                        String clusterName = collResult.split(cluster, 0);
                        String clusterState = collResult.split(cluster, 1);

                        String clustUnitId = this.PRE_UNITID + "-22:" + deviceId + "-" + Formater.neatenunitid(clusterName);
                        // 集群名称
                        collResult.addKPI(clusterName, "CM-00-01-001-18", clusterName);
                        // 集群状态
                        collResult.addKPI(clusterName, "FM-00-01-001-04", clusterState);

                }
            }
            logger.info("=========================cluster end=========================");
        } catch (Exception e) {
            logger.error("Exception while get cluster!", e);
        }

        List<String> upTime = list.get(11);
        if (null != upTime && !upTime.isEmpty()) {
            String uptime = upTime.get(0);
            collResult.addKPI(unitId, "PM-20-20-001-52", uptime);
        }
     // ------------------------------- 集群  End------------------------------------------

        try{
            logger.info("=========================VG start=========================");
            // 逻辑卷状态
            List<String> VGInfos = list.get(12);
            if(VGInfos != null && VGInfos.size() > 0){
                for(int i = 0;i < VGInfos.size();i++){
                    String VGName = split(VGInfos.get(i), 2).trim();
                    String VGState = split(VGInfos.get(i+1), 2).trim();
                    String VGUnitId = "10-10-21-33:" + deviceId + "-" + Formater.neatenunitid(VGName) ;
                    //逻辑卷名称
                    collResult.addKPI(VGUnitId, "CM-00-01-001-57", VGName);
                    //逻辑卷状态
                    collResult.addKPI(VGUnitId, "FM-00-01-001-14", VGState);
                    i++;
                }
            }
            logger.info("=========================VG end=========================");
        } catch (Exception e) {
            logger.error("Exception while get LVState!", e);
        }
        try{
            logger.info("=========================kernel start=========================");
            // 内核信息
            List<String> usageInfos = list.get(13);
            if(usageInfos != null && usageInfos.size() > 0){
                String usageInfo = usageInfos.get(usageInfos.size()-1);
                //全系统进程数使用率%
                String[] proc_usage = split(usageInfo, 3).trim().split("/");
                int proc_useRate = Integer.parseInt(proc_usage[0])*100/Integer.parseInt(proc_usage[1]);
                collResult.addKPI(unitId, "PM-00-01-005-20", Integer.toString(proc_useRate));
            }
            List<String> kernelInfos = list.get(14);
            if(kernelInfos != null && kernelInfos.size() > 0){
                //用户核心线程数使用率
                String kth_usage1 = split(kernelInfos.get(0), 1).trim();
                String kth_usage2 = split(kernelInfos.get(0), 3).trim();
                int croProc_useRate = Integer.parseInt(kth_usage1)*100/Integer.parseInt(kth_usage2);
                collResult.addKPI(unitId, "PM-00-01-005-18", Integer.toString(croProc_useRate));
                //用户进程数使用率
                String uprc_usage1 = split(kernelInfos.get(1), 1).trim();
                String uprc_usage2 = split(kernelInfos.get(1), 3).trim();
                int uproc_useRate = Integer.parseInt(uprc_usage1)*100/Integer.parseInt(uprc_usage2);
                collResult.addKPI(unitId, "PM-00-01-005-19", Integer.toString(uproc_useRate));
            }
            logger.info("=========================kernel end=========================");
        } catch (Exception e) {
        logger.error("Exception while get kernel information!", e);
        }
        try{
            List<String> syslogStatus = list.get(15);
            if(syslogStatus != null && syslogStatus.size() > 0){
                // syslog状态
                collResult.addKPI(unitId, "FM-00-01-001-17", "true");
            }else {
                collResult.addKPI(unitId, "FM-00-01-001-17", "false");
            }
        }catch (Exception e){
            logger.error("Exception while getsyslog", e);
        }
        logger.info("=========================machineSerialNum start=========================");
        try{
            //主机序列号
            List<String> machineSerialNum = list.get(16);
            if(machineSerialNum !=null && machineSerialNum.size()>0){
                collResult.addKPI(unitId,"CM-01-03-001-08",split(machineSerialNum.get(0),3));
            }
            logger.info("=========================machineSerialNum end=========================");
        }catch (Exception e){
            logger.error("Exception while get machineSerialNum", e);
        }

        return collResult.getKPISet();
    }// end getConfig

    /**
     * 网卡状态放在这个方法里面了
     *
     * @param params
     * @return
     */
    public Vector<TblATO_KPIDETAIL> getCpu(HashMap<String, String> params) {
        logger.info("begin getCpu");
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        List<List<String>> list = null;
        List<String> result = null;
        try{
			exec(SH_COLL_CPU);
			// 获得脚本执行结果
			result = getResult(RESULT_CPU);
			if (result == null || result.size() == 0) {
				return collResult.KPISet;
			}
			list = parseResult(result, 3);
        } catch (Exception e){
            logger.error("[HP Coll] Exception while execute " + SH_COLL_CPU,e);
        }

        try{
            String deviceId = params.get("DEVICE_ID");
			if (null == deviceId || "".equals(deviceId.trim())) {
				// 获取主机名称 : uname -a
				List<String> vHostName = list.get(0);
				deviceId = split(vHostName.get(0), 1);
			}

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

            String cpuUnitId = PRE_UNITID + "-11:" + deviceId + "-cpu"; // total值
            String value = ""; // 临时变量

            // vmstat 2 10
            List<String> cpuout = list.get(1);
            if(null==cpuout || cpuout.size()<1){
                throw new Exception("[HP COLL] vmstat 2 10 : null");
            }

            String cpurun = cpuout.get(cpuout.size() - 1);

            // CPU时间：空闲百分比
            collResult.addKPI(cpuUnitId,
                    "PM-00-01-001-01", Formater.formatDecimalKpivalue(collResult.split(cpurun, 17)));

            // CPU时间：系统百分比
            collResult.addKPI(cpuUnitId,
                    "PM-00-01-001-02", Formater.formatDecimalKpivalue(collResult.split(cpurun, 16)));

            // CPU时间：用户百分比
            collResult.addKPI(cpuUnitId,
                    "PM-00-01-001-03", Formater.formatDecimalKpivalue(collResult.split(cpurun, 15)));
            
            // CPU运行队列中进程个数
            collResult.addKPI(cpuUnitId,
                    "PM-00-01-001-06", Formater.formatDecimalKpivalue(collResult.split(cpurun, 0)));
            // CPU阻塞队列中进程个数
            collResult.addKPI(cpuUnitId,
                    "PM-00-01-001-11", Formater.formatDecimalKpivalue(collResult.split(cpurun, 1)));

            // cpu利用率, 调用后扩的方法
            value = this.getCPU_Rate(cpuout);
            collResult.addKPI(cpuUnitId, "PM-00-01-001-05", value);

            // CPU时间：等待百分比
            // sar -u 2 10
            List<String> sar_cpuout = list.get(2);
			if (null == sar_cpuout || sar_cpuout.size() < 1) {
				logger.warn("[HP COLL] sar -u 2 10 : null");
			} else {
				String sar_cpurun = sar_cpuout.get(sar_cpuout.size() - 1);
				value = split(sar_cpurun, 3);
				collResult.addKPI(cpuUnitId, "PM-00-01-001-04",
						Formater.formatDecimalKpivalue(value));
			}
        } catch (Exception e){
            logger.error("[HP COLL] Exception while coll HP CPU ",e);
        }

        return collResult.getKPISet();
    }
    
	private String getCPU_Rate(List<String> cpuout) {
		double cpuRate = 0;
		int j=0;
		for (int i = cpuout.size() - 1; i >= 2 && j <= 20; i--) {//不要读取头两行title
			String cpurun = cpuout.get(i);
			cpuRate += 100 - Integer.parseInt(split(cpurun, 17));
			j++;
		}
		
		//cpuRate = cpuRate / 20;如果使用vmstat 2 10命令，那么cpuout只有12行结果，除数应该是10，而不是20
        cpuRate = cpuRate / j;
		return Formater.formatDecimalKpivalue(Double.toString(cpuRate));
	}

    public Vector<TblATO_KPIDETAIL> getDisk(HashMap<String, String> params) {
        logger.info("begin getActiveDisk");

        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();

        // 本方法得到的kpi值的unit_id,均以PRE_UNITID + "-13"开头，代表disk数据
        String disk_PRE_UNITID = PRE_UNITID + "-13";

        String value = "";// 临时变量

        // 从出现Average的这行开始，每一行表示一个磁盘的数据
//		Vector diskV = rpctarget.getKPISet("sar -d 5 5");
        exec(SH_COLL_DISK);

        try {
            // 获得脚本执行结果
            List<String> result = getResult(RESULT_DISK);
            if (result == null || result.size() == 0) {
                return collResult.KPISet;
            }
            List<List<String>> list = parseResult(result, 2);

            // 获取主机名称
//            String host_name = this.getHostName();
            String deviceId = params.get("DEVICE_ID");
            if(null==deviceId || "".equals(deviceId.trim())){
                // 获取主机名称 : uname -a
                List<String> vHostName = list.get(0);
                deviceId = split(vHostName.get(0), 1);
            }
            // 得到unit_id中使用的主机名称
            String neat_host_name = Formater.neatenunitid(deviceId);

            List<String> diskV = list.get(1);
            
            Set<String> sarDiskSet = new HashSet<String>(); // 保存所有sar命令能取到的io设备名称
            for (int i = 0; i < diskV.size(); i++) {
                String disk_value = diskV.get(i);

                if (disk_value.indexOf("Average") < 0){
                    continue;
                }

                String disk_name = split(disk_value, 1);
                sarDiskSet.add(disk_name);

                String neat_disk_name = Formater.neatenunitid(disk_name);

                collResult.addKPI(PRE_UNITID + "-13" + ":" + neat_host_name + "-"
                        + Formater.neatenunitid(disk_name), "CM-00-01-001-20", disk_name);

                // 磁盘物理IO操作速率
                value = split(disk_value, 5);
                collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name + "-"
                        + neat_disk_name, "PM-00-01-003-01", Formater.formatDecimalKpivalue(value));

                // 等待磁盘系统进程线程数
                value = split(disk_value, 3);
                collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name + "-"
                        + neat_disk_name, "PM-00-01-003-02", Formater.formatDecimalKpivalue(value));

                // 磁盘忙的百分比
                value = split(disk_value, 2);
                collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name + "-"
                        + neat_disk_name, "PM-00-01-003-03", Formater.formatDecimalKpivalue(value));

                // 每秒读请求
                value = split(disk_value, 4);
                collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name + "-"
                        + neat_disk_name, "PM-00-01-003-04", Formater.formatDecimalKpivalue(value));

                // 每秒写请求
                value = split(disk_value, 4);
                collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name + "-"
                        + neat_disk_name, "PM-00-01-003-05", Formater.formatDecimalKpivalue(value));
            }
        } catch (Exception e) {
            logger.info("[HP COLL] Exception while getActiveDisk!");
        }

        collResult.displayKPI();
        logger.info("[HP COLL] End getActiveDisk!");
        return collResult.getKPISet();

    }


    /**
     * 采集所有主机磁盘状态，读写指标 对于当前采集周期非活动的状态为CLAIMED的磁盘，其指标设定默认值 0
     * <p/>
     * 每秒磁盘读写请求 PM-00-01-003-04/05现在得到的值为 r+w
     * <p/>
     * 在规范磁盘性能指标基础上，增加了FM指标，内置盘状态
     *
     * @param params
     * @return
     */
    public Vector<TblATO_KPIDETAIL> getAllDisk(HashMap<String, String> params) {
        logger.info("begin getAllDisk");

        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();

        List<String> result = null;
        List<List<String>> list = null;
        try{
            exec(SH_COLL_ALLDISK);
            result = getResult(RESULT_ALLDISK);
            if(result == null || result.size() == 0){
                return collResult.KPISet;
            }
            list = parseResult(result,2);
        } catch (Exception e){
            logger.error("[HP Coll] Exception while execute "+SH_COLL_ALLDISK,e);
        }

        // 本方法得到的kpi值的unit_id,均以PRE_UNITID + "-13"开头，代表disk数据
        String disk_PRE_UNITID = PRE_UNITID + "-13";

        // 获取主机名称
//        String host_name = this.getHostName();
        String deviceId = params.get("DEVICE_ID");
        if(null==deviceId || "".equals(deviceId.trim())){
            // 获取主机名称 : uname -a
            List<String> vHostName = list.get(0);
            deviceId = split(vHostName.get(0), 1);
        }
        // 得到unit_id中使用的主机名称
        String neat_host_name = Formater.neatenunitid(deviceId);

        // 增加采集时间指标
        String pattern = "yyyy-MM-dd-HH-mm-ss";
        SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
        collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name + "",
                "CM-00-01-001-22", dateFormat.format(new java.util.Date()));

        String value = "";// 临时变量

        // 内置盘状态
//        Vector diskState = rpctarget.getKPISet("ioscan -fnkC disk | grep -v 'Description' | grep -v '==' ");
        List<String> diskState = list.get(0);
        Vector diskStateV = this.transMSG(diskState);
        HashMap disk_stateMap = new HashMap();// 用于存储磁盘名称与磁盘状态。用于后面sar命令中没有得到的磁盘指标附值，hp主机sar命令只采活动io设备
        // 输出格式

        for (int i = 0; i < diskStateV.size(); i = i + 2) {

            String diskInfo1 = (String) diskStateV.elementAt(i); // "disk 0
            // 10/0/14/0.0.0
            // sdisk
            // CLAIMED
            // DEVICE
            // TEAC
            // CD-532E-B"
            String diskInfo2 = (String) diskStateV.elementAt(i + 1); // "/dev/dsk/c0t0d0
            // /dev/rdsk/c0t0d0"

            String disk_state = split(diskInfo1, 4);

            String disk_nameInfo = split(diskInfo2, 0); // /dev/dsk/c0t0d0
            String disk_name = disk_nameInfo;
            // 只取 / 后面的名称
            if (disk_nameInfo.indexOf('/') > -1) {
                disk_name = disk_nameInfo.substring(disk_nameInfo
                        .lastIndexOf('/') + 1, disk_nameInfo.length());
            }

            disk_stateMap.put(disk_name, disk_state);
            collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name + "-"
                    + Formater.neatenunitid(disk_name), "FM-00-01-001-02",
                    disk_state);
        }

        // 从出现Average的这行开始，每一行表示一个磁盘的数据
//        Vector diskV = rpctarget.getKPISet("sar -d 5 5");
        List<String> diskV = list.get(1);
        Set sarDiskSet = new HashSet(); // 保存所有sar命令能取到的io设备名称
        for (int i = 0; i < diskV.size(); i++) {
//            String disk_value = (String) diskV.elementAt(i);
            String disk_value = (String) diskV.get(i);
            if (disk_value.indexOf("Average") < 0)
                continue;

            String disk_name = split(disk_value, 1);
            sarDiskSet.add(disk_name);

            String neat_disk_name = Formater.neatenunitid(disk_name);

            // 磁盘物理IO操作速率
            value = split(disk_value, 5);
            collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name + "-"
                    + neat_disk_name, "PM-00-01-003-01", Formater
                    .formatDecimalKpivalue(value));

            // 等待磁盘系统进程线程数
            value = split(disk_value, 3);
            collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name + "-"
                    + neat_disk_name, "PM-00-01-003-02", Formater
                    .formatDecimalKpivalue(value));

            // 磁盘忙的百分比
            value = split(disk_value, 2);
            collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name + "-"
                    + neat_disk_name, "PM-00-01-003-03", Formater
                    .formatDecimalKpivalue(value));

            // 每秒读请求
            value = split(disk_value, 4);
            collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name + "-"
                    + neat_disk_name, "PM-00-01-003-04", Formater
                    .formatDecimalKpivalue(value));

            // 每秒写请求
            value = split(disk_value, 4);
            collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name + "-"
                    + neat_disk_name, "PM-00-01-003-05", Formater
                    .formatDecimalKpivalue(value));

        }

        // 给sar命令没有取到的磁盘设备,该设备为CLAIMED状态的情况 附初始值
        Set allDiskSet = disk_stateMap.keySet();
        Iterator iter = allDiskSet.iterator();
        while (iter.hasNext()) {
            String disk_name = (String) iter.next();
            if (sarDiskSet.contains(disk_name)) {
                continue;
            } else {
                if (disk_stateMap.get(disk_name).equals("CLAIMED")) {
                    String neat_disk_name = Formater.neatenunitid(disk_name);
                    // 磁盘物理IO操作速率
                    collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name
                            + "-" + neat_disk_name, "PM-00-01-003-01", "0");
                    // 等待磁盘系统进程线程数
                    collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name
                            + "-" + neat_disk_name, "PM-00-01-003-02", "0");
                    // 磁盘忙的百分比
                    collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name
                            + "-" + neat_disk_name, "PM-00-01-003-03", "0");
                    // 每秒读请求
                    collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name
                            + "-" + neat_disk_name, "PM-00-01-003-04", "0");
                    // 每秒写请求
                    collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name
                            + "-" + neat_disk_name, "PM-00-01-003-05", "0");
                }

            }
        }

        return collResult.getKPISet();
    }

    private Vector transMSG(List vec) {
        Vector vector = new Vector();
        int size = vec.size();
        String tmp = "";

        for (int i = 0; i < size; i++) {
//            String msg_1 = (String) vec.elementAt(i);
            String msg_1 = (String) vec.get(i);
            if (msg_1.indexOf("/dev/dsk") != -1
                    && tmp.indexOf("/dev/dsk") != -1) {
                continue;
            }
            vector.addElement(msg_1);
            tmp = msg_1;
        }
        return vector;
    }

    public Vector<TblATO_KPIDETAIL> getAllProcess(HashMap<String, String> params) {
        logger.info("[HP COLL]begin getAllProcess");

        String pro_PRE_UNITID = PRE_UNITID + "-15"; // total值
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        List<String> result = null;
        List<List<String>> list = null;
        try{
            exec(SH_COLL_ALLPROCESS);
            // 获得脚本执行结果
            result = getResult(RESULT_ALLPROCESS);
            if(result == null || result.size() == 0){
                return collResult.KPISet;
            }
            list = parseResult(result,2);
        } catch (Exception e){
            logger.error("[HP COLL] Exception while execute "+SH_COLL_ALLPROCESS,e);
        }
        String deviceId = params.get("DEVICE_ID");
        if(null==deviceId || "".equals(deviceId.trim())){
            List<String> vHostName = list.get(0);
            deviceId = split(vHostName.get(0), 1);
        }
        // 得到unit_id中使用的主机名称
        String neat_host_name = Formater.neatenunitid(deviceId);

        String unit_process = "export UNIX95=XPG4;ps -ef -o pcpu,state,sz,pid,ruser,stime,args | grep -v '%CPU'";

	
	/*	String unit_process = "ps -ef -o pcpu,state,sz,pid,ruser,stime,args | grep \""
			+ process_name + "\" | grep -v grep | grep -v '%CPU'";
	
	*/
        logger.info("process_name_cmd=" + unit_process);
//        Vector proV = rpctarget.getKPISet(unit_process);
        List<String> proV = list.get(1);
        for (int i = 0; i < proV.size(); i++) {
//            String pro_info = (String) proV.elementAt(i);
            String pro_info = (String) proV.get(i);
            String pcpu = split(pro_info, 0); // 占用cpu时间
            String state = split(pro_info, 1);
            if (state.equals("R")) {
                state = "Running";
            } else if (state.equals("S")) {
                state = "Sleeping";
            } else if (state.equals("0")) {
                state = "Nonexistent";
            } else if (state.equals("W")) {
                state = "Waiting";
            } else if (state.equals("I")) {
                state = "Intermediate";
            } else if (state.equals("Z")) {
                state = "Terminated";
            } else if (state.equals("T")) {
                state = "Stopped";
            } else if (state.equals("X")) {
                state = "Growing";
            }
            String vsz = split(pro_info, 2);
            String pid = split(pro_info, 3);
            String puser = split(pro_info, 4);

            String pstime = split(pro_info, 5);
            pstime = pstime.indexOf(":") > -1 ? pstime : pstime + split(pro_info, 6); // 把那种月份+天的时间加上
            int pos_command = pstime.indexOf(":") > 0 ? 6 : 7; // 有冒号就是第6位，没有就是第7位
            String command = split(pro_info, pos_command);
            String full_command = pro_info.substring(pro_info.indexOf(command), pro_info.length());

            collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-" + i,
                    "TM-00-01-005-01", Formater.formatDecimalKpivalue(pcpu));
            collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-" + i,
                    "TM-00-01-005-02", state);
            collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-" + i,
                    "TM-00-01-005-03", full_command);
            collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-" + i,
                    "TM-00-01-005-04", pstime);
            collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-" + i,
                    "TM-00-01-005-05", Formater.formatDecimalKpivalue(vsz));
			/*collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-" + i,
					"TM-00-01-005-07", ""+i);*/
            collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-" + i,
                    "TM-00-01-005-08", pid);
            collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-" + i,
                    "TM-00-01-005-09", puser);

        }
        return collResult.getKPISet();
    }

    // 采集Syslog
    public Vector<TblATO_KPIDETAIL> getSyslog(HashMap<String, String> params) {
        logger.info("begin getSyslog ");
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        String host_ip = (String) params.get("IP_ADDR");
        String data_path = (String) params.get("bin_home");
        String now_filename = "now_" + host_ip + ".dat";
        String tmp_filename = "tmp_" + host_ip + ".dat";
        String diff_filename = "diff_" + host_ip + ".dat";
        List<String> result = null;
        List<List<String>> list = null;
        try {

            String syslogcmd = "grep -E 'EMS|err' /var/adm/syslog/syslog.log | sed -n \"1,1000p\"";
            exec(SH_COLL_SYSLOG);
            result = getResult(RESULT_SYSLOG);
            if(result == null || result.size() == 0){
                return collResult.KPISet;
            }
            list = parseResult(result,2);
//            Vector syslogV = rpctarget.getKPISet(syslogcmd);
            List<String> syslogV = list.get(1);
            String now = this.getVetorString(syslogV);

            File now_file = new File(data_path + now_filename);// 最新日志信息
            File tmp_file = new File(data_path + tmp_filename);// 上周期日志信息
            File diff_file = new File(data_path + diff_filename);// 增量日志
            PrintWriter write_now = new PrintWriter(new OutputStreamWriter(
                    new FileOutputStream(now_file), "GB2312"));
            PrintWriter write_tmp = new PrintWriter(new OutputStreamWriter(
                    new FileOutputStream(tmp_file, true), "GB2312"));
            PrintWriter write_diff = new PrintWriter(new OutputStreamWriter(
                    new FileOutputStream(diff_file), "GB2312"));
            String path = now_file.getAbsolutePath();
            logger.info("Current path is " + path);
            // 日志解析
            if (tmp_file.exists() && tmp_file.length() > 0) {// 非第一次采集
                write_now.write(now);
                write_now.flush();
                write_now.close();
                // 读取上周期日志文件(tmp)
                FileReader tmp_reader = new FileReader(tmp_file);
                BufferedReader tmp = new BufferedReader(tmp_reader);
                String line;
                String tmp_file_string = "";
                while ((line = tmp.readLine()) != null) {
                    tmp_file_string += line + "\n";
                }
                tmp.close();
                tmp_reader.close();
                // 读取本周期日志文件(now)，生成差异文件(diff)
                FileReader now_reader = new FileReader(now_file);
                BufferedReader br = new BufferedReader(now_reader);
                while ((line = br.readLine()) != null) {
                    if (tmp_file_string.indexOf(line) == -1)
                        write_diff.write(line);
                    else
                        continue;
                }
                br.close();
                now_reader.close();
                write_diff.flush();
                write_diff.close();
                write_tmp = new PrintWriter(new OutputStreamWriter(
                        new FileOutputStream(tmp_file), "GB2312"));
                write_tmp.write(now);
                write_tmp.flush();
                write_tmp.close();
            } else {// 第一次采集
                write_tmp.write(now);
                write_tmp.flush();
                write_tmp.close();
                write_diff.write(now);
                write_diff.flush();
                write_diff.close();
            }
            // 生成指标
            FileReader diff_reader = new FileReader(diff_file);
            BufferedReader diff = new BufferedReader(diff_reader);
            String line1;
            // 获取主机名称
            String deviceId = params.get("DEVICE_ID");
            if(null==deviceId || "".equals(deviceId.trim())){
                List<String> vHostName = list.get(0);
                deviceId = split(vHostName.get(0), 1);
            }
            String host_name = deviceId;
            // 得到unit_id中使用的主机名称
            String neat_host_name = Formater.neatenunitid(host_name);
            int j = 0;
            //限制为10条
            while ((line1 = diff.readLine()) != null && j < 10) {
			/*	String value1 = "err";
				String value2 = (line1.split("Value:"))[1];
				String[] value3_m = ((line1.split(":"))[2]).split(" ");
				String value3 = value3_m[2] + value3_m[3];
				String[] value4_m = line1.split(" ");
				String value4 = value4_m[0] + value4_m[1] + value4_m[2];*/
                String unitid = "10-10-21-20:" + neat_host_name + "-syslog-"
                        + j;
                collResult.addKPI(unitid, "FM-00-01-900-04", line1);
                collResult.addKPI(unitid, "CM-00-01-900-03", "err");
                j++;
            }
            diff.close();
            diff_reader.close();
        } catch (Exception e) {
            e.getMessage();
            e.printStackTrace();
        } finally {

        }
        return collResult.getKPISet();
    }

    /**
     * 新增时钟同步信息KPI信息
     * PM-00-01-006-01	远程服务器名称
     * PM-00-01-006-03	远程服务器级别
     * PM-00-01-006-04	请求间隔
     * PM-00-01-006-05	同步频率
     * PM-00-01-006-07	循环时间
     * PM-00-01-006-08	时间偏移量
     * PM-00-01-006-09	时间精确度
     */
    public Vector<TblATO_KPIDETAIL> getClockInfo(HashMap<String, String> params) {

        logger.info("[HP COLL]begin getClockInfo");

        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        List<String> result = null;
        List<List<String>> list = null;
        try{
            exec(SH_COLL_CLOCK);
            // 获得脚本执行结果
            result = getResult(RESULT_CLOCK);
            if(result == null || result.size() == 0){
                return collResult.KPISet;
            }
            // 分隔每个命令的执行结果
            list = parseResult(result, 1);
        } catch (Exception e){
            logger.error("[HP COLL] Exception while execute "+SH_COLL_CLOCK,e);
        }

        // 本方法得到的kpi值的unit_id,均以PRE_UNITID + "-24"开头
        String ntpq_PRE_UNITID = PRE_UNITID + "-24";

        // 获取主机名称
        String deviceId = params.get("DEVICE_ID");
        if(null==deviceId || "".equals(deviceId.trim())){
            List<String> vHostName = list.get(0);
            deviceId = split(vHostName.get(0), 1);
        }
        // 得到unit_id中使用的主机名称
        String neat_host_name = Formater.neatenunitid(deviceId);

        // 增加采集时间指标
        String pattern = "yyyy-MM-dd-HH-mm-ss";
        SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);

//        Vector ntpqV = rpctarget.getKPISet("/usr/sbin/ntpq -p ");
        List<String> ntpqV = list.get(0);
        String remoteName, remoteST, lastWhen, poll, delay, offset, jitter;
        if (ntpqV != null && ntpqV.size() > 0) {
            for (int i = 2; i < ntpqV.size(); i++) {
//                logger.info("into getClockInfo" + (String) ntpqV.elementAt(i));
                logger.info("into getClockInfo" + (String) ntpqV.get(i));
//                String strTmp = (String) ntpqV.elementAt(i);
                String strTmp = (String) ntpqV.get(i);
                remoteName = split(strTmp, 0);        //远程服务器名
                remoteST = split(strTmp, 2);        //服务器级别
                lastWhen = split(strTmp, 4);        //请求间隔
                poll = split(strTmp, 5);            //同步频率
                delay = split(strTmp, 7);            //循环时间
                offset = split(strTmp, 8);            //时间偏移量
                jitter = split(strTmp, 9);            //时间精确度
                logger.info("into my getClockInfo" + remoteName + "--" + remoteST + "--" + lastWhen + "--" + poll + "--" + delay + "--" + offset + "--" + jitter);

                collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name + "-ntpq" + i,
                        "PM-00-01-006-01", remoteName);
                collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name + "-ntpq" + i,
                        "PM-00-01-006-03", remoteST);
                collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name + "-ntpq" + i,
                        "PM-00-01-006-05", lastWhen);
                collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name + "-ntpq" + i,
                        "PM-00-01-006-06", poll);
                collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name + "-ntpq" + i,
                        "PM-00-01-006-08", delay);
                collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name + "-ntpq" + i,
                        "PM-00-01-006-09", offset);
                collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name + "-ntpq" + i,
                        "PM-00-01-006-10", jitter);
                collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name + "-ntpq" + i,
                        "CM-00-01-001-99", dateFormat.format(new java.util.Date()));
            }
        }
        return collResult.getKPISet();
    }

    /**
     * 采集指定路径文件大小信息
     * @param params
     * @return
     */
    public Vector<TblATO_KPIDETAIL> getFileSize(HashMap<String, String> params) {
        logger.info("[HP COLL]begin getFileSize");

        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        List<String> result = null;
        List<List<String>> list = null;
        try{
            exec(SH_COLL_FILESIZE);
            // 获得脚本执行结果
            result = getResult(RESULT_FILESIZE);
            if(result == null || result.size() == 0){
                return collResult.KPISet;
            }
            // 分隔每个命令的执行结果
            list = parseResult(result, 2);
        } catch (Exception e){
            logger.error("[HP COLL] Exception while execute "+SH_COLL_FILESIZE,e);
        }
        try{
            // 本方法得到的kpi值的unit_id,均以PRE_UNITID + "-27"开头
            String ntpq_PRE_UNITID = PRE_UNITID + "-27";

            // 获取主机名称
            String deviceId = params.get("DEVICE_ID");
            if(null==deviceId || "".equals(deviceId.trim())){
                List<String> vHostName = list.get(0);
                deviceId = split(vHostName.get(0), 1);
            }
            // 得到unit_id中使用的主机名称
            String neat_host_name = Formater.neatenunitid(deviceId);

            List<String> fileSizes = list.get(1);
            String now = this.getVetorString(fileSizes);
            String data_path = "../filechange";
            String last_filename = "last_" + deviceId + "-fileSize.dat";

            //目录不存在则创建
            File f = new File(data_path);
            if(!f.exists()){
                f.mkdir();
            }

            File last_file = new File(data_path+"/" + last_filename);// 最近日志信息

            String path = last_file.getAbsolutePath();
            logger.info("Current path is " + path);
            // 日志解析
            if (last_file.exists() && last_file.length() > 0) {// 非第一次采集
                // 读取上次日志文件(last)
                FileReader last_reader = new FileReader(last_file);
                BufferedReader last = new BufferedReader(last_reader);
                String line;
                while ((line = last.readLine()) != null) {
                    String fileSize, filePath;
                    if (fileSizes != null && fileSizes.size() > 0) {
                        for (int i = 0; i < fileSizes.size(); i++) {
                            logger.info("into getFileSize：" + (String) fileSizes.get(i));
                            String strTmp = (String) fileSizes.get(i);
                            double tempSize = Double.parseDouble(split(strTmp, 0));
                            fileSize = BigDecimal.valueOf(tempSize).divide(BigDecimal.valueOf(1024),2, RoundingMode.HALF_UP).toString();
                            filePath = split(strTmp, 1);
                            if(filePath.equals(split(line,1))){
                                logger.info("into my getFileSize：" + fileSize + "--" + filePath);
                                //关键路径
                                collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name + "-" + filePath,
                                        "CM-20-21-027-01", filePath);
                                //关键路径大小
                                collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name + "-" + filePath,
                                        "PM-20-21-027-01", fileSize);
                                //关键路径大小变动比率
                                collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name + "-" + filePath, "PM-00-01-004-15",
                                        BigDecimal.valueOf(tempSize-Double.parseDouble(split(line,0))).multiply(BigDecimal.valueOf(100)).divide
                                                (BigDecimal.valueOf(Double.parseDouble(split(line,0))),
                                                1, RoundingMode.HALF_UP).toString());
                            }
                        }
                    }
                }
                last.close();
                last_reader.close();
            } else {// 第一次采集
                String fileSize, filePath;
                if (fileSizes != null && fileSizes.size() > 0) {
                    for (int i = 0; i < fileSizes.size(); i++) {
                        logger.info("into getFileSize：" + (String) fileSizes.get(i));
                        String strTmp = (String) fileSizes.get(i);
                        double tempSize = Double.parseDouble(split(strTmp, 0));
                        fileSize = BigDecimal.valueOf(tempSize).divide(BigDecimal.valueOf(1024),2, RoundingMode.HALF_UP).toString();
                        filePath = split(strTmp, 1);
                        logger.info("into my getFileSize:" + fileSize + "--" + filePath);
                        //关键路径
                        collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name + "-" + filePath,
                                "CM-20-21-027-01", filePath);
                        //关键路径大小
                        collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name + "-" + filePath,
                                "PM-20-21-027-01", fileSize);
                    }
                }
            }

            //生成指标后，将最新信息写入记录文件
            PrintWriter write_last = new PrintWriter(new OutputStreamWriter(new FileOutputStream(last_file), "GB2312"));
            write_last.write(now);
            write_last.flush();
            write_last.close();
        } catch (Exception e) {
            e.getMessage();
            e.printStackTrace();
            logger.error("[HP COLL] Exception while execute "+SH_COLL_FILESIZE,e);
        } finally {
        }
        return collResult.getKPISet();
    }

    /**
     * 采集硬件信息
     * @param params
     * @return
     */
    public Vector<TblATO_KPIDETAIL> getHardware(HashMap<String, String> params) {
        logger.info("[HP COLL]begin getHardware");

        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        List<String> result = null;
        List<List<String>> list = null;
        try{
            //脚本指令需root权限，由crontab执行
//            exec(SH_COLL_HARDWARE);
            // 获得脚本执行结果
            result = getResult(RESULT_HARDWARE);
            if(result == null || result.size() == 0){
                return collResult.KPISet;
            }
            // 分隔每个命令的执行结果
            list = parseResult(result, 7);

            // 本方法得到的kpi值的unit_id,均以PRE_UNITID + "-28"开头
            String ntpq_PRE_UNITID = PRE_UNITID + "-28";

            // 获取主机名称
            String deviceId = params.get("DEVICE_ID");
            if(null==deviceId || "".equals(deviceId.trim())){
                List<String> vHostName = list.get(0);
                deviceId = split(vHostName.get(0), 1);
            }
            // 得到unit_id中使用的主机名称
            String neat_host_name = Formater.neatenunitid(deviceId);

            logger.info(list);
            List<String> cpuInfo = list.get(1);
            String cpuNUM = cpuInfo.isEmpty()? "0":Integer.toString(cpuInfo.size()-2);
            collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name+"-hardware",
                    "FM-00-01-028-01", cpuNUM);

            List<String> memoryInfo = list.get(2);
            String memorySize = memoryInfo.isEmpty()? "fail":split(memoryInfo.get(0),1);
            collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name+"-hardware",
                    "FM-00-01-028-02", memorySize);

            List<String> diskInfo = list.get(3);
            String diskNUM = diskInfo.isEmpty()? "0":Integer.toString(diskInfo.size() - 2);
            collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name+"-hardware",
                    "FM-00-01-028-03", diskNUM);

            List<String> lanInfo = list.get(4);
            String lanNUM = lanInfo.isEmpty()? "0":Integer.toString(lanInfo.size() - 2);
            collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name+"-hardware",
                    "FM-00-01-028-04", lanNUM);

            List<String> fcInfo = list.get(5);
            String fcNUM = fcInfo.isEmpty()? "0":Integer.toString(fcInfo.size()-2);
            collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name+"-hardware",
                    "FM-00-01-028-05", fcNUM);

            List<String> mpInfo = list.get(6);
            String mpLineNUM = mpInfo.isEmpty()? "0":Integer.toString(mpInfo.size());
            collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name+"-hardware",
                    "FM-00-01-028-06", mpLineNUM);
        } catch (Exception e){
            logger.error("[HP COLL] Exception while execute "+SH_COLL_HARDWARE,e);
        }
        return collResult.getKPISet();
    }

    /**
     * 采集mount点下文件信息
     * @param params
     * @return
     */
    public Vector<TblATO_KPIDETAIL> getFileMount(HashMap<String, String> params) {
        logger.info("[HP COLL]begin getFileMount");

        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        List<String> result = null;
        List<List<String>> list = null;

//        exec(SH_COLL_FILEMOUNT);
        // 获得脚本执行结果
        result = getResult(RESULT_FILEMOUNT);
        if(result == null || result.size() == 0){
            return collResult.KPISet;
        }
        // 分隔每个命令的执行结果
        list = parseResult(result, 2);


        // 获取主机名称
        String deviceId = params.get("DEVICE_ID");
        if(null==deviceId || "".equals(deviceId.trim())){
            List<String> vHostName = list.get(0);
            deviceId = split(vHostName.get(0), 1);
        }
        // 得到unit_id中使用的主机名称
        String neat_host_name = Formater.neatenunitid(deviceId);

        try {
            //得到挂载点 UnitId
            String mountUnitId = PRE_UNITID + "-29:" +  neat_host_name + "-";
            String dir = "../filechange";
            String path = "../filechange/mountSize.properties";
            Hashtable<String , String> ht = new Hashtable<String , String>();
            //目录不存在则创建
            File f = new File(dir);
            if(!f.exists()){
                f.mkdir();
            }
            //如果没有文件则创建
            PropertyUtils.createPropertiesFile(path, new Hashtable<String, String>());
            Properties pro =  PropertyUtils.getProperties(path);
            //得到锁文件
            LockFile file = new LockFile(path);
            ReentrantReadWriteLock lock = file.getLock();
            //如果该文件已经加锁则等待
            while(true){
                if(lock.isWriteLocked()){
                    Thread.sleep(1000);
                }else{
                    lock.writeLock().lock();
                    break;
                }
            }

            //mount点下是否有隐藏文件
            List<String> mountInfo = list.get(1);
            if (mountInfo != null && mountInfo.size() > 0) {
                for (int i = 0; i < mountInfo.size(); i++) {
                    logger.info("into getFileMount-mount on:" + (String) mountInfo.get(i));
                    //mount点
                    String fileMount =split((String) mountInfo.get(i), 0);
                    ///dev/vg00/lvol3 mount点下文件挂载数
                    String fileMountNUM_ff =split((String) mountInfo.get(i+1), 0);
                    //mount点下文件挂载数
                    String fileMountNUM_bdf =split((String) mountInfo.get(i+2), 0);
                    //mount点下占用空间大小
                    String mountSize =split((String) mountInfo.get(i+3), 0);
                    //mount点名称
                    collResult.addKPI(mountUnitId+fileMount,
                            "CM-20-21-029-01", fileMount);
                    ///dev/vg00/lvol3 mount点下文件挂载数(ff获取)
                    collResult.addKPI(mountUnitId+fileMount,
                            "PM-20-21-029-01", fileMountNUM_ff);
                    //mount点下文件挂载数（bdf获取）
                    collResult.addKPI(mountUnitId+fileMount,
                            "PM-20-21-029-02", fileMountNUM_bdf);

                    checkMountSize(collResult, mountUnitId, path, pro, ht, fileMount, mountSize);
                    i=i+3;
                }
            }
            PropertyUtils.setValueAndStore(path, ht);
            lock.writeLock().unlock();
        } catch (Exception e){
            logger.error("[HP COLL] Exception while execute getFileMount",e);
        }

        return collResult.getKPISet();
    }

    /**
     * 网络连接性故障信息
     * @param params
     * @return
     */
    public Vector<TblATO_KPIDETAIL> getNetLog(HashMap<String, String> params) {
        logger.info("begin getNetLog ");
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        List<String> result = null;
        List<List<String>> list = null;
        try {

            exec(SH_COLL_NETLOG);
            result = getResult(RESULT_NETLOG);
            if(result == null || result.size() == 0){
                return collResult.KPISet;
            }
            list = parseResult(result,2);

            // 获取主机名称
            String deviceId = params.get("DEVICE_ID");
            if(null==deviceId || "".equals(deviceId.trim())){
                List<String> vHostName = list.get(0);
                deviceId = split(vHostName.get(0), 1);
            }

            List<String> netlogV = list.get(1);
            String now = this.getVetorString(netlogV);
            String data_path = "../filechange";
            String now_filename = "now_" + deviceId + "-netlog.dat";
            String tmp_filename = "tmp_" + deviceId + "-netlog.dat";
            String diff_filename = "diff_" + deviceId + "-netlog.dat";

            //目录不存在则创建
            File f = new File(data_path);
            if(!f.exists()){
                f.mkdir();
            }

            File now_file = new File(data_path+"/" + now_filename);// 最新日志信息
            File tmp_file = new File(data_path+"/" + tmp_filename);// 上次日志信息
            File diff_file = new File(data_path+"/" + diff_filename);// 增量日志
            PrintWriter write_now = new PrintWriter(new OutputStreamWriter(
                    new FileOutputStream(now_file), "GB2312"));
            PrintWriter write_tmp = new PrintWriter(new OutputStreamWriter(
                    new FileOutputStream(tmp_file, true), "GB2312"));
            PrintWriter write_diff = new PrintWriter(new OutputStreamWriter(
                    new FileOutputStream(diff_file), "GB2312"));
            String path = now_file.getAbsolutePath();
            logger.info("Current path is " + path);
            // 日志解析
            if (tmp_file.exists() && tmp_file.length() > 0) {// 非第一次采集
                write_now.write(now);
                write_now.flush();
                write_now.close();
                // 读取上次日志文件(tmp)
                FileReader tmp_reader = new FileReader(tmp_file);
                BufferedReader tmp = new BufferedReader(tmp_reader);
                String line;
                String tmp_file_string = "";
                while ((line = tmp.readLine()) != null) {
                    tmp_file_string += line + "\n";
                }
                tmp.close();
                tmp_reader.close();
                // 读取本次日志文件(now)，生成差异文件(diff)
                FileReader now_reader = new FileReader(now_file);
                BufferedReader br = new BufferedReader(now_reader);
                while ((line = br.readLine()) != null) {
                    if (tmp_file_string.indexOf(line) == -1)
                        write_diff.write(line);
                    else
                        continue;
                }
                br.close();
                now_reader.close();
                write_diff.flush();
                write_diff.close();
                write_tmp = new PrintWriter(new OutputStreamWriter(
                        new FileOutputStream(tmp_file), "GB2312"));
                write_tmp.write(now);
                write_tmp.flush();
                write_tmp.close();
            } else {// 第一次采集
                write_tmp.write(now);
                write_tmp.flush();
                write_tmp.close();
                write_diff.write(now);
                write_diff.flush();
                write_diff.close();
            }
            // 生成指标
            FileReader diff_reader = new FileReader(diff_file);
            BufferedReader diff = new BufferedReader(diff_reader);
            String host_name = deviceId;
            // 得到unit_id中使用的主机名称
            String neat_host_name = Formater.neatenunitid(host_name);
            int j = 0;
            String tempDiff = "";
            String tempLine = "";
            //限制为10条
            while ((tempLine = diff.readLine()) != null && j < 10) {
//                tempDiff =tempDiff+ tempLine+ "\r\n";
                j++;

            }
            //配置告警kpi-网络连接性故障
            if (j>0){
                collResult.addKPI("10-10-21-28:" + neat_host_name, "FM-00-01-028-06","true");
//                collResult.addKPI("10-10-21-69:" + neat_host_name+ "-netLogDiff", "FM-00-01-028-07", tempDiff);
            }else{
                collResult.addKPI("10-10-21-28:" + neat_host_name, "FM-00-01-028-06","false");
            }

            diff.close();
            diff_reader.close();
        } catch (Exception e) {
            e.getMessage();
            e.printStackTrace();
        } finally {

        }
        return collResult.getKPISet();
    }

    /**
     * 内置RAID状态检查（适用于配置了SAS RAID控制卡的主机）
     * @param params
     * @return
     */
    public Vector<TblATO_KPIDETAIL> getRAIDStatus(HashMap<String, String> params) {
        logger.info("[HP COLL]begin getRAIDStatus");

        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        List<String> result = null;
        List<List<String>> list = null;

//        exec(SH_COLL_RAIDSTATUS);
        // 获得脚本执行结果
        result = getResult(RESULT_RAIDSTATUS);
        if(result == null || result.size() == 0){
            return collResult.KPISet;
        }
        // 分隔每个命令的执行结果
        list = parseResult(result, 3);


        // 获取主机名称
        String deviceId = params.get("DEVICE_ID");
        if(null==deviceId || "".equals(deviceId.trim())){
            List<String> vHostName = list.get(0);
            deviceId = split(vHostName.get(0), 1);
        }
        // 得到unit_id中使用的主机名称
        String neat_host_name = Formater.neatenunitid(deviceId);
        // 本方法得到的kpi值的unit_id,均以PRE_UNITID + "-28"开头
        String ntpq_PRE_UNITID = PRE_UNITID + "-28";
        try{
            List<String> sasmgrInfo = list.get(1);
            int sasmgrFailedNUM = 0;
            if (sasmgrInfo != null && sasmgrInfo.size() > 0) {
                for (int i = 0; i < sasmgrInfo.size(); i++) {
                    if(StringUtils.contains((String) sasmgrInfo.get(i),"failed")){
                        sasmgrFailedNUM++;
                        logger.info("into sasmgr get_info -D" + (String) sasmgrInfo.get(i));
                    }
                }
            }
            //sasmgr检查错误数
            collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name + "-sasmgrInfo",
                    "FM-00-01-028-08", Integer.toString(sasmgrFailedNUM));
        } catch (Exception e){
            logger.error("[HP COLL] Exception while execute getSasmgrInfo",e);
        }
        try{
            List<String> sautilInfo = list.get(2);
            int sautilFailedNUM = 0;
            if (sautilInfo != null && sautilInfo.size() > 0) {
                for (int i = 0; i < sautilInfo.size(); i++) {
                    if(StringUtils.contains((String) sautilInfo.get(i),"failed")){
                        sautilFailedNUM++;
                        logger.info("into getSautilInfo:" + (String) sautilInfo.get(i));
                    }
                }
            }
            //sautil检查错误数
            collResult.addKPI(ntpq_PRE_UNITID + ":" + neat_host_name + "-sautilInfo",
                    "FM-00-01-028-09", Integer.toString(sautilFailedNUM));
        } catch (Exception e){
            logger.error("[HP COLL] Exception while execute getSautilInfo",e);
        }

        return collResult.getKPISet();
    }


    public Vector getProcessTop10Cpu(HashMap params) {
        logger.info("begin getProcessTop10Cpu");
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        List<String> result = null;
        List<List<String>> list = null;

        exec(SH_COLL_PROCESS);
        // 获得脚本执行结果
        result = getResult(RESULT_PROCESS);
        if(result == null || result.size() == 0){
            return collResult.KPISet;
        }
        // 分隔每个命令的执行结果
        list = parseResult(result, 2);
        // 获取主机名称
        String deviceId = (String)params.get("DEVICE_ID");
        if(null==deviceId || "".equals(deviceId.trim())){
            List<String> vHostName = list.get(0);
            deviceId = split(vHostName.get(0), 1);
        }
        // 得到unit_id中使用的主机名称
        String neat_host_name = Formater.neatenunitid(deviceId);
        try {
            //占用CPU前十进程
            String pro_PRE_UNITID = PRE_UNITID + "-32:" + neat_host_name;
            List<String> processInfos = list.get(1);
            if (processInfos == null || processInfos.equals("") || processInfos.equals("null")) {
                //
            } else {
                //拆出进程信息
                String tempLine = "CPU TTY  PID USERNAME PRI NI   SIZE    RES STATE    TIME %WCPU  %CPU COMMAND";
                int processLine = 0;
                for (int i = 0;i< processInfos.size();i++) {
                    if(processInfos.get(i).equals(tempLine)){
                        processLine = i+1;
                    }
                }
                processInfos = processInfos.subList(processLine,processInfos.size());
                //解析结果
                int k = 1;
                for(String processInfo : processInfos){
                    String processPid = split(processInfo, 2);
                    String processUser = split(processInfo, 3);
                    String processMem = split(processInfo, 7);
                    String processState = split(processInfo, 8);
                    String processCpu = split(processInfo, 10);
                    String unitId = pro_PRE_UNITID + "-" + k++;
                    // 进程用户
                    collResult.addKPI(unitId, "CM-00-01-005-06", processUser);
                    // 进程PID
                    collResult.addKPI(unitId, "CM-00-01-005-01", processPid);
                    // 进程占用CPU百分比
                    collResult.addKPI(unitId, "PM-00-01-005-10", processCpu);
                    // 进程占用MEM
                    collResult.addKPI(unitId, "PM-00-01-005-14", processMem);
                    // 进程状态
                    collResult.addKPI(unitId, "PM-00-01-005-02", processState);
                }
            }
        } catch (Exception e) {
            logger.error("getProcessTop10Cpu has error", e);
        }
        logger.info("end getProcessTop10Cpu");
        return collResult.getKPISet();
    }

    public Vector getProcessByKey(HashMap<String, String> params) {
        logger.info("begin getProcessByKey");
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        List<String> result = null;
        List<List<String>> list = null;
        String keywords = params.get("KEYWORDS");
        String[] keywordsList = keywords.split("#");

        exec(SH_COLL_KEY_PROCESS);
        // 获得脚本执行结果
        result = getResult(RESULT_KEY_PROCESS);
        if(result == null || result.size() == 0){
            return collResult.KPISet;
        }
        // 分隔每个命令的执行结果
        list = parseResult(result, 3);
        // 获取主机名称
        String deviceId = (String)params.get("DEVICE_ID");
        if(null==deviceId || "".equals(deviceId.trim())){
            List<String> vHostName = list.get(0);
            deviceId = split(vHostName.get(0), 1);
        }
        // 得到unit_id中使用的主机名称
        String neat_host_name = Formater.neatenunitid(deviceId);
        try {
            String pro_PRE_UNITID = PRE_UNITID + "-25:" + neat_host_name;
            List<String> processInfos = list.get(1);
            List<String> memInfo = list.get(2);
            BigDecimal menTotal = BigDecimal.valueOf(Double.valueOf(split(memInfo.get(0),1)));
            int i = 1;
            for (String processInfo : processInfos) {
                for(String key : keywordsList){
                    if(StringUtils.contains(processInfo,key)){
                        String processUser = split(processInfo, 4);
                        String processPid = split(processInfo, 3);
                        String processCpu = split(processInfo, 0);
                        String processCmd = split(processInfo, 7);
                        processCmd = processCmd+StringUtils.substringAfter(processInfo, processCmd);
                        String memSize = split(processInfo, 2);
                        BigDecimal processMem = BigDecimal.valueOf(Double.valueOf(memSize)*400).divide(menTotal.multiply(BigDecimal.valueOf(1024)),2,RoundingMode.HALF_UP);
                        System.out.println(processUser + "#@#" + processPid + "#@#" + processCpu + "#@#" + processMem.toString());
                        String unitId = pro_PRE_UNITID + "-" + i++;
                        // 进程用户
                        collResult.addKPI(unitId, "CM-00-01-005-06", processUser);
                        // 进程ID
                        collResult.addKPI(unitId, "CM-00-01-005-01", processPid);
                        // 进程占用CPU百分比
                        collResult.addKPI(unitId, "PM-00-01-005-10", processCpu);
                        // 进程占用MEM百分比
                        collResult.addKPI(unitId, "PM-00-01-005-11", processMem.toString());
                        // 进程指令行
                        collResult.addKPI(unitId, "CM-00-01-005-08", processCmd);
                        // 更新时间
                        collResult.addKPI(unitId, "CM-00-03-002-10", Formater.datetimeToString(new Date()));
                    }
                }
            }
        } catch (Exception e) {
            logger.error("getProcessTop10Cpu has error", e);
        }
        logger.info("end getProcessTop10Cpu");
        return collResult.getKPISet();
    }
    /**
     * 网络信息
     * @param params
     * @return
     */
    public Vector<TblATO_KPIDETAIL> getNet(HashMap<String, String> params) {
        logger.info("[HP COLL]begin getNet");
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        List<String> result = null;
        List<List<String>> list = null;

        exec(SH_COLL_NET);
        // 获得脚本执行结果
        result = getResult(RESULT_NET);
        if(result == null || result.size() == 0){
            return collResult.KPISet;
        }
        // 分隔每个命令的执行结果
        list = parseResult(result, 4);


        // 获取主机名称
        String deviceId = params.get("DEVICE_ID");
        if(null==deviceId || "".equals(deviceId.trim())){
            List<String> vHostName = list.get(0);
            deviceId = split(vHostName.get(0), 1);
        }
        // 得到unit_id中使用的主机名称
        String neat_host_name = Formater.neatenunitid(deviceId);
        String unitId = PRE_UNITID + "-10:"+neat_host_name+"-total";
        try{
            List<String> netResult = list.get(1);
            int fin_wait_number =0;
            int wait_number =0;
            int established_number =0;
            for(String tempNet : netResult){
                if(tempNet.contains("FIN")){
                    fin_wait_number++;
                }else if(tempNet.contains("WAIT")){
                    wait_number++;
                }else if(tempNet.contains("ESTABLISHED")){
                    established_number++;
                }
            }
            // 失效网络数
            collResult.addKPI(unitId, "PM-00-01-006-11", Integer.toString(fin_wait_number));
            // 等待网络数
            collResult.addKPI(unitId, "PM-00-01-006-12",Integer.toString(wait_number));
            // 连接网络数
            collResult.addKPI(unitId, "PM-00-01-006-13",Integer.toString(established_number));
        } catch (Exception e){
            logger.error("[HP COLL] Exception while execute getNet",e);
        }

        // ---------------------------- 网卡配置Begin -------------------------------------------
        // netstat -in | grep -v Mtu | grep -v 127.0.0.1 | grep -v none

        logger.info("=========================netstat  lanscan start=========================");
        List<String> netstatV = list.get(2);

        // lanscan | grep -v Hardware | grep -v Path
        List<String> lanscanV = list.get(3);

        // CM-00-01-001-10 系统网络接口数 , lanscan得出的行数
        collResult.addKPI(unitId, "CM-00-01-001-10", String.valueOf(lanscanV.size()));

        Map<String, String> ips = new HashMap<String, String>();
        long lan_ipkts_total = 0;
        long lan_opkts_total = 0;
        for (String netstatInfo: netstatV) {
            String lanName = split(netstatInfo, 0);
            String ip = split(netstatInfo, 3);
            lan_ipkts_total = lan_ipkts_total+ Long.parseLong(split(netstatInfo, 4));
            lan_opkts_total = lan_opkts_total+ Long.parseLong(split(netstatInfo, 6));
            ips.put(lanName, ip);
        }
        //网卡总出包数
        collResult.addKPI(unitId, "PM-00-01-001-17", String.valueOf(lan_opkts_total));
        //网卡总入包数
        collResult.addKPI(unitId, "PM-00-01-001-18", String.valueOf(lan_ipkts_total));

        Map<String, String> phyAddrMap = new HashMap<String, String>();
        Map<String, String> ifStateMap = new HashMap<String, String>();
        for (String lancanInfo : lanscanV) {
            String lanName = split(lancanInfo, 4);
            String phyAddr = split(lancanInfo, 1);
            String ifState = split(lancanInfo, 3);
            phyAddrMap.put(lanName, phyAddr);
            ifStateMap.put(lanName, ifState);
        }

        Set<String> ipskeys = ips.keySet();
        Object[] arrObj = ipskeys.toArray();

        String serviceIp = "";
        for (String lanName : ips.keySet()) {
            if (null != phyAddrMap.get(lanName)) {
                String ifUnitId = this.PRE_UNITID + "-16:" + deviceId + "-" + Formater.neatenunitid(lanName);
                // 系统网络接口IP地址
                collResult.addKPI(ifUnitId, "CM-00-01-001-11", ips.get(lanName));

                // 系统网络接口物理地址
                collResult.addKPI(ifUnitId, "CM-00-01-001-12", phyAddrMap.get(lanName));

                // 网卡状态
                collResult.addKPI(ifUnitId, "FM-00-01-001-03", ifStateMap.get(lanName));

                serviceIp = serviceIp + "," + ips.get(lanName);
            }
        }

        // 主机（服务）地址 CM-00-01-001-02， 将所有ip地址累加
        if (serviceIp.length() > 0) {
            collResult.addKPI(unitId, "CM-00-01-001-02", serviceIp.substring(1));
        }

        logger.info("=========================netstat  lanscan end=========================");
        // ---------------------------- 网卡配置End -------------------------------------------

        return collResult.getKPISet();
    }
    public Vector<TblATO_KPIDETAIL> getFileChange(HashMap<String, String> params) {
        logger.info("Begin getFileChange...");
        logger.info(params.toString());
        CollBase collResult = new CollBase();
        // 执行脚本
        exec(SH_COLL_FILE);
        // 获得脚本执行结果
        List<String> result = getResult(RESULT_FILE);
        if(null == result || result.isEmpty()){
            return collResult.KPISet;
        }
        List<List<String>> list = parseResult(result);
        String deviceId = params.get("DEVICE_ID");
        String UNIT_ID = params.get("KBP_CLASS");
        if(null == deviceId || "".equals(deviceId.trim())){
            // 获取主机名称 : uname -a
            List<String> vHostName = list.get(0);
            deviceId = split(vHostName.get(0), 1);
        }
        //kctune 系统参数变动监控
        try{
            List<String> netlogV = list.get(1);
            String host_name = deviceId;
            // 得到unit_id中使用的主机名称
            String neat_host_name = Formater.neatenunitid(host_name);
            //文件名称
            collResult.addKPI(UNIT_ID + "-20:" + neat_host_name+"-kctune", "CM-10-10-020-01", "kctune");
            Boolean isChange = checkFileChange(netlogV,"kctune",deviceId);
            //变动部分有结果,则生成告警指标
            collResult.addKPI(UNIT_ID + "-20:" + neat_host_name+"-kctune", "FM-10-10-020-01",isChange.toString());

        } catch (Exception e) {
            e.getMessage();
            e.printStackTrace();
        } finally {

        }
        try {
            //得到filechange UnitId
            String filechangeUnitId = UNIT_ID + "-20:" +  deviceId + "-";

            /**
             * 分析传入的文件绝对路径参数
             * 如果传入的参数中是路径则采集该路径下所有的文件
             * 如果传入的参数中包含文件名则采集该文件
             */
            for(int n=2;n <list.size();n++){
                List<String> paths = list.get(n);
                if(paths.size()<2) continue;//如果某条指令结果不正常，跳过；
                String p = paths.get(0);
                //文件名称
                collResult.addKPI(filechangeUnitId+p, "CM-10-10-020-01", p);
                Boolean isChange = checkFileChange(paths,p,deviceId);
                //变动部分有结果,则生成告警指标
                collResult.addKPI(filechangeUnitId+ p, "FM-10-10-020-01",isChange.toString());
            }
        }catch (Exception e) {
            logger.error("Exception while get fileChange!",e);
        }
        logger.info("END COLL fileChange ");
        return collResult.getKPISet();
    }

    private Boolean checkFileChange(List result,String fileName,String deviceId){
        Boolean isChange = false;
        try{
            String now = this.getVetorString(result);
            String data_path = "../filechange";
            fileName = StringUtils.replace(fileName,"/","-");
            String now_filename = "now_" + deviceId + "-"+fileName+".dat";
            String tmp_filename = "tmp_" + deviceId + "-"+fileName+".dat";
            String diff_filename = "diff_" + deviceId + "-"+fileName+".dat";

            //目录不存在则创建
            File f = new File(data_path);
            if(!f.exists()){
                f.mkdir();
            }

            File now_file = new File(data_path+"/" + now_filename);// 最新日志信息
            File tmp_file = new File(data_path+"/" + tmp_filename);// 上次日志信息
            File diff_file = new File(data_path+"/" + diff_filename);// 增量日志
            PrintWriter write_now = new PrintWriter(new OutputStreamWriter(
                    new FileOutputStream(now_file), "GB2312"));
            PrintWriter write_tmp = new PrintWriter(new OutputStreamWriter(
                    new FileOutputStream(tmp_file, true), "GB2312"));
            PrintWriter write_diff = new PrintWriter(new OutputStreamWriter(
                    new FileOutputStream(diff_file), "GB2312"));
            String path = now_file.getAbsolutePath();
            logger.info("Current path is " + path);
            // 日志解析
            if (tmp_file.exists() && tmp_file.length() > 0) {// 非第一次采集
                write_now.write(now);
                write_now.flush();
                write_now.close();
                // 读取上次日志文件(tmp)
                FileReader tmp_reader = new FileReader(tmp_file);
                BufferedReader tmp = new BufferedReader(tmp_reader);
                String line;
                String tmp_file_string = "";
                while ((line = tmp.readLine()) != null) {
                    tmp_file_string += line + "\n";
                }
                tmp.close();
                tmp_reader.close();
                // 读取本次日志文件(now)，生成差异文件(diff)
                FileReader now_reader = new FileReader(now_file);
                BufferedReader br = new BufferedReader(now_reader);
                while ((line = br.readLine()) != null) {
                    if (tmp_file_string.indexOf(line) == -1)
                        write_diff.write(line);
                    else
                        continue;
                }
                br.close();
                now_reader.close();
                write_diff.flush();
                write_diff.close();
                write_tmp = new PrintWriter(new OutputStreamWriter(
                        new FileOutputStream(tmp_file), "GB2312"));
                write_tmp.write(now);
                write_tmp.flush();
                write_tmp.close();

                // 生成指标
                FileReader diff_reader = new FileReader(diff_file);
                BufferedReader diff = new BufferedReader(diff_reader);
                //变动部分有结果,则生成告警指标
                if (diff.readLine() != null) {
                    isChange =true;
                }
                diff.close();
                diff_reader.close();
            } else {// 第一次采集
                write_tmp.write(now);
                write_tmp.flush();
                write_tmp.close();
                write_diff.write(now);
                write_diff.flush();
                write_diff.close();
            }
        }catch (Exception e) {
            logger.error("Exception while get fileChange!",e);
        }finally {

            return isChange;
        }
    }

    public String getVetorString(List v) {
        StringBuffer sb = new StringBuffer();
        if (v != null && v.size() > 0) {
            for (int i = 0; i < v.size(); i++) {
                String s = (String) v.get(i);
                if (s != null && i < v.size()) {
                    sb.append(s + "\n");
                }
            }
        }
        return sb.toString();
    }


    /**
     * 通知执行脚本
     * 通知方式：写一个文件(文件名为采集脚本名称，如：getCpu.sh、getMem.sh)到notice目录，
     * contab会定时执行脚本扫描该目录，得到文件名，并执行脚本
     *
     * @throws
     * @since Ver 1.1
     */
    private void exec(String shellName) {
        String noticePath = "../notice/ibm/";
        String noticeFileName = noticePath + shellName;
        PrintWriter kpiFileStream = null;
        try {
            kpiFileStream = new PrintWriter(new FileWriter(Formater.replaceSpace(noticeFileName), false), true);
            kpiFileStream.println(shellName);
        } catch (IOException e) {
            logger.error("[HP COLL] Exception while exec(" + shellName + ")", e);
        } finally {
            if (kpiFileStream != null) {
                kpiFileStream.flush();
                kpiFileStream.close();
            }
        }
    }


    /**
     * 获得脚本执行结果
     *
     * @throws
     * @since　Ver 1.1
     */
    private List<String> getResult(String resultFileName) {
        try {
            Thread.sleep(20 * 1000L);
        } catch (InterruptedException e) {
            logger.warn("[HP COLL] InterruptedException.");
        }

        StringBuffer sb = new StringBuffer();
        // 超时时间：2分钟
        long timeout = 3 * 60 * 1000L;
        List<String> result = new ArrayList<String>();
        long beginTime = new Date().getTime();
        File file = new File(RESULT_PATH);
        while (true) {
            if (new Date().getTime() - beginTime > timeout) {
                // 超时退出
                logger.warn("[HP COLL] Timeout, exit.");
                break;
            }

            File[] filelist = file.listFiles();
            if (filelist == null || filelist.length == 0) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    logger.error("[HP COLL] InterruptedException", e);
                }
                continue;
            }

            File resultFile = null;
            // 根据文件名找到采集文件
            for (int i = 0; i < filelist.length; i++) {
                if (filelist[i].getName().startsWith(resultFileName)) {
                    resultFile = filelist[i];
                    break;
                }
            }

            if (resultFile != null) {
                BufferedReader br = null;
                try {
                    br = new BufferedReader(new FileReader(resultFile));
                    String line = "";
                    while ((line = br.readLine()) != null) {
                        result.add(line);
                        sb.append(line + "\n");
                    }
                    break;
                } catch (Exception e) {
                    logger.error("[HP COLL] Exception while readFile:" + resultFileName, e);
                } finally {
                    if (br != null) {
                        try {
                            br.close();
                        } catch (IOException e) {
                            logger.error("[HP COLL] IOException:", e);
                        }
                    }
                    logger.info("[HP COLL] Delete coll result file : " + resultFile.getName());
                    logger.info(RESULT_PATH + ":\n" + sb.toString());
                    resultFile.delete();
                }
            }
        }// end while

        return result;
    }

    /**
     * 解析每个命令的执行结果
     *
     * @throws
     * @since　Ver 1.1
     */
    private List<List<String>> parseResult(List<String> result) {
        //计算结果有多少个分割线分割的集合
        int num =1;
        for (String line : result) {
            if (line.trim().equals(SPLIT_LINE) || line.trim().endsWith(SPLIT_LINE)){
                num++;
            }
        }

        List<List<String>> list = new ArrayList<List<String>>();
        for (int i = 0; i < num; i++) {
            list.add(new ArrayList<String>());
        }

        int i = 0;
        for (String line : result) {
            if (line.trim().equals(SPLIT_LINE)) {
                i++;
                continue;
            }else if(line.trim().endsWith(SPLIT_LINE)){
                line = line.replace(SPLIT_LINE,"");
                list.get(i).add(line);
                i++;
            }else{
                list.get(i).add(line);
            }
        }
        return list;
    }

    /**
     * 解析每个命令的执行结果
     *
     * @throws
     * @since　Ver 1.1
     */
    private List<List<String>> parseResult(List<String> result, int num) {
        List<List<String>> list = new ArrayList<List<String>>();
        for (int i = 0; i < num; i++) {
            list.add(new ArrayList<String>());
        }

        int i = 0;
        for (String line : result) {
            if (line.trim().equals(SPLIT_LINE)) {
                i++;
                continue;
            }else if(line.trim().endsWith(SPLIT_LINE)){
                line = line.replace(SPLIT_LINE,"");
                list.get(i).add(line);
                i++;
            }else{
                list.get(i).add(line);
            }
        }
        return list;
    }

    /**
     * 挂载点占用空间变动验证并记录告警和空间大小kpi
     * @param collResult
     * @param mountUnitId
     * @param path
     * @param pro
     * @param ht
     * @param fileMount
     * @param mountSize
     */
    private void checkMountSize(CollBase collResult, String mountUnitId,
                               String path, Properties pro, Hashtable<String, String> ht,
                               String fileMount, String mountSize) {
        //mount点占用空间
        collResult.addKPI(mountUnitId+fileMount,"PM-20-21-029-03", mountSize);
        String oldsize="";
        boolean sizekey = pro.containsKey(mountUnitId+fileMount+"[PM-20-21-029-03]");
        if(sizekey){
            //获得上次采集数据
            oldsize=pro.getProperty(mountUnitId+fileMount+"[PM-20-21-029-03]");
            //对比上次采集结果创建文件变更kpi
            if(!mountSize.equals(oldsize)){
                collResult.addKPI(mountUnitId+fileMount, "FM-20-21-029-01", "true");
            }else{
                collResult.addKPI(mountUnitId+fileMount, "FM-20-21-029-01", "false");
            }

        }
        if(!sizekey){
            ht.put(mountUnitId+fileMount+"[PM-20-21-029-03]", mountSize);
        }else{
            PropertyUtils.updateValue(path, mountUnitId+fileMount+"[PM-20-21-029-03]", mountSize);
        }
    }

    public static void main(String[] args) {

//        System.out.println(BigDecimal.valueOf(912).divide(BigDecimal.valueOf(1024),2, RoundingMode.HALF_UP));
//        System.out.println(StringUtils.substringAfterLast("aababcc","b"));
//        System.out.println(StringUtils.substringAfter("aababcc","b"));
//        System.out.println(StringUtils.substringBefore("aababcc","b"));
//        System.out.println(StringUtils.substringBeforeLast("aababcc","b"));
        HashMap<String, String > params = new HashMap<String, String>();
        params.put("bin_home", "/yfbnms/agent/masteragent/cron_temp/");
        params.put("IP_ADDR", "172.21.0.117");
        params.put("KEYWORDS", "masteragent#WebLogic");
        CollHPWithCMDByCron coll = new CollHPWithCMDByCron();
        coll.getConfig(params);
        Vector<TblATO_KPIDETAIL> result = coll.getConfig(params);
        //Vector<TblATO_KPIDETAIL> result = coll.getCpu(params);
        for (int i = 0; i < result.size(); i++) {
            TblATO_KPIDETAIL record = (TblATO_KPIDETAIL) result.get(i);
            System.out.println(record.UNIT_ID + "\t" + record.KPI_ID + "\t" + record.KPI_VALUE);
        }
//        List<String> result = coll.getResult(RESULT_CONFIG);
//        List<List<String>> list = coll.parseResult(result, 12);
//        coll.getConfig(params);
    }

}