package com.sitech.ismp.coll.centercoll;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Pattern;

import com.tongweb.server.logging.SystemOutandErrHandler;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

import com.sitech.ismp.coll.CollBase;
import com.sitech.ismp.coll.basic.TblATO_KPIDETAIL;
import com.sitech.util.DES3;
import com.sitech.util.Formater;
import com.sitech.util.JSONUtil;
import com.sitech.util.upload.RomoteController;
import com.sitech.util.upload.SSHThread;
import com.sitech.util.upload.TelnetThread;

/**
 * @author maozr 修改版本： 与IBM、HP主机采集指标的度量单位一致,将内存大小指标（CM-00-01-001-07）采集到的值升级到M
 */
public class CollLinuxWithCMD {

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

	String PRE_UNITID = "10-10-24"; // linux主机的标识

	RomoteController tt = null;
	String neat_host_name = "";
	String hostname = "";
	String ipAddr;
	Vector result = new Vector();
	TblATO_KPIDETAIL record = null;
	String value = null;
	boolean isConnect = false;
	static private String data_path;
    DecimalFormat df = new DecimalFormat("#.###");

    boolean flag = false;

	public String split(String str, int pos) {
		StringTokenizer st = new StringTokenizer(str);
		Vector values = new Vector();
		while (st.hasMoreTokens()) {
			values.add(st.nextToken());
		}
		if (pos >= 0 && pos < values.size()) {
			return (String) values.elementAt(pos);
		}
		return "";
	}

	public void init(HashMap params) {
        String user = null;
        String passwd = null;
        String protol = null;
        if (this.flag) {
            ipAddr = (String)params.get("PING_IP_ADDR");
            user = (String)params.get("PING_USERNAME");
            passwd = (String)params.get("PING_PASSWORD");
            protol = (String)params.get("PING_PROTOCOL");
        } else {
            ipAddr = (String)params.get("IP_ADDR");
            user = (String)params.get("USERNAME");
            passwd = (String)params.get("PASSWORD");
            protol = (String)params.get("PROTOCOL");
        }
        passwd = DES3.decrypt(passwd);
		hostname = (String) params.get("HOSTNAME");
		this.neat_host_name = Formater.neatenunitid(hostname);
		
		String protocolPort = null;
		if (params.get("PROTOCOL_PORT") != null) {
			protocolPort = ((String) params.get("PROTOCOL_PORT")).trim();
		}


        if (protol != null && protol.equals("telnet")) {
            if (null != protocolPort && !"".equals(protocolPort)) {
                tt = new TelnetThread(ipAddr, Integer.parseInt(protocolPort), user, passwd);
            } else {
                tt = new TelnetThread(ipAddr, 23, user, passwd);
            }
        } else {
            if (null != protocolPort && !"".equals(protocolPort)) {
                tt = new SSHThread(ipAddr, Integer.parseInt(protocolPort), user, passwd);
            } else {
                tt = new SSHThread(ipAddr, 22, user, passwd);
            }
        }

		tt.initial();
		
		this.isConnect = tt.isAuthorized();
	}

	public Vector collLinux(HashMap params) {
		try {
			init(params);
		} catch (Exception e) {
			logger.error("Exception while init Linux Coll:" + JSONUtil.toJSON(params), e);
		} finally {
			this.release();
		}
		neat_host_name = Formater.neatenunitid(this.hostname);
		if (isConnect) {
			result.addAll(getConfig(params));
//			result.addAll(getCpu(params));
//			result.addAll(getMemory(params));
//			result.addAll(getDiskForIOstat(params));
//			//result.addAll(getDisk(params));
//			result.addAll(getFileSystem(params));
//			//result.addAll(getSpecProcess(params));
//			//result.addAll(getSpecUserProNum(params));
//			result.addAll(getUserProNum(params));
//			result.addAll(getDmesg(params));
		}
		return result;
	}
	
	/**
	 * @return 采集时间
	 */
	private String getCollTime(){
		try{
			return Formater.datetimeToString(new Date());
		}catch (Exception e) {
			logger.error("Exception while getCollTime()", e);
		}
		return null;
	}

	public Vector getConfig(HashMap params) {

        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
		try {
			init(params);
			
			if(!tt.isAuthorized()){
				String totalUnitId = this.PRE_UNITID + "-10:" + neat_host_name + "-total";
//				collResult.addKPI(totalUnitId, "FM-00-01-001-01", tt.getError());
				return collResult.KPISet;
			}else{
				String totalUnitId = this.PRE_UNITID + "-10:" + neat_host_name + "-total";
//				collResult.addKPI(totalUnitId, "FM-00-01-001-01", "UP");
			}
			
			
			// 本方法得到的kpi值的unit_id,均以PRE_UNITID + "-10"开头，代表Total数据
			String config_PRE_UNITID = PRE_UNITID + "-10"; // total值
			
			

			// 获取主机名称
			Vector host = tt.getResultAsVector("uname -a");

			String realHostName = split((String) host.elementAt(0), 1);
			String os_version = split((String) host.elementAt(0), 2);

			System.out.println("host_type : "+split((String) host.elementAt(0), 0));
			String host_type = split((String) host.elementAt(0), 0);

			// 增加采集时间指标
//			collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name + "-total", "CM-00-01-001-22", getCollTime());

			// 常用ip,用于告警标题
			/*collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
					+ "-total", "CM-00-01-001-50", (String) params
					.get("IP_ADDR"));*/
			
			collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
					+ "-total", "CM-00-01-001-02", (String) params
					.get("IP_ADDR"));
			
			// 主机名称
			collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
					+ "-total", "CM-00-01-001-01", realHostName);

//			// 主机类型
//			collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
//					+ "-total", "CM-00-01-001-03", "Linux");

			// 主机操作系统版本 CM-00-01-001-08
			collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
					+ "-total", "CM-00-01-001-08", host_type + " " + os_version);
			//zhangdj-add
			//主机操作系统类型
			collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name 
					+ "-total", "CM-00-01-001-010", host_type);
			//主机型号
			String host_model = "uname -i";
			Vector vc = tt.getResultAsVector(host_model);
			host_model = split((String) vc.elementAt(0), 0);
			System.out.println("host_model : "+host_model);
			collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name 
					+ "-total", "CM-00-01-001-011", host_model);
			
			// ----cpu信息 ， CM-00-01-001-04(个数)/05(型号)/06(主频)-----
			// Vector cpunumV = tt.getResultAsVector("sh linux/cpucount.sh");
			// 1 CM-00-01-001-04 cpu个数
			// cat /proc/cpuinfo |grep "physical id"|sort -u
			String cupcount_cmd = "cat /proc/cpuinfo |grep \"physical id\"|sort -u";
			Vector cpunumV = tt.getResultAsVector(cupcount_cmd);
			String cpu_size = String.valueOf(cpunumV.size());

			collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
					+ "-total", "CM-00-01-001-04", Formater
					.formatDecimalKpivalue(cpu_size));

			// 2 CM-00-01-001-05 cpu类型
			// Vector cputypeV = tt.getResultAsVector("sh linux/cpuinfo.sh");
			// cat /proc/cpuinfo |grep "model name"|sort -u
			//cat /proc/cpuinfo|grep \"model name\"|awk '{print $4,$5,$6,$7,$8,$9,$10}'|sort -u
			String cuptype_cmd = "cat /proc/cpuinfo|grep \"model name\"|awk '{print $4,$5,$6,$7,$8,$9,$10}'|sort -u";
			Vector cputypeV = tt.getResultAsVector(cuptype_cmd);
			if (cputypeV != null && cputypeV.size() != 0) {
				String cpu_type = (String) cputypeV.elementAt(0);
				System.out.println("linux cpu type:"+cpu_type);
//				int index_split = cpu_type.indexOf(":");
//				if (index_split >= 0 && index_split + 1 < cpu_type.length()) {
					collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
							+ "-total", "CM-00-01-001-05", cpu_type
//							.substring(index_split + 1)
							);
//				}
			}
            //cpu主频
			Vector cpu_freq = tt.getResultAsVector("cat /proc/cpuinfo|grep 'cpu MHz'|awk '{print int($4)}'|sort -u");
			if(cpu_freq!=null){
				String freq = (String) cpu_freq.elementAt(0);
				collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
						+ "-total", "CM-00-01-001-06", freq
						);
			}

            // 系统运行时长 PM-20-20-001-52
            Vector uptime = tt.getResultAsVector("export LANG=en_US.UTF-8;uptime | awk '{print $3\" \"$4\" \"$5}'");
            if (uptime != null) {
                String up_time = (String) uptime.elementAt(0);
                collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name + "-total", "PM-20-20-001-52", up_time);
            }

			/*
             * 交换分区大小
			 * 交换分区使用率
			 */
            String swap_String = "/sbin/swapon -s";
            Vector swap_value = tt.getResultAsVector(swap_String);
            int swapSize = swap_value.size();
//			System.out.println("swapSize:"+swapSize);
            if (swapSize > 0) {
                System.out.println("value : " + swap_value.get(0));
                long swap_total = Long.parseLong(split((String) swap_value.elementAt(1), 2).trim()) / 1024;
                Double swap_free = Double.parseDouble(split((String) swap_value.elementAt(1), 3).trim()) / 1024;
                Double rate = swap_free * 100 / swap_total;
                //系统交换区大小CM-00-01-001-13
                collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
                        + "-total", "CM-00-01-001-13", Long.toString(swap_total));
                //交换分区使用率PM-00-01-004-02
                collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
                        + "-total", "PM-00-01-004-02", df.format(Double.parseDouble(Formater.realyRate(String.valueOf(rate)))));
//				System.out.println("total:"+swap_total+"M");
//				System.out.println("free:"+swap_free+"M");
//				System.out.println("rate:"+String.valueOf(rate)+"%");
            }
			/*
			 * 文件系统大小
			 * 文件系统使用率
			 */
			
			
			/*
			 * Vector filerate_result = tt.getResultAsVector("sh linux/mem.sh");
			 * String filerate_string = (String) filerate_result
			 * .elementAt(filerate_result.size() - 1);
			 * 
			 * String sub_msg[] = this.split2Array(filerate_string, " "); String
			 * sum = sub_msg[0].trim(); float value = Float.parseFloat(sum) /
			 * 1000; // 2009-1-17,
			 */
			// maozr有改,单位升级到M
			/*
			 * collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name +
			 * "-total", "CM-00-01-001-07", Formater
			 * .formatDecimalKpivalue(Float.toString(value)));
			 */
			// free -m
			// get total real memory of the host
			String memory_cmd = "cat /proc/meminfo |grep MemTotal|awk '{print int($2/1024)}'";
			Vector memoryV = tt.getResultAsVector(memory_cmd);
			if (memoryV != null && memoryV.size() != 0) {
				String memoryInfo = (String) memoryV.elementAt(0);
                float memTotal = Float.parseFloat(memoryInfo.trim());
//                float memTotal = Float.parseFloat(memoryInfo.trim()) / 1024;
//				while (memoryInfo.indexOf("  ") >= 0) {
//					memoryInfo.replaceAll("  ", " ");
//				}
//				String[] memory = memoryInfo.split(" ");
//				if (memory != null && memory.length >= 2) {
//					String total_memory = memory[1];
					collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name
							+ "-total", "CM-00-01-001-07", Formater.formatDecimalByScale(String.valueOf(memTotal), 2));
//				}

			}

            Vector<String> vSwap = tt.getResultAsVector("free -m");
            for(String swap : vSwap){
                if (swap.indexOf("buffers/cache:") > -1) {
                    Double buffers_used = Double.parseDouble(split(swap, 2).trim());
                    Double buffers_free = Double.parseDouble(split(swap, 3).trim());
                    Double rate = buffers_used * 100 / (buffers_used + buffers_free);
                    String sRate = Formater.formatDecimalKpivalue(String.valueOf(rate));
                    collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name + "-total", "PM-00-01-002-08", sRate);
                }
            }
			
//			try {
//				String memory_type = "dmidecode|grep -P -A5 \"Memory Device\" | grep Size | grep -v \"No Module\" | head -1 | awk -F\" \" '{ print $2 }'";
//				Vector memoryTypeV = tt.getResultAsVector(memory_type);
//				if (memoryTypeV != null && memoryTypeV.size() != 0) {
//					String memoryTypeInfo = (String) memoryTypeV.elementAt(0);
//                    if(Pattern.compile("[0-9]*").matcher(memoryTypeInfo).matches()){//如果memoryTypeInfo为数字，则表示采集成功
//                        collResult.addKPI(config_PRE_UNITID + ":" + neat_host_name + "-total",
//                                "CM-00-01-001-45", memoryTypeInfo);
//                    }
//				}
//			} catch (Exception e) {
//				e.printStackTrace();
//			}

            String username = (String) params.get("USERNAME");
            Vector<String> ulimitV = tt.getResultAsVector("ulimit -a");
            for (String ulimit : ulimitV) {
                if (ulimit.indexOf("open files") > -1) {
                    String _ulimit = split(ulimit, 3).trim();
                    collResult.addKPI(PRE_UNITID + "-71:" + neat_host_name + "-" + username, "CM-00-01-900-16", username);
                    collResult.addKPI(PRE_UNITID + "-71:" + neat_host_name + "-" + username, "PM-00-01-004-13", _ulimit);
                }
            }

            Vector<String> chageV = tt.getResultAsVector("chage -l " + username);
            for (String chage : chageV) {
                if (chage.indexOf("Password expires") > -1) {
                    String _chage = split(chage, 3).trim();
                    collResult.addKPI(PRE_UNITID + "-73:" + neat_host_name + "-" + username, "CM-00-01-900-16", username);
                    collResult.addKPI(PRE_UNITID + "-73:" + neat_host_name + "-" + username, "FM-00-01-026-02", _chage);
                }
            }

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

    public Vector getNet(HashMap params) {
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        try {
            init(params);

            if (!tt.isAuthorized()) {
                return collResult.KPISet;
            }

			/*
			 * 主机网卡采集,共采集三个指标:
			 * 系统网络接口IP(CM-00-01-001-11),
			 * 系统网络接口物理地址(CM-00-01-001-12),
			 * 主机网卡状态(FM-00-01-001-03)
			 * unit_id为:10-10-21-16:主机名-网卡名
			 */
            // first coll
			Vector vLan = tt.getResultAsVector("/sbin/ifconfig -a");
            Date firstDate = new Date();
			int size = vLan.size();

			String net_unit = "10-10-24-16:" + neat_host_name;
			String ip_addr = "&lt;none&gt;";
			String phy_addr = "&lt;none&gt;";
			String state = "down";
			String network_name = "";
			boolean phy_pass = true;
			boolean ip_pass = true;
			boolean state_pass = true;
			boolean hard_pass = true;
            int sleepSeconds = 2;
            String networkName = "";
            String serviceIp = "";

            Map<String, Map<String, String>> networkMap = new HashMap<String, Map<String, String>>();

            for (Object _network : vLan) {
                Map<String, String> map = null;
                String network = (String) _network;
                if (network.indexOf("Link encap:") >= 0) {
                    map = new HashMap<String, String>();
                    networkName = network.substring(0, network.indexOf("Link encap:")).trim();
                    String networkType = "unknown";
                    if(network.indexOf("HWaddr")!=-1){
                        networkType = network.substring(network.indexOf("Link encap:") + "Link encap:".length(), network.indexOf("HWaddr")).trim();
                    }else{
                        networkType = network.substring(network.indexOf("Link encap:") + "Link encap:".length()).trim();
                    }
                    map.put("Link encap:", networkType);

                } else {
                    map = networkMap.get(networkName);
                }

                if (network.indexOf("HWaddr") >= 0) {
                    String macaddr = network.substring(network.indexOf("HWaddr") + "HWaddr".length()).trim();
                    map.put("HWaddr", macaddr);
                }

                if (network.indexOf("inet addr") >= 0) {
                    int index1 = network.indexOf("Bcast");
                    int index2 = network.indexOf("Mask");
                    int tmp = (index1 == -1) ? index2 : index1;
                    String ipaddr = network.substring(network.indexOf(":") + 1, tmp).trim();
                    map.put("inet addr", ipaddr);
                }

                if (network.indexOf("RX packets") >= 0){
                    String packets = network.substring(network.indexOf("RX") + 2).trim();
                    String[] temps = packets.split(" ");
                    for(String temp:temps){
                        map.put("rx_" + temp.split(":")[0].trim(), temp.split(":")[1].trim());
                    }
                }

                if (network.indexOf("TX packets") >= 0){
                    String packets = network.substring(network.indexOf("TX") + 2).trim();
                    String[] temps = packets.split(" ");
                    for(String temp:temps){
                        map.put("tx_" + temp.split(":")[0].trim(), temp.split(":")[1].trim());
                    }
                }

                if (network.indexOf("RX bytes") >= 0) {
                    String rx_bytes = network.substring(network.indexOf("RX bytes:") + "RX bytes:".length(), network.indexOf("(")).trim();
                    String tx_bytes = network.substring(network.indexOf("TX bytes:") + "TX bytes:".length(), network.lastIndexOf("(")).trim();
                    map.put("rx_bytes", rx_bytes);
                    map.put("tx_bytes", tx_bytes);

                    System.out.println(networkName + " 1 " + Long.parseLong(map.get("rx_bytes")) + " " + Long.parseLong(map.get("tx_bytes")));
                }

                networkMap.put(networkName, map);
            }

            for(String key : networkMap.keySet()) {
                Map<String, String> map = networkMap.get(key);
                if(!map.containsKey("inet addr")) {
                    map.put("inet addr", "N/A");
                }
                if(!map.containsKey("HWaddr")) {
                    map.put("HWaddr", "N/A");
                }

                // RX packets:0 errors:0 dropped:0 overruns:0 frame:0
                // TX packets:0 errors:0 dropped:478644 overruns:0 carrier:0

                long int_rxpackets = Long.parseLong(map.get("rx_packets"));
                long int_rxerrors = Long.parseLong(map.get("rx_errors"));
                long int_rxdropped = Long.parseLong(map.get("rx_dropped"));
                long int_rxoverruns = Long.parseLong(map.get("rx_overruns"));
                long int_rxframe = Long.parseLong(map.get("rx_frame"));

                long int_txpackets = Long.parseLong(map.get("tx_packets"));
                long int_txerrors = Long.parseLong(map.get("tx_errors"));
                long int_txdropped = Long.parseLong(map.get("tx_dropped"));
                long int_txoverruns = Long.parseLong(map.get("tx_overruns"));
                long int_txcarrier = Long.parseLong(map.get("tx_carrier"));

                if(int_rxpackets > 0 || int_rxerrors > 0 || int_rxdropped > 0 || int_rxoverruns > 0 || int_rxframe > 0 ||
                        int_txpackets > 0 || int_txerrors > 0 || int_txdropped > 0 || int_txoverruns > 0 || int_txcarrier > 0) {
                    map.put("networkState", "UP");
                } else {
                    map.put("networkState", "DOWN");
                }
            }

            // sleep 2 seconds
            try {
                Thread.sleep(sleepSeconds * 1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            vLan = tt.getResultAsVector("export LANG=en_US.UTF-8;sar -n DEV 3 3|grep '^Average'|grep -v 'rxpck/s'");
            Map<String, String> speedMap = new HashMap<String, String>();
            for (Object networkSpeed : vLan) {
                String averageSpeed = (String) networkSpeed;
                speedMap.put(split(averageSpeed,1),averageSpeed);
            }
            // second coll
            vLan = tt.getResultAsVector("/sbin/ifconfig -a");
            Date secondDate = new Date();
            long tempSeconds =(secondDate.getTime() - firstDate.getTime())/1000;

            if (vLan == null || vLan.size() == 0) {
                return collResult.KPISet;
            }

            for (Object _network : vLan) {
                String network = (String) _network;
                Map<String, String> map = null;
                String key = "";
                String firstCollStr = "";
                String secondCollStr = "";

                if (network.indexOf("Link encap:") >= 0) {
                    networkName = network.substring(0, network.indexOf("Link encap:")).trim();
                    map = networkMap.get(networkName);
                } else {
                    map = networkMap.get(networkName);
                }

                if (network.indexOf("RX packets") >= 0){
                    String packets = network.substring(network.indexOf("RX") + 2).trim();
                    String[] temps = packets.split(" ");
                    for(String temp:temps){
                        key = "rx_" + temp.split(":")[0].trim();
                        if(map.containsKey(key)){
                            firstCollStr = map.get(key);
                            secondCollStr = temp.split(":")[1].trim();
                            map.put(key, String.valueOf(Long.parseLong(secondCollStr)-Long.parseLong(firstCollStr)));
                        }
                    }
                }

                if (network.indexOf("TX packets") >= 0){
                    String packets = network.substring(network.indexOf("TX") + 2).trim();
                    String[] temps = packets.split(" ");
                    for(String temp:temps){
                        key = "tx_" + temp.split(":")[0].trim();
                        if(map.containsKey(key)){
                            firstCollStr = map.get(key);
                            secondCollStr = temp.split(":")[1].trim();
                            map.put(key, String.valueOf(Long.parseLong(secondCollStr)-Long.parseLong(firstCollStr)));
                        }
                    }
                }

                if (network.indexOf("RX bytes") >= 0) {
                    String rx_bytes = network.substring(network.indexOf("RX bytes:") + "RX bytes:".length(), network.indexOf("(")).trim();
                    String tx_bytes = network.substring(network.indexOf("TX bytes:") + "TX bytes:".length(), network.lastIndexOf("(")).trim();
                    if(map.containsKey("rx_bytes")){
                        firstCollStr = map.get("rx_bytes");;
                        map.put("rx_bytes", String.valueOf(Long.parseLong(rx_bytes)-Long.parseLong(firstCollStr)));
                    }

                    if(map.containsKey("tx_bytes")){
                        firstCollStr = map.get("tx_bytes");;
                        map.put("tx_bytes", String.valueOf(Long.parseLong(tx_bytes)-Long.parseLong(firstCollStr)));
                    }
                }
            }

            // create coll kpi
            Double rx_total=0D;
            Double tx_total=0D;
            for(String key : networkMap.keySet()){
                Map<String,String> map = networkMap.get(key);
                String unitId = net_unit + "-" + Formater.neatenunitid(key);
                // ifname CM-00-01-001-40
                collResult.addKPI(unitId, "CM-00-01-001-40", key);
                // macaddr
                collResult.addKPI(unitId, "CM-00-01-001-12", map.get("HWaddr"));
                // ipaddr
                String inetAddr = map.get("inet addr");
                collResult.addKPI(unitId, "CM-00-01-001-11", inetAddr);
                if(!inetAddr.equals("N/A")) {
                    serviceIp += inetAddr + ",";
                }
                // network status
                collResult.addKPI(unitId, "FM-00-01-001-03", map.get("networkState"));
                // network use kbps
                String speedInfo = speedMap.get(key);
                if(StringUtils.isNotBlank(speedInfo)){

                    String rx_bytes=split(speedInfo,4);
                    String tx_bytes=split(speedInfo,5);
                    collResult.addKPI(unitId, "PM-00-01-900-04", df.format(Double.parseDouble(rx_bytes)+Double.parseDouble(tx_bytes)));

                    System.out.println(networkName + " 2 " + Long.parseLong(map.get("rx_bytes")) + " " + Long.parseLong(map.get("tx_bytes")));
                    collResult.addKPI(unitId, "PM-00-02-001-24", rx_bytes);
                    collResult.addKPI(unitId, "PM-00-02-001-25", tx_bytes);
                    rx_total = rx_total+ Double.parseDouble(rx_bytes);
                    tx_total = tx_total+ Double.parseDouble(tx_bytes);
//                }else {
//
//                    String rx_bytes=Formater.formatDecimalByScale(String.valueOf(Math.abs(Long.parseLong(map.get("rx_bytes")) / 1024.0 / tempSeconds)), 2);
//                    String tx_bytes=Formater.formatDecimalByScale(String.valueOf(Math.abs(Long.parseLong(map.get("rx_bytes")) / 1024.0 / tempSeconds)), 2);
//                    collResult.addKPI(unitId, "PM-00-01-900-04", String.valueOf(Double.parseDouble(rx_bytes)+Double.parseDouble(tx_bytes)));
//
//                    System.out.println(networkName + " 2 " + Long.parseLong(map.get("rx_bytes")) + " " + Long.parseLong(map.get("tx_bytes")));
//                    collResult.addKPI(unitId, "PM-00-02-001-24", rx_bytes);
//                    collResult.addKPI(unitId, "PM-00-02-001-25", tx_bytes);
                }

                collResult.addKPI(unitId, "PM-00-01-900-01", Formater.formatDecimalByScale(String.valueOf((Long.parseLong(map.get("rx_bytes")) + Long.parseLong(map.get("rx_bytes"))) / 1024.0 / sleepSeconds), 2));

                long long_packets = Long.parseLong(map.get("rx_packets")) + Long.parseLong(map.get("tx_packets"));
                long long_dropped = Long.parseLong(map.get("rx_dropped")) + Long.parseLong(map.get("tx_dropped"));
                long long_errors = Long.parseLong(map.get("rx_errors")) + Long.parseLong(map.get("tx_errors"));

                String dropped = "";
                String errors = "";

                if (long_packets == 0) {
                    if (long_dropped > 0) {
                        dropped = "1.00";
                    } else {
                        dropped = "0.00";
                    }

                    if (long_errors > 0) {
                        errors = "1.00";
                    } else {
                        errors = "0.00";
                    }
                } else {
                    dropped = Formater.formatDecimalByScale(String.valueOf(long_dropped / long_packets), 2);
                    errors = Formater.formatDecimalByScale(String.valueOf(long_errors / long_packets), 2);
                }

                collResult.addKPI(unitId, "PM-00-01-900-06", dropped);
                collResult.addKPI(unitId, "PM-00-01-900-07", errors);

            }
            collResult.addKPI(net_unit + "-NET", "CM-00-01-001-40", "NET");
            collResult.addKPI(net_unit + "-NET", "PM-00-02-001-24", Formater.formatDecimalByScale(rx_total.toString(),2));
            collResult.addKPI(net_unit + "-NET", "PM-00-02-001-25", Formater.formatDecimalByScale(tx_total.toString(),2));

			// 根据字符串标志位进行指标获取
//			for (int i = 0; i < size; i++) {
//				String network = (String) lan.elementAt(i);
//				// 网卡名称
//				int hard_flag = network.indexOf("Link encap");
//				if (hard_flag != -1 && hard_pass) {
//					network_name = network.substring(0, network.indexOf("Link encap")).trim();
//					net_unit = net_unit + "-" + network_name;
//					hard_pass = false;
//				}
//
//				// 网卡物理地址获取
//				int phy_flag = network.indexOf("HWaddr");
//				if (phy_flag != -1 && phy_pass) {
//					phy_addr = network.substring(network.indexOf("HWaddr") + 6).trim();
//					phy_pass = false;
//				}
//
//				// 获取网卡绑定的IP地址
//				int ip_flag = network.indexOf("inet addr");
//				if (ip_flag != -1 && ip_pass) {
//					int index = network.indexOf("Bcast");
//					int inde1 = network.indexOf("Mask");
//					int tmp = (index == -1) ? inde1 : index;
//					ip_addr = network.substring(network.indexOf(":") + 1, tmp);
//					ip_pass = false;
//				}
//
//				int metri_flag = network.indexOf("Metric:");
//				if(metri_flag!=-1&& state_pass){
//					if(network.indexOf("UP")>-1){
//						state = "up";
//					}
//					state_pass = false;
//				}
//                if (("".equals(network) && hard_pass == false) || (network.trim().length() == 0 && hard_pass == false) || (i == size - 1 && hard_pass == false)) {
//                    //if ("".equals(network) || network.trim().length() == 0) {
//					// 网卡名称
//					collResult.addKPI(net_unit, "CM-00-01-001-40", network_name);
//					// 生成网卡物理地址指标
//					collResult.addKPI(net_unit, "CM-00-01-001-12", phy_addr);
//					// 生成网卡ip地址指标
//					collResult.addKPI(net_unit, "CM-00-01-001-11", ip_addr);
//					// 网卡状态
//					collResult.addKPI(net_unit, "FM-00-01-001-03", state);
//					phy_pass = true;
//					ip_pass = true;
//					state_pass = true;
//					hard_pass = true;
//					ip_addr = "&lt;none&gt;";
//					phy_addr = "&lt;none&gt;";
//					state = "down";
//					network_name = "";
//					net_unit = "10-10-24-16:" + neat_host_name;
//				}
//			}

            String username = (String) params.get("USERNAME");
            Vector<String> ulimitV = tt.getResultAsVector("ulimit -a");
            for (String ulimit : ulimitV) {
                if (ulimit.indexOf("open files") > -1) {
                    String _ulimit = split(ulimit, 3).trim();
                    collResult.addKPI(PRE_UNITID + "-71:" + neat_host_name + "-" + username, "CM-00-01-900-16", username);
                    collResult.addKPI(PRE_UNITID + "-71:" + neat_host_name + "-" + username, "PM-00-01-004-13", _ulimit);
                }
            }

            Vector<String> chageV = tt.getResultAsVector("chage -l " + username);
            for (String chage : chageV) {
                if (chage.indexOf("Password expires") > -1) {
                    String _chage = split(chage, 3).trim();
                    collResult.addKPI(PRE_UNITID + "-73:" + neat_host_name + "-" + username, "CM-00-01-900-16", username);
                    collResult.addKPI(PRE_UNITID + "-73:" + neat_host_name + "-" + username, "FM-00-01-026-02", _chage);
                }
            }

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

	/**
	 * 采集cpu指标
	 */
	public Vector getCpu(HashMap params) {
		logger.info("begin getCpu");
		// 保存采集结果，并返回值
		CollBase collResult = new CollBase();
		try {
			init(params);
            String totalUnitId = "";
			if(!tt.isAuthorized()){
				totalUnitId = this.PRE_UNITID + "-10:" + neat_host_name + "-total";
//				collResult.addKPI(totalUnitId, "FM-00-01-001-01", tt.getError());
				return collResult.KPISet;
			}else{
				totalUnitId = this.PRE_UNITID + "-10:" + neat_host_name + "-total";
//				collResult.addKPI(totalUnitId, "FM-00-01-001-01", "UP");
			}

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

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

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

			Vector cpuout = tt.getResultAsVector("vmstat 1 3");
			String cpurun = (String) cpuout.elementAt(cpuout.size() - 1);

			// CPU时间：空闲百分比
			collResult
					.addKPI(cpu_PRE_UNITID + ":" + neat_host_name + "-cpu",
							"PM-00-01-001-01", Formater
									.formatDecimalKpivalue(collResult.split(
											cpurun, 14)));

			// CPU时间：系统百分比
			collResult
					.addKPI(cpu_PRE_UNITID + ":" + neat_host_name + "-cpu",
							"PM-00-01-001-02", Formater
									.formatDecimalKpivalue(collResult.split(
											cpurun, 13)));

			// CPU时间：用户百分比
			collResult
					.addKPI(cpu_PRE_UNITID + ":" + neat_host_name + "-cpu",
							"PM-00-01-001-03", Formater
									.formatDecimalKpivalue(collResult.split(
											cpurun, 12)));

			// cpu利用率, 100-idle
			value = this.getCPU_Rate(3, 3);
			collResult.addKPI(cpu_PRE_UNITID + ":" + neat_host_name + "-cpu", "PM-00-01-001-05", Formater.realyRate(value));

            // 剩余可使用主机CPU PM-00-01-001-07
            Vector totalCpuMHZ = tt.getResultAsVector("cat /proc/cpuinfo | grep 'cpu MHz' | awk '{print int($4)}' | awk '{sum+=$1}END{print sum}'");
            String cpuMHZ = (String) totalCpuMHZ.elementAt(0);
            Float lessCpuMHZ = Integer.parseInt(cpuMHZ) * (1 - Float.parseFloat(value) / 100);
            collResult.addKPI(cpu_PRE_UNITID + ":" + neat_host_name + "-cpu",
                    "PM-00-01-001-07", Formater.formatDecimalKpivalue(String.valueOf(lessCpuMHZ)));

			// CPU运行队列中进程个数
			Vector vmstat_result = tt.getResultAsVector("vmstat 2 2");
			String vmstat_string = (String) vmstat_result
					.elementAt(vmstat_result.size() - 1);
			value = collResult.split(vmstat_string, 0);
			collResult.addKPI(cpu_PRE_UNITID + ":" + neat_host_name + "-cpu",
					"PM-00-01-001-06", Formater.formatDecimalKpivalue(value));

			// CPU时间：等待百分比
			try {
				Vector sar_cpuout = tt.getResultAsVector("sar -u 1 3");
				String sar_cpurun = (String) sar_cpuout.elementAt(sar_cpuout.size() - 1);
				value = split(sar_cpurun, 5);
				collResult.addKPI(cpu_PRE_UNITID + ":" + neat_host_name + "-cpu",
                        "PM-00-01-001-04", Formater.formatDecimalKpivalue(value));
			} catch (Exception e) {
				logger.info("cpu采集可能没有sar命令!");
			}

            //网络接收速率及发送速率 sar -n DEV 1 10  |grep ':'
            Vector netRate = tt.getResultAsVector("sar -n DEV 1 10  |grep ':'");//linux中文操作系统适合用此命令
            boolean netflag = false;
            for (int i = 0; i < netRate.size(); i++) {
                String vs = netRate.get(i).toString();
                if (vs.indexOf("Average") > -1) {
                    netflag = true;
                }
            }
            if (netflag) {
                //如果linux操作系统是英文的，则用以下命令sar -n DEV 1 10 | sed  -n '/Average/p'
                netRate = tt.getResultAsVector("sar -n DEV 1 10 | sed  -n '/Average/p'");
            }
            String rxValue = ""; // 临时变量
            String txValue = ""; // 临时变量
            //网络接收速率
            rxValue = this.get_rxValue(netRate);
            collResult.addKPI(totalUnitId, "PM-00-01-006-14", rxValue);
            //网络发送速率
            txValue = this.get_txValue(netRate);
            collResult.addKPI(totalUnitId, "PM-00-01-006-15", txValue);

            //网络连接数  State为TIME_WAIT，CLOSE_WAIT，ESTABLISHED，LISTEN等 之和
            Vector net_number = tt.getResultAsVector("netstat -an | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'");
            int number_net = 0;
            if(!net_number.isEmpty()){
                for(int i =0;i<net_number.size();i++){
                    String str_net_number = net_number.get(i).toString();
                    number_net += Integer.parseInt(split(str_net_number,1));
                }
            }
            collResult.addKPI(totalUnitId,"PM-00-01-006-17",Integer.toString(number_net));

            // lsof文件句柄 PRE_UNITID + "-71:" + neat_host_name + "-" + username
            Vector lsofV = tt.getResultAsVector("/usr/sbin/lsof | awk '{print $3}' | awk '{a[$1]++} END{for(i in a){print i,a[i]}}'");
            if (!lsofV.isEmpty()) {
                for (int i = 0; i < lsofV.size(); i++) {
                    String _lsof = (String) lsofV.elementAt(i);
                    String user = _lsof.split(" ")[0];
                    String openfile = _lsof.split(" ")[1];
                    // lsof用户名 进程用户
                    collResult.addKPI(PRE_UNITID + "-71:" + neat_host_name + "-" + user, "CM-00-01-900-16", user);
                    // 实际打开文件数
                    collResult.addKPI(PRE_UNITID + "-71:" + neat_host_name + "-" + user, "PM-00-01-004-12", openfile);
                }
            }

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

		logger.info("end collCpu");
		return collResult.getKPISet();
	}
	private String get_rxValue(Vector<String>netRate){
        double rxRate = 0;
        //计算eth0  eth1  eth2 等端口之和
        for(int i=netRate.size()-1;i>=2;i--){
            String rx = netRate.get(i);
            rxRate += Double.parseDouble(split(rx, 4));
        }
        rxRate=rxRate*8;//单位从kBps转换为kbps
        return Formater.formatDecimalKpivalue(Double.toString(rxRate));
    }
    private String get_txValue(Vector<String>netRate){
        double txRate = 0;
        //计算eth0  eth1  eth2 等端口之和
        for(int i=netRate.size()-1;i>=2;i--){
            String tx = netRate.get(i);
            txRate += Double.parseDouble(split(tx, 5));
        }
        txRate=txRate*8;//单位从kBps转换为kbps
        return Formater.formatDecimalKpivalue(Double.toString(txRate));
    }
	public Vector getDiskForIOstat(HashMap params) {
		CollBase collResult = new CollBase();
		try {
			init(params);
			// 本方法得到的kpi值的unit_id,均以PRE_UNITID + "-13"开头，代表disk数据
			String disk_PRE_UNITID = PRE_UNITID + "-13";

			// 增加采集时间指标
			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 = "";// 临时变量

			// 从出现Average的这行开始，每一行表示一个磁盘的数据
			try {
				Vector diskV = tt.getResultAsVector("/usr/bin/iostat -xd");
				Set sarDiskSet = new HashSet(); // 保存所有sar命令能取到的io设备名称
				for (int i = 1; i < diskV.size(); i++) {
					String disk_value = (String) diskV.elementAt(i);
					if(disk_value!=null&&!disk_value.trim().equals("")&&disk_value.indexOf("rsec/s")==-1){
						
						try{
							String neat_disk_name = "";
							String device_name ="";
							String busy = "";
							String svctm = "";
							String rs = "";
							String ws = "";
							String kws = "";
							String krs ="";
							device_name=split(disk_value,0);
							neat_disk_name =Formater.neatenunitid(device_name);
							busy = split(disk_value,9);
							rs = split(disk_value,3);
							ws = split(disk_value,4);
							krs = split(disk_value,7);
							kws = split(disk_value,8);
							svctm = split(disk_value,10);
							
							
							collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name
									+ "-" + neat_disk_name, "CM-00-01-001-20",
									neat_disk_name);

							// 磁盘物理IO操作速率
							double krs_d = 0;
							double kws_d = 0;
							try{
								krs_d = Double.valueOf(krs).longValue();
								kws_d = Double.valueOf(kws).longValue();
								
							}catch(Exception e){
								e.printStackTrace();
							}
							collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name
									+ "-" + neat_disk_name, "PM-00-01-003-01", String.valueOf(krs_d+kws_d));

							// 每秒读请求
							collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name
									+ "-" + neat_disk_name, "PM-00-01-003-04", rs);

							// 每秒写请求
							collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name
									+ "-" + neat_disk_name, "PM-00-01-003-05", ws);
							
							// PM-00-01-003-06
							collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name
									+ "-" + neat_disk_name, "PM-00-01-003-06", busy);
							
							collResult.addKPI(disk_PRE_UNITID + ":"
									+ neat_host_name + "-" + neat_disk_name,
									"PM-00-01-003-07", svctm);
							
						}catch(Exception e){
							e.printStackTrace();
						}
						
					}
				}
			} catch (Exception e) {
				logger.debug("disk 采集时没有sar命令");
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			release();
		}
		return collResult.getKPISet();

	}
	public Vector getDisk(HashMap params) {
		logger.info("begin getActiveDisk");
		// 保存采集结果，并返回值
		CollBase collResult = new CollBase();
		try {
			init(params);
			
			if(!tt.isAuthorized()){
				String totalUnitId = this.PRE_UNITID + "-10:" + neat_host_name + "-total";
//				collResult.addKPI(totalUnitId, "FM-00-01-001-01", tt.getError());
				return collResult.KPISet;
			}else{
				String totalUnitId = this.PRE_UNITID + "-10:" + neat_host_name + "-total";
//				collResult.addKPI(totalUnitId, "FM-00-01-001-01", "UP");
			}
			
			// 本方法得到的kpi值的unit_id,均以PRE_UNITID + "-13"开头，代表disk数据
			String disk_PRE_UNITID = PRE_UNITID + "-13";

			// 增加采集时间指标
			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 = "";// 临时变量
			
			String pwd = tt.getResultAsStr("pwd");
			System.out.println(pwd);

			// 从出现Average的这行开始，每一行表示一个磁盘的数据
			try {
				Vector diskV = tt.getResultAsVector("sar -d -p 1 3");
				Set sarDiskSet = new HashSet(); // 保存所有sar命令能取到的io设备名称
                Double read_total=0D;
                Double write_total=0D;
                Double kbps_total=0D;
				for (int i = 0; i < diskV.size(); i++) {
                    String disk_value = (String) diskV.elementAt(i);

//					if (disk_value.indexOf("Average") > -1 || disk_value.indexOf("平均时间") > -1)
//						continue;
//
//					if (disk_value.indexOf("DEV") != -1)
//						continue;

                    if((disk_value.indexOf("Average") >= 0 || disk_value.indexOf("平均时间") >= 0) && disk_value.indexOf("DEV") == -1)
                    {
                        String disk_name = split(disk_value, 1);
                        sarDiskSet.add(disk_name);

                        String neat_disk_name = Formater.neatenunitid(disk_name);
                        String unitId = disk_PRE_UNITID + ":" + neat_host_name + "-" + neat_disk_name;

                        collResult.addKPI(unitId, "CM-00-01-001-20", neat_disk_name);

                        // 每秒磁盘读请求 PM-00-01-003-04
                        value = split(disk_value, 3);
                        collResult.addKPI(unitId, "PM-00-01-003-04", Formater.formatDecimalKpivalue(value));

                        // 每秒磁盘写请求 PM-00-01-003-05
                        value = split(disk_value, 4);
                        collResult.addKPI(unitId, "PM-00-01-003-05", Formater.formatDecimalKpivalue(value));

                        // 磁盘忙百分比 PM-00-01-003-03
                        value = split(disk_value, 9);
                        collResult.addKPI(unitId, "PM-00-01-003-03", Formater.formatDecimalKpivalue(value));

                        // 等待进程线程数 PM-00-01-003-02
                        value = split(disk_value, 6);
                        collResult.addKPI(unitId, "PM-00-01-003-02", Formater.formatDecimalKpivalue(value));


                        // 磁盘I/O速率
                        double kbps = 0;
                        try {
                            // 每秒读速率 PM-00-01-003-17
                            String sRdSec = split(disk_value, 3);
							Double rdSec = Double.parseDouble(sRdSec)/2;//扇区大小512byte，sRdSec为每秒扇区读数量，所以除以2之后是读速率k/s。
                            collResult.addKPI(unitId, "PM-00-01-003-17", Formater.formatDecimalKpivalue(rdSec.toString()));
							read_total = read_total+rdSec;
                            // 每秒写速率 PM-00-01-003-18
                            String sWrSec = split(disk_value, 4);
							Double wdSec = Double.parseDouble(sWrSec)/2;//扇区大小512byte，sRdSec为每秒扇区读数量，所以除以2之后是读速率k/s。
                            collResult.addKPI(unitId, "PM-00-01-003-18", Formater.formatDecimalKpivalue(wdSec.toString()));
							write_total = write_total+wdSec;
                            kbps = (Double.parseDouble(sRdSec) + Double.parseDouble(sWrSec)) ;
                        } catch (Exception e) {
                            kbps = -1;
                            logger.error("Error", e);
                        }
                        String sKbps = Formater.formatDecimalKpivalue(kbps + "");
                        // 磁盘命令时延
                        String await = split(disk_value, 7);

                        // PM-00-01-003-16 每秒磁盘I/O命令数量 数量
                        // PM-00-01-003-07 磁盘访问平均等待时间(磁盘命令时延)
                        collResult.addKPI(unitId, "PM-00-01-003-16", Formater.formatDecimalKpivalue(sKbps));
                        collResult.addKPI(unitId, "PM-00-01-003-07", Formater.formatDecimalKpivalue(await));
						// 磁盘物理IO操作速率 k/s
						collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name + "-" + neat_disk_name, "PM-00-01-003-01", Formater.formatDecimalKpivalue(Double.toString(kbps/2)));
                        kbps_total = kbps_total+kbps/2;

					}
                }
                collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name + "-DISK", "CM-00-01-001-20", "DISK");
                collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name + "-DISK", "PM-00-01-003-17", Formater.formatDecimalKpivalue(Double.toString(read_total)));
                collResult.addKPI(disk_PRE_UNITID + ":" + neat_host_name + "-DISK", "PM-00-01-003-18", Formater.formatDecimalKpivalue(Double.toString(write_total)));

			} catch (Exception e) {
				logger.debug("disk 采集时没有sar命令");
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			release();
		}
		return collResult.getKPISet();
	}

	public Vector<TblATO_KPIDETAIL> getFileSystem(HashMap<String, String> params) {
		logger.info("Begin getFileSystem[IP=" + params.get("IP_ADDR") + "]");
		// 保存采集结果，并返回值
		CollBase collResult = new CollBase();
		try {
			init(params);
			
			if(!tt.isAuthorized()){
				String totalUnitId = this.PRE_UNITID + "-10:" + neat_host_name + "-total";
//				collResult.addKPI(totalUnitId, "FM-00-01-001-01", tt.getError());
				return collResult.KPISet;
			}else{
				String totalUnitId = this.PRE_UNITID + "-10:" + neat_host_name + "-total";
//				collResult.addKPI(totalUnitId, "FM-00-01-001-01", "UP");
			}

			// 采集各文件系统占用率
			String command = "export LANG=en_US.UTF-8;df -kP|sed -n '2,$p'|awk '{print $1 A OFS $2 A OFS $3 A OFS $4 A OFS $5 A OFS $6}'";

			Vector<String> vFilsSystem = tt.getResultAsVector(command);

			long size = vFilsSystem.size();
			long totalSize = 0;
			Double usedSize = 0D;
			
			try {
				for (String line : vFilsSystem) {
					if (line.indexOf("Permission") >= 0) {
						continue;
					}
					String file_sys_name = split(line, 0);
					String rate = split(line, 4).trim();
					// 去除百分号
					rate = rate.substring(0, rate.length()-1);
					String disk_name = split(line, 5).trim();
					String max_size = split(line, 1).trim();
                    String used_size = split(line, 2).trim();
					String available = split(line, 3).trim();
					
					usedSize = usedSize + Double.parseDouble(split(line, 2).trim())/1024;
					
					float avaliavle_tmp = Float.parseFloat(available.trim()) / 1024;
					totalSize = totalSize + Long.parseLong(max_size.trim())/1024;
					
					String unitId;
					if (disk_name != null && disk_name.equals("/")) {
						unitId = PRE_UNITID + "-14:" + neat_host_name + "-//";
					} else {
						unitId = PRE_UNITID + "-14:" + neat_host_name + "-" + Formater.neatenunitid(disk_name);
					}
					
					collResult.addKPI(unitId, "CM-00-01-001-16", disk_name);

                    // CM-00-01-001-17 文件系统配置大小
                    collResult.addKPI(unitId, "CM-00-01-001-17", Formater.formatDecimalKpivalue(Double.toString(Double.parseDouble(max_size) / 1024)));

                    // 文件系统已使用大小
                    collResult.addKPI(unitId, "PM-00-01-004-21", Formater.formatDecimalKpivalue(Double.toString(Double.parseDouble(used_size) / 1024)));

					collResult.addKPI(unitId, "PM-00-01-004-03", Formater.realyRate(Formater.formatDecimalKpivalue(rate)));

					collResult.addKPI(unitId, "PM-00-01-004-04", Formater.formatDecimalKpivalue(Float.toString(avaliavle_tmp)));
					
					collResult.addKPI(unitId, "CM-00-01-001-42", file_sys_name);
				}
			} catch (Exception e) {
				logger.error("Exception while getFileSystem()", e);
			}
            Double rate= totalSize==0? 0:usedSize * 100 / totalSize;

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

			// totalSize = totalSize/1000;
			collResult.addKPI(totalUnitId, "CM-00-01-001-17", String.valueOf(totalSize));

            // 已分配文件句柄的数目、已使用文件句柄的数目、文件句柄的最大数目
            // $ cat /proc/sys/fs/file-nr
            // 7168    0       1607133
            String strUserRate = "cat /proc/sys/fs/file-nr";
            Vector<String> listUserRate = tt.getResultAsVector(strUserRate);

            if (listUserRate != null && listUserRate.size() > 0) {
                String strMsg = listUserRate.get(0);
                String strTotal = split(strMsg, 0);
                String strUsed = split(strMsg, 1);
                String strMaxed = split(strMsg, 2);
                String unitId = PRE_UNITID + "-10:" + neat_host_name + "-total";
                // 允许打开文件数
                collResult.addKPI(unitId, "PM-00-01-004-13", strTotal);
                // 实际打开文件数
                collResult.addKPI(unitId, "PM-00-01-004-12", strUsed);
                // 最大打开文件数 PM-00-01-004-17
                collResult.addKPI(unitId, "PM-00-01-004-17", strMaxed);
            }

            // netstat -n | awk '/^tcp/ {++state[$NF]} END {for(key in state) print key,"\t",state[key]}'
            // TIME_WAIT        1
            // SYN_SENT         4
            // ESTABLISHED      8
            String strNet = "netstat -n | awk '/^tcp/ {++state[$NF]} END {for(key in state) print key,\"\\t\",state[key]}'";
            Vector<String> listNet = tt.getResultAsVector(strNet);
            String strNetTypeNums = ",";
            if (listNet != null && listNet.size() > 0) {
                for (int i = 0; i < listNet.size(); i++) {
                    String strMsg = listNet.get(i);
                    String strType = split(strMsg, 0);
                    String strNum = split(strMsg, 1);
//                    strNetTypeNums += splitNetTypeNum(strType, strNum);
                    String unitId = PRE_UNITID + "-59:" + neat_host_name + "-" + Formater.neatenunitid(strType);
                    // 网络连接类型 CM-00-01-001-74
                    collResult.addKPI(unitId, "CM-00-01-001-74", strType);
                    // 网络连接情况 PM-00-01-900-10
                    collResult.addKPI(unitId, "PM-00-01-900-10", strNum);
                }
            }

            // 采集各文件系统inode
            String commandInode = "export LANG=en_US.UTF-8;df -iP|sed -n '2,$p'|awk '{print $1 A OFS $2 A OFS $3 A OFS $4 A OFS $5 A OFS $6}'";
            Vector<String> vInode = tt.getResultAsVector(commandInode);
            try {
                for (String line : vInode) {
                    if (line.indexOf("Permission") >= 0) {
                        continue;
                    }
                    String disk_name = split(line, 5).trim();
                    String inodeIused = split(line, 4).trim();

                    String unitId;
                    if (disk_name != null && disk_name.equals("/")) {
                        unitId = PRE_UNITID + "-14:" + neat_host_name + "-//";
                    } else {
                        unitId = PRE_UNITID + "-14:" + neat_host_name + "-" + Formater.neatenunitid(disk_name);
                    }
                    // PM-00-01-004-23 inode使用率
                    collResult.addKPI(unitId, "PM-00-01-004-23", inodeIused);
                }
		} catch (Exception e) {
			logger.error("Exception while getFileSystem()", e);
            }

            //增加文件系统索引使用情况统计
            String commandStr = "df -iP|sed -n '2,$p'|grep -v .iso|awk '{print $1 A OFS $2 A OFS $3 A OFS $4 A OFS $5 A OFS $6}'";
            Vector<String> fileSysIndexRate = tt.getResultAsVector(commandStr);
            for(String indexRate : fileSysIndexRate){
                String theRate = split(indexRate, 4).trim();
                theRate = theRate.substring(0, theRate.length()-1);
                String diskName = split(indexRate, 5);

                String unitId = PRE_UNITID + "-10:" + neat_host_name  + "-" + Formater.neatenunitid(diskName);
                collResult.addKPI(unitId, "PM-00-01-004-40", Formater.formatDecimalKpivalue(theRate));
            }

            //打开文件的句柄数 lsof |wc -l
            String fileHandle = "/usr/sbin/lsof | wc -l";
            Vector<String> vHandle = tt.getResultAsVector(fileHandle);
            try {
                for (String line : vHandle) {
                    String fileHandleNum = split(line, 0).trim();
                    String unitId;
                    unitId = PRE_UNITID + "-10:" + neat_host_name + "-total";
                    // PM-00-01-004-24 打开文件的句柄数
                    collResult.addKPI(unitId, "PM-00-01-004-24", fileHandleNum);
                }
            } catch (Exception e) {
                logger.error("Exception while getFileSystem()", e);
            }

        } catch (Exception e) {
			logger.error("Exception while getFileSystem()", e);
		} finally {
			release();
		}
		
		logger.info("End getFileSystem[IP=" + params.get("IP_ADDR") + "]");
		return collResult.getKPISet();
	}

    private String splitNetTypeNum(String strType, String strNum) {
        if ("ESTABLISHED".equalsIgnoreCase(strType)) {
            return "ES:" + strNum + ",";
        } else if ("SYN_SENT".equalsIgnoreCase(strType)) {
            return "SS:" + strNum + ",";
        } else if ("SYN_RECV".equalsIgnoreCase(strType)) {
            return "SR:" + strNum + ",";
        } else if ("FIN_WAIT1".equalsIgnoreCase(strType)) {
            return "F1:" + strNum + ",";
        } else if ("FIN_WAIT2".equalsIgnoreCase(strType)) {
            return "F2:" + strNum + ",";
        } else if ("TIME_WAIT".equalsIgnoreCase(strType)) {
            return "TW:" + strNum + ",";
        } else if ("CLOSED".equalsIgnoreCase(strType)) {
            return "CD:" + strNum + ",";
        } else if ("CLOSE_WAIT".equalsIgnoreCase(strType)) {
            return "CW:" + strNum + ",";
        } else if ("LAST_ACK".equalsIgnoreCase(strType)) {
            return "LA:" + strNum + ",";
        } else if ("LISTEN".equalsIgnoreCase(strType)) {
            return "LI:" + strNum + ",";
        } else if ("CLOSING".equalsIgnoreCase(strType)) {
            return "CL:" + strNum + ",";
        } else if ("UNKNOWN".equalsIgnoreCase(strType)) {
            return "UN:" + strNum + ",";
        } else {
            return strType.substring(0, 3) + ":" + strNum + ",";
        }
    }

	/**
	 * 
	 * 获取所有用户用户进程数
	 * 
	 * @param params
	 * @return
	 */

	public Vector getUserProNum(HashMap params) {
		logger.info("begin getUserProNum ");
		// 保存采集结果，并返回值
		CollBase collResult = new CollBase();
		try {
			init(params);
			// 得到所有用户的列表，该用户名出现多少次，就表明ps出来有多少行，即有多少进程
			Vector userV = new Vector();
			String process_cmd = "ps -ef|grep -v UID";
			// Vector processV = tt.getResultAsVector("sh linux/process.sh");
			Vector processV = tt.getResultAsVector(process_cmd);

			for (int i = 0; i < processV.size(); i++) {
				String processInfo = (String) processV.elementAt(i);
				userV.add(collResult.split(processInfo, 0));
			}
			processV = null;

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

			// 计算各个用户的进程数，并保存在这个map中
			// user - user process numer
			Map user_pronum = new HashMap();
			// 将用户排序，然后遍历计算
			java.util.Collections.sort(userV);
			String userName = "";
			for (int i = 0; i < userV.size(); i++) {
				userName = ((String) userV.elementAt(i)).trim();
                if("".equals(userName)){continue;}
				int pro_number = 1;
				String nextUer = "";
				for (int j = i + 1; j < userV.size(); j++) {

					// 到了下一个用户
					nextUer = ((String) (userV.elementAt(j))).trim();
					if (!userName.equals(nextUer)) {
						i = j - 1;
						break;
					}
					pro_number++;
				}
				user_pronum.put(userName, new Integer(pro_number));
			}

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

			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));

			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			release();
		}
		return collResult.getKPISet();
	}
	
	/**
	 * 采集内存指标
	 */
	public Vector<TblATO_KPIDETAIL> getMemory(HashMap<String, String> params) {
		logger.info("begin getMemory");
		// 保存采集结果，并返回值
		CollBase collResult = new CollBase();
		try {
			init(params);
			
			if(!tt.isAuthorized()){
				String totalUnitId = this.PRE_UNITID + "-10:" + neat_host_name + "-total";
//				collResult.addKPI(totalUnitId, "FM-00-01-001-01", tt.getError());
				return collResult.KPISet;
			}else{
				String totalUnitId = this.PRE_UNITID + "-10:" + neat_host_name + "-total";
//				collResult.addKPI(totalUnitId, "FM-00-01-001-01", "UP");
			}

			String memUnitId = PRE_UNITID + "-12:" + neat_host_name + "-memory";

			/**用这个命令执行之后的结果为：vmstat 2 2 | awk '{print $7,$8}'
			 * procs -----------memory---------- ---swap-- -----io---- --system-- -----cpu------
 				r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 				1  0    240 1685884 919504 2095656    0    0     1   117    0    0 14  1 84  0  0
 				1  0    240 1686140 919516 2095516    0    0     0   744 11520 22153 19  3 78  0  0

			 * 我们获取第七个和第八个数 si   so  
			 * si:读取时的内存交换数  7
			 * so：写入时的内存交换数	 8
			 */
			String swap_read = "vmstat 2 2 | awk '{print $7,$8,$2}'";
			Vector<String> memory_swap = tt.getResultAsVector(swap_read);
			if (memory_swap == null || memory_swap.size() == 0) {
				logger.error("vmstat's result is null, exit!!");
				return collResult.KPISet;
			}
			
			String swap_read_string = memory_swap.elementAt(memory_swap.size()-1);
			// PM-00-01-002-20  读取时的内存交换数
			collResult.addKPI(memUnitId, "PM-00-01-002-20", split(swap_read_string, 0));

			// PM-00-01-002-21 写入时的内存交换数
			collResult.addKPI(memUnitId, "PM-00-01-002-21", split(swap_read_string, 1));

            // 等待内存的进程或线程数量 PM-00-01-002-05
            collResult.addKPI(memUnitId, "PM-00-01-002-05", split(swap_read_string, 2));

			//PM-00-01-002-01内存使用率
			String cmdFree = "free | grep 'Mem:'";

			Vector<String> vFreeResult = tt.getResultAsVector(cmdFree);
			
			if (vFreeResult != null && vFreeResult.size() > 0) {
				String temp = vFreeResult.get(0);

				double total = Double.parseDouble(split(temp, 1));
                double used = Double.parseDouble(split(temp, 2));
                double free = Double.parseDouble(split(temp, 3));
                double shared = Double.parseDouble(split(temp, 4));
				double buffers = Double.parseDouble(split(temp, 5));
				double cached = Double.parseDouble(split(temp, 6));
				
				logger.info("-- Memory total=" + total + ", used=" + used + ", free=" + free
                        + ", buffers=" + buffers + ", shared=" + shared + ", cached=" + cached);
				double memoryUsage = (1 - (free + buffers + cached) / total) * 100;
				String memoryUsageStr = String.valueOf(memoryUsage);
				memoryUsageStr = Formater.formatDecimalKpivalue(memoryUsageStr);
				
				logger.info("-- Memory usage=" + memoryUsageStr);

				collResult.addKPI(memUnitId, "PM-00-01-002-01", Formater.realyRate(memoryUsageStr));
                // 剩余可使用主机内存 PM-00-01-002-14
				collResult.addKPI(memUnitId, "PM-00-01-002-14", Formater.formatDecimalKpivalue(String.valueOf((free + buffers + cached) / 1024)));
			}

            // 系统内存使用率 PM-00-01-002-06
            String sysMem = "ps aux | grep ^root | awk '{print $4}' | awk '{sum+=$1}END{print sum}'";
            Vector<String> sys_mem = tt.getResultAsVector(sysMem);
            if (sys_mem == null || sys_mem.size() == 0 || sys_mem.isEmpty()) {
                logger.error("(ps aux grep root)'s result is null, exit!!");
                return collResult.KPISet;
            }

            String _sysmem = sys_mem.elementAt(0);
            collResult.addKPI(memUnitId, "PM-00-01-002-06", _sysmem);

            // 用户内存使用率 PM-00-01-002-07
            String userMem = "ps aux | grep -v ^root | grep -v %MEM | awk '{print $4}' | awk '{sum+=$1}END{print sum}'";
            Vector<String> user_mem = tt.getResultAsVector(userMem);
            if (user_mem == null || user_mem.size() == 0 || user_mem.isEmpty()) {
                logger.error("(ps aux grep -v root)'s result is null, exit!!");
                return collResult.KPISet;
            }

            String _usermem = user_mem.elementAt(0);
            collResult.addKPI(memUnitId, "PM-00-01-002-07", _usermem);

		} catch (Exception e) {
			logger.error("Exception while getMemory().", e);
		} finally {
			release();
		}
		
		logger.info("end getMemory");
		return collResult.getKPISet();
	}

	public Vector getSpecProcess(HashMap params) {
		logger.info("begin getSpecProcess : " + params.get("PROCESS_NAME"));
		// 保存采集结果，并返回值
		CollBase collResult = new CollBase();
		try {
			init(params);
			String process_name = (String) params.get("PROCESS_NAME");
			String max_c = (String) params.get("MAX_COUNT");
			String min_c = (String) params.get("MIN_COUNT");
			int max_count = 0;
			int min_count = 0;
			if (max_c != null && !max_c.equals("") && !max_c.equals("null")) {
				max_count = new Integer(max_c).intValue();
			} else {
				max_count = -1;
			}
			if (min_c != null && !min_c.equals("") && !min_c.equals("null")) {
				min_count = new Integer(min_c).intValue();
			} else {
				min_count = 0;
			}

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

			// 获取进程开始时间PM-00-01-005-04，所属用户PM-00-01-005-07,
			// 时间中没有 ":" , 那么把后面的一位也算上
			String cmd1 = "ps -ef | grep -v grep | grep -v 'PPID' |grep '"
					+ process_name + "' | wc -l";
			// 含义UID PID PPID C STIME TTY TIME CMD
			// 数据：" root 98368 1 0 Mar 17 - 18:51 /usr/sbin/syncd 60"
			// 数据："agent 299122 831586 0 11:05:34 pts/3 0:00 -ksh"
			String v1 = tt.getResultAsStr(cmd1);
			if (v1 == null || v1.equals("") || v1.equals("null")) {
				// 不存在该进程
				collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
						+ Formater.neatenunitid(process_name),
						"PM-00-01-005-02", "DOWN");
				return collResult.getKPISet();
			} else {
				int count = new Integer(v1).intValue();
				collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
						+ Formater.neatenunitid(process_name),
						"PM-00-01-005-06", v1);
				if (max_count == -1) {
					if (count >= min_count) {
						collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name
								+ "-" + Formater.neatenunitid(process_name),
								"PM-00-01-005-06", "natural");
					} else {
						collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name
								+ "-" + Formater.neatenunitid(process_name),
								"PM-00-01-005-06", "abnormity");
					}
				} else {
					if (count >= min_count && count < max_count) {
						collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name
								+ "-" + Formater.neatenunitid(process_name),
								"PM-00-01-005-06", "natural");
					} else {
						collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name
								+ "-" + Formater.neatenunitid(process_name),
								"PM-00-01-005-06", "abnormity");
					}
				}
			}// end v1
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			release();
		}
		logger.info("end getSpecProcess : " + params.get("PROCESS_NAME"));
		return collResult.getKPISet();
	}

    public Vector getPortListenings(HashMap params) {
        logger.info("begin getPortListenings : "+ params.get("IP_ADDR") + ":" + params.get("LISTENING_PORT"));
        System.out.println("begin getPortListenings : "+ params.get("IP_ADDR") + ":" + params.get("LISTENING_PORT"));
        String pro_PRE_UNITID = PRE_UNITID + "-26";
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();

        try {
            init(params);
            String linteningHost = (String) params.get("IP_ADDR");
            String listeningPorts = (String) params.get("LISTENING_PORT");
            String correctListening = (String) params.get("CORRECT_LISTENING");
            String[] arrayListeningPorts = listeningPorts.split(",");
            String[] arrayCorrectListening = correctListening.split(",");

            for (int i = 0; i < arrayListeningPorts.length; i++) {
                int count = 0;
                String _listeningAddr = linteningHost + ":" + arrayListeningPorts[i];
                int _correntListenings = new Integer(StringUtils.isNotBlank(arrayCorrectListening[i])? arrayCorrectListening[i]:"0").intValue();
                String listeningStatus = "Normal";
                String cmd = "netstat -an | grep " + _listeningAddr + " | grep ESTABLISHED";
                System.out.println(cmd);
                Vector vec = tt.getResultAsVector(cmd);
                String _unitID = pro_PRE_UNITID + ":" + neat_host_name + "-"
                        + Formater.neatenunitid(arrayListeningPorts[i]);
                // 网络连接监听地址 CM-00-01-001-55
                collResult.addKPI(_unitID, "CM-00-01-001-55", _listeningAddr);
                // 监听地址正常连接个数 CM-00-01-001-56
                collResult.addKPI(_unitID, "CM-00-01-001-56", _correntListenings + "");

                if (vec == null || vec.equals("") || vec.equals("null") || vec.isEmpty()) {
                    // 监听地址当前连接个数 PM-00-01-001-55
                    collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
                            + Formater.neatenunitid(arrayListeningPorts[i]), "PM-00-01-001-55", "0");
                    // 监听地址当前连接个数是否正常 FM-00-01-026-01
                    collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
                            + Formater.neatenunitid(arrayListeningPorts[i]), "FM-00-01-026-01", listeningStatus);
                } else {
                    count = new Integer(String.valueOf(vec.size())).intValue();
                    // 监听地址当前连接个数 PM-00-01-001-55
                    collResult.addKPI(_unitID, "PM-00-01-001-55", count + "");
                    if (count != _correntListenings) {
                        listeningStatus = "Unnormal";
                    }
                    // 监听地址当前连接个数是否正常 FM-00-01-026-01
                    collResult.addKPI(_unitID, "FM-00-01-026-01", listeningStatus);
                }

                // 提供给安徽移动云平台同步用KPI指标 CM-00-01-001-57
                String res = _listeningAddr + ":" + _correntListenings + ":" + count + ":" + listeningStatus;
                collResult.addKPI(_unitID, "CM-00-01-001-57", res);
            }
        } catch (Exception e) {
            logger.error("getPortListenings error", e);
        } finally {
            release();
        }

        logger.info("end getPortListenings : " + params.get("LISTENING_PORT"));
        return collResult.getKPISet();
    }

    public Vector getBusiProcess(HashMap params) {
        logger.info("begin getBusiProcess : " + params.get("PROCESS_NAME"));
        System.out.println("begin getBusiProcess : " + params.get("PROCESS_NAME"));
        String pro_PRE_UNITID = PRE_UNITID + "-25";
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        try {
            init(params);
            if (isConnect) {
                String processName = (String) params.get("PROCESS_NAME");
                if(StringUtils.isNotBlank(processName)){

                    String[] processNames = processName.split(",");
                    for (String _processName : processNames) {
                        String secondProcessName = _processName;
                        if(StringUtils.isBlank(_processName.trim())){
                            continue;
                        }
                        //若每个参数包含特殊符号~，则说明，进程关键字要拼接，进行多重筛选
                        String[] subProcessName = _processName.split("~");
                        _processName = "";
                        for(String _subProcessName : subProcessName){
                            _processName += _subProcessName + "'|grep '";
                        }
                        _processName = _processName.substring(0,_processName.lastIndexOf("|")-1);
                        String cmd = "ps aux | grep -v grep | grep '" + _processName + "'";
                        System.out.println(cmd);
                        Vector vec = tt.getResultAsVector(cmd);
                        _processName = secondProcessName;
                        if (tt.isAuthorized()) {
                            int _count = -1;
                            int count = 0;
                            for (int i = 0; i < 10; i++) {
                                count = new Integer(String.valueOf(vec.size())).intValue();
                                Thread.sleep(3000);
                                logger.info("exec command " + (i + 1) + " t");
                                if (count != _count) {
                                    vec = tt.getResultAsVector(cmd);
                                    _count = count;
                                } else {
                                    if (((String) vec.elementAt(0)).length() == 0) {
                                        vec = tt.getResultAsVector(cmd);
                                        _count = count;
                                        continue;
                                    } else {
                                        break;
                                    }
                                }
                            }
                            // 进程关键字 CM-00-01-005-10
                            collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
                                    + Formater.neatenunitid(_processName), "CM-00-01-005-10", _processName);
                            // 更新时间 CM-00-03-002-10
                            collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
                                    + Formater.neatenunitid(_processName), "CM-00-03-002-10", Formater.datetimeToString(new Date()));
                            // 进程个数 PM-00-01-005-12 CPU使用率 PM-00-01-000-01  内存使用率 PM-00-01-002-01
                            String temp = "";
                            String result = "";
                            Double cpu_usage = 0D;
                            Double mem_usage = 0D;
                            for (int i = 0; i < count; i++) {
                                String proInfo = (String) vec.elementAt(i);
                                if(StringUtils.isBlank(proInfo)) continue;
                                String puser = split(proInfo, 0);
                                String ppid = split(proInfo, 1);
                                Double cpu = Double.parseDouble(split(proInfo, 2));
                                Double mem = Double.parseDouble(split(proInfo, 3));
                                String pstart = split(proInfo, 8);

                                cpu_usage = cpu_usage+cpu;
                                mem_usage = mem_usage+mem;
                                temp += puser + ":" + ppid + ":" + pstart + ",";
                                if(i==count-1){
                                    result +=StringUtils.isBlank(ppid)?"0":ppid;
                                }else{
                                    result +=StringUtils.isBlank(ppid)?"0":ppid + ",";
                                }
                            }
                            // 关键进程PID PM-00-01-005-17
                            collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
                                    + Formater.neatenunitid(_processName), "PM-00-01-005-17", result);

                            if ("::,".equals(temp) || "".equals(temp)) {
                                // 借用进程指令行KPI CM-00-01-005-08
                                collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
                                        + Formater.neatenunitid(_processName), "CM-00-01-005-08", "");
                                collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
                                        + Formater.neatenunitid(_processName), "PM-00-01-005-12", "0");
                                collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
                                        + Formater.neatenunitid(_processName), "PM-00-01-000-01", "0");
                                collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
                                        + Formater.neatenunitid(_processName), "PM-00-01-002-01", "0");
                            } else {
                                // 借用进程指令行KPI CM-00-01-005-08
                                collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
                                        + Formater.neatenunitid(_processName), "CM-00-01-005-08", temp.substring(0, temp.length() - 1));
                                collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
                                        + Formater.neatenunitid(_processName), "PM-00-01-005-12", count + "");
                                collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
                                        + Formater.neatenunitid(_processName), "PM-00-01-000-01", BigDecimal.valueOf(cpu_usage).divide(BigDecimal.ONE, 2, BigDecimal.ROUND_HALF_UP).toString());
                                collResult.addKPI(pro_PRE_UNITID + ":" + neat_host_name + "-"
                                        + Formater.neatenunitid(_processName), "PM-00-01-002-01", BigDecimal.valueOf(mem_usage).divide(BigDecimal.ONE, 2, BigDecimal.ROUND_HALF_UP).toString());
                            }
                        }else {
                            logger.error("fail getBusiProcess:" + _processName + "! SSH session is down!! isAuthorized=" + tt.isAuthorized());
                            if (!_processName.equals(processNames[processNames.length - 1])) {
                                init(params);
                            }
                        }
                    }
                }
            }else {
                logger.error("getBusiProcess has error:ssh session Failed!! isConnect=" + isConnect);
            }
        } catch (Exception e) {
            logger.error("getBusiProcess has error", e);
        } finally {
            release();
        }
        logger.info("end getBusiProcess : " + params.get("PROCESS_NAME"));
        return collResult.getKPISet();
    }

    public Vector getProcessTop5Mem(HashMap params) {
        logger.info("begin getProcessTop5Mem");
        System.out.println("begin getProcessTop5Mem");
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        try {
            init(params);

            if(!tt.isAuthorized()){
                String totalUnitId = this.PRE_UNITID + "-10:" + neat_host_name + "-total";
//                collResult.addKPI(totalUnitId, "FM-00-01-001-01", tt.getError());
                return collResult.KPISet;
            }else{
                String totalUnitId = this.PRE_UNITID + "-10:" + neat_host_name + "-total";
//                collResult.addKPI(totalUnitId, "FM-00-01-001-01", "UP");
            }

            String pro_PRE_UNITID = PRE_UNITID + "-27:" + neat_host_name;

            String cmd = "ps aux | grep -v %CPU | sort -k4 | tail -5";
            System.out.println(cmd);
            Vector<String> vec = tt.getResultAsVector(cmd);
            if (vec == null || vec.equals("") || vec.equals("null")) {
                //
            } else {
                int i = 5;
                for (String processInfo : vec) {
                    String processUser = split(processInfo, 0);
                    String processPid = split(processInfo, 1);
                    String processCpu = split(processInfo, 2);
                    String processMem = split(processInfo, 3);
                    String processCmd = split(processInfo, 10);
                    System.out.println(processUser + "#@#" + processPid + "#@#" + processCpu + "#@#" + processMem);
                    String unitId = pro_PRE_UNITID + "-" + i--;
                    // 进程用户 CM-00-01-005-06
                    collResult.addKPI(unitId, "CM-00-01-005-06", processUser);
                    // 进程ID CM-00-01-005-01
                    collResult.addKPI(unitId, "CM-00-01-005-01", processPid);
                    // 进程占用CPU百分比 PM-00-01-005-10
                    collResult.addKPI(unitId, "PM-00-01-005-10", processCpu);
                    // 进程占用MEM百分比 PM-00-01-005-11
                    collResult.addKPI(unitId, "PM-00-01-005-11", processMem);
                    // 进程指令行 CM-00-01-005-08
                    collResult.addKPI(unitId, "CM-00-01-005-08", processCmd);
                    // 更新时间 CM-00-03-002-10
                    collResult.addKPI(unitId, "CM-00-03-002-10", Formater.datetimeToString(new Date()));
                }
            }
        } catch (Exception e) {
            logger.error("getProcessTop5Mem has error", e);
        } finally {
            release();
        }
        logger.info("end getProcessTop5Mem");
        return collResult.getKPISet();
    }

    public Vector getProcessTop5Cpu(HashMap params) {
        logger.info("begin getProcessTop5Cpu");
        System.out.println("begin getProcessTop5Cpu");
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        try {
            init(params);

            if(!tt.isAuthorized()){
                String totalUnitId = this.PRE_UNITID + "-10:" + neat_host_name + "-total";
//                collResult.addKPI(totalUnitId, "FM-00-01-001-01", tt.getError());
                return collResult.KPISet;
            }else{
                String totalUnitId = this.PRE_UNITID + "-10:" + neat_host_name + "-total";
//                collResult.addKPI(totalUnitId, "FM-00-01-001-01", "UP");
            }

            String pro_PRE_UNITID = PRE_UNITID + "-28:" + neat_host_name;

            String cmd = "ps aux --sort=-pcpu | grep -v %CPU | head -5";
            System.out.println(cmd);
            Vector<String> vec = tt.getResultAsVector(cmd);
            if (vec == null || vec.equals("") || vec.equals("null")) {
                //
            } else {
                int i = 1;
                for (String processInfo : vec) {
                    String processUser = split(processInfo, 0);
                    String processPid = split(processInfo, 1);
                    String processCpu = split(processInfo, 2);
                    String processMem = split(processInfo, 3);
                    String processCmd = split(processInfo, 10);
                    System.out.println(processUser + "#@#" + processPid + "#@#" + processCpu + "#@#" + processMem);
                    String unitId = pro_PRE_UNITID + "-" + i++;
                    // 进程用户 CM-00-01-005-06
                    collResult.addKPI(unitId, "CM-00-01-005-06", processUser);
                    // 进程ID CM-00-01-005-01
                    collResult.addKPI(unitId, "CM-00-01-005-01", processPid);
                    // 进程占用CPU百分比 PM-00-01-005-10
                    collResult.addKPI(unitId, "PM-00-01-005-10", processCpu);
                    // 进程占用MEM百分比 PM-00-01-005-11
                    collResult.addKPI(unitId, "PM-00-01-005-11", processMem);
                    // 进程指令行 CM-00-01-005-08
                    collResult.addKPI(unitId, "CM-00-01-005-08", processCmd);
                    // 更新时间 CM-00-03-002-10
                    collResult.addKPI(unitId, "CM-00-03-002-10", Formater.datetimeToString(new Date()));
                }
            }
        } catch (Exception e) {
            logger.error("getProcessTop5Cpu has error", e);
        } finally {
            release();
        }
        logger.info("end getProcessTop5Cpu");
        return collResult.getKPISet();
    }

	// 采集Syslog
	public Vector getSyslog(HashMap params) {
		logger.info("begin getSyslog ");
		// 保存采集结果，并返回值
		CollBase collResult = new CollBase();
		String host_ip = (String) params.get("IP_ADDR");
		String now_filename = "now_" + host_ip + ".dat";
		String tmp_filename = "tmp_" + host_ip + ".dat";
		String diff_filename = "diff_" + host_ip + ".dat";
		try {
			init(params);
			String now = tt
					.getResultAsStr("grep -i warning /var/log/syslog | sed -n \"1,1000p\"");
			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;
			while ((line1 = diff.readLine()) != null) {
				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-26-17:" + neat_host_name + "-syslog-"
						+ value3;
				collResult.addKPI(unitid, "FM-00-01-900-03", value1);
				collResult.addKPI(unitid, "FM-00-01-900-04", value2);
				collResult.addKPI(unitid, "CM-00-01-900-03", value3);
				collResult.addKPI(unitid, "CM-00-01-900-04", value4);
			}
			diff.close();
			diff_reader.close();
		} catch (Exception e) {
			e.getMessage();
			e.printStackTrace();
		} finally {
			release();
		}
		return collResult.getKPISet();
	}

	public void release() {
        if (tt != null){
            tt.close();
            tt=null;
        }
        System.gc();
    }

	public Vector getDmesg(HashMap params) {
		/**
		 * KPI1=CM-00-01-900-04 #事件id KPI2=CM-00-01-900-05 #发生的时间
		 * KPI3=CM-00-01-900-06 #事件类型 KPI4=CM-00-01-900-07 #事件来源
		 * KPI5=CM-00-01-900-08 #错误的资源的名称 KPI6=CM-00-01-900-09 #错误汇总
		 */

		CollBase collResult = new CollBase();
		String host_ip = (String) params.get("IP_ADDR");
		String now_filename = "now_" + host_ip + ".mesg";
		String tmp_filename = "tmp_" + host_ip + ".mesg";
		String diff_filename = "diff_" + host_ip + ".mesg";
		String keywords = (String) params.get("KEYWORDS");
		String sys_log_path = (String)params.get("SYSLOG_PATH");
		
		if(sys_log_path==null||sys_log_path.trim().equals("")){
			sys_log_path = "/var/log/";
		}else{
			if(!sys_log_path.startsWith("/")){
				sys_log_path = "/" + sys_log_path;
			}
			if(!sys_log_path.endsWith("/")){
				sys_log_path = sys_log_path + "/";
			}
		}
		String[] keyword = null;
		if(keywords==null||keywords.equals("")){
			keywords ="error,ERROR,Error,warning,Warning,WARNING";
			
		}
		keyword = keywords.split(",");
		try {
			init(params);
			String now =null;
			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(host_ip.equals("192.168.3.180")){
//				logger.info(" the now file is too long "+host_ip+" : "+now.toString());
//			}

			try {
				// 日志解析
				if (tmp_file.exists() && tmp_file.length() > 0) {// 非第一次采集
					
					// write_now.close();
					// 读取上周期日志文件(tmp)
					
					
					
					FileReader tmp_reader = new FileReader(tmp_file);
					BufferedReader tmp = new BufferedReader(tmp_reader);
					String line;
					//StringBuffer tmp_file_string = new StringBuffer();
					HashSet set = new HashSet();
					while ((line = tmp.readLine()) != null) {
						//tmp_file_string.append(line + "\n");
						set.add(line.trim());
					}
					try {
						tmp.close();
					} catch (Throwable th1) {
						th1.printStackTrace();
					}
					try {
						tmp_reader.close();
					} catch (Throwable th1) {
						th1.printStackTrace();
					}
					write_tmp = new PrintWriter(new OutputStreamWriter(
							new FileOutputStream(tmp_file), "GB2312"));

					for(int i=0;i<keyword.length;i++){
						now = tt.getResultAsStr("cat "+sys_log_path+"messages | grep '"+keyword[i]+"'");
						write_now.write(now+"\n");
						write_tmp.write(now+"\n");
					}
					write_now.flush();
					write_tmp.flush();
					// tmp.close();
					// tmp_reader.close();
					// 读取本周期日志文件(now)，生成差异文件(diff)
					FileReader now_reader = new FileReader(now_file);
					BufferedReader br = new BufferedReader(now_reader);
					try {
						while ((line = br.readLine()) != null) {
							/*if (tmp_file_string.indexOf(line) == -1)
								write_diff.write(line);
							else
								continue;*/
							if(!set.contains(line.trim())){
								write_diff.write(line+"\n");
							}else{
								continue;
							}
						}
					} catch (Exception e) {
						e.printStackTrace();
					} finally {
						try {
							br.close();
						} catch (Throwable th1) {
							th1.printStackTrace();
						}
						try {
							now_reader.close();
						} catch (Throwable th1) {
							th1.printStackTrace();
						}
					}

					write_diff.flush();
					// write_diff.close();
					
					// write_tmp.close();
				} else {// 第一次采集
					for(int i=0;i<keyword.length;i++){
						now = tt.getResultAsStr("cat "+sys_log_path+"messages | grep '"+keyword[i]+"'");
						write_diff.write(now+"\n");
						write_tmp.write(now+"\n");
					}
					write_tmp.flush();
					write_diff.flush();
				}
			} catch (Throwable th) {
				th.printStackTrace();
			} finally {
				try {
					write_now.close();
				} catch (Throwable th1) {
					th1.printStackTrace();
				}
				try {
					write_diff.close();
				} catch (Throwable th1) {
					th1.printStackTrace();
				}

				try {
					write_tmp.close();
				} catch (Throwable th1) {
					th1.printStackTrace();
				}

			}
			try {
				// 生成指标
				FileReader diff_reader = new FileReader(diff_file);
				BufferedReader diff = new BufferedReader(diff_reader);
				String line1;
				// example{tg3: eth0: Link is up at 100 Mbps, full duplex.}

				try {
					while ((line1 = diff.readLine()) != null) {
						// 判断该行是否存在错误关键字
						boolean isError = false;
						String error_words = "";
						if (keyword != null) {
							for (int j = 0; j < keyword.length; j++) {
								if (line1.indexOf(keyword[j]) != -1) {
									isError = true;
									error_words = keyword[j];
									break;
								}
							}
						} else {
							if (line1.indexOf("error") != -1
									|| line1.indexOf("ERROR") != -1
									|| line1.indexOf("Error") != -1) {
								isError = true;
								error_words = "ERROR";

							} else if (line1.indexOf("warning") != -1
									|| line1.indexOf("Warning") != -1
									|| line1.indexOf("WARNING") != -1) {
								error_words = "WARNING";
								isError = true;
							}
						}
						// 如果包含错误关键字 则生成KPI
						if (isError == true) {
							/*
							 * String device = ""; String msg = ""; if
							 * (line1.indexOf(":") != -1) { device =
							 * line1.substring(0, line1.indexOf(":")); } String
							 * unitid = "10-10-22-17:" + neat_host_name +
							 * "-syslog-" + device; collResult .addKPI(unitid,
							 * "CM-00-01-900-08", device);
							 * collResult.addKPI(unitid, "CM-00-01-900-09",
							 * line1); if (line1.indexOf("error") != -1 ||
							 * line1.indexOf("ERROR") != -1 ||
							 * line1.indexOf("Error") != -1) {
							 * collResult.addKPI(unitid, "FM-00-01-900-04",
							 * "ERROR"); } else { collResult.addKPI(unitid,
							 * "FM-00-01-900-04", "WARING"); }
							 */
							String unitid = PRE_UNITID+"-17:" + neat_host_name
									+ "-dmesg-" + error_words;
							collResult.addKPI(unitid, "CM-00-01-900-08", error_words);
							if(line1.length()<200){
								collResult.addKPI(unitid, "CM-00-01-900-09", line1);
							}else{
								collResult.addKPI(unitid, "CM-00-01-900-09", line1.substring(0,200));
							}
							collResult.addKPI(unitid, "CM-00-01-001-30",Formater.datetimeToString(new Date()));
							//collResult.addKPI(unitid, "CM-00-01-990-10","YES");
						}
					}
				} catch (Throwable th4) {

				} finally {
					try {
						if (diff != null) {
							diff.close();
						}
					} catch (Exception e3) {
						e3.printStackTrace();
					}
					try {
						if (diff != null) {
							diff_reader.close();
						}
					} catch (Exception e3) {
						e3.printStackTrace();
					}
				}

			} catch (Throwable th2) {
				th2.printStackTrace();
			}

		} catch (Exception e) {
			e.getMessage();
			e.printStackTrace();
		} catch (Error er) {
			logger.error(er);
		} finally {
			release();
		}
		return collResult.getKPISet();
	}

	public Vector getSyslogBylogPath(HashMap params) {
		/**
		 * KPI1=CM-00-01-900-04 #事件id KPI2=CM-00-01-900-05 #发生的时间
		 * KPI3=CM-00-01-900-06 #事件类型 KPI4=CM-00-01-900-07 #事件来源
		 * KPI5=CM-00-01-900-08 #错误的资源的名称 KPI6=CM-00-01-900-09 #错误汇总
		 */

		CollBase collResult = new CollBase();
		String host_ip = (String) params.get("IP_ADDR");
		String now_filename = "now_" + host_ip + ".syslog";
		String tmp_filename = "tmp_" + host_ip + ".syslog";
		String diff_filename = "diff_" + host_ip + ".syslog";
		String keywords = (String) params.get("KEYWORDS");
		String log_path = (String) params.get("SYSLOG_PATH");
		if(log_path==null||log_path.equals("")){
			return collResult.getKPISet();
		}
		try {
			init(params);
			String now = tt.getResultAsStr("cat "+log_path);
			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);

			try {
				// 日志解析
				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);
					try {
						while ((line = br.readLine()) != null) {
							if (tmp_file_string.indexOf(line) == -1)
								write_diff.write(line);
							else
								continue;
						}
					} catch (Exception e) {
						e.printStackTrace();
					} finally {
						try {
							tmp.close();
						} catch (Throwable th1) {
							th1.printStackTrace();
						}
						try {
							tmp_reader.close();
						} catch (Throwable th1) {
							th1.printStackTrace();
						}
						try {
							br.close();
						} catch (Throwable th1) {
							th1.printStackTrace();
						}
						try {
							now_reader.close();
						} catch (Throwable th1) {
							th1.printStackTrace();
						}
					}

					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();
				}
			} catch (Throwable th) {
				th.printStackTrace();
			} finally {
				try {
					write_now.close();
				} catch (Throwable th1) {
					th1.printStackTrace();
				}
				try {
					write_diff.close();
				} catch (Throwable th1) {
					th1.printStackTrace();
				}

				try {
					write_tmp.close();
				} catch (Throwable th1) {
					th1.printStackTrace();
				}

			}
			try {
				// 生成指标
				FileReader diff_reader = new FileReader(diff_file);
				BufferedReader diff = new BufferedReader(diff_reader);
				String line1;
				// example{tg3: eth0: Link is up at 100 Mbps, full duplex.}
				String[] keyword = null;
				keyword = keywords.split(",");

				try {
					while ((line1 = diff.readLine()) != null) {
						// 判断该行是否存在错误关键字
						boolean isError = false;
						String error_words = "";
						if (keyword != null) {
							for (int j = 0; j < keyword.length; j++) {
								if (line1.indexOf(keyword[j]) != -1) {
									isError = true;
									error_words = keyword[j];
									break;
								}
							}
						} else {
							if (line1.indexOf("error") != -1
									|| line1.indexOf("ERROR") != -1
									|| line1.indexOf("Error") != -1) {
								isError = true;
								error_words = "ERROR";

							} else if (line1.indexOf("waring") != -1
									|| line1.indexOf("Waring") != -1
									|| line1.indexOf("WARING") != -1) {
								error_words = "WARING";
								isError = true;
							}
						}
						// 如果包含错误关键字 则生成KPI
						if (isError == true) {
							/*
							 * String device = ""; String msg = ""; if
							 * (line1.indexOf(":") != -1) { device =
							 * line1.substring(0, line1.indexOf(":")); } String
							 * unitid = "10-10-22-17:" + neat_host_name +
							 * "-syslog-" + device; collResult .addKPI(unitid,
							 * "CM-00-01-900-08", device);
							 * collResult.addKPI(unitid, "CM-00-01-900-09",
							 * line1); if (line1.indexOf("error") != -1 ||
							 * line1.indexOf("ERROR") != -1 ||
							 * line1.indexOf("Error") != -1) {
							 * collResult.addKPI(unitid, "FM-00-01-900-04",
							 * "ERROR"); } else { collResult.addKPI(unitid,
							 * "FM-00-01-900-04", "WARING"); }
							 */
							String unitid = PRE_UNITID+"-17:" + neat_host_name
									+ "-dmesg-" + error_words;
							collResult
									.addKPI(unitid, "CM-00-01-900-08", error_words);
							if(line1.length()<200){
								collResult.addKPI(unitid, "CM-00-01-900-09", line1);
							}else{
								collResult.addKPI(unitid, "CM-00-01-900-09", line1.substring(0,200));
							}
							collResult.addKPI(unitid, "FM-00-01-900-04",error_words);
						}
					}
				} catch (Throwable th4) {

				} finally {
					try {
						if (diff != null) {
							diff.close();
						}
					} catch (Exception e3) {
						e3.printStackTrace();
					}
					try {
						if (diff != null) {
							diff_reader.close();
						}
					} catch (Exception e3) {
						e3.printStackTrace();
					}
				}

			} catch (Throwable th2) {
				th2.printStackTrace();
			}

		} catch (Exception e) {
			e.getMessage();
			e.printStackTrace();
		} catch (Error er) {
			logger.error(er);
		} finally {
			release();
		}
		return collResult.getKPISet();
	}

	public Vector getSyslogBylogPathUseGrep(HashMap params) {
		CollBase collResult = new CollBase();
		String host_ip = (String) params.get("IP_ADDR");
		String now_filename = "now_" + host_ip + ".syslog";
		String tmp_filename = "tmp_" + host_ip + ".syslog";
		String diff_filename = "diff_" + host_ip + ".syslog";
		String keywords = (String) params.get("KEYWORDS");
		String log_path = (String) params.get("SYSLOG_PATH");
		if(log_path==null||log_path.equals("")){
			return collResult.getKPISet();
		}
		String[] keyword ={"error","ERROR","Error","waring","Waring","WARING"};
		if(keywords!=null){
			keyword = keywords.split(",");
		}
		
		try {
			init(params);
			
			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);

			try {
				
				String now = "";
				// 日志解析
				if (tmp_file.exists() && tmp_file.length() > 0) {// 非第一次采集
						StringBuffer tmp_file_string = new StringBuffer();
						// write_now.close();
						// 读取上周期日志文件(tmp)
						FileReader tmp_reader = new FileReader(tmp_file);
						BufferedReader tmp = new BufferedReader(tmp_reader);
						String line;
						while ((line = tmp.readLine()) != null) {
							tmp_file_string.append( line + "\n");
						}
						
						for(int i=0;i<keyword.length;i++){
							now = tt.getResultAsStr("grep "+keyword[i]+" "+log_path);
							write_now.write(now);
						}	
						write_now.flush();
						// tmp.close();
						// tmp_reader.close();
						// 读取本周期日志文件(now)，生成差异文件(diff)
						FileReader now_reader = new FileReader(now_file);
						BufferedReader br = new BufferedReader(now_reader);
						try {
							while ((line = br.readLine()) != null) {
								if (tmp_file_string.indexOf(line) == -1)
									write_diff.write(line);
								else
									continue;
							}
						} catch (Exception e) {
							e.printStackTrace();
						} finally {
							try {
								tmp.close();
							} catch (Throwable th1) {
								th1.printStackTrace();
							}
							try {
								tmp_reader.close();
							} catch (Throwable th1) {
								th1.printStackTrace();
							}
							try {
								br.close();
							} catch (Throwable th1) {
								th1.printStackTrace();
							}
							try {
								now_reader.close();
							} catch (Throwable th1) {
								th1.printStackTrace();
							}
						}

						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 {
					// 第一次采集
					for(int i=0;i<keyword.length;i++){
						now = tt.getResultAsStr("grep "+keyword[i]+" "+log_path);
						write_tmp.write(now);
						write_tmp.flush();
						// write_tmp.close();
						write_diff.write(now);
						write_diff.flush();
						// write_diff.close();
					}

				}
			} catch (Throwable th) {
				th.printStackTrace();
			} finally {
				try {
					write_now.close();
				} catch (Throwable th1) {
					th1.printStackTrace();
				}
				try {
					write_diff.close();
				} catch (Throwable th1) {
					th1.printStackTrace();
				}

				try {
					write_tmp.close();
				} catch (Throwable th1) {
					th1.printStackTrace();
				}

			}
			try {
				// 生成指标
				FileReader diff_reader = new FileReader(diff_file);
				BufferedReader diff = new BufferedReader(diff_reader);
				String line1;
				// example{tg3: eth0: Link is up at 100 Mbps, full duplex.}
				try {
					while ((line1 = diff.readLine()) != null) {
						// 判断该行是否存在错误关键字
						boolean isError = false;
						String error_words = "";
						if (keyword != null) {
							for (int j = 0; j < keyword.length; j++) {
								if (line1.indexOf(keyword[j]) != -1) {
									isError = true;
									error_words = keyword[j];
									break;
								}
							}
						} 
						// 如果包含错误关键字 则生成KPI
						if (isError == true) {
							/*
							 * String device = ""; String msg = ""; if
							 * (line1.indexOf(":") != -1) { device =
							 * line1.substring(0, line1.indexOf(":")); } String
							 * unitid = "10-10-22-17:" + neat_host_name +
							 * "-syslog-" + device; collResult .addKPI(unitid,
							 * "CM-00-01-900-08", device);
							 * collResult.addKPI(unitid, "CM-00-01-900-09",
							 * line1); if (line1.indexOf("error") != -1 ||
							 * line1.indexOf("ERROR") != -1 ||
							 * line1.indexOf("Error") != -1) {
							 * collResult.addKPI(unitid, "FM-00-01-900-04",
							 * "ERROR"); } else { collResult.addKPI(unitid,
							 * "FM-00-01-900-04", "WARING"); }
							 */
							String unitid = PRE_UNITID+"-17:" + neat_host_name
									+ "-syslog-" + error_words;
							collResult
									.addKPI(unitid, "CM-00-01-900-08", error_words);
							if(line1.length()<200){
								collResult.addKPI(unitid, "CM-00-01-900-09", line1);
							}else{
								collResult.addKPI(unitid, "CM-00-01-900-09", line1.substring(0,200));
							}
							collResult.addKPI(unitid, "FM-00-01-900-04",error_words);
						}
					}
				} catch (Throwable th4) {

				} finally {
					try {
						if (diff != null) {
							diff.close();
						}
					} catch (Exception e3) {
						e3.printStackTrace();
					}
					try {
						if (diff != null) {
							diff_reader.close();
						}
					} catch (Exception e3) {
						e3.printStackTrace();
					}
				}

			} catch (Throwable th2) {
				th2.printStackTrace();
			}

		} catch (Exception e) {
			e.getMessage();
			e.printStackTrace();
		} catch (Error er) {
			logger.error(er);
		} finally {
			release();
		}

		return collResult.getKPISet();
	}

    public Vector getPing(HashMap<String, String> params) {
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        try {
            if ((params.get("PING_IP_ADDR") != null && !"".equals(params.get("PING_IP_ADDR").toString())) &&
                    (params.get("PING_USERNAME") != null && !"".equals(params.get("PING_USERNAME").toString())) &&
                    (params.get("PING_PASSWORD") != null && !"".equals(params.get("PING_PASSWORD").toString())) &&
                    (params.get("PING_PROTOCOL") != null) && !"".equals(params.get("PING_PROTOCOL").toString())){
                this.flag = true;
                init(params);
                if (isConnect) {
                    String net_unit = PRE_UNITID + "-35:" + neat_host_name;
                    List<String> ips = split(params.get("POINT_IPS"), ",");
                    for (String ip : ips) {
                        String pingResult = "ping -c 5 " + ip + "|grep -E 'transmitted|pipe|rtt'";
                        Vector pingV = tt.getResultAsVector(pingResult);
                        if (tt.isAuthorized()) {
                            if (!pingV.isEmpty()) {
                                String unitid = net_unit + "-" + ip;
                                String packageLoss = "";
                                String responseAvgTime = "";
                                String responseMaxTime = "";
                                String lossInfo = pingV.get(0).toString();
                                String respInfo = "";
                                if (pingV.size() == 2) {
                                    respInfo = pingV.get(1).toString();
                                    packageLoss = StringUtils.remove(split(lossInfo, 5), "%");
                                    responseAvgTime = split(respInfo, "/").get(4).toString();
                                    responseMaxTime = split(respInfo, "/").get(5).toString();
                                } else {
                                    packageLoss = "100";
                                    responseAvgTime = "∞";
                                    responseMaxTime = "∞";
                                }
                                collResult.addKPI(unitid, "CM-00-01-006-01", (String)params.get("PING_IP_ADDR"));
                                collResult.addKPI(unitid, "CM-01-03-001-02", ip);
                                collResult.addKPI(unitid, "PM-00-01-006-04", packageLoss);
                                collResult.addKPI(unitid, "PM-00-01-006-05", responseAvgTime);
                                collResult.addKPI(unitid, "PM-00-01-006-16", responseMaxTime);
                            }
                        }else{
                            logger.error("fail getPing:" + ip + "! SSH session is down!! isAuthorized=" + tt.isAuthorized());
                            if (!ip.equals(ips.get(ips.size()-1))) {
                                init(params);
                            }
                        }
                    }
                }else{
                    logger.error("getPing has error:ssh session Failed!! isConnect=" + isConnect);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            release();
        }
        return collResult.getKPISet();
    }

    /**
     * 获取demsg信息，过滤关键字
     * PM-00-01-001-25 demsg异常记录数
     */
    public Vector getDemsg(HashMap<String, String> params) {
        logger.info("begin getDemsg : " + params.get("DEMSG_KEY"));
        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        try {
            init(params);
            String demsg_key = (String) params.get("DEMSG_KEY");
            String pro_PRE_UNITID = PRE_UNITID + "-10:" + neat_host_name + "-total";
            String cmd = "dmesg | grep -E '" + demsg_key + "'";
//            [ssdbomc@kfapp ~]$ dmesg | grep Disabled
//            SELinux:  Disabled at runtime.
//            lo: Disabled Privacy Extensions
            Vector demsgV = tt.getResultAsVector(cmd);
            if (!demsgV.isEmpty() && !"".equals(demsgV.get(0))) {
                collResult.addKPI(pro_PRE_UNITID, "PM-00-01-001-25", demsgV.size() + "");
                return collResult.getKPISet();
            } else {
                collResult.addKPI(pro_PRE_UNITID, "PM-00-01-001-25", "0");
                return collResult.getKPISet();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            release();
        }
        logger.info("end getDemsg : " + params.get("DEMSG_KEY"));
        return collResult.getKPISet();
    }
    public Vector<TblATO_KPIDETAIL> getFileChange(HashMap<String, String> params) {
        logger.info("Begin getFileChange...");
        logger.info(params.toString());
        CollBase collResult = new CollBase();
        String UNIT_ID = params.get("KBP_CLASS");
        init(params);
        try{
            logger.info("-------coll------filepaths--------");
            //得到filechange UnitId
            String filechangeUnitId = UNIT_ID + "-20:" +  neat_host_name + "-";
            String filePaths = params.get("FILE_PATHS");
            String[] filePathList = filePaths.split(",");
            // 获得结果
            for(String tempPath:filePathList) {

                Vector<String> fileResult = tt.getResultAsVector("ls -l " +tempPath);
                /**
                 * 分析传入的文件绝对路径参数
                 * 如果传入的参数中是路径则采集该路径下所有的文件
                 * 如果传入的参数中包含文件名则采集该文件
                 */
                if (fileResult.size() > 1) {//说明该tempPath为目录，记录当前目录下文件数(除去文件夹及文件夹下内容)。
                    Vector<String> dirResult = tt.getResultAsVector("ls -l " +tempPath+" |grep \"^-\"");
                    //文件数量
                    collResult.addKPI(filechangeUnitId + tempPath, "PM-01-09-021-01", dirResult.size()+"");
                }else {
                    collResult.addKPI(filechangeUnitId + tempPath, "PM-01-09-021-01", "0");
                }
                Boolean isChange = checkFileChange(fileResult, tempPath, neat_host_name);
                //文件名称
                collResult.addKPI(filechangeUnitId + tempPath, "CM-10-10-020-01", tempPath);
                //变动部分有结果,则生成告警指标
                collResult.addKPI(filechangeUnitId + tempPath, "FM-10-10-020-01", isChange.toString());

            }
        }catch (Exception e) {
            logger.error("Exception while get fileChange!",e);
        }finally {
            release();
        }
        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 Vector<TblATO_KPIDETAIL> getCatalog(HashMap<String, String> params) {
        logger.info("Begin getCatalog...");
        logger.info(params.toString());
        CollBase collResult = new CollBase();
        String UNIT_ID = params.get("KBP_CLASS");
        //建立连接
        init(params);
        try{
            int count=0;
            String[] catalogList =  params.get("CATALOG").split(",");
            //单目录采集 开始
            String catalog = catalogList[0];
            String size = new BigDecimal(catalogList[1]).toPlainString().toString();
            // ls -ltrd catalog | grep '^d' | grep -v '201[456789]' |sort -nrk5 | awk '$5>size {print $0}' |head -50
            StringBuffer cmdsb = new StringBuffer();
            //拼接采集语句
            cmdsb.append("ls -ltrd ").append(catalog).append(" | grep '^d' | grep -v '201[456789]' |sort -nrk5 | awk '$5>").append(size).append(" {print $0}' |head -50");
            logger.info("-------coll------Catalog--------");
            // 获得结果
            Vector<String> netlogV = tt.getResultAsVector(cmdsb.toString());
            List<List<String>> resultList = analyticalResult(netlogV);
            for(List list:resultList){
                if(list.size() ==2){
                    //添加采集路径
                    //  CM-20-21-027-21关键路径
                    collResult.addKPI(UNIT_ID + "-74:"+neat_host_name+"-" + list.get(0).toString(), "CM-20-21-027-01" , list.get(0).toString());
                    //添加采集路径大小  保留小数点后四位           b
                    // PM-20-21-027-21关键路径大小

                    collResult.addKPI(UNIT_ID + "-74:"+neat_host_name+"-" + list.get(0).toString(), "PM-20-21-027-01" , Formater.formatDecimalByScale((Double.parseDouble(list.get(1).toString())/1024/1024)+"",4));
                }
            }
            //循环执行 用于多目录采集
//            for(count = 0;count<catalogList.length;count=count+2){
//                 String catalog = catalogList[count];
//                 String size = catalogList[count+1];
//                 // ls -ltrd catalog | grep '^d' | grep -v '201[456789]' |sort -nrk5 | awk '$5>size {print $0}' |head -50
//                 StringBuffer cmdsb = new StringBuffer();
//                //拼接采集语句
//                 cmdsb.append("ls -ltrd ").append(catalog).append(" | grep '^d' | grep -v '201[456789]' |sort -nrk5 | awk '$5>").append(size).append(" {print $0}' |head -50");
//                 logger.info("-------coll------Catalog--------");
//                 // 获得结果
//                 Vector<String> netlogV = tt.getResultAsVector(cmdsb.toString());
//                 String host_name = deviceId;
//                 // 得到unit_id中使用的主机名称
//                 String neat_host_name = Formater.neatenunitid(host_name);
//                 List<List<String>> resultList = analyticalResult(netlogV);
//                    for(List list:resultList){
//                        if(list.size() ==2){
//                        //添加采集路径
//                        //  CM-20-21-027-21关键路径
//                        collResult.addKPI(UNIT_ID + "-74:"+host_name+"-" + list.get(0).toString(), "CM-20-21-027-01" , list.get(0).toString());
//                        //添加采集路径大小      保留小数点后4位
//                        // PM-20-21-027-21关键路径大小
//                        collResult.addKPI(UNIT_ID + "-74:"+host_name+"-" + list.get(0).toString(), "PM-20-21-027-01" , Formater.formatDecimalByScale((Double.parseDouble(list.get(1).toString())/1024/1024)+"",4));
//                        }
//                    }
//            }
        }catch (Exception e) {
            logger.error("Exception while get Catalog!",e);
        }finally {
            release();
        }
        logger.info("END COLL Catalog ");
        return collResult.getKPISet();
    }

    /**
     * 解析目录采集结果返回指定集合
     * @param list
     * @return
     */
    private List<List<String>> analyticalResult(List list){
        List<List<String>> resultList = new ArrayList<List<String>>();
        int i = 0;
        for(i=0;i< list.size();i++){
            //目标目录
            String path = split(list.get(i).toString(), 8);
            //目录大小
            String size = split(list.get(i).toString(),4);
            List<String>  strList = new ArrayList<String>();
            strList.add(path);
            strList.add(size);
            if((path != null & path !="")  && (size != null & size != "") ){
                resultList.add(strList);
            }
        }
        return  resultList;
    }

    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();
    }

	public ArrayList split(String str, String sp) {
		int ip = 0;
		ArrayList al = new ArrayList();
		ip = str.indexOf(sp);
		if (ip != -1) {
			al.add(str.substring(0, ip));
			str = str.substring(ip + sp.length());
			if (str.length() != 0) {
				al.addAll(split(str, sp));
			}
		} else {
			al.add(str);
		}
		return al;
	}

	// 采集cpu利用率,共采集times次,每次采集间隔interval秒
	private String getCPU_Rate(int times, int interval) {
		CollBase collResult = new CollBase();
		float cpu_value = 0;
		for (int i = 0; i < times; i++) {

			Vector cpuout = this.tt.getResultAsVector("vmstat 1 3");
			String cpurun = (String) cpuout.elementAt(cpuout.size() - 1);

			cpu_value = (100 - Integer.parseInt(collResult.split(cpurun, 14)))
					+ cpu_value;

			try {
				Thread.sleep(interval * 1000L);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		cpu_value = cpu_value / times;
		return Formater.formatDecimalKpivalue(Float.toString(cpu_value));
	}

	public String[] split2Array(String str, String sp) {
		ArrayList al = split(str, sp);

		Object[] os = al.toArray();
		String[] ss = new String[os.length];
		for (int i = 0; i < os.length; i++) {
			ss[i] = (String) os[i];
		}
		return ss;
	}

	public static void main(String[] args) {
		HashMap params = new HashMap();
		System.out.print(BigDecimal.valueOf(1.05599999999999).divide(BigDecimal.ONE,2,BigDecimal.ROUND_HALF_UP));
//		params.put("IP_ADDR", "172.18.30.32");
//		params.put("USERNAME", "basd");
//		params.put("PASSWORD",
//				"c88b4daa9cefa1803e45d3905008c490aa1a0278bff3c367");
//		params.put("PROTOCOL", "ssh");
//		params.put("PROCESS_NAME", "");
//		params.put("MAX_COUNT", "2");
//		params.put("HOSTNAME", "yf-ys2");
//		params.put("MIN_COUNT", "1");
		if(args.length<6){
			System.exit(0);
		}
		params.put("IP_ADDR", args[0]);
		params.put("USERNAME", args[1]);
		String pass = args[2];
		pass = DES3.encrypt(pass);
		System.out.println("password:"+pass);
		params.put("PASSWORD",pass);
		params.put("PROTOCOL", args[3]);
//		params.put("PROCESS_NAME", "");
//		params.put("MAX_COUNT", "2");
		params.put("HOSTNAME", args[4]);
		params.put("KEYWORDS", args[5]);
		CollLinuxWithCMD coll = new CollLinuxWithCMD();
//		Vector lst = coll.getDiskForIOstat(params);
		Vector lst = coll.getDmesg(params);
		System.out.println("lst.size() is " + lst.size());
		for (int i = 0; i < lst.size(); i++) {
			TblATO_KPIDETAIL kpidetail = (TblATO_KPIDETAIL) lst.get(i);
			System.out.println(kpidetail.UNIT_ID + "|" + kpidetail.KPI_ID + "|"
					+ kpidetail.CLL_TIME + "|" + kpidetail.KPI_VALUE);
		}
	}
}