package com.sitech.ismp.coll.host;

import java.text.SimpleDateFormat;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;

import org.apache.log4j.Logger;

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

/**
 * @author zang
 * @author mao 修改日期：2009-1-17
 *         修改原因：与IBM、IP主机采集指标度量单位保持一致,将交换区大小指标CM-00-01-001-13的值/1024，单位升级到M
 * 
 * 不支持多线程调用
 */
public class CollSUNWithCMD extends CollBase {

	private String UNIT_ID = "10-10-22";
	
	String deviceId = "";

//	String neat_host_name = "";

	Vector<TblATO_KPIDETAIL> result = new Vector<TblATO_KPIDETAIL>();

	String value = null;

	TblATO_KPIDETAIL record = null;

	RPCTarget rpctarget = null;

	public CollSUNWithCMD() {

	}

	public Vector<TblATO_KPIDETAIL> coll(HashMap<String,String> params) {
		init(params);

		if (getState()) {
			result.addAll(getFM(params));
			result.addAll(getConfig(params));
			result.addAll(getCpu(params));
			result.addAll(getMemory(params));
			result.addAll(getDisk(params));
			result.addAll(getFileSystem(params));
			result.addAll(getSpecProcess(params));
			// result.addAll(getSpecUserProNum(params));
			result.addAll(getUserProNum(params));
		} else {
			try {
				value = "down";
				record = new TblATO_KPIDETAIL();
				record.setCLL_TIME(new java.util.Date());
				record.setKPI_ID("FM-00-01-001-01");
				record.setKPI_VALUE(value);
				record.setUNIT_ID(this.UNIT_ID + ":state");

				result.add(record);

			} catch (Exception e) {
				logger.error(e);
			}
		}
		release();
		System.out.println("End Coll SUNHost");
		return result;

	}

	public Vector<TblATO_KPIDETAIL> getFM(HashMap<String,String> params) {
		init(params);

		CollBase collResult = new CollBase();

		try {
			Vector<String> lancard_state1 = rpctarget
					.getKPISet("/usr/sbin/ifconfig -a |grep '<'");

			String lancard_state2 = (String) lancard_state1
					.elementAt(lancard_state1.size() - 1);

			int card_index1 = lancard_state2.indexOf("<");

			int card_index2 = lancard_state2.indexOf(",", card_index1);

			String lancard_state = lancard_state2.substring(card_index1 + 1,
					card_index2);
			// FM-00-01-001-03 主机网卡状态 该主机网卡的工作状态
			collResult.addKPI(
					UNIT_ID + ":" + deviceId + "-netcard_state",
					"FM-00-01-001-03", lancard_state);

		} catch (Exception e) {
			logger.error(e);
		}

		return collResult.getKPISet();
	}

	public Vector<TblATO_KPIDETAIL> getConfig(HashMap<String,String> params) {
		init(params);

		CollBase collResult = new CollBase();
		// 本方法得到的kpi值的unit_id,均以PRE_UNITID + "-10"开头，代表Total数据
		String config_PRE_UNITID = UNIT_ID + "-10"; // total值

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

		// 常用ip,用于告警标题
		collResult.addKPI(config_PRE_UNITID + ":" + deviceId + "-total",
				"CM-00-01-001-50", (String) params.get("IP_ADDR"));

		try {
			String memorySize = rpctarget
					.getKPIValue("/etc/prtconf -v | grep Memory");
			memorySize = split(memorySize, 2);
			collResult.addKPI(config_PRE_UNITID + ":" + deviceId
					+ "-total", "CM-00-01-001-07", memorySize);
		} catch (Exception e) {
			logger.error(e);
		}
		try {
			Vector<String> cpunum = rpctarget.getKPISet("mpstat");
			// String cpufrequency = rpctarget
			// .getKPIValue("prtdiag -v | awk -FX '{if($0~/System
			// Configuration/) print $2 }'| awk '{print substr($2,0,6)}'");
//			String cpufrequency = rpctarget
//					.getKPIValue("prtdiag -v |awk -F 'NR==10 {print $1}'|awk '{print $4}'");

			String cpuNum = String.valueOf(cpunum.size() - 1);

			// cpu个数
			collResult.addKPI(config_PRE_UNITID + ":" + deviceId
					+ "-total", "CM-00-01-001-04", cpuNum);

//			// cpu频率
//			collResult.addKPI(config_PRE_UNITID + ":" + deviceId
//					+ "-total", "CM-00-01-001-06", cpufrequency);

		} catch (Exception e) {
			logger.error(e);
		}
		try {
			// String cputype = rpctarget
			// .getKPIValue("prtdiag -v | awk -FX '{if($0~/System
			// Configuration/) print $2 }'| awk '{print $1}'");
//			String cputype = rpctarget
//					.getKPIValue("prtdiag -v |awk -F 'NR==10 {print $1}'|awk '{print $5}'");

			// CM-00-01-001-05 主机CPU型号 主机CPU的（型号
//			collResult.addKPI(config_PRE_UNITID + ":" + deviceId
//					+ "-total", "CM-00-01-001-05", cputype);

		} catch (Exception e) {
			logger.error(e);
		}
		try {
			String swap_size = rpctarget
					.getKPIValue("swap -s | awk '{print $11}'");
			// 交换分区大小
			// 2009-1-17号有改，单位单位统一为M
			long swap_size_w = Long.parseLong(swap_size.substring(0, swap_size
					.length() - 1)) / 1024;
			collResult.addKPI(config_PRE_UNITID + ":" + deviceId
					+ "-total", "CM-00-01-001-13", Long.toString(swap_size_w));

		} catch (Exception e) {
			logger.error(e);
		}

		Vector<String> lancard_num = rpctarget
				.getKPISet("/usr/sbin/ifconfig -a |awk '{print $1}' |grep :");

		try {
			logger.debug(lancard_num);
			String lancard = String.valueOf(lancard_num.size() - 1);
			logger.debug(lancard);

			// KPI: CM-00-01-001-10 系统网络接口数
			collResult.addKPI(config_PRE_UNITID + ":" + deviceId
					+ "-total", "CM-00-01-001-10", lancard);

		} catch (Exception e) {
			logger.error(e);
		}
		try {
			for (int i = 0; i < lancard_num.size(); i++) {
				String temp = (String) lancard_num.elementAt(i);
				if (temp.substring(0, 2).equals("lo"))
					lancard_num.remove(temp);
			}
		} catch (Exception e) {

		}

		try {

			Vector<String> lancard_all = rpctarget.getKPISet("/usr/sbin/ifconfig -a ");
			String address_ip = null;
			StringBuffer sb = new StringBuffer();
			for (int i = 0; i < lancard_all.size(); i++) {

				if (lancard_num.indexOf(split(
						(String) lancard_all.elementAt(i), 0)) != -1) {
					address_ip = split((String) lancard_all.elementAt(i + 1), 1);
					// address_phy = split((String) lancard_all.elementAt(i +
					// 2),
					// 1);
					// KPI:CM-00-01-001-2 主机地址
					// KPI:CM-00-01-001-11 系统网络接口IP地址
					// KPI:CM-00-01-001-12 系统网络接口物理地址

					// ip地址
					collResult.addKPI(config_PRE_UNITID + ":" + deviceId
							+ "-total", "CM-00-01-001-11", address_ip);
					// CM-00-01-001-02 主机地址 主机的IP地址(服务IP)
					collResult.addKPI(config_PRE_UNITID + ":" + deviceId
							+ "-total", "CM-00-01-001-02", address_ip);

					sb.append(address_ip);
					if (i + 1 < lancard_all.size() - 1) {
						sb.append(",");
					}

					// collResult.addKPI(config_PRE_UNITID + ":" +
					// deviceId
					// + "-total", "CM-00-01-001-12", address_phy);
					// logger.debug(address_ip + "=======" + address_phy);
				}

			}
			/*
			 * collResult.addKPI(config_PRE_UNITID + ":" + deviceId +
			 * "-total", "CM-00-01-001-11", sb.toString());
			 */
		} catch (Exception e) {
			logger.error("sss", e);
		}

		Vector<String> getOS = rpctarget.getKPISet("uname -a");

		try {

			// 主机名称
			collResult.addKPI(config_PRE_UNITID + ":" + deviceId
					+ "-total", "CM-00-01-001-01", split((String) getOS
					.elementAt(0), 1));

			// 主机版本
			collResult.addKPI(config_PRE_UNITID + ":" + deviceId
					+ "-total", "CM-00-01-001-08", split((String) getOS
					.elementAt(0), 2));

			// 主机类型
			collResult.addKPI(config_PRE_UNITID + ":" + deviceId
					+ "-total", "CM-00-01-001-03", split((String) getOS
					.elementAt(0), 0));

		} catch (Exception e) {
			logger.error(e);
		}

		// id 使用 -14
		String fs_PRE_UNITID = this.UNIT_ID + "-14";
		// 16 CM-00-01-001-16 文件系统名称 文件系统的标识 1天 字符串型
		// 17 CM-00-01-001-17 文件系统的总空间 主机文件系统总的可用量 1天 数值型
		// 文件系统名称 ，并 计算文件系统总空间
		Vector<String> fileSystem = rpctarget.getKPISet("df -k | grep -v Filesystem");
		long fs_sum = 0; // 文件系统总空间，兆
		for (int i = 0; i < fileSystem.size(); i++) {
			try {
				String fs_info = (String) fileSystem.elementAt(i);
				String fs_name = collResult.split(fs_info, 5);
				if (fs_name != null && fs_name.trim().equals("/")) {
					collResult.addKPI(fs_PRE_UNITID + ":" + deviceId
							+ "-" + Formater.neatenunitid("//"),
							"CM-00-01-001-16", fs_name);
				} else {
					collResult.addKPI(fs_PRE_UNITID + ":" + deviceId
							+ "-" + Formater.neatenunitid(fs_name),
							"CM-00-01-001-16", fs_name);
				}

				String fs_size = collResult.split(fs_info, 1);
				fs_size = (fs_size == null || fs_size.trim().length() == 0 || fs_size
						.trim().equals("-")) ? "0" : fs_size.trim();
				long lfs_size = Long.parseLong(fs_size);
				fs_sum = fs_sum + lfs_size;

			} catch (Exception e) {
				logger.error(e);
			}
		}// end for
		collResult.addKPI(config_PRE_UNITID + ":" + deviceId + "-total",
				"CM-00-01-001-17", String.valueOf(fs_sum / 1024));

		return collResult.getKPISet();
	}

	public Vector<TblATO_KPIDETAIL> getCpu(HashMap<String,String> params) {
		init(params);

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

		try {
			Vector<String> vmstat_result = rpctarget.getKPISet("vmstat 2 10");
			String vmstat_string = (String) vmstat_result
					.elementAt(vmstat_result.size() - 1);

			// PM-00-01-001-06 CPU运行队列中进程个数 CPU运行队列中进程个数
			collResult.addKPI(cpu_PRE_UNITID + ":" + deviceId + "-cpu",
					"PM-00-01-001-06", split(vmstat_string, 0));

			Vector<String> cpuout = rpctarget.getKPISet("sar -u 1 20");
			String cpurun = (String) cpuout.elementAt(cpuout.size() - 1);
			// PM-00-01-001-03 CPU时间：用户百分比 用户任务所占用CPU时间量占CPU时间总量的百分比。

			collResult.addKPI(cpu_PRE_UNITID + ":" + deviceId + "-cpu",
					"PM-00-01-001-03", split(cpurun, 1));

			// PM-00-01-001-02 CPU时间：系统百分比 CPU在系统相关任务上所用的时间量并报告它所占CPU时间总量的百分比值

			collResult.addKPI(cpu_PRE_UNITID + ":" + deviceId + "-cpu",
					"PM-00-01-001-02", split(cpurun, 2));

			// PM-00-01-001-04 CPU时间：等待百分比
			// CPU等待（包括I/O等待，Swap等待和进程输入输出等待）所占用CPU时间量占CPU时间总量的百分比。

			collResult.addKPI(cpu_PRE_UNITID + ":" + deviceId + "-cpu",
					"PM-00-01-001-04", split(cpurun, 3));

			// PM-00-01-001-01 CPU时间：空闲百分比 CPU空闲时间量占CPU时间总量的百分比的值
			collResult.addKPI(cpu_PRE_UNITID + ":" + deviceId + "-cpu",
					"PM-00-01-001-01", split(cpurun, 4));

			// PM-00-01-001-05 CPU使用率 用户CPU时间百分比和系统CPU时间百分比之和的平均值。
			String value = String
					.valueOf(Integer.parseInt(split(cpurun, 1)) + Integer
							.parseInt(split(cpurun, 2)));

			collResult.addKPI(cpu_PRE_UNITID + ":" + deviceId + "-cpu",
					"PM-00-01-001-05", value);

		} catch (Exception e) {
			logger.error(e);
		}

		return collResult.getKPISet();
	}

	public Vector<TblATO_KPIDETAIL> getMemory(HashMap<String,String> params) {
		init(params);

		// 本方法得到的kpi值的unit_id,均以PRE_UNITID + "-12"开头
		String memory_PRE_UNITID = UNIT_ID + "-12";
		CollBase collResult = new CollBase();

		try {

			Vector<String> vmstat_result = rpctarget.getKPISet("vmstat 2 2");
			String vmstat_string = (String) vmstat_result
					.elementAt(vmstat_result.size() - 1);
			logger.debug(vmstat_string);
			logger.debug(split(vmstat_string, 0));
			logger.debug(split(vmstat_string, 1));
			logger.debug(split(vmstat_string, 2));
			logger.debug(split(vmstat_string, 3));

			value = split(vmstat_string, 9);
			// PM-00-01-002-02 内存交换请求数 Page request（包括page in&out）操作的数量
			collResult.addKPI(memory_PRE_UNITID + ":" + deviceId
					+ "-memory", "PM-00-01-002-02", value);

			value = split(vmstat_string, 7);
			// PM-00-01-002-03 内存交换页换进率 内存交换页换进速率
			collResult.addKPI(memory_PRE_UNITID + ":" + deviceId
					+ "-memory", "PM-00-01-002-03", value);
			value = split(vmstat_string, 8);
			// PM-00-01-002-04 内存交换页换出率 内存交换页换出速率
			collResult.addKPI(memory_PRE_UNITID + ":" + deviceId
					+ "-memory", "PM-00-01-002-04", value);

			value = split(vmstat_string, 0);
			// PM-00-01-002-05 内存队列数 等待内存的进程或线程数量
			collResult.addKPI(memory_PRE_UNITID + ":" + deviceId
					+ "-memory", "PM-00-01-002-05", value);

			// PM-00-01-002-01 内存的使用率 主机内存的使用量与内存总量的比值
			String memorySize = rpctarget
					.getKPIValue("/etc/prtconf -v | grep Memory");
			memorySize = split(memorySize, 2);

			int free_mem = Integer.parseInt(split(vmstat_string, 4)) / 1024; // 空余内存
			// 单位：M
			int total_mem = Integer.parseInt(memorySize); // 总内存 单位：M
			double use_per = 100.0 - (free_mem * 100.0) / total_mem; // 内存使用率
			String mem_use_per = this
					.getByScale(new Double(use_per).toString());
			collResult.addKPI(memory_PRE_UNITID + ":" + deviceId
					+ "-memory", "PM-00-01-002-01", Formater
					.formatDecimalKpivalue(mem_use_per));

		} catch (Exception e) {
			logger.error(e);
		}
		try {
			Vector<String> filerate_result = rpctarget.getKPISet("sar -b 2 10");
			String filerate_string = (String) filerate_result
					.elementAt(filerate_result.size() - 1);
			int r_rate = Integer.parseInt(split(filerate_string, 2));
			int w_rate = Integer.parseInt(split(filerate_string, 5));
			logger.debug("-------------");
			logger.debug(r_rate + "");
			logger.debug(w_rate + "");
			value = String.valueOf((r_rate + w_rate) / 2);
			// PM-00-01-002-08 文件系统数据缓冲命中率 文件系统数据缓冲命中率
			collResult.addKPI(memory_PRE_UNITID + ":" + deviceId
					+ "-memory", "PM-00-01-002-08", value);
		} catch (Exception e) {
			logger.error(e);
		}
		return collResult.getKPISet();
	}

	public Vector<TblATO_KPIDETAIL> getDisk(HashMap<String, String> params) {
		// 保存采集结果，并返回值
		CollBase collResult = new CollBase();
		
		logger.info("*********** CollSUNWithCMD.getDisk() Begin!  ***********");
		
		init(params);

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

		Vector<String> otherResult = rpctarget.getKPISet("sar -d 1 2");
//		// 执行脚本
//		exec("getSunHostDisk.sh");
//		
//		// 获得脚本执行结果
//		List<String> otherResult = getResult("sunHostDiskResult.txt");
//		if(result == null || result.size() == 0){
//			return collResult.KPISet;
//		}
		
		
		if(otherResult != null || !otherResult.isEmpty() ){
			int iPos = -1;
			for (int i = 0; i < otherResult.size(); i++) {
				String disk_value = (String) otherResult.elementAt(i);
				String neat_disk_name = "";
				String busy = "";
				String avque = "";
				String rws = "";
				String blks = "";
				
				if (iPos == -1) {
					iPos = disk_value.indexOf("Average");
					neat_disk_name = split(disk_value, 1);
					busy = split(disk_value, 2);
					avque = split(disk_value, 3);
					rws = split(disk_value, 4);
					blks = split(disk_value, 5);
				} else if (iPos >= 0) {
					neat_disk_name = split(disk_value, 0);
					busy = split(disk_value, 1);
					avque = split(disk_value, 2);
					rws = split(disk_value, 3);
					blks = split(disk_value, 4);
				}
				
				if (iPos >= 0) {
					// 磁盘名称
					collResult.addKPI(preUnitId + "-" + neat_disk_name,
							"CM-00-01-001-20", neat_disk_name);
					// 磁盘忙的百分比
					collResult.addKPI(preUnitId + "-" + neat_disk_name,
							"PM-00-01-003-03", busy);
					// 等待磁盘系统进程线程数
					collResult.addKPI(preUnitId + "-" + neat_disk_name,
							"PM-00-01-003-02", avque);
					// 每秒读请求
					collResult.addKPI(preUnitId + "-" + neat_disk_name,
							"PM-00-01-003-04", rws);
					// 每秒写请求
					collResult.addKPI(preUnitId + "-" + neat_disk_name,
							"PM-00-01-003-05", rws);
					// 磁盘物理IO操作速率
					collResult.addKPI(preUnitId + "-" + neat_disk_name,
							"PM-00-01-003-01", blks);
				}
			}
		}

		logger.info("*********** CollSUNWithCMD.getDisk() End!  ***********");
		return collResult.getKPISet();
	}

	public Vector<TblATO_KPIDETAIL> getFileSystem(HashMap<String,String> params) {
		CollBase collResult = new CollBase();
		init(params);
		
		String swap_size = rpctarget.getKPIValue("swap -s | awk '{print $11}'");
		String swap_used = rpctarget.getKPIValue("swap -s | awk '{print $9}'");
		double swapsize = Integer.parseInt(swap_size.substring(0, swap_size
				.length() - 1));
		double swapused = Integer.parseInt(swap_used.substring(0, swap_used
				.length() - 1));

		try {
			value = String.valueOf((swapused * 100) / (swapsize + swapused));
			// PM-00-01-004-02 交换区使用百分比
			collResult.addKPI(UNIT_ID + "-10:" + deviceId + "-total",
					"PM-00-01-004-02", Formater.formatDecimalKpivalue(value));
		} catch (Exception e) {
			logger.error("Exception while getFileSystem().", e);
		}

		// 1 PM-00-01-004-01 文件系统使用比率 文件系统已使用的空间与总空间的比值
		// 3 PM-00-01-004-03 逻辑卷(裸设备)文件系统使用率 各逻辑卷上文件系统的使用率

		// 采集各文件系统占用率
		long fs_sum = 0; // 文件系统总空间
		long fs_sum_free = 0; // 文件系统总已空余空间
		Vector<String> filesystemV = rpctarget.getKPISet("df -k");
		if (filesystemV.size() > 0) {
			for (int i = 1; i < filesystemV.size(); i++) {
				String fsInfo = (String) filesystemV.elementAt(i);
				String fs_name = split(fsInfo, 5);
				String usedPercent = split(fsInfo, 4);
				String fs_size = split(fsInfo, 1);
				String fs_free = split(fsInfo, 3);
				fs_size = fs_size.equals("-") ? "0" : fs_size; // proce的情况为 -
				fs_free = fs_free.equals("-") ? "0" : fs_free; // proce的情况为 -
				fs_sum = fs_sum + Long.parseLong(fs_size);
				fs_sum_free = fs_sum_free + Long.parseLong(fs_free);

				String neat_fs_name = Formater.neatenunitid(fs_name);
				// 去除百分号，如果是/proc， 直接设定为0
				if (usedPercent.length() > 1) {
					if (usedPercent.trim().equals("-")) {
						usedPercent = "0";
					} else {
						usedPercent = usedPercent.substring(0, usedPercent
								.length() - 1);
					}
				}

				try {
					if (neat_fs_name != null && neat_fs_name.equals("/")) {
						collResult.addKPI(UNIT_ID + "-14:" + deviceId
								+ "-//", "PM-00-01-004-03", usedPercent);
						collResult.addKPI(UNIT_ID + "-14:" + deviceId
								+ "-//", "PM-00-01-004-04", fs_free);
					} else {
						collResult.addKPI(UNIT_ID + "-14:" + deviceId
								+ "-" + neat_fs_name, "PM-00-01-004-03",
								usedPercent);
						collResult.addKPI(UNIT_ID + "-14:" + deviceId
								+ "-" + neat_fs_name, "PM-00-01-004-04",
								fs_free);
					}

				} catch (Exception e) {
					logger.error("Exception while getFileSystem().", e);
				}

			}
		}// 获取文件系统使用率完毕

		// PM-00-01-004-01 文件系统总占用率需要计算
		if (fs_sum != 0) {
			collResult.addKPI(UNIT_ID + "-10:" + deviceId + "-total",
					"PM-00-01-004-01", getByScale(String.valueOf(100
							- fs_sum_free * 100.0 / fs_sum)));
		}

		logger.info("end getFileSystem");
		return collResult.getKPISet();
	}

	/**
	 * 
	 * 得到指定精度的double类型数值 精度设定为4
	 * 
	 * @param double_value
	 * @return
	 */
	private String getByScale(String double_value) {
		int scale = 4;
		return Formater.getByScale(double_value, scale);
	}

	/*
	 * public Vector<TblATO_KPIDETAIL> getSpecUserProNum(HashMap<String,String> params) { init(params); String
	 * user_name = (String) params.get("SPEC_USER"); CollBase collResult = new
	 * CollBase(); String pro_PRE_UNITID = UNIT_ID + "-15";
	 * 
	 * Vector<String> proNumV = rpctarget.getKPISet("ps -fu" + user_name); int pro_size =
	 * proNumV.size() - 2; // 去掉 ps进程 和 首行'UID PID PPID C STIME // TTY TIME CM'
	 * pro_size = pro_size < 0 ? 0 : pro_size;
	 * 
	 * String proNum = String.valueOf(pro_size); // PM-00-01-005-06 特定用户进程数
	 * 主机上某用户的当前进程连接数 collResult.addKPI(pro_PRE_UNITID + ":" + deviceId +
	 * "-" + Formater.neatenunitid(user_name), "PM-00-01-005-06", proNum
	 * .trim()); return collResult.getKPISet(); }
	 */

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

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

		// 得到所有用户的列表，该用户名出现多少次，就表明ps出来有多少行，即有多少进程
		Vector<String> userV = new Vector<String>();
		Vector<String> processV = rpctarget.getKPISet("ps -ef | grep -v UID");
		// 原来采用以下命令，但在jilin 10.161.1.132 hp主机上有时出现 用户名称为 _3的情况，所以弃用
		// rpctarget.getKPISet("export UNIX95=XPG4;ps -ef -o user | grep -v
		// USER");
		for (int i = 0; i < processV.size(); i++) {
			String processInfo = (String) processV.elementAt(i);
			userV.add(collResult.split(processInfo, 0));
		}
		processV = null;

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

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

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

		// 本方法得到的kpi值的unit_id,均以PRE_UNITID + "-10"开头，代表Total数据
		String pro_PRE_UNITID = UNIT_ID + "-15"; // total值
		
		for (String username : user_pronum.keySet()) {
			collResult.addKPI(pro_PRE_UNITID + ":" + deviceId + "-"
					+ Formater.neatenunitid(username), "PM-00-01-005-06",
					((Integer) user_pronum.get(username)).toString());
		}

		return collResult.getKPISet();
	}

	public Vector<TblATO_KPIDETAIL> getSpecProcess(HashMap<String,String> params) {
		init(params);
		// 保存采集结果，并返回值
		String process_name = (String) params.get("PROCESS_NAME");
		CollBase collResult = new CollBase();
		String pro_PRE_UNITID = UNIT_ID + "-15";

		try {
			String unit_process = "ps -ef -o pcpu,s,stime,vsz,comm,pid |grep  '"
					+ process_name + "'";

			Vector<String> otherCpu = rpctarget.getKPISet(unit_process);
			if (otherCpu == null || otherCpu.size() == 0) {
				// 不存在该进程
				collResult.addKPI(pro_PRE_UNITID + ":" + deviceId + "-"
						+ Formater.neatenunitid(process_name),
						"PM-00-01-005-02", "DOWN");
				return collResult.getKPISet();
			} else {
				for (int i = 0; i < otherCpu.size(); i++) {
					String pro_info = (String) otherCpu.elementAt(i);
					String pcpu = split(pro_info, 0);
					String state = split(pro_info, 1);
					String stime = split(pro_info, 2);
					String vsz = split(pro_info, 3);
					String command = split(pro_info, 4);
					String pid = split(pro_info, 5);
					// PM-00-01-005-01 占用CPU时间 进程单位时间在CPU中运行的时间
					collResult.addKPI(pro_PRE_UNITID + ":" + deviceId
							+ "-" + pid + ":" + Formater.neatenunitid(command),
							"PM-00-01-005-01", pcpu);
					// PM-00-01-005-02 进程状态 进程状态包括运行，等待，阻塞，挂起，停止
					collResult.addKPI(pro_PRE_UNITID + ":" + deviceId
							+ "-" + pid + ":" + Formater.neatenunitid(command),
							"PM-00-01-005-02", state);
					// PM-00-01-005-04 进程开始时间 进程启动的时间
					collResult.addKPI(pro_PRE_UNITID + ":" + deviceId
							+ "-" + pid + ":" + Formater.neatenunitid(command),
							"PM-00-01-005-04", stime);
					value = split(pro_info, 3);
					// PM-00-01-005-05 进程的规模 进程占用内存的空间大小
					collResult.addKPI(pro_PRE_UNITID + ":" + deviceId
							+ "-" + pid + ":" + Formater.neatenunitid(command),
							"PM-00-01-005-05", vsz);

					value = split(pro_info, 4);
					// PM-00-01-005-03 进程指令行 进程的指令行
					collResult.addKPI(pro_PRE_UNITID + ":" + deviceId
							+ "-" + pid + ":" + Formater.neatenunitid(command),
							"PM-00-01-005-03", command);

				}
			}
		} catch (Exception e) {
			logger.error(e);
		}

		return collResult.getKPISet();
	}

	// 采集占用主机内存资源的top 15进程，分析内存占用量趋势，判断主机内存是否泄漏
	public Vector<TblATO_KPIDETAIL> getTopProcess(HashMap<String,String> params) {
		init(params);
		// 保存采集结果，并返回值
		CollBase collResult = new CollBase();
		String pro_PRE_UNITID = UNIT_ID + "-16";
		try {
			Vector<String> process = rpctarget.getKPISet("prstat -s rss|head -15");
			for (int i = 1; i < process.size(); i++) {//去除结果中前1行
				String pro_info = (String) process.elementAt(i);
				String PID = split(pro_info, 0);
				String USERNAME = split(pro_info, 1);
				String SIZE = split(pro_info, 2);
				String RSS = split(pro_info, 3);
				String STATE = split(pro_info, 4);
				String CPU = split(pro_info, 8);
				String PROCESS_NAME = split(pro_info, 9);
				collResult.addKPI(pro_PRE_UNITID + ":" + deviceId + "-"
						+ PID, "CM-00-01-005-07", PROCESS_NAME);
				collResult.addKPI(pro_PRE_UNITID + ":" + deviceId + "-"
						+ PID, "CM-00-03-008-016", USERNAME);
				collResult.addKPI(pro_PRE_UNITID + ":" + deviceId + "-"
						+ PID, "PM-00-02-001-17", SIZE.substring(0, SIZE
						.length() - 1));
				collResult.addKPI(pro_PRE_UNITID + ":" + deviceId + "-"
						+ PID, "PM-00-02-002-14", RSS.substring(0,
						RSS.length() - 1));
				collResult.addKPI(pro_PRE_UNITID + ":" + deviceId + "-"
						+ PID, "FM-00-01-002-05", STATE);
				collResult.addKPI(pro_PRE_UNITID + ":" + deviceId + "-"
						+ PID, "PM-00-03-009-01", CPU.substring(0,
						CPU.length() - 1));
			}
		} catch (Exception e) {
			logger.error(e);
		}

		return collResult.getKPISet();
	}

	public void init(HashMap<String,String> params) {
		// 获取主机名称
		rpctarget = new RPCTarget();

		rpctarget.setRpcCmd("sh RPCTarget_suport.sh");

		rpctarget.getKPISet("LANG=C;export LANG");
		
		deviceId = params.get("DEVICE_ID");
		
		if(deviceId == null || "".equals(deviceId) || "null".equals(deviceId)){
			Vector<String> host = rpctarget.getKPISet("uname -a");
			if (host != null && !host.isEmpty()) {
				deviceId = split(host.get(0), 1);
			}
		}
		
		deviceId = Formater.neatenunitid(deviceId);
	}

	public boolean getState() {
		String value = rpctarget.getKPIValue("echo OK");
		if (value.equals("OK"))
			return true;
		else {
			return false;
		}
	}

	public static void main(String[] args) {
		String s = "21031400k";
		long swap_size_w = Long.parseLong(s.substring(0, s.length() - 1)) / 1024;
		System.out.println(swap_size_w);
	}
}