package com.sitech.ismp.coll.tivoli;

import java.util.List;
import java.util.Map;

import com.sitech.util.Formater;

;

/**
 * 该类只采集 规范中的 ibm提供采集方法的 主机相关指标
 * 
 * @author winnerbao
 * 
 */
public class GXCollHost {

	private boolean debug = false;
	private SoapClient soapClient = null;

	private String pre_unitid = "";

	/**
	 * 
	 * @param pre_unit
	 *            对于aix , pre_unit="10-10-20" 对于hp-ux , pre_unit="10-10-21"
	 *            对于solaris , pre_unit="10-10-22"
	 */
	public GXCollHost(String pre_unit) {
		this.pre_unitid = pre_unit;

		// 
		String url = SoapParam.getString("SOAP_URL");
		soapClient = new SoapClient(url);
	}

	/**
	 * 采集规范中指标 PM-00-01-001-01 CPU时间：空闲百分比 CPU空闲时间量占CPU时间总量的百分比的值 Idle
	 * CPU(Percent) PM-00-01-001-02 CPU时间：系统百分比
	 * CPU在系统相关任务上所用的时间量并报告它所占CPU时间总量的百分比值 System CPU(Percent) PM-00-01-001-03
	 * CPU时间：用户百分比 用户任务所占用CPU时间量占CPU时间总量的百分比。 User CPU(Percent) PM-00-01-001-04
	 * CPU时间：等待百分比 CPU等待（包括I/O等待，Swap等待和进程输入输出等待）所占用CPU时间量占CPU时间总量的百分比。 Wait
	 * I/O(Percent) PM-00-01-001-05 CPU使用率 用户CPU时间百分比和系统CPU时间百分比之和的平均值。 CPU
	 * Busy(Percent) PM-00-01-001-06 CPU运行队列中进程个数 CPU运行队列中进程个数 Processes/Threads
	 * in Run Queue
	 * 
	 * 获取这些指标需要发送2个soap请求 PM-00-01-001-01/02/03/04/05 object=SMP_CPU
	 * PM-00-01-001-06 object=System
	 * 
	 * @param params
	 * @return
	 * @throws Exception
	 */
	public java.util.Vector getCpu(java.util.HashMap params) throws Exception {

		// debug=true;
		String host_name = (String) params.get("HOST_NAME");
		String neat_host_name = Formater.neatenunitid(host_name);
		// String neat_host_name =
		// Formater.neatenunitid(CollHostNameHelper.getHostName(host_name));

		String soap_host_name = SOAPITCMNameHelper.getSoapHostName(host_name);

		com.sitech.ismp.coll.CollBase collResult = new com.sitech.ismp.coll.CollBase();

		/*
		 * FM-00-01-001-04 主机Cluster状态 主机当前CLUSTER的状态 UA for Cluster HA UA
		 * HACMPCLUSTER00.clusterState
		 */
		// getSoap_HACMPCLUSTER00
		String Soap_HACMPCLUSTER = GXCollHostSoapHelper
				.getSoap_HACMPCLUSTER00(host_name);
		String Soap_HACMPCLUSTER_res = soapClient
				.getSoapStringResponse(Soap_HACMPCLUSTER);
		List HACMPCLUSTER_result = CollHostXmlHelper
				.parseSoapResponse(Soap_HACMPCLUSTER_res);

		for (int i = 0; i < HACMPCLUSTER_result.size(); i++) {
			Map resultMap = (Map) HACMPCLUSTER_result.get(i);
			String clusterState = (String) resultMap.get("clusterState");

			collResult.addKPI(pre_unitid + "-10:" + neat_host_name + "-total",
					"FM-00-01-001-04", clusterState);
		}

		// 采集PM-00-01-01-01/02/03/04/05
		// object=SMP_CPU
		String soap_cpu_SMPCPU = GXCollHostSoapHelper
				.getSoap_cpu_SMPCPU(soap_host_name); // soap消息
		String soap_cpu_SMPCPU_res = soapClient
				.getSoapStringResponse(soap_cpu_SMPCPU);
		if (debug)
			System.out.println(new java.util.Date() + soap_cpu_SMPCPU_res);

		List cpu_results = CollHostXmlHelper
				.parseSoapResponse(soap_cpu_SMPCPU_res);
		Map cpu_aggregate = null;
		// 得到 CPU_ID=aggregate 的那个
		for (int i = 0; i < cpu_results.size(); i++) {
			Map cpu = (Map) cpu_results.get(i);
			String cpu_id = (String) cpu.get("CPU_ID");
			if (cpu_id.equals("aggregate")) {
				cpu_aggregate = cpu;
				break;
			}
		}
		if (cpu_aggregate == null) {
			System.out
					.println("@tivoli , no cpu info got by tivoli in collCpu "
							+ new java.util.Date());
		} else {
			collResult.addKPI(pre_unitid + "-11:" + neat_host_name + "-cpu",
					"PM-00-01-001-01", (String) cpu_aggregate.get("Idle_CPU"));
			collResult
					.addKPI(pre_unitid + "-11:" + neat_host_name + "-cpu",
							"PM-00-01-001-02", (String) cpu_aggregate
									.get("System_CPU"));
			collResult.addKPI(pre_unitid + "-11:" + neat_host_name + "-cpu",
					"PM-00-01-001-03", (String) cpu_aggregate.get("User_CPU"));
			collResult.addKPI(pre_unitid + "-11:" + neat_host_name + "-cpu",
					"PM-00-01-001-04", (String) cpu_aggregate.get("Wait_IO"));
			collResult.addKPI(pre_unitid + "-11:" + neat_host_name + "-cpu",
					"PM-00-01-001-05", (String) cpu_aggregate.get("CPU_Busy"));
		}

		// 采集PM-00-01-001-06
		// object=System
		String soap_cpu_System = GXCollHostSoapHelper
				.getSoap_cpu_System(soap_host_name); // soap消息
		String soap_cpu_System_res = soapClient
				.getSoapStringResponse(soap_cpu_System);
		if (debug)
			System.out.println(new java.util.Date() + soap_cpu_System_res);
		List system_results = CollHostXmlHelper
				.parseSoapResponse(soap_cpu_System_res);
		if (system_results == null || system_results.size() < 1) {
			System.out.println("@tivoli , no System info got by tivoli"
					+ new java.util.Date());
		} else {
			// 该结果中，肯定只有一条记录，这是由tivoli机制所保证的
			Map system_map = (Map) system_results.get(0);
			if (debug)
				System.out.println(soap_host_name + ":"
						+ "Processes_in_Run_Queue:"
						+ system_map.get("Processes_in_Run_Queue"));
			collResult.addKPI(pre_unitid + "-11:" + neat_host_name + "-cpu",
					"PM-00-01-001-06", (String) system_map
							.get("Processes_in_Run_Queue"));
		}
		// begin 2006-7-6 lianlian
		// 采集FM-00-01-01-01
		// object=Network
		String soap_cpu_Network = GXCollHostSoapHelper
				.getSoap_cpu_Network(soap_host_name);
		String soap_cpu_Network_res = soapClient
				.getSoapStringResponse(soap_cpu_Network);
		List Network_results = CollHostXmlHelper
				.parseSoapResponse(soap_cpu_Network_res);
		String Interface_Status_result = "DOWN";

		for (int i = 0; i < Network_results.size(); i++) {
			Map networkMap = (Map) Network_results.get(i);
			String Interface_Status = (String) networkMap
					.get("Interface_Status");
			// 如果有一个interface_status为up整体状态视为up，所有为down整体状态视为down
			if (Interface_Status.equalsIgnoreCase("UP")) {
				Interface_Status_result = "UP";
				break;
			}

		}
		collResult.addKPI(pre_unitid + "-10:" + neat_host_name + "-total",
				"FM-00-01-001-01", Interface_Status_result);

		return collResult.getKPISet();
	}

	// end

	/**
	 * 
	 * PM-00-01-002-01 内存的使用率 主机内存的使用量与内存总量的比值 提供Free Memeory和Total Memeory
	 * PM-00-01-002-02 内存交换请求数 Page request（包括page in&out）操作的数量 Page-Ins(Per
	 * Sec),Page-Outs(Per Sec) PM-00-01-002-03 内存交换页换进率 内存交换页换进速率 Page-Ins Rate
	 * PM-00-01-002-04 内存交换页换出率 内存交换页换出速率 Page_Out Rate PM-00-01-002-05 内存队列数
	 * 等待内存的进程或线程数量 Processes/Threads in Run Queue PM-00-01-002-06 系统内存使用率
	 * 系统内存占所有物理内存的百分比 无此概念 PM-00-01-002-07 用户内存使用率 用户内存占所有物理内存的百分比 无此概念
	 * PM-00-01-002-08 文件系统数据缓冲命中率 文件系统数据缓冲命中率 "ITM提供 Logical Block
	 * Reads(lread)，Logical Block Write(lwrite)，Block Reads(bread)和Block
	 * Write(bwrite). 读命中率=100*(lread - bread)/lread 写命中率=100*(lwrite -
	 * bwrite)/lwrite" 我们计算命中率方法 100*[ (lread - bread)+ (lwrite - bwrite) /
	 * (lread+lwrite)] 获取这些指标需要发送1个soap请求 PM-00-01-002-01/02/03/04/08
	 * object=System 有的要计算 PM-00-01-002-05 object=System
	 * ibm提供采集方法与PM-00-01-01-06写成了一个，我们也这样采 ~~~PM-00-01-002-06/07 没法采，ibm称无此概念
	 * 
	 * @param params
	 * @return
	 * @throws Exception
	 */
	public java.util.Vector getMemory(java.util.HashMap params)
			throws Exception {

		String host_name = (String) params.get("HOST_NAME");
		// String neat_host_name = Formater.neatenunitid(host_name);
		String neat_host_name = Formater.neatenunitid(host_name);

		String soap_host_name = SOAPITCMNameHelper.getSoapHostName(host_name);

		com.sitech.ismp.coll.CollBase collResult = new com.sitech.ismp.coll.CollBase();

		// 采集PM-00-01-002-01/02/03/04/08/05
		// object=System
		String soap_memory_System = GXCollHostSoapHelper
				.getSoap_memory_System(soap_host_name); // soap消息
		String soap_memory_System_res = soapClient
				.getSoapStringResponse(soap_memory_System);
		List system_results = CollHostXmlHelper
				.parseSoapResponse(soap_memory_System_res);
		if (system_results == null || system_results.size() < 1) {
			System.out
					.println("@tivoli , no System info got by tivoli in collMemory : "
							+ new java.util.Date());
		} else {
			// 该结果中，肯定只有一条记录，这是由tivoli机制所保证的
			Map system_map = (Map) system_results.get(0);
			String Free_Memory = (String) system_map.get("Free_Memory");
			String Total_Real_Memory = (String) system_map
					.get("Total_Real_Memory");
			double memory_use_rate = 100 * (1 - Double.parseDouble(Free_Memory)
					/ Double.parseDouble(Total_Real_Memory));

			String Page_Ins = (String) system_map.get("Page_Ins");
			String Page_Outs = (String) system_map.get("Page_Outs");
			double page_in_and_out = Double.parseDouble(Page_Ins)
					+ Double.parseDouble(Page_Outs);

			String Page_Ins_Rate = (String) system_map.get("Page_Ins_Rate");
			// double page_in_rate = Double.parseDouble(Page_Ins_Rate);

			String Page_Out_Rate = (String) system_map.get("Page_Out_Rate");
			// double page_out_rate = Double.parseDouble(Page_Out_Rate);

			String Processes_in_Run_Queue = (String) system_map
					.get("Processes_in_Run_Queue");

			String Logical_Block_Reads = (String) system_map
					.get("Logical_Block_Reads");
			String Logical_Block_Writes = (String) system_map
					.get("Logical_Block_Writes");
			String Block_Reads = (String) system_map.get("Block_Reads");
			String Block_Writes = (String) system_map.get("Block_Writes");
			double lread = Double.parseDouble(Logical_Block_Reads);
			double lwrite = Double.parseDouble(Logical_Block_Writes);
			double bread = Double.parseDouble(Block_Reads);
			double bwrite = Double.parseDouble(Block_Writes);

			double hit_rate = 0;
			if ((lread + lwrite) == 0) {
				hit_rate = 0;
			} else {
				hit_rate = 100 * ((lread - bread) + (lwrite - bwrite) * 1.0
						/ (lread + lwrite));
			}
			collResult.addKPI(pre_unitid + "-12:" + neat_host_name + "-memory",
					"PM-00-01-002-01", getByScale(String
							.valueOf(memory_use_rate)));
			collResult.addKPI(pre_unitid + "-12:" + neat_host_name + "-memory",
					"PM-00-01-002-02", String.valueOf(page_in_and_out));
			collResult.addKPI(pre_unitid + "-12:" + neat_host_name + "-memory",
					"PM-00-01-002-03", Page_Ins_Rate);
			collResult.addKPI(pre_unitid + "-12:" + neat_host_name + "-memory",
					"PM-00-01-002-04", Page_Out_Rate);
			collResult.addKPI(pre_unitid + "-12:" + neat_host_name + "-memory",
					"PM-00-01-002-05", Processes_in_Run_Queue);
			collResult.addKPI(pre_unitid + "-12:" + neat_host_name + "-memory",
					"PM-00-01-002-08", String.valueOf(hit_rate));
		}

		return collResult.getKPISet();
	}

	/**
	 * PM-00-01-003-01 磁盘物理IO操作速率 磁盘物理IO操作速率（秒） Transferred Bytes(KBytes)
	 * PM-00-01-003-02 等待磁盘系统进程线程数 等待磁盘系统（disk、inode、cache、CDFS）的进程和线程数
	 * 使用iostat命令通过UA获取 PM-00-01-003-03 磁盘忙的百分比 磁盘读写的时间占用总时间的百分比 PM-00-01-003-04
	 * 每秒磁盘读请求 每秒磁盘读请求字节数 PM-00-01-003-05 每秒磁盘写请求 每秒磁盘写请求字节数
	 * 
	 * 获取这些指标需要发送1个soap请求 PM-00-01-003-01 object=Disk_Performance
	 * ~~~PM-00-01-003-02/03/04/05采不到，可以通过命令iostat采，本程序不提供
	 * 
	 * @param params
	 * @return
	 * @throws Exception
	 */

	public java.util.Vector getDisk(java.util.HashMap params) throws Exception {

		String host_name = (String) params.get("HOST_NAME");
		String ua_host_name = GXUaHostHelper.getUaHostName(host_name);
		// String neat_host_name = Formater.neatenunitid(host_name);
		String neat_host_name = Formater.neatenunitid(host_name);

		String soap_host_name = SOAPITCMNameHelper.getSoapHostName(host_name);

		com.sitech.ismp.coll.CollBase collResult = new com.sitech.ismp.coll.CollBase();

		// 采集PM-00-01-003-01
		// object=Disk_Performance
		String soap_disk_DiskPerformance = GXCollHostSoapHelper
				.getSoap_disk_DiskPerformance(soap_host_name); // soap消息
		String soap_disk_DiskPerformance_res = soapClient
				.getSoapStringResponse(soap_disk_DiskPerformance);
		List diskp_results = CollHostXmlHelper
				.parseSoapResponse(soap_disk_DiskPerformance_res);
		if (diskp_results == null || diskp_results.size() < 1) {
			System.out.println("@tivoli , no Disk Perf info got by tivoli"
					+ new java.util.Date());
		} else {
			// 该结果中，肯定只有一条记录，这是由tivoli机制所保证的
			Map diskper_map = (Map) diskp_results.get(0);
			collResult.addKPI(pre_unitid + "-13:" + neat_host_name + "-disk",
					"PM-00-01-003-01", (String) diskper_map
							.get("Transferred_Bytes"));
		}

		/*
		 * PM-00-01-003-02 等待磁盘系统进程线程数 等待磁盘系统（disk、inode、cache、CDFS）的进程和线程数
		 * OOSTAT00 UA OOAINFOIOINFO00.ProcessNumber
		 */
		// getSoap_OOAINFOIOINFO00
		String soap_OOAINFOIO = GXCollHostSoapHelper
				.getSoap_OOAINFOIOINFO00(ua_host_name);
		String soap_OOAINFOIO_res = soapClient
				.getSoapStringResponse(soap_OOAINFOIO);
		List OOAINFOIO_results = CollHostXmlHelper
				.parseSoapResponse(soap_OOAINFOIO_res);

		for (int i = 0; i < OOAINFOIO_results.size(); i++) {
			Map resultMap = (Map) OOAINFOIO_results.get(i);

			String ProcessNumber = (String) resultMap.get("ProcessNumber");
			collResult.addKPI(pre_unitid + "-10:" + neat_host_name + "-total",
					"PM-00-01-003-02", ProcessNumber);
		}

		/*
		 * PM-00-01-003-03 磁盘忙的百分比 磁盘读写的时间占用总时间的百分比 OOSTAT00
		 * OOSTATOOSTAT00.BusyPercent PM-00-01-003-04 每秒磁盘读请求 每秒磁盘读请求字节数
		 * OOSTAT00 OOSTATOOSTAT00.Kr_Per_Second PM-00-01-003-05 每秒磁盘写请求
		 * 每秒磁盘写请求字节数 OOSTAT00 OOSTATOOSTAT00.Kw_Per_Second
		 */

		String soap_OOSTAT = GXCollHostSoapHelper
				.getSoap_OOSTATOOSTAT00(ua_host_name);
		String soap_OOSTAT_res = soapClient.getSoapStringResponse(soap_OOSTAT);
		List OOSTAT_results = CollHostXmlHelper
				.parseSoapResponse(soap_OOSTAT_res);

		for (int i = 0; i < OOSTAT_results.size(); i++) {
			Map resultMap = (Map) OOSTAT_results.get(i);
			String BusyPercent = (String) resultMap.get("BusyPercent");
			String Kr_Per_Second = (String) resultMap.get("Kr_Per_Second");
			String Kw_Per_Second = (String) resultMap.get("Kw_Per_Second");

			collResult.addKPI(pre_unitid + "-13:" + neat_host_name,
					"PM-00-01-003-03", BusyPercent);
			collResult.addKPI(pre_unitid + "-13:" + neat_host_name,
					"PM-00-01-003-04", Kr_Per_Second);
			collResult.addKPI(pre_unitid + "-13:" + neat_host_name,
					"PM-00-01-003-05", Kw_Per_Second);

		}

		/*
		 * FM-00-01-001-02 主机内置盘状态，改为所有磁盘状态 主机的内置盘是否正常 OOAINFODISKINFO00.多个
		 */
		// getSoap_OOAINFODISKINFO00
		String Soap_OOAINFODISKINFO = GXCollHostSoapHelper
				.getSoap_OOAINFODISKINFO00(ua_host_name);
		String Soap_OOAINFODISKINFO_res = soapClient
				.getSoapStringResponse(Soap_OOAINFODISKINFO);
		List OOAINFODISKINFO_result = CollHostXmlHelper
				.parseSoapResponse(Soap_OOAINFODISKINFO_res);

		for (int i = 0; i < OOAINFODISKINFO_result.size(); i++) {
			Map resultMap = (Map) OOAINFODISKINFO_result.get(i);
			String pvname = (String) resultMap.get("PVName");
			String pvstate = (String) resultMap.get("PVState");
			if (pvstate == "") {
				pvstate = "UNKNOW";
			}
			collResult.addKPI(pre_unitid + "-13:" + neat_host_name + "-"
					+ pvname, "FM-00-01-001-02", pvstate);
		}

		return collResult.getKPISet();
	}

	/**
	 * 
	 * PM-00-01-004-01 文件系统使用比率 文件系统已使用的空间与总空间的比值 Space Used Percent
	 * PM-00-01-004-02 交换区使用百分比 交换区使用百分比 = Swap Space Free/(Total Virtual Memory -
	 * Total Real Memory) PM-00-01-004-03 逻辑卷(裸设备)文件系统使用率 各逻辑卷上文件系统的使用率 Space
	 * Used Percent
	 * 
	 * 获取这些指标需要发送2个soap请求 PM-00-01-004-01/03 Object=Disk PM-00-01-004-02
	 * Object=System , 公式错误！ibm提供的公式应该是计算空闲百分比的。更正为 1- Swap Space
	 * Free*1024/(Total Virtual Memory - Total Real Memory)
	 * 
	 * @param params
	 * @return
	 * @throws Exception
	 */
	public java.util.Vector getFileSystem(java.util.HashMap params)
			throws Exception {

		String host_name = (String) params.get("HOST_NAME");
		// String neat_host_name = Formater.neatenunitid(host_name);
		String neat_host_name = Formater.neatenunitid(host_name);

		String soap_host_name = SOAPITCMNameHelper.getSoapHostName(host_name);

		com.sitech.ismp.coll.CollBase collResult = new com.sitech.ismp.coll.CollBase();
		// PM-00-01-004-01/03 Object=Disk
		// 得到soap请求
		String soap_filesystem_Disk = GXCollHostSoapHelper
				.getSoap_filesystem_Disk(soap_host_name); // soap消息
		// 发送soap请求，并返回结果
		String soap_filesystem_Disk_res = soapClient
				.getSoapStringResponse(soap_filesystem_Disk);
		// 分析返回结果，得到list
		List disk_results = CollHostXmlHelper
				.parseSoapResponse(soap_filesystem_Disk_res);

		// 获取每个文件系统的kpi值，顺便计算总的文件系统大小和总的已使用文件系统大小
		int total_filesystem = 0;
		int used_filesystem = 0;
		for (int i = 0; i < disk_results.size(); i++) {
			Map diskMap = (Map) disk_results.get(i);
			String Mount_Point = (String) diskMap.get("Mount_Point");
			String Space_Used_Percent = (String) diskMap
					.get("Space_Used_Percent");
			String Size = (String) diskMap.get("Size");
			String Space_Used = (String) diskMap.get("Space_Used");

			String neatMount_Point = Formater.neatenunitid(Mount_Point);
			collResult.addKPI(pre_unitid + "-14:" + neat_host_name + "-"
					+ neatMount_Point, "PM-00-01-004-03", Space_Used_Percent);

			total_filesystem = total_filesystem + Integer.parseInt(Size);
			used_filesystem = used_filesystem + Integer.parseInt(Space_Used);
		}

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

		// PM-00-01-004-02 Object=System
		String soap_filesystem_System = GXCollHostSoapHelper
				.getSoap_filesystem_System(soap_host_name); // soap消息
		String soap_filesystem_System_res = soapClient
				.getSoapStringResponse(soap_filesystem_System);
		List system_results = CollHostXmlHelper
				.parseSoapResponse(soap_filesystem_System_res);
		if (system_results == null || system_results.size() < 1) {
			System.out
					.println("@tivoli , no System info got by tivoli in collFileSystem"
							+ new java.util.Date());
		} else {
			// 该结果中，肯定只有一条记录，这是由tivoli机制所保证的
			Map system_map = (Map) system_results.get(0);
			String Swap_Space_Free = (String) system_map.get("Swap_Space_Free");
			String Total_Virtual_Memory = (String) system_map
					.get("Total_Virtual_Memory");
			String Total_Real_Memory = (String) system_map
					.get("Total_Real_Memory");
			// System.out.println("Swap_Space_Free:"+Swap_Space_Free);
			// System.out.println("Total_Virtual_Memory:"+Total_Virtual_Memory);
			// System.out.println("Total_Real_Memory:"+Total_Real_Memory);

			double swap_use_rate = 100 * (1 - Double
					.parseDouble(Swap_Space_Free)
					* 1024
					/ (Double.parseDouble(Total_Virtual_Memory) - Double
							.parseDouble(Total_Real_Memory)));

			collResult.addKPI(pre_unitid + "-10:" + neat_host_name + "-total",
					"PM-00-01-004-02", Formater.formatDecimalKpivalue(String
							.valueOf(swap_use_rate)));

		}
		// System.out.println(soap_filesystem_System_res);

		// collResult.displayKPI();
		return collResult.getKPISet();
	}

	/**
	 * 
	 * PM-00-01-005-01 占用CPU时间(?) 进程单位时间在CPU中运行的时间 CPU Utilization
	 * PM-00-01-005-02 进程状态 进程状态包括运行，等待，阻塞，挂起，停止 Execution State PM-00-01-005-03
	 * 进程指令行 进程的指令行 Command PM-00-01-005-04 进程开始时间 进程启动的时间 StartTime
	 * PM-00-01-005-05 进程的规模 进程占用内存的空间大小 Size (KBytes) PM-00-01-005-06 特定用户进程数
	 * 主机上某用户的当前进程连接数 入库时使用SQL Count获取 *
	 * 
	 * 获取这些指标需要发送1个soap请求 PM-00-01-005-01/02/03/04/05 Object=Process
	 * ~~~PM-00-01-005-06 ， 需要数据都上来后，通过sql语句获取，这里面有没有特定用户的参数
	 * 
	 * @param params
	 * @return
	 * @throws Exception
	 */
	public java.util.Vector getProcess(java.util.HashMap params)
			throws Exception {

		String host_name = (String) params.get("HOST_NAME");
		// String neat_host_name = Formater.neatenunitid(host_name);
		String neat_host_name = Formater.neatenunitid(host_name);

		String soap_host_name = SOAPITCMNameHelper.getSoapHostName(host_name);

		com.sitech.ismp.coll.CollBase collResult = new com.sitech.ismp.coll.CollBase();

		// PM-00-01-005-01/02/03/04/05
		// Object=Process
		String soap_process_Process = GXCollHostSoapHelper
				.getSoap_process_Process(soap_host_name); // soap消息

		String soap_process_Process_res = soapClient
				.getSoapStringResponse(soap_process_Process);

		List process_results = CollHostXmlHelper
				.parseSoapResponse(soap_process_Process_res);
		if (process_results == null || process_results.size() == 0) {
			System.out.println("getSoap_process_Process error");
		} else {
			// 获取每个进程相关值
			for (int i = 0; i < process_results.size(); i++) {
				Map processMap = (Map) process_results.get(i);

				String CPU_Utilization = (String) processMap
						.get("CPU_Utilization");
				String Execution_State = (String) processMap
						.get("Execution_State");
				// String Command = (String)processMap.get("Command") ;
				// //此属性返回没参数，可能造成进程名称一致的情况
				String Command = (String) processMap.get("Process_Command"); // 此属性返回100个字以内的参数

				String StartTime = (String) processMap.get("StartTime");
				String Size = (String) processMap.get("Size");

				collResult.addKPI(pre_unitid + "-15:" + neat_host_name + "-"
						+ Command, "PM-00-01-005-01", CPU_Utilization);
				collResult.addKPI(pre_unitid + "-15:" + neat_host_name + "-"
						+ Command, "PM-00-01-005-02", Execution_State);
				collResult.addKPI(pre_unitid + "-15:" + neat_host_name + "-"
						+ Command, "PM-00-01-005-03", Command);
				collResult.addKPI(pre_unitid + "-15:" + neat_host_name + "-"
						+ Command, "PM-00-01-005-04", StartTime);
				collResult.addKPI(pre_unitid + "-15:" + neat_host_name + "-"
						+ Command, "PM-00-01-005-05", Size);

			}
		}

		// begin 2006-7-13 lianlian
		// PM-00-01-005-06
		String Soap_System_Situations_Unix_Os = GXCollHostSoapHelper
				.getSoap_System_Situations_Unix_Os(soap_host_name);
		String Soap_System_Situations_Unix_Os_res = soapClient
				.getSoapStringResponse(Soap_System_Situations_Unix_Os);
		List Unix_Os_result = CollHostXmlHelper
				.parseSoapResponse(Soap_System_Situations_Unix_Os_res);

		for (int i = 0; i < Unix_Os_result.size(); i++) {
			Map rowMap = (Map) Unix_Os_result.get(i);

			String Processes_Running = (String) rowMap.get("Processes_Running");

			collResult.addKPI(pre_unitid + "-15:" + neat_host_name + "-total",
					"PM-00-01-005-06", Processes_Running);
		}

		// begin 2006-7-8 lianlian
		// FM-00-01-001-05 关键进程状态 Process.Execution_Stat
		String Soap_process_Execution = GXCollHostSoapHelper
				.getSoap_process_Execution(soap_host_name);
		String Soap_process_Execution_res = soapClient
				.getSoapStringResponse(Soap_process_Execution);
		List Execution_result = CollHostXmlHelper
				.parseSoapResponse(Soap_process_Execution_res);
		for (int i = 0; i < Execution_result.size(); i++) {
			Map ExecutionMap = (Map) Execution_result.get(i);
			String Execution_State = (String) ExecutionMap
					.get("Execution_State");

			collResult.addKPI(pre_unitid + "-15:" + neat_host_name + "-total",
					"FM-00-01-001-05", Execution_State);
		}
		// end

		return collResult.getKPISet();
	}

	/**
	 * 
	 * FM-00-01-001-03 主机网卡状态 该主机网卡的工作状态 Interface Status
	 * 
	 * 获取这些指标需要发送1个soap请求 FM-00-01-001-03 Object=Network
	 * 
	 * @param params
	 * @return
	 * @throws Exception
	 */
	public java.util.Vector getNetwork(java.util.HashMap params)
			throws Exception {

		String host_name = (String) params.get("HOST_NAME");
		// String neat_host_name = Formater.neatenunitid(host_name);
		String neat_host_name = Formater.neatenunitid(host_name);

		String soap_host_name = SOAPITCMNameHelper.getSoapHostName(host_name);

		com.sitech.ismp.coll.CollBase collResult = new com.sitech.ismp.coll.CollBase();
		// FM-00-01-001-03
		// Object=Network
		String soap_network_Network = GXCollHostSoapHelper
				.getSoap_network_Network(soap_host_name); // soap消息
		String soap_network_Network_res = soapClient
				.getSoapStringResponse(soap_network_Network);
		List network_results = CollHostXmlHelper
				.parseSoapResponse(soap_network_Network_res);

		// 获取每个网卡的信息
		for (int i = 0; i < network_results.size(); i++) {
			Map networkMap = (Map) network_results.get(i);
			String Network_Interface_Name = (String) networkMap
					.get("Network_Interface_Name");
			String Interface_Status = (String) networkMap
					.get("Interface_Status");

			if ("Aggregate".equals(Network_Interface_Name)) {
				continue;
			}
			collResult.addKPI(pre_unitid + "-16:" + neat_host_name + "-"
					+ Network_Interface_Name, "FM-00-01-001-03",
					Interface_Status);

		}
		return collResult.getKPISet();
	}

	/**
	 * 得到主机配置数据
	 * 
	 * CM-00-01-001-16 文件系统名称 CM-00-01-001-17 文件系统总空间
	 * 
	 * @param paramsVector
	 * @return
	 */
	public java.util.Vector getConfig(java.util.HashMap params)
			throws Exception {

		String host_name = (String) params.get("HOST_NAME");
		String ip_addr = (String) params.get("IP_ADDR");

		String neat_host_name = Formater.neatenunitid(host_name);
		// String neat_host_name = Formater.neatenunitid(host_name);

		String soap_host_name = SOAPITCMNameHelper.getSoapHostName(host_name);

		com.sitech.ismp.coll.CollBase collResult = new com.sitech.ismp.coll.CollBase();

		collResult.addKPI(pre_unitid + "-10" + ":" + neat_host_name + "-total",
				"CM-00-01-001-50", ip_addr);
		// PM-00-01-004-01/03 Object=Disk
		// 得到soap请求
		String soap_filesystem_Disk = GXCollHostSoapHelper
				.getSoap_config_Disk(soap_host_name); // soap消息
		// 发送soap请求，并返回结果
		String soap_filesystem_Disk_res = soapClient
				.getSoapStringResponse(soap_filesystem_Disk);
		// 分析返回结果，得到list
		List disk_results = CollHostXmlHelper
				.parseSoapResponse(soap_filesystem_Disk_res);

		// CM-00-01-001-16 每个文件系统的名称
		double total_filesystem = 0;
		for (int i = 0; i < disk_results.size(); i++) {
			Map diskMap = (Map) disk_results.get(i);
			String Mount_Point = (String) diskMap.get("Mount_Point");
			String neatMount_Point = Formater.neatenunitid(Mount_Point);

			String Size = (String) diskMap.get("Size");
			total_filesystem = total_filesystem + Double.parseDouble(Size);

			collResult.addKPI(pre_unitid + "-14:" + neat_host_name + "-"
					+ neatMount_Point, "CM-00-01-001-16", Mount_Point);

		}

		// CM-00-01-001-17 文件系统总空间
		if (total_filesystem != 0) {
			total_filesystem = total_filesystem / 1024; // 变单位为兆
			collResult.addKPI(pre_unitid + "-10:" + neat_host_name + "-total",
					"CM-00-01-001-17", Formater.formatDecimalKpivalue(String
							.valueOf(total_filesystem)));

		}

		// begin 2006-7-6 lianlian
		// 当主机为双机情况下才有此指标，否则没有此指标。
		if (GXHaHostHelper.isHaHost(host_name)) {
			String ha_host_name = GXHaHostHelper.getHaHostName(host_name);
			String Soap_config_UAFORClouster = GXCollHostSoapHelper
					.getSoap_config_UAFORClouster(ha_host_name);
			String soap_config_UAFORClouster_res = soapClient
					.getSoapStringResponse(Soap_config_UAFORClouster);
			List UAFORClouster_results = CollHostXmlHelper
					.parseSoapResponse(soap_config_UAFORClouster_res);

			for (int i = 0; i < UAFORClouster_results.size(); i++) {
				Map uaMap = (Map) UAFORClouster_results.get(i);
				String clusterState = (String) uaMap.get("clusterState");
				collResult.addKPI(pre_unitid + "-10:" + neat_host_name
						+ "-total", "FM-00-01-001-04", clusterState);
			}
		} else {
			collResult.addKPI(pre_unitid + "-10:" + neat_host_name + "-total",
					"FM-00-01-001-04", "UNKNOW");
		}

		// end

		return collResult.getKPISet();

	}

	/*
	 * PM-00-01-003-06 磁盘访问平均等待时间 dingran
	 */

	public java.util.Vector getDisk_WaitTime(java.util.HashMap params)
			throws Exception {

		String host_name = (String) params.get("HOST_NAME");
		// String neat_host_name = Formater.neatenunitid(host_name);
		String neat_host_name = Formater.neatenunitid(host_name);

		String soap_host_name = SOAPITCMNameHelper.getSoapHostName(host_name);

		com.sitech.ismp.coll.CollBase collResult = new com.sitech.ismp.coll.CollBase();

		String soap_network_Network = GXCollHostSoapHelper
				.getSoap_Disk_WaitTime(soap_host_name); // soap消息
		String soap_network_Network_res = soapClient
				.getSoapStringResponse(soap_network_Network);
		List disk_results = CollHostXmlHelper
				.parseSoapResponse(soap_network_Network_res);

		for (int i = 0; i < disk_results.size(); i++) {
			Map networkMap = (Map) disk_results.get(i);
			String Disk_WaitTime = (String) networkMap.get("Avg_Wait");
			String Disk_Name = (String) networkMap.get("Disk_Name");

			// System.out.println(Disk_Name+" = "+Disk_WaitTime);
			collResult.addKPI(pre_unitid + "-13:" + neat_host_name + "-"
					+ Disk_Name, "PM-00-01-003-06", Disk_WaitTime);

		}
		return collResult.getKPISet();
	}

	/*
	 * PM-00-01-003-07 等待I/O进程线程数 dingran
	 */

	public java.util.Vector getIO_ProcessNumber(java.util.HashMap params)
			throws Exception {

		String host_name = (String) params.get("HOST_NAME");
		// String neat_host_name = Formater.neatenunitid(host_name);
		String neat_host_name = Formater.neatenunitid(host_name);

		String soap_host_name = host_name;

		com.sitech.ismp.coll.CollBase collResult = new com.sitech.ismp.coll.CollBase();

		String soap_io_processnumber = GXCollHostSoapHelper
				.getSoap_IO_ProcessNumber(soap_host_name); // soap消息

		String soap_network_Network_res = soapClient
				.getSoapStringResponse(soap_io_processnumber);
		List io_results = CollHostXmlHelper
				.parseSoapResponse(soap_network_Network_res);

		for (int i = 0; i < io_results.size(); i++) {
			Map networkMap = (Map) io_results.get(i);
			String UserName = (String) networkMap.get("UserName");
			String ProcessNumber = (String) networkMap.get("ProcessNumber");

			collResult.addKPI(pre_unitid + "-13:" + neat_host_name + "-"
					+ UserName, "PM-00-01-003-07", ProcessNumber);
		}
		return collResult.getKPISet();
	}

	/*
	 * PM-00-01-002-06 系统内存使用率 dingran
	 */

	public java.util.Vector getMemory_Useage(java.util.HashMap params)
			throws Exception {

		String host_name = (String) params.get("HOST_NAME");
		// String neat_host_name = Formater.neatenunitid(host_name);
		String neat_host_name = Formater.neatenunitid(host_name);

		String soap_host_name = host_name;

		com.sitech.ismp.coll.CollBase collResult = new com.sitech.ismp.coll.CollBase();

		String soap_io_processnumber = GXCollHostSoapHelper
				.getSoap_Memory_Useage(soap_host_name); // soap消息

		//
		String soap_network_Network_res = soapClient
				.getSoapStringResponse(soap_io_processnumber);
		List memory_results = CollHostXmlHelper
				.parseSoapResponse(soap_network_Network_res);

		for (int i = 0; i < memory_results.size(); i++) {
			Map networkMap = (Map) memory_results.get(i);
			String UsedPercent = (String) networkMap.get("UsedPercent");
			// String ProcessNumber = (String)networkMap.get("ProcessNumber");

			System.out.println(UsedPercent);
			collResult.addKPI(pre_unitid + "-12:" + neat_host_name + "-memory",
					"PM-00-01-002-06", UsedPercent);

		}
		return collResult.getKPISet();
	}

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

	public static void main(String[] args) throws Exception {
		GXCollHost aix = new GXCollHost("10-10-20");
		java.util.HashMap params = new java.util.HashMap();
		params.put("HOST_NAME", "cboss_1");
		aix.getMemory_Useage(params);
		// aix.getConfig(params);
		// aix.getCpu(params);
		// aix.getFileSystem(params);
		// aix.getDisk(params);
		// aix.getMemory(params);
		// aix.getNetwork(params);
		// aix.getProcess(params);
		// TestCollHost.displayKPI(aix.getDisk_Target_use_hostname(params));

	}

}