package com.sitech.ismp.coll.host;

import java.net.URL;
import java.rmi.RemoteException;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;

import com.sitech.util.DES3;
import com.vmware.vim25.*;
import com.vmware.vim25.mo.*;
import org.apache.log4j.Logger;

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

/**
 * @author wangtaoc
 * Jul 12, 2012 10:07:43 AM
 */
public class CollEsxiWithCMD {
	
	private Logger logger = Logger.getLogger(CollEsxiWithCMD.class);
	// Esx/Esxi主机的标识
	String PRE_HOST_UNITID = "10-10-25";
	// 数据中心的标识
	String PRE_DATACENTER_UNITID = "10-31-10";
	// 集群的标识
	String PRE_CLUSTER_UNITID = "10-32-10";
	// 数据存储的标识
	String PRE_DATASTORE_UNITID = "10-14-11";
	// 虚拟交换机的标识
	String PRE_ROUTER_UNITID = "10-16-12";

	private static String DATACENTER = "Datacenter";
	private static String CLUSTERCOMPUTERESOURCE = "ClusterComputeResource";
	private static String HOSTSYSTEM = "HostSystem";
	private static String VIRTUALMACHINE = "VirtualMachine";
	private static String HOSTVIRTUALSWITCH = "HostVirtualSwitch";
	private static String DATASTORE = "Datastore";

	ServiceInstance si = null;
	Folder rootFolder = null;

    String vcenterFlag = "VCENTER.m0";
	String dcname = "";
	String ccrname = "";
	String hsname = "";
	String vmname = "";
	String vsname = "";
	String dsname = "";
	String deviceId = "";

	String ignoreCert = "true";

	ManagedEntity dc = null;
	ManagedEntity ccr = null;
	ManagedEntity hs = null;
	VirtualMachine vm = null;
	ManagedEntity vs = null;
	ManagedEntity ds = null;
	
	public CollEsxiWithCMD() {
	}

    private synchronized ServiceInstance getServiceInstanceByKey(String key) {
//        ServiceInstance si = null;
        try {
            si = VMwareConnectFactory.getInstance().getServiceInstanceByKey(key);
        } catch (Exception e) {
            logger.error("获取VMware监控连接失败！", e);
        }
        return si;
    }
	
	public Vector<TblATO_KPIDETAIL> getDatacenterConfig(HashMap<String, String> params) {
		logger.info("BEGIN getDatacenterConfig");

        // 保存采集结果，并返回值
        CollBase collResult = new CollBase();
        // 数据中心device_id
        String neat_dc_name = Formater.neatenunitid((String) params.get("DATACENTER"));

		// 初始化参数
        try {
            init(params);
            if (deviceId.length() > 0) {
                neat_dc_name = Formater.neatenunitid((String) params.get("DEVICEID"));
            }
        } catch (Exception e) {
            // 数据中心连接状态
            collResult.addKPI(PRE_DATACENTER_UNITID + "-10:" + neat_dc_name + "-total", "FM-10-10-010-01", "DISCONNECTED");
            return collResult.getKPISet();
        }

        try {
            logger.info("dcname is: " + dcname);

            // 常规-数据中心名称
            collResult.addKPI(PRE_DATACENTER_UNITID + "-10:" + neat_dc_name + "-total", "CM-10-10-10-30", dc.getName());

			// 常规-主机
			collResult.addKPI(PRE_DATACENTER_UNITID + "-10:" + neat_dc_name + "-total", "CM-10-10-10-31", (new InventoryNavigator(dc).searchManagedEntities("HostSystem")).length + "");

			// 常规-虚拟机和模板
			collResult.addKPI(PRE_DATACENTER_UNITID + "-10:" + neat_dc_name + "-total", "CM-10-10-10-32", (new InventoryNavigator(dc).searchManagedEntities("VirtualMachine")).length + "");

			// 常规-群集
			collResult.addKPI(PRE_DATACENTER_UNITID + "-10:" + neat_dc_name + "-total", "CM-10-10-10-33", (new InventoryNavigator(dc).searchManagedEntities("ClusterComputeResource")).length + "");

			// 常规-网络
			collResult.addKPI(PRE_DATACENTER_UNITID + "-10:" + neat_dc_name + "-total", "CM-10-10-10-34", (new InventoryNavigator(dc).searchManagedEntities("Network")).length + "");

			// 常规-数据存储
			collResult.addKPI(PRE_DATACENTER_UNITID + "-10:" + neat_dc_name + "-total", "CM-10-10-10-35", (new InventoryNavigator(dc).searchManagedEntities("Datastore")).length + "");

            // 数据中心连接状态
            collResult.addKPI(PRE_DATACENTER_UNITID + "-10:" + neat_dc_name + "-total", "FM-10-10-010-01", "CONNECTED");
		} catch (Exception e) {
			e.printStackTrace();
		}

		return collResult.getKPISet();
	}
	
	public Vector<TblATO_KPIDETAIL> getClusterConfig(HashMap<String, String> params) {
		logger.info("BEGIN getClusterConfig");

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

		// 集群名称device_id
		String neat_ccr_name = Formater.neatenunitid((String) params.get("CLUSTER"));

        // 初始化参数
        try {
            init(params);
            if (deviceId.length() > 0) {
                neat_ccr_name = Formater.neatenunitid((String) params.get("DEVICEID"));
            }
        } catch (Exception e) {
            // 集群连接状态
            collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "FM-10-11-010-01", "DISCONNECTED");
            return collResult.getKPISet();
        }

		// 集群命名
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-30", ccr.getName());

		// 接入控制(已启用)
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-31",
				((ClusterComputeResource) ccr).getConfiguration().getDasConfig().admissionControlEnabled + "");

		// 主机隔离响应(保持打开电源)
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-32",
				((ClusterComputeResource) ccr).getConfiguration().getDasConfig().getDefaultVmSettings().isolationResponse);

		// 虚拟机重新启动优先级(中等)
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-33",
				((ClusterComputeResource) ccr).getConfiguration().getDasConfig().getDefaultVmSettings().restartPriority);

		// 虚拟机使用集群设置(使用集群设置)
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-34",
				((ClusterComputeResource) ccr).getConfiguration().getDasConfig().getDefaultVmSettings().getVmToolsMonitoringSettings().clusterSettings + "");

		// 心跳失败探测时长
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-35",
				((ClusterComputeResource) ccr).getConfiguration().getDasConfig().getDefaultVmSettings().getVmToolsMonitoringSettings().failureInterval + "");

		// 允许的最大数量的故障
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-36",
				((ClusterComputeResource) ccr).getConfiguration().getDasConfig().getDefaultVmSettings().getVmToolsMonitoringSettings().maxFailures + "");

		// 允许自动响应停止的秒数
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-37", 
				((ClusterComputeResource) ccr).getConfiguration().getDasConfig().getDefaultVmSettings().getVmToolsMonitoringSettings().maxFailureWindow + "");

		// 虚拟机通电最短心跳时间
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-38", 
				((ClusterComputeResource) ccr).getConfiguration().getDasConfig().getDefaultVmSettings().getVmToolsMonitoringSettings().minUpTime + "");

		// 虚拟机监控类型
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-39", 
				((ClusterComputeResource) ccr).getConfiguration().getDasConfig().getDefaultVmSettings().getVmToolsMonitoringSettings().vmMonitoring + "");

		// VSphere HA(开启)
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-40", 
				((ClusterComputeResource) ccr).getConfiguration().getDasConfig().enabled + "");

		// 群集允许故障的主机个数
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-41", 
				((ClusterComputeResource) ccr).getConfiguration().getDasConfig().failoverLevel + "");

		// 数据存储检测信号
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-42", 
				((ClusterComputeResource) ccr).getConfiguration().getDasConfig().hBDatastoreCandidatePolicy + "");

		// 主机故障重启虚拟机
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-43", 
				((ClusterComputeResource) ccr).getConfiguration().getDasConfig().hostMonitoring);

		// HA虚拟机健康监测(已禁用)
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-44", 
				((ClusterComputeResource) ccr).getConfiguration().getDasConfig().vmMonitoring);

		// VSphere DRS(开启)
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-45", 
				((ClusterComputeResource) ccr).getConfiguration().getDrsConfig().enabled + "");

		// 迁移自动化级别(全自动)
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-46", 
				((ClusterComputeResource) ccr).getConfiguration().getDrsConfig().defaultVmBehavior + "");

		// 启用个别虚拟机自动化级别(开启)
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-47", 
				((ClusterComputeResource) ccr).getConfiguration().getDrsConfig().enableVmBehaviorOverrides + "");

		// 迁移阀值
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-48", 
				((ClusterComputeResource) ccr).getConfiguration().getDrsConfig().vmotionRate + "");

		// 交换文件位置(与虚拟机相同的目录)
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-49", 
				((ComputeResource) ccr).getConfigurationEx().vmSwapPlacement + "");

		// 浏览器对象标识
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-50", 
				((ComputeResource) ccr).getEnvironmentBrowser() + "");

		// 主机数
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-51", 
				((ComputeResource) ccr).getHosts().length + "");

		// 网络数
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-52", 
				((ComputeResource) ccr).getNetworks().length + "");

		// 资源池
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-53", 
				((ComputeResource) ccr).getResourcePool() + "");

		// 有效CPU容量
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-54", 
				((ComputeResource) ccr).getSummary().effectiveCpu + "");

		// 有效内存容量
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-55", 
				((ComputeResource) ccr).getSummary().effectiveMemory + "");

		// 处理器总数
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-56", 
				((ComputeResource) ccr).getSummary().numCpuCores + "");

		// CPU线程数
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-57", 
				((ComputeResource) ccr).getSummary().numCpuThreads + "");

		// 有效主机数
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-58", 
				((ComputeResource) ccr).getSummary().numEffectiveHosts + "");

		// 主机数
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-59", 
				((ComputeResource) ccr).getSummary().numHosts + "");

		// 整体告警状态
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-60", 
				((ComputeResource) ccr).getSummary().getOverallStatus() + "");

		// 总CPU资源
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-61", 
				((ComputeResource) ccr).getSummary().totalCpu + "");

		// 总内存
		collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "CM-10-10-11-62", 
				Formater.formatDecimalByScale(((ComputeResource) ccr).getSummary().totalMemory/1024/1024.0 + "", 2));

        // 集群连接状态
        collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "FM-10-11-010-01", "CONNECTED");
		return collResult.getKPISet();
	}
	
	public Vector<TblATO_KPIDETAIL> getClusterPerfor(HashMap<String, String> params) {
		logger.info("BEGIN getClusterPerfor");

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

        // 集群名称device_id
        String neat_ccr_name = Formater.neatenunitid((String) params.get("CLUSTER"));

        // 初始化参数
        try {
            init(params);
            if (deviceId.length() > 0) {
                neat_ccr_name = Formater.neatenunitid((String) params.get("DEVICEID"));
            }
        } catch (Exception e) {
            // 集群连接状态
            collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "FM-10-11-010-01", "DISCONNECTED");
            return collResult.getKPISet();
        }

		// CPU已使用大小 集群下所有虚拟机的CPU使用情况
		// CPU使用率 集群下所有虚拟机的CPU使用情况/集群的有效CPU
		// 内存使用率 集群下所有虚拟机的已消耗的内存/集群有效内存 /*（集群下所有虚拟机的已消耗的内存 + 内存开销）/集群有效内存*/
		try {
			double _cpu = 0.0;
			double _mem = 0.0;
			for (int i = 0; i <((ComputeResource) ccr).getHosts().length; i++) {
				for (int j = 0; j < ((ComputeResource) ccr).getHosts()[i].getVms().length; j++) {
					double cpuusage = ((ComputeResource) ccr).getHosts()[i].getVms()[j].getSummary().getQuickStats().getOverallCpuUsage();
					_cpu += cpuusage;
					double memusage = ((ComputeResource) ccr).getHosts()[i].getVms()[j].getSummary().getQuickStats().getHostMemoryUsage();
//					double memusage = ((ComputeResource) ccr).getHosts()[i].getVms()[j].getSummary().getQuickStats().getConsumedOverheadMemory();
					_mem += memusage;
					VirtualMachineRuntimeInfo runtimeInfo = ((ComputeResource) ccr).getHosts()[i].getVms()[j].getSummary().getRuntime();
					double memoverhead = 0;
					if(runtimeInfo!=null &&  runtimeInfo.getMemoryOverhead() != null){
						memoverhead = runtimeInfo.getMemoryOverhead()/1024/1024.0;
					}
					_mem += memoverhead;
				}
			}
			if (((ComputeResource) ccr).getSummary().effectiveCpu != 0) {
				// CPU已使用大小
				collResult.addKPI(PRE_CLUSTER_UNITID + "-11:" + neat_ccr_name + "-cpu", "PM-00-01-001-43", 
						Formater.formatDecimalByScale(_cpu + "", 2));
				// CPU使用率
				collResult.addKPI(PRE_CLUSTER_UNITID + "-11:" + neat_ccr_name + "-cpu", "PM-00-01-001-05", 
						Formater.formatDecimalByScale(_cpu/((ComputeResource) ccr).getSummary().effectiveCpu*100 + "", 2));
				// 已消耗的主机内存 PM-00-01-001-44
				collResult.addKPI(PRE_CLUSTER_UNITID + "-12:" + neat_ccr_name + "-mem", "PM-00-01-001-44", 
						Formater.formatDecimalByScale(_mem + "", 2));
				// 内存使用率
//				collResult.addKPI(PRE_CLUSTER_UNITID + "-12:" + neat_ccr_name + "-mem", "PM-00-01-002-01", 
//						Formater.formatDecimalByScale(_mem/((ComputeResource) ccr).getSummary().effectiveMemory*100 + "", 4));
				collResult.addKPI(PRE_CLUSTER_UNITID + "-12:" + neat_ccr_name + "-mem", "PM-00-01-002-01", 
						Formater.formatDecimalByScale((_mem)/(((ComputeResource) ccr).getSummary().totalMemory/1024/1024.0)*100 + "", 2));
				
			} else {
				// CPU已使用大小
				collResult.addKPI(PRE_CLUSTER_UNITID + "-11:" + neat_ccr_name + "-cpu", "PM-00-01-001-43", "0");
				// CPU使用率
				collResult.addKPI(PRE_CLUSTER_UNITID + "-11:" + neat_ccr_name + "-cpu", "PM-00-01-001-05", "0");
				// 已消耗的主机内存 PM-00-01-001-44
				collResult.addKPI(PRE_CLUSTER_UNITID + "-12:" + neat_ccr_name + "-mem", "PM-00-01-001-44", "0");
				// 内存使用率
				collResult.addKPI(PRE_CLUSTER_UNITID + "-12:" + neat_ccr_name + "-mem", "PM-00-01-002-01", "0");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}

		return collResult.getKPISet();
	}
	
	public Vector<TblATO_KPIDETAIL> getClusterAlarm(HashMap<String, String> params) {
		logger.info("BEGIN getClusterAlarm");

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

        // 集群名称device_id
        String neat_ccr_name = Formater.neatenunitid((String) params.get("CLUSTER"));

        // 初始化参数
        try {
            init(params);
            if (deviceId.length() > 0) {
                neat_ccr_name = Formater.neatenunitid((String) params.get("DEVICEID"));
            }
        } catch (Exception e) {
            // 集群连接状态
            collResult.addKPI(PRE_CLUSTER_UNITID + "-10:" + neat_ccr_name + "-total", "FM-10-11-010-01", "DISCONNECTED");
            return collResult.getKPISet();
        }
		Event events[] = ccr.getConfigIssue();
		AlarmState alarmState[] = ccr.getDeclaredAlarmState();
		for (AlarmState as : alarmState) {
			if (as.getEntity().type.trim().toString().equals(CLUSTERCOMPUTERESOURCE)) {
				ClusterComputeResource _ccr = new ClusterComputeResource(si.getServerConnection(), as.getEntity());
				String pre_unit_id = PRE_CLUSTER_UNITID + "-30:" + Formater.neatenunitid(as.key.substring(as.key.indexOf(".") + 1)) + "-" + Formater.neatenunitid(as.key.substring(0, as.key.indexOf(".")));
				// 对象设备类型
				collResult.addKPI(pre_unit_id, "CM-10-10-10-37", as.getEntity().type);
				// 对象名称
				collResult.addKPI(pre_unit_id, "CM-10-10-10-38", _ccr.getName());
				// 状态
				collResult.addKPI(pre_unit_id, "CM-10-10-10-39", this.changeStringPosition(as.key));
//					String key = this.getAlarmId(as.key);
//					if ((Integer.parseInt(key) > 55)) {
//						key = "99";
//					}
				// 警报名称
				collResult.addKPI(pre_unit_id, "FM-00-31-001-01", (new Alarm(si.getServerConnection(), as.getAlarm())).getAlarmInfo().getName());
				// 触发时间
				collResult.addKPI(pre_unit_id, "CM-10-10-10-41", Formater.getSybaseFormatDateTime(as.getTime().getTime()));
			}
		}
		if (ccr.getTriggeredAlarmState() != null) {
			// 警报个数
			//collResult.addKPI(PRE_DATACENTER_UNITID + "-30:" + neat_dc_name + "-alarm", "CM-10-10-10-36", dc.getTriggeredAlarmState().length + "");
			for (AlarmState as : ccr.getTriggeredAlarmState()) {
				if (as.getEntity().type.trim().toString().equals(CLUSTERCOMPUTERESOURCE)) {
					ClusterComputeResource _ccr = new ClusterComputeResource(si.getServerConnection(), as.getEntity());
					String pre_unit_id = PRE_CLUSTER_UNITID + "-30:" + Formater.neatenunitid(as.key.substring(as.key.indexOf(".") + 1)) + "-" + Formater.neatenunitid(as.key.substring(0, as.key.indexOf(".")));
					// 对象设备类型
					collResult.addKPI(pre_unit_id, "CM-10-10-10-37", as.getEntity().type);
					// 对象名称
					collResult.addKPI(pre_unit_id, "CM-10-10-10-38", _ccr.getName());
					// 状态
					collResult.addKPI(pre_unit_id, "CM-10-10-10-39", this.changeStringPosition(as.key));
//					String key = this.getAlarmId(as.key);
//					if ((Integer.parseInt(key) > 55)) {
//						key = "99";
//					}
					// 警报名称 
					collResult.addKPI(pre_unit_id, "FM-00-31-001-01", (new Alarm(si.getServerConnection(), as.getAlarm())).getAlarmInfo().getName());
					// 触发时间
					collResult.addKPI(pre_unit_id, "CM-10-10-10-41", Formater.getSybaseFormatDateTime(as.getTime().getTime()));
				}
			}
		}
		return collResult.getKPISet();
	}
	
	public Vector<TblATO_KPIDETAIL> getConfig(HashMap<String, String> params) {
		logger.info("BEGIN getConfig");

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

		// 获取主机名称device_id
		String neat_host_name = Formater.neatenunitid((String) params.get("HOSTNAME"));

        // 初始化参数
        try {
            init(params);
            if (deviceId.length() > 0) {
                neat_host_name = Formater.neatenunitid((String) params.get("DEVICEID"));
            }
        } catch (Exception e) {
            // 主机状态
//            collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "FM-00-01-001-01", "DISCONNECTED");
            return collResult.getKPISet();
        }

		// 主机名称 CM-00-01-001-01
		collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "CM-00-01-001-01", ((HostSystem) hs).getName());
		
		// 设备全名 CM-00-01-001-42
		collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "CM-00-01-001-42", ((HostSystem) hs).getConfig().getProduct().fullName);

		// 主机厂家 CM-00-01-001-03
		collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "CM-00-01-001-03", ((HostSystem) hs).getSummary().getHardware().vendor);
		
		// 设备型号 CM-00-01-001-43
		collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "CM-00-01-001-43", ((HostSystem) hs).getSummary().getHardware().model);
		
		// 主机操作系统版本 CM-00-01-001-08
		collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "CM-00-01-001-08", ((HostSystem) hs).getConfig().getProduct().osType);

		// 主机CPU个数 CM-00-01-001-04
		collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "CM-00-01-001-04", ((HostSystem) hs).getHardware().getCpuInfo().numCpuCores + "");

		// 主机CPU型号 CM-00-01-001-05
		collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "CM-00-01-001-05", ((HostSystem) hs).getSummary().getHardware().cpuModel);

		// 主机CPU主频 CM-00-01-001-06
		collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "CM-00-01-001-06", ((HostSystem) hs).getHardware().getCpuInfo().hz / 1000 / 1000 + "");
		
		// 主机内存大小 CM-00-01-001-07
		collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "CM-00-01-001-07", ((HostSystem) hs).getHardware().memorySize / 1024 / 1024 + "");
		
		// 系统网络接口数 CM-00-01-001-10 #网络适配器的数量
		collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "CM-00-01-001-10", ((HostSystem) hs).getSummary().getHardware().numNics + "");
		
		// 主机启动时间 CM-00-01-001-22
		collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "CM-00-01-001-22", Formater.getSybaseFormatDateTime(((HostSystem) hs).getRuntime().bootTime.getTime()));
		
		// 主机总线适配器个数 CM-00-01-001-36
		collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "CM-00-01-001-36", ((HostSystem) hs).getSummary().getHardware().numHBAs + "");
		
		// 主机连接状态 FM-00-01-001-06
		collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "FM-00-01-001-06", ((HostSystem) hs).getRuntime().connectionState.toString());
		
		// VirtualCenter地址 CM-00-01-001-23
		collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "CM-00-01-001-23", ((HostSystem) hs).getSummary().managementServerIp);
		
		// 主机状态 FM-00-01-001-01
//		collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "FM-00-01-001-01", ((HostSystem) hs).getRuntime().powerState.name());
		
		// 网络适配器
		try {
			for (int i =0; i < ((HostSystem) hs).getHostNetworkSystem().getNetworkInfo().getPnic().length; i++) {
				String nicname = ((HostSystem) hs).getHostNetworkSystem().getNetworkInfo().getPnic()[i].device;
				String nicmac = ((HostSystem) hs).getHostNetworkSystem().getNetworkInfo().getPnic()[i].mac;
				// 设备
				collResult.addKPI(PRE_HOST_UNITID + "-16:" + neat_host_name + "-" + nicname, "CM-00-01-001-40", nicname);
				// MAC地址
				collResult.addKPI(PRE_HOST_UNITID + "-16:" + neat_host_name + "-" + nicname, "CM-00-01-001-41", nicmac);
			}
		} catch (InvalidProperty e) {
			e.printStackTrace();
		} catch (RuntimeFault e) {
			e.printStackTrace();
		} catch (RemoteException e) {
			e.printStackTrace();
		}

		return collResult.getKPISet();
	}

	public Vector<TblATO_KPIDETAIL> getCpu(HashMap<String, String> params) {
		logger.info("BEGIN getCpu");

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

        // 获取主机名称device_id
        String neat_host_name = Formater.neatenunitid((String) params.get("HOSTNAME"));

        // 初始化参数
        try {
            init(params);
            if (deviceId.length() > 0) {
                neat_host_name = Formater.neatenunitid((String) params.get("DEVICEID"));
            }
        } catch (Exception e) {
            // 主机状态
//            collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "FM-00-01-001-01", "DISCONNECTED");
            return collResult.getKPISet();
        }

		int ovsrallcpuusage = ((HostSystem) hs).getSummary().getQuickStats().overallCpuUsage;
		long hz = ((HostSystem) hs).getHardware().getCpuInfo().hz;
		int numcpucores = ((HostSystem) hs).getHardware().getCpuInfo().numCpuCores;
		double tatolhz = hz * numcpucores / 1000 / 1000;
		// 已消耗的主机CPU PM-00-01-001-10
		collResult.addKPI(PRE_HOST_UNITID + "-11:" + neat_host_name + "-cpu", "PM-00-01-001-10", Formater.formatDecimalByScale(String.valueOf(ovsrallcpuusage), 2));
		// CPU使用情况 PM-00-01-001-05
		collResult.addKPI(PRE_HOST_UNITID + "-11:" + neat_host_name + "-cpu", "PM-00-01-001-05", Formater.realyRate(Formater.dev2IntIntoFloat(String.valueOf(ovsrallcpuusage), String.valueOf(tatolhz), 2)));

		return collResult.getKPISet();
	}

	public Vector<TblATO_KPIDETAIL> getMemory(HashMap<String, String> params) {
		logger.info("BEGIN getMemory");

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

        // 获取主机名称device_id
        String neat_host_name = Formater.neatenunitid((String) params.get("HOSTNAME"));

        // 初始化参数
        try {
            init(params);
            if (deviceId.length() > 0) {
                neat_host_name = Formater.neatenunitid((String) params.get("DEVICEID"));
            }
        } catch (Exception e) {
            // 主机状态
//            collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "FM-00-01-001-01", "DISCONNECTED");
            return collResult.getKPISet();
        }

		long memorysize = ((HostSystem) hs).getHardware().memorySize / 1024 / 1024;
		int overallmemoryusage = ((HostSystem) hs).getSummary().getQuickStats().overallMemoryUsage;
		// 已消耗的主机内存 PM-00-01-002-12
		collResult.addKPI(PRE_HOST_UNITID + "-12:" + neat_host_name + "-mem", "PM-00-01-002-12", overallmemoryusage + "");
		// 内存使用情况 PM-00-01-002-01
		collResult.addKPI(PRE_HOST_UNITID + "-12:" + neat_host_name + "-mem", "PM-00-01-002-01", Formater.realyRate(Formater.dev2IntIntoFloat(String.valueOf(overallmemoryusage), String.valueOf(memorysize), 2)));
		return collResult.getKPISet();
	}

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

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

        // 获取主机名称device_id
        String neat_host_name = Formater.neatenunitid((String) params.get("HOSTNAME"));

        // 初始化参数
        try {
            init(params);
            if (deviceId.length() > 0) {
                neat_host_name = Formater.neatenunitid((String) params.get("DEVICEID"));
            }
        } catch (Exception e) {
            // 主机状态
//            collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "FM-00-01-001-01", "DISCONNECTED");
            return collResult.getKPISet();
        }
		
		try {
			double totalAll = 0.0;
			double totalFree  = 0.0;
			for (int i = 0; i < ((HostSystem) hs).getDatastores().length; i++) {
				// 数据存储名称
				String datastore_name = ((HostSystem) hs).getDatastores()[i].getInfo().name;
				String _dsname = Formater.neatenunitid(datastore_name);
				// 数据存储名称 CM-00-01-001-16
				collResult.addKPI(PRE_HOST_UNITID + "-14:" + neat_host_name + "-" + _dsname, "CM-00-01-001-16", datastore_name);
				// 数据存储路径 CM-00-02-999-02
				collResult.addKPI(PRE_HOST_UNITID + "-14:" + neat_host_name + "-" + _dsname, "CM-00-02-999-02", (((HostSystem) hs).getDatastores()[i].getInfo().url));
				// 数据存储使用率 PM-00-01-004-03
				double capacity = (((HostSystem) hs).getDatastores()[i].getSummary().capacity)/1024/1024/1024.0;
				totalAll += capacity;
				double freespace = (((HostSystem) hs).getDatastores()[i].getInfo().freeSpace)/1024/1024/1024.0;
				totalFree += freespace;
				collResult.addKPI(PRE_HOST_UNITID + "-14:" + neat_host_name + "-" + _dsname, "PM-00-01-004-03", Formater.dev2IntIntoFloat(String.valueOf(capacity - freespace), String.valueOf(capacity), 4));
				// 数据存储容量 CM-00-02-999-03
				collResult.addKPI(PRE_HOST_UNITID + "-14:" + neat_host_name + "-" + _dsname, "CM-00-02-999-03", Formater.formatDecimalByScale((((HostSystem) hs).getDatastores()[i].getSummary().capacity)/1024/1024/1024.0 + "", 2));
				// 可用空间 PM-00-01-004-04
				collResult.addKPI(PRE_HOST_UNITID + "-14:" + neat_host_name + "-" + _dsname, "PM-00-01-004-04", Formater.formatDecimalByScale((((HostSystem) hs).getDatastores()[i].getInfo().freeSpace)/1024/1024/1024.0 + "", 2));
				// 系统卷类型 CM-00-02-999-05
				collResult.addKPI(PRE_HOST_UNITID + "-14:" + neat_host_name + "-" + _dsname, "CM-00-02-999-05", (((HostSystem) hs).getDatastores()[i].getSummary().type));
				// 额外的存储空间 CM-00-02-999-06
				if(null != (((HostSystem) hs).getDatastores()[i].getSummary().uncommitted)) {
					collResult.addKPI(PRE_HOST_UNITID + "-14:" + neat_host_name + "-" + _dsname, "CM-00-02-999-06", (((HostSystem) hs).getDatastores()[i].getSummary().uncommitted)/1024/1024.0 + "");
				} else {
					collResult.addKPI(PRE_HOST_UNITID + "-14:" + neat_host_name + "-" + _dsname, "CM-00-02-999-06", "0.0");
				}
			}

//			// 已使用容量 PM-00-01-004-15
//			collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "PM-00-01-004-15", Formater.formatDecimalByScale(String.valueOf(totalAll - totalFree), 4));
//			// 所连接的数据存储总容量 CM-00-02-999-03
//			collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "CM-00-02-999-03", Formater.formatDecimalByScale(String.valueOf(totalAll), 4));
			// 特供磁盘使用率走势图KPI 磁盘使用率 PM-00-01-004-14
			collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "PM-00-01-004-14", Formater.dev2IntIntoFloat(String.valueOf(totalAll - totalFree), String.valueOf(totalAll), 4));
			
		} catch (InvalidProperty e) {
			e.printStackTrace();
		} catch (RuntimeFault e) {
			e.printStackTrace();
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return collResult.getKPISet();
	}

	public Vector<TblATO_KPIDETAIL> getNet(HashMap<String, String> params) {
		logger.info("BEGIN getNet");

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

        // 获取主机名称device_id
        String neat_host_name = Formater.neatenunitid((String) params.get("HOSTNAME"));

        // 初始化参数
        try {
            init(params);
            if (deviceId.length() > 0) {
                neat_host_name = Formater.neatenunitid((String) params.get("DEVICEID"));
            }
        } catch (Exception e) {
            // 主机状态
//            collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "FM-00-01-001-01", "DISCONNECTED");
            return collResult.getKPISet();
        }

		try {
			String hsname = hs.getName();
			if (hs == null) {
				System.out.println("HostSystem " + hsname + " Not Found");
				return null;
			}
			PerformanceManager perfMgr = si.getPerformanceManager();

			PerfCounterInfo[] pcis = perfMgr.getPerfCounter();
			Map<String, Integer> counteridmap = new HashMap<String, Integer>();
			for (PerfCounterInfo _pci : pcis) {
				String groupinfo = _pci.getGroupInfo().key;
				if ("net".equals(groupinfo)) {
					int key = _pci.getKey();
					String nameinfo = _pci.getNameInfo().key;
					String rolluptype = _pci.getRollupType().toString();
					counteridmap.put(groupinfo + "-" + nameinfo + "-" + rolluptype, key);
				}
			}
			
			Map catchcounteridlist = getCatchCounterId(counteridmap);
			System.out.println("catchcounteridlist.size() " + catchcounteridlist.size());
			
			PerfProviderSummary hspps = perfMgr.queryPerfProviderSummary(hs);
		    int hsrefreshRate = hspps.getRefreshRate().intValue();
		    PerfMetricId[] hspmis = perfMgr.queryAvailablePerfMetric(hs, null, null, hsrefreshRate);
		    PerfQuerySpec hsqSpec = createPerfQuerySpec(hs, hspmis, 3, hsrefreshRate);
			PerfEntityMetricBase[] phsValues = perfMgr.queryPerf(new PerfQuerySpec[] {hsqSpec});
			if (phsValues != null) {
				for (int i = 0; i < phsValues.length; ++i) {
//					String entityDesc = phsValues[i].getEntity().getType() + ":" + phsValues[i].getEntity().get_value();
					getAllCounterInfo(phsValues[i], collResult, neat_host_name, PRE_HOST_UNITID, catchcounteridlist);
				}
			}
		} catch (RuntimeFault e) {
			e.printStackTrace();
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return collResult.getKPISet();
	}
	
	public Vector<TblATO_KPIDETAIL> getAlarm(HashMap<String, String> params) {
		logger.info("BEGIN getAlarm");

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

        // 获取主机名称device_id
        String neat_host_name = null;
		try{
			Formater.neatenunitid((String) params.get("HOSTNAME"));
		}catch (Exception ex){}

        // 初始化参数
        try {
            init(params);
            if (deviceId.length() > 0) {
                neat_host_name = Formater.neatenunitid((String) params.get("DEVICEID"));
            }
        } catch (Exception e) {
            // 主机状态
//            collResult.addKPI(PRE_HOST_UNITID + "-10:" + neat_host_name + "-total", "FM-00-01-001-01", "DISCONNECTED");
            return collResult.getKPISet();
        }

		if (hs.getTriggeredAlarmState() != null) {
			// 警报个数
//			collResult.addKPI(PRE_DATACENTER_UNITID + "-30:" + neat_dc_name + "-alarm", "CM-10-10-10-36", dc.getTriggeredAlarmState().length + "");
			for (AlarmState as : hs.getTriggeredAlarmState()) {
				if (as.getEntity().type.trim().toString().equals(HOSTSYSTEM)) {
					HostSystem _hs = new HostSystem(si.getServerConnection(), as.getEntity());
					String pre_unit_id = PRE_HOST_UNITID + "-30:" + neat_host_name + "-" + Formater.neatenunitid(as.key.substring(0, as.key.indexOf(".")));
					// 对象设备类型
					collResult.addKPI(pre_unit_id, "CM-10-10-10-37", as.getEntity().type);
					// 对象名称
					collResult.addKPI(pre_unit_id, "CM-10-10-10-38", _hs.getName());
					// 状态
					collResult.addKPI(pre_unit_id, "CM-10-10-10-39", this.changeStringPosition(as.key));
//					String key = this.getAlarmId(as.key);
//					if ((Integer.parseInt(key) > 55)) {
//						key = "99";
//					}
					// 警报名称
					collResult.addKPI(pre_unit_id, "FM-00-31-001-01", (new Alarm(si.getServerConnection(), as.getAlarm())).getAlarmInfo().getName());
					// 触发时间
					collResult.addKPI(pre_unit_id, "CM-10-10-10-41", Formater.getSybaseFormatDateTime(as.getTime().getTime()));
				}
			}
		}
		return collResult.getKPISet();
	}

	public Vector<TblATO_KPIDETAIL> getVMInfo(HashMap<String, String> params) {
		logger.info("BEGIN getVMInfo");

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

		// 初始化参数
        try {
            init(params);
        } catch (Exception e) {
            return collResult.getKPISet();
        }

        // 获取主机名称device_id
        String neat_vm_name = Formater.neatenunitid((String) params.get("VMNAME"));
        if (deviceId.length() > 0) {
            neat_vm_name = Formater.neatenunitid((String) params.get("DEVICEID"));
        }

        // 客户机操作系统
        String osversion = vm.getSummary().getConfig().guestFullName;
		String p_unit_id = getPREVMKbp(osversion);

		// 虚拟机版本 CM-00-02-001-03
		collResult.addKPI(p_unit_id  + "-10:" + neat_vm_name + "-total", "CM-00-02-001-03", vm.getConfig().version + "");
		// 启动模式 CM-00-01-001-24
		collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-00-01-001-24", vm.getConfig().flags.monitorType + "");
		// 客户机操作系统 CM-00-01-001-25
		collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-00-01-001-25", osversion);
		// 客户机内存 CM-00-01-001-26
		collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-00-01-001-26", vm.getSummary().getConfig().memorySizeMB + "");

		// 总容量 CM-00-01-001-45
		collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-00-01-001-45", vm.getSummary().getRuntime().maxMemoryUsage + "");
		// 磁盘总大小
		double totalAll = 0.0;
//		if (vm.getGuest().getDisk() != null) {
//			for (int i = 0; i < vm.getGuest().getDisk().length; i++) {
//				// 数据存储使用率 PM-00-01-004-03
//				double capacity = (vm.getGuest().getDisk()[i].getCapacity())/1024/1024/1024.0;
//				totalAll += capacity;
//			}
//			collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-00-05-002-05", Formater.formatDecimalByScale(String.valueOf(totalAll), 4));
//		} else {
//			collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-00-05-002-05", "0");
//		}
		for (int i = 0; i < vm.getConfig().getHardware().getDevice().length; i++) {
			if (vm.getConfig().getHardware().getDevice()[i] instanceof VirtualDisk) {
				totalAll += ((VirtualDisk)((VirtualMachine) vm).getConfig().getHardware().getDevice()[i]).getCapacityInKB()/1024/1024.0;
			}
		}
		collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-00-05-002-05", Formater.formatDecimalByScale(String.valueOf(totalAll), 2));
		
		// 虚拟CPU个数 CM-00-01-001-27
		collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-00-01-001-27", vm.getSummary().getConfig().numCpu + "");
		// 虚拟网卡个数 CM-00-01-001-28
		collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-00-01-001-28", vm.getSummary().getConfig().numEthernetCards + "");
		// 虚拟磁盘个数 CM-00-01-001-29
		collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-00-01-001-29", vm.getSummary().getConfig().numVirtualDisks + "");
		// 电源状态 FM-00-05-002-12
        String powerState = null != vm.getSummary().getRuntime().powerState ? vm.getSummary().getRuntime().powerState.toString() : "";
		collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "FM-00-05-002-12", powerState + "");
//		collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "FM-00-01-001-01", vm.getSummary().getRuntime().powerState.name());

		for (int i = 0; i < vm.getConfig().getHardware().getDevice().length; i++) {
			if (vm.getConfig().getHardware().getDevice()[i] instanceof VirtualEthernetCard) {
				String label = vm.getConfig().getHardware().getDevice()[i].getDeviceInfo().getLabel();
				String mac = ((VirtualEthernetCard) vm.getConfig().getHardware().getDevice()[i]).getMacAddress();
				String _label = this.changeMACAddress(mac);
				// 网卡名称 CM-00-01-001-40
				collResult.addKPI(p_unit_id + "-16" + ":" + neat_vm_name + "-" + _label, "CM-00-01-001-40", label);

				// MAC地址 CM-00-01-001-41
				collResult.addKPI(p_unit_id + "-16" + ":" + neat_vm_name + "-" + _label, "CM-00-01-001-41", mac);
			}
		}
		
		// VMware Tools状态 CM-00-01-001-30
		collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-00-01-001-30", (vm.getGuest().guestState));
		// 虚拟机健康状态 CM-00-01-001-31
		collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-00-01-001-31", (vm.getGuestHeartbeatStatus().toString()));
		// 主机CPU
		collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-10-10-11-61", Formater.formatDecimalByScale(String.valueOf(vm.getSummary().getRuntime().maxCpuUsage), 2));

		return collResult.getKPISet();
	}
	
	public Vector<TblATO_KPIDETAIL> getVMCpu(HashMap<String, String> params) {
		logger.info("BEGIN getVMCpu");

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

        // 初始化参数
        try {
            init(params);
        } catch (Exception e) {
            return collResult.getKPISet();
        }

        // 获取主机名称device_id
        String neat_vm_name = Formater.neatenunitid((String) params.get("VMNAME"));
        if (deviceId.length() > 0) {
            neat_vm_name = Formater.neatenunitid((String) params.get("DEVICEID"));
        }

		// 客户机操作系统
		String osversion = vm.getSummary().getConfig().guestFullName;
		String p_unit_id = getPREVMKbp(osversion);

		// CPU使用率 PM-00-01-001-05
		int overallcpu = vm.getSummary().getQuickStats().overallCpuUsage;
		int maxcpuusage = vm.getSummary().getRuntime().maxCpuUsage;
		collResult.addKPI(p_unit_id + "-11:" + neat_vm_name + "-cpu", "PM-00-01-001-05", Formater.realyRate(Formater.dev2IntIntoFloat(String.valueOf(overallcpu), String.valueOf(maxcpuusage), 2)));
		// 已消耗的主机CPU PM-00-01-001-10
		collResult.addKPI(p_unit_id + "-11:" + neat_vm_name + "-cpu", "PM-00-01-001-10", (vm.getSummary().getQuickStats().overallCpuUsage + ""));
		return collResult.getKPISet();
	}
	
	public Vector<TblATO_KPIDETAIL> getVMMemory(HashMap<String, String> params) {
		logger.info("BEGIN getVMMemory");

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

        // 初始化参数
        try {
            init(params);
        } catch (Exception e) {
            return collResult.getKPISet();
        }

        // 获取主机名称device_id
        String neat_vm_name = Formater.neatenunitid((String) params.get("VMNAME"));
        if (deviceId.length() > 0) {
            neat_vm_name = Formater.neatenunitid((String) params.get("DEVICEID"));
        }

		// 客户机操作系统
		String osversion = vm.getSummary().getConfig().guestFullName;
		String p_unit_id = getPREVMKbp(osversion);

		// 内存使用率 PM-00-01-002-01
		int guestmemoryusage = vm.getSummary().getQuickStats().guestMemoryUsage;
		int maxmemoryusage = vm.getSummary().getRuntime().maxMemoryUsage;
		collResult.addKPI(p_unit_id + "-12:" + neat_vm_name + "-mem", "PM-00-01-002-01", Formater.realyRate(Formater.dev2IntIntoFloat(String.valueOf(guestmemoryusage), String.valueOf(maxmemoryusage), 2)));
		// 活动客户机内存 PM-00-01-002-13
		collResult.addKPI(p_unit_id + "-12:" + neat_vm_name + "-mem", "PM-00-01-002-13", (vm.getSummary().getQuickStats().guestMemoryUsage + ""));
//		// 客户机内存 CM-00-01-001-43
//		collResult.addKPI(p_unit_id + "-12:" + neat_vm_name + "-mem", "CM-00-01-001-43", (vm.getSummary().getRuntime().maxMemoryUsage + ""));

		// 已消耗的主机内存 PM-00-01-002-12
		collResult.addKPI(p_unit_id + "-12:" + neat_vm_name + "-mem", "PM-00-01-002-12", (vm.getSummary().getQuickStats().hostMemoryUsage + ""));
		// 客户机专用内存 PM-00-01-002-09
		collResult.addKPI(p_unit_id + "-12:" + neat_vm_name + "-mem", "PM-00-01-002-09", (vm.getSummary().getQuickStats().privateMemory == null ? "0" : vm.getSummary().getQuickStats().privateMemory + ""));
		// 客户机已共享内存 PM-00-01-002-10
		collResult.addKPI(p_unit_id + "-12:" + neat_vm_name + "-mem", "PM-00-01-002-10", (vm.getSummary().getQuickStats().sharedMemory + ""));
		// 内存开销 PM-00-01-002-11
		//collResult.addKPI(p_unit_id + "-12:" + neat_vm_name + "-mem", "PM-00-01-002-11", Formater.formatDecimalByScale((vm.getSummary().getRuntime().memoryOverhead)/1024/1024.0 + "", 2));

		return collResult.getKPISet();
	}

	public Vector<TblATO_KPIDETAIL> getVMDisk(HashMap<String, String> params) {
		logger.info("BEGIN getVMDisk");

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

        // 初始化参数
        try {
            init(params);
        } catch (Exception e) {
			//e.printStackTrace();
            return collResult.getKPISet();
        }

        // 获取主机名称device_id
        String neat_vm_name = Formater.neatenunitid((String) params.get("VMNAME"));
        if (deviceId.length() > 0) {
            neat_vm_name = Formater.neatenunitid((String) params.get("DEVICEID"));
        }

		// 客户机操作系统
		String osversion = vm.getSummary().getConfig().guestFullName;
		String p_unit_id = getPREVMKbp(osversion);

		// 数据存储相关信息
		double totalAll = 0.0;
		double totalFree  = 0.0;
		double totalReal = 0.0;
		if (vm.getGuest().getDisk() != null) {
			for (int i = 0; i < vm.getConfig().getHardware().getDevice().length; i++) {
				if (vm.getConfig().getHardware().getDevice()[i] instanceof VirtualDisk) {
					totalAll += ((VirtualDisk)((VirtualMachine) vm).getConfig().getHardware().getDevice()[i]).getCapacityInKB()/1024/1024.0;
				}
			}
			//microsoft操作系统
			if("10-10-23".equals(p_unit_id)){
				for (int i = 0; i < vm.getGuest().getDisk().length; i++) {
					// 数据存储名称
					String datastore_name = vm.getGuest().getDisk()[i].getDiskPath();
					// 数据存储路径 CM-00-01-001-16
					collResult.addKPI(p_unit_id + "-14:" + neat_vm_name + "-" + datastore_name, "CM-00-01-001-16", (vm.getGuest().getDisk()[i].getDiskPath()));
					// 数据存储使用率 PM-00-01-004-03
					double capacity = (vm.getGuest().getDisk()[i].getCapacity())/1024/1024/1024.0;
					totalReal += capacity;
					double freespace = (vm.getGuest().getDisk()[i].getFreeSpace())/1024/1024/1024.0;
					totalFree += freespace;
					collResult.addKPI(p_unit_id + "-14:" + neat_vm_name + "-" + datastore_name, "PM-00-01-004-04", Formater.formatDecimalByScale(String.valueOf(freespace), 2));
					collResult.addKPI(p_unit_id + "-14:" + neat_vm_name + "-" + datastore_name, "PM-00-01-004-03", Formater.dev2IntIntoFloat(String.valueOf(capacity - freespace), String.valueOf(capacity), 2));
				}
			}else {
				for (int i = 0; i < vm.getGuest().getDisk().length; i++) {
					// 数据存储名称
					String datastore_name = vm.getGuest().getDisk()[i].getDiskPath();
					// 数据存储路径 CM-00-01-001-16
					collResult.addKPI(p_unit_id + "-14:" + neat_vm_name + "-" + datastore_name, "CM-00-01-001-16", (vm.getGuest().getDisk()[i].getDiskPath()));
					// 数据存储使用率 PM-00-01-004-03
					double capacity = (vm.getGuest().getDisk()[i].getCapacity())/1024/1024/1024.0;
					totalReal += capacity;
					double freespace = (vm.getGuest().getDisk()[i].getFreeSpace())/1024/1024/1024.0;
					totalFree += freespace;
					//linux操作系统会把5%左右的空间留给root用户使用,df命令的使用率是针对分配给普通用户95%的空间来计算的
					//vmware则是把普通用户和管理员放一起计算的
					double fivePercent = capacity*5/100;// 5%的误差
					//collResult.addKPI(p_unit_id + "-14:" + neat_vm_name + "-" + datastore_name, "PM-00-01-004-04", Formater.formatDecimalByScale(String.valueOf(freespace), 2));
					//collResult.addKPI(p_unit_id + "-14:" + neat_vm_name + "-" + datastore_name, "PM-00-01-004-03", Formater.dev2IntIntoFloat(String.valueOf(capacity - freespace), String.valueOf(capacity), 2));
					collResult.addKPI(p_unit_id + "-14:" + neat_vm_name + "-" + datastore_name, "PM-00-01-004-04", Formater.formatDecimalByScale(String.valueOf(freespace-fivePercent), 2));
					String usedPercent = Formater.dev2IntIntoFloat(String.valueOf(capacity - freespace), String.valueOf(capacity - fivePercent), 2);//使用率
					if (Float.parseFloat(usedPercent)>100){
						usedPercent = "100";//使用率超过100，则按100计算
					}
					collResult.addKPI(p_unit_id + "-14:" + neat_vm_name + "-" + datastore_name, "PM-00-01-004-03", usedPercent);
				}
			}

			
			// CM-00-01-001-35存储总容量  CM-00-01-001-32存储已使用容量, 置备的存储和分配给操作系统的区别 totalAll  totalReal
			collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-00-01-001-35", Formater.formatDecimalByScale(String.valueOf(totalAll), 2));
			collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-00-01-001-32", Formater.formatDecimalByScale(String.valueOf(totalReal - totalFree), 2));
			
			// 特供磁盘使用率走势图KPI 磁盘使用率 PM-00-01-004-14
			collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "PM-00-01-004-14", Formater.dev2IntIntoFloat(String.valueOf(totalReal - totalFree), String.valueOf(totalAll), 2));
		} else {
			collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-00-01-001-35", "0");
			collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "CM-00-01-001-32", "0");
			// 特供磁盘使用率走势图KPI 磁盘使用率 PM-00-01-004-14
			collResult.addKPI(p_unit_id + "-10:" + neat_vm_name + "-total", "PM-00-01-004-14", "0");
		}

		return collResult.getKPISet();
	}

	public Vector<TblATO_KPIDETAIL> getVMNet(HashMap<String, String> params) {
		logger.info("BEGIN getVMNet");

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

        // 初始化参数
        try {
            init(params);
        } catch (Exception e) {
            return collResult.getKPISet();
        }

        // 获取主机名称device_id
        String neat_vm_name = Formater.neatenunitid((String) params.get("VMNAME"));
        if (deviceId.length() > 0) {
            neat_vm_name = Formater.neatenunitid((String) params.get("DEVICEID"));
        }

		// 客户机操作系统
		String osversion = vm.getSummary().getConfig().guestFullName;
		String p_unit_id = getPREVMKbp(osversion);

		try {
			PerformanceManager perfMgr = si.getPerformanceManager();
			PerfCounterInfo[] pcis = perfMgr.getPerfCounter();
			Map<String, Integer> counteridmap = new HashMap<String, Integer>();
			for (PerfCounterInfo _pci : pcis) {
				String groupinfo = _pci.getGroupInfo().key;
				int key = _pci.getKey();
				String nameinfo = _pci.getNameInfo().key;
				String rolluptype = _pci.getRollupType().toString();
				counteridmap.put(groupinfo + "-" + nameinfo + "-" + rolluptype, key);
			}
			
			Map catchcounteridlist = getCatchCounterId(counteridmap);
			System.out.println("catchcounteridlist.size() " + catchcounteridlist.size());
			PerfProviderSummary vmpps = perfMgr.queryPerfProviderSummary(vm);
		    int vmrefreshRate = vmpps.getRefreshRate().intValue();
		    PerfMetricId[] vmpmis = perfMgr.queryAvailablePerfMetric(vm, null, null, vmrefreshRate);
		    PerfQuerySpec vmqSpec = createPerfQuerySpec(vm, vmpmis, 3, vmrefreshRate);
			PerfEntityMetricBase[] pvmValues = perfMgr.queryPerf(new PerfQuerySpec[] {vmqSpec});
			if (pvmValues != null) {
				for (int i = 0; i < pvmValues.length; ++i) {
					getAllCounterInfo(pvmValues[i], collResult, neat_vm_name, p_unit_id, catchcounteridlist);
				}
			}
		} catch (RuntimeFault e) {
			e.printStackTrace();
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return collResult.getKPISet();
	}
	
	public Vector<TblATO_KPIDETAIL> getVMAlarm(HashMap<String, String> params) {
		logger.info("BEGIN getVMAlarm");

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

        // 初始化参数
        try {
            init(params);
        } catch (Exception e) {
            return collResult.getKPISet();
        }

        // 获取主机名称device_id
        String neat_vm_name = null;
		try {
			neat_vm_name = Formater.neatenunitid((String) params.get("VMNAME"));
		}catch (Exception ex){

		}
        if (deviceId.length() > 0) {
            neat_vm_name = Formater.neatenunitid((String) params.get("DEVICEID"));
        }

		if (vm.getTriggeredAlarmState() != null) {
			
			String osversion = vm.getSummary().getConfig().guestFullName;
			
			String p_unit_id = getPREVMKbp(osversion);
			
			// 警报个数
//			collResult.addKPI(PRE_DATACENTER_UNITID + "-30:" + neat_dc_name + "-alarm", "CM-10-10-10-36", dc.getTriggeredAlarmState().length + "");
			for (AlarmState as : vm.getTriggeredAlarmState()) {
				if (as.getEntity().type.trim().toString().equals(VIRTUALMACHINE)) {
					VirtualMachine _vm = new VirtualMachine(si.getServerConnection(), as.getEntity());
					String pre_unit_id = p_unit_id + "-30:" + neat_vm_name + "-" + Formater.neatenunitid(as.key.substring(0, as.key.indexOf(".")));
					// 对象设备类型
					collResult.addKPI(pre_unit_id, "CM-10-10-10-37", as.getEntity().type);
					// 对象名称
					collResult.addKPI(pre_unit_id, "CM-10-10-10-38", _vm.getName());
					// 状态
					collResult.addKPI(pre_unit_id, "CM-10-10-10-39", this.changeStringPosition(as.key));
//					String key = this.getAlarmId(as.key);
//					if ((Integer.parseInt(key) > 55)) {
//						key = "99";
//					}
					// 警报名称
					collResult.addKPI(pre_unit_id, "FM-00-31-001-01", (new Alarm(si.getServerConnection(), as.getAlarm())).getAlarmInfo().getName());
					// 触发时间
					collResult.addKPI(pre_unit_id, "CM-10-10-10-41", Formater.getSybaseFormatDateTime(as.getTime().getTime()));
				}
			}
		}
		return collResult.getKPISet();
	}

	public Vector<TblATO_KPIDETAIL> getVSwitch(HashMap<String, String> params) {
		logger.info("BEGIN getVSwitch");

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

        // 初始化参数
        try {
            init(params);
        } catch (Exception e) {
            return collResult.getKPISet();
        }

        // 获取主机名称device_id
        String neat_host_name = Formater.neatenunitid((String) params.get("HOSTNAME"));
        if (deviceId.length() > 0) {
            neat_host_name = Formater.neatenunitid((String) params.get("DEVICEID"));
        }

		try {
			for (int m = 0; m < ((HostSystem) hs).getHostNetworkSystem().getNetworkConfig().getVswitch().length; m++) {
				String vSwitchName = ((HostSystem) hs).getHostNetworkSystem().getNetworkConfig().getVswitch()[m].getName();
				int numPorts = ((HostSystem) hs).getHostNetworkSystem().getNetworkConfig().getVswitch()[m].getSpec().getNumPorts();
				// 虚拟交换机名称 CM-00-01-001-50
				collResult.addKPI(PRE_ROUTER_UNITID + "-10:" + neat_host_name + "_" + vSwitchName + "-total", "CM-00-01-001-50", ((HostSystem) hs).getName() + "-" + vSwitchName);
				// 端口数量 CM-00-02-002-06
				collResult.addKPI(PRE_ROUTER_UNITID + "-10:" + neat_host_name + "_" + vSwitchName + "-total", "CM-00-02-002-06", numPorts + "");
				for (int n = 0; n < ((HostSystem) hs).getHostNetworkSystem().getNetworkConfig().getPortgroup().length; n++) {
					String pgName = ((HostSystem) hs).getHostNetworkSystem().getNetworkConfig().getPortgroup()[n].getSpec().getName();
					int vlanId = ((HostSystem) hs).getHostNetworkSystem().getNetworkConfig().getPortgroup()[n].getSpec().getVlanId();
					String _pgName = Formater.neatenunitid(pgName);
					// 端口组名称 CM-00-01-001-51
					collResult.addKPI(PRE_ROUTER_UNITID + "-11:" + neat_host_name + "_" + vSwitchName + "-" + _pgName, "CM-00-01-001-51", pgName);
					// VLAN CM-00-01-001-52
					collResult.addKPI(PRE_ROUTER_UNITID + "-11:" + neat_host_name + "_" + vSwitchName + "-" + _pgName, "CM-00-01-001-52", vlanId + "");
				}
			}
		} catch (InvalidProperty e) {
			e.printStackTrace();
		} catch (RuntimeFault e) {
			e.printStackTrace();
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return collResult.getKPISet();
	}
	
	public Vector<TblATO_KPIDETAIL> getVDatastore(HashMap<String, String> params) {
		logger.info("BEGIN getVDatastore");

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

        // 初始化参数
        try {
            init(params);
        } catch (Exception e) {
			//e.printStackTrace();
            return collResult.getKPISet();
        }

        // 获取主机名称device_id
        String neat_ds_name = Formater.neatenunitid((String) params.get("DATASTORENAME"));
        if (deviceId.length() > 0) {
            neat_ds_name = Formater.neatenunitid((String) params.get("DEVICEID"));
        }

		// 数据存储名称
		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-30", ds.getName());

		// 是否有目录可以创建此数据存储上
		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-31",
				((Datastore) ds).getCapability().directoryHierarchySupported + "");

		// 是否在数据存储上每一个文件的基础上支持自动精简配置
		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-32",
				((Datastore) ds).getCapability().perFileThinProvisioningSupported + "");

		// 是否可以创建此数据存储上的原始磁盘映射
		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-33",
				((Datastore) ds).getCapability().rawDiskMappingsSupported + "");

		// 是否支持存储I/O资源管理
		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-34",
				((Datastore) ds).getCapability().storageIORMSupported + "");

		// 数据存储上的主机数
		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-35",
				((Datastore) ds).getHost().length + "");

		// 数据存储的可用空间
		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-36",
				Formater.formatDecimalByScale(((Datastore) ds).getInfo().getFreeSpace()/1024/1024/1024.0 + "", 2));

		// 存放文件的最大大小
		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-37", 
				((Datastore) ds).getInfo().getMaxFileSize()/1024/1024/1024.0 + "");

		// 数据存储信息更新时间
		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-38", 
				Formater.getSybaseFormatDateTime(((Datastore) ds).getInfo().getTimestamp().getTime()));

		// 数据存储位置
		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-39", 
				((Datastore) ds).getInfo().getUrl() + "");

//		// 数据存储的拥塞的等待时长
//		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-40",
//				((Datastore) ds).getIormConfiguration().getCongestionThreshold() + "");

//		// I/O控制是否已启用该服务
//		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-41",
//				((Datastore) ds).getIormConfiguration().enabled + "");

//		// 聚合统计是否被禁用
//		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-42",
//				((Datastore) ds).getIormConfiguration().getStatsAggregationDisabled() + "");

//		// 服务是否正在运行统计信息收集模式
//		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-43",
//				((Datastore) ds).getIormConfiguration().getStatsCollectionEnabled() + "");

		// 数据存储的连接状态
		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-44", 
				((Datastore) ds).getSummary().accessible + "");

		// 总格式化容量
		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-45", 
				((Datastore) ds).getSummary().capacity/1024/1024/1024.0 + "");

//		// 可用空间
//		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-46", 
//				((Datastore) ds).getSummary().freeSpace/1024/1024/1024.0 + "");

		// 当前维护模式
		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-47", 
				((Datastore) ds).getSummary().maintenanceMode + "");

		// 多主机访问
		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-48", 
				((Datastore) ds).getSummary().multipleHostAccess + "");

		// 文件系统类型
		collResult.addKPI(PRE_DATASTORE_UNITID + "-10:" + neat_ds_name + "-total", "CM-10-10-12-49", 
				((Datastore) ds).getSummary().type + "");

		return collResult.getKPISet();
	}
	
	public Map<Integer, Integer> getCatchCounterId(Map<String, Integer> counteridmap) {
		Map<Integer, Integer> counterids = new HashMap<Integer, Integer>();
		for (Object o : counteridmap.keySet()) {
			String key = String.valueOf(o);
			Integer intkey = Integer.parseInt(String.valueOf(counteridmap.get(key)));
			if ("cpu-usage-none".equals(key)) {
				counterids.put(intkey, 2);
			}
			if ("cpu-wait-summation".equals(key)) {
				counterids.put(intkey, 11);
			}
			if ("cpu-used-summation".equals(key)) {
				counterids.put(intkey, 14);
			}
			if ("mem-consumed-none".equals(key)) {
				counterids.put(intkey, 98);
			}
			if ("mem-granted-none".equals(key)) {
				counterids.put(intkey, 29);
			}
			if ("mem-usage-none".equals(key)) {
				counterids.put(intkey, 24);
			}
			if ("net-usage-none".equals(key)) {
				counterids.put(intkey, 143);
			}
			if ("net-transmitted-average".equals(key)) {
				counterids.put(intkey, 149);
			}
			if ("disk-usage-none".equals(key)) {
				counterids.put(intkey, 125);
			}
			if ("disk-commands-summation".equals(key)) {
				counterids.put(intkey, 408);
			}
		}
		return counterids;		
	}
	
	public void getAllCounterInfo(PerfEntityMetricBase pvmValues, CollBase collResult, String neat_vm_name, String config_PRE_UNITID, Map catchcounteridlist) {
		if (pvmValues instanceof PerfEntityMetric) {
			PerfEntityMetric pem = (PerfEntityMetric) pvmValues;
			PerfMetricSeries[] vals = pem.getValue();
			PerfSampleInfo[] infos = pem.getSampleInfo();
			
			for (int j = 0; vals != null && j < infos.length; j++) {
//				System.out.println("Sample time: " + infos[j].getTimestamp().getTime());
//				System.out.println("Sample interval (sec):" + infos[j].getInterval());
			}
			for (int k = 0; vals != null && k < vals.length; ++k) {
//				System.out.println("Perf counter ID:" + vals[k].getId().getCounterId());
//				System.out.println("Device instance ID:" + vals[k].getId().getInstance());
				String instanceid = vals[k].getId().getInstance();
				int counterid = vals[k].getId().getCounterId();
				if (catchcounteridlist.get(counterid) != null) {
					int counter_id = Integer.parseInt(String.valueOf(catchcounteridlist.get(counterid)));
//					System.out.println("counter_id is " + counter_id);
					if (vals[k] instanceof PerfMetricIntSeries) {
						PerfMetricIntSeries val = (PerfMetricIntSeries) vals[k];
						long[] longs = val.getValue();
//						for (int m = 0; m < longs.length; m++) {
//							System.out.print(longs[m] + " ");
//						}
						if (instanceid.equals("")) {
							getCounterInfo(collResult, neat_vm_name, config_PRE_UNITID, counter_id, longs);
						}
//						System.out.println("Total:" + longs.length);
					} else if (vals[k] instanceof PerfMetricSeriesCSV) {
						PerfMetricSeriesCSV val = (PerfMetricSeriesCSV) vals[k];
//						System.out.println("CSV value:" + val.getValue());
					}
				}
			}			
		} else if (pvmValues instanceof PerfEntityMetricCSV) {
			PerfEntityMetricCSV pems = (PerfEntityMetricCSV) pvmValues;
			System.out.println("SampleInfoCSV:" + pems.getSampleInfoCSV());
			PerfMetricSeriesCSV[] csvs = pems.getValue();
			for (int j = 0; j < csvs.length; j++) {
//				System.out.println("PerfCounterId:" + csvs[j].getId().getCounterId());
//				System.out.println("CSV sample values:" + csvs[j].getValue());
			}
		} else {
			System.out.println("UnExpected sub-type of " + "PerfEntityMetricBase.");
		}
	}
	
	public void getCounterInfo(CollBase collResult, String neat_vm_name, String config_PRE_UNITID, int counterid, long[] longs) {
		if (counterid == 2) {
			// CPU使用率 PM-00-01-001-07
//			collResult.addKPI(config_PRE_UNITID + "-11:" + neat_vm_name + "-cpu", "PM-00-01-001-07", longs[longs.length - 1] + "");
		}
		if (counterid == 11) {
			// CPU等待 PM-00-01-001-08
//			collResult.addKPI(config_PRE_UNITID + "-11:" + neat_vm_name + "-cpu", "PM-00-01-001-08", longs[longs.length - 1] + "");
		}
		if (counterid == 14) {
			// 已用的CPU PM-00-01-001-09
//			collResult.addKPI(config_PRE_UNITID + "-11:" + neat_vm_name + "-cpu", "PM-00-01-001-09", longs[longs.length - 1] + "");
		}
		
		if (counterid == 98) {
			// 已消耗的内存 PM-00-01-001-10
			collResult.addKPI(config_PRE_UNITID + "-12:" + neat_vm_name + "-mem", "PM-00-01-001-10", longs[longs.length - 1] + "");
		}
		if (counterid == 29) {
			// 已分配的内存 PM-00-01-001-11
			collResult.addKPI(config_PRE_UNITID + "-12:" + neat_vm_name + "-mem", "PM-00-01-001-11", longs[longs.length - 1] + "");
		}
		if (counterid == 24) {
			// 内存使用情况 PM-00-01-001-12
			collResult.addKPI(config_PRE_UNITID + "-12:" + neat_vm_name + "-mem", "PM-00-01-001-12", longs[longs.length - 1] + "");
		}
		
		if (counterid == 143) {
			// 网络使用情况 PM-00-01-900-09
			collResult.addKPI(config_PRE_UNITID + "-16:" + neat_vm_name + "-net", "PM-00-01-900-09", longs[longs.length - 1] + "");
		}
		if (counterid == 149) {
			// 网络数据传输速度 PM-00-01-900-08
			collResult.addKPI(config_PRE_UNITID + "-10:" + neat_vm_name + "-total", "PM-00-01-900-08", longs[longs.length - 1] + "");
		}

		if (counterid == 125) {
			// 磁盘使用情况 PM-00-01-001-15
			collResult.addKPI(config_PRE_UNITID + "-13:" + neat_vm_name + "-disk", "PM-00-01-001-15", longs[longs.length - 1] + "");
		}
		if (counterid == 408) {
			// 已发出的磁盘命令 PM-00-01-001-16
			collResult.addKPI(config_PRE_UNITID + "-13:" + neat_vm_name + "-disk", "PM-00-01-001-16", longs[longs.length - 1] + "");
		}
	}
	
	static PerfQuerySpec createPerfQuerySpec(ManagedEntity me,
			PerfMetricId[] metricIds, int maxSample, int interval) {
		PerfQuerySpec qSpec = new PerfQuerySpec();
		qSpec.setEntity(me.getMOR());
		qSpec.setMaxSample(new Integer(maxSample));
		qSpec.setFormat("normal");
		qSpec.setIntervalId(new Integer(interval));
		return qSpec;
	}

    /**
     * 10-10-20	IBM
     * 10-10-21	HP
     * 10-10-22	SUN
     * 10-10-23	MicroSoft
     * 10-10-24	Red-Hat
     * 10-10-25	VMWare
     * 10-10-29 Ubuntu
     * 10-10-30 Centos
     * 10-10-31 Suse
     */
    public String getPREVMKbp(String osversion) {
        String _preVMKbp = "";
        if (osversion.toLowerCase().indexOf("aix") != -1 ) {
            _preVMKbp = "10-10-20";
        }
        if (osversion.toLowerCase().indexOf("hp") != -1 ) {
            _preVMKbp = "10-10-21";
        }
        if (osversion.toLowerCase().indexOf("sunos") != -1 ) {
            _preVMKbp = "10-10-22";
        }
        if (osversion.toLowerCase().indexOf("microsoft") != -1 ) {
            _preVMKbp = "10-10-23";
        }
        if (osversion.toLowerCase().indexOf("linux") != -1 ) {
            _preVMKbp = "10-10-24";
        }
        if (osversion.toLowerCase().indexOf("vmkernel") != -1 ) {
            _preVMKbp = "10-10-25";
        }
        if (osversion.toLowerCase().indexOf("ubuntu") != -1 ) {
            _preVMKbp = "10-10-29";
        }
        if (osversion.toLowerCase().indexOf("centos") != -1 ) {
            _preVMKbp = "10-10-30";
        }
        if (osversion.toLowerCase().indexOf("suse") != -1 ) {
            _preVMKbp = "10-10-31";
        }
        return _preVMKbp;
    }

//	private String getHostName(String ipaddress, String username, String password) {
//		SSHThread ssh = new SSHThread(ipaddress, 22, username, DES3.encrypt(password));
//		String hostName = "";
//		try {
//			ssh.initial();
//			hostName = ssh.getResultAsStr("uname -a");
//			hostName = split(hostName, 1);
//			ssh.close();
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//		return hostName;
//	}
//	
//	private String split(String str, int pos) {
//		StringTokenizer st = new StringTokenizer(str);
//		Vector<String> values = new Vector<String>();
//		while (st.hasMoreTokens()) {
//			values.add(st.nextToken());
//		}
//		if (pos >= 0 && pos < values.size()) {
//			return values.elementAt(pos);
//		}
//		return "";
//	}
	
	private String changeStringPosition(String inputstr) {
		String res = "";
		if (inputstr != null) {
			String _res = inputstr;
			res = Formater.neatenunitid(inputstr.substring(inputstr.indexOf(".") + 1));
			res += "-" + Formater.neatenunitid(_res.substring(0, _res.indexOf(".")));
		}
		return res;
	}
	
	private String changeMACAddress(String macaddress) {
		return macaddress.replaceAll(":", "_");
	}
	
	private String getAlarmId(String alarmKey) {
		String alarmId = alarmKey.substring(alarmKey.indexOf("-") + 1, alarmKey.indexOf("."));
		NumberFormat formatter = new DecimalFormat("00");
		return formatter.format(Integer.parseInt(alarmId));
	}

	/**
	 * 初始化
	 * @param params
	 */
	public void init(HashMap<String, String> params) throws Exception {

        /*String url = (String) params.get("URL");
        String username = (String) params.get("USERNAME");
        String password = (String) params.get("PASSWORD");*/

        if ((String) params.get("IGNORECERT") != null) {
            ignoreCert = (String) params.get("IGNORECERT");
        }

        if ((null != (String) params.get("VCENTERFLAG")) && (((String) params.get("VCENTERFLAG")).length() > 0)) {
            vcenterFlag = (String) params.get("VCENTERFLAG");
        }

        if ((String) params.get("DEVICEID") != null) {
            deviceId = (String) params.get("DEVICEID");
        }

//        if (url == null || username == null || password == null) {
//            url = (String) params.get("PH.URL");
//            username = (String) params.get("PH.USERNAME");
//            password = (String) params.get("PH.PASSWORD");
//        }

        dcname = (String) params.get("DATACENTER");
        ccrname = (String) params.get("CLUSTER");
        hsname = (String) params.get("HOSTNAME");
        vmname = (String) params.get("VMNAME");
        vsname = (String) params.get("VSWITCHNAME");
        dsname = (String) params.get("DATASTORENAME");

        logger.info("Begin to connect VCenter: " + vcenterFlag);
        //si = new ServiceInstance(new URL(url), username, password, this.ignoreCert.equalsIgnoreCase("true"));
        si = getServiceInstanceByKey(vcenterFlag);
        logger.info("si is: " + si);
        rootFolder = si.getRootFolder();
        ServerConnection sc = si.getServerConnection();

        ManagedObjectReference vdcmor = new ManagedObjectReference();
        vdcmor.setType(DATACENTER);
        vdcmor.setVal(dcname);
        dc = new Datacenter(sc, vdcmor);

        ManagedObjectReference ccrmor = new ManagedObjectReference();
        ccrmor.setType(CLUSTERCOMPUTERESOURCE);
        ccrmor.setVal(ccrname);
        ccr = new ClusterComputeResource(sc, ccrmor);

        ManagedObjectReference hostmor = new ManagedObjectReference();
        hostmor.setType(HOSTSYSTEM);
        hostmor.setVal(hsname);
        hs = new HostSystem(sc, hostmor);

        ManagedObjectReference vmmor = new ManagedObjectReference();
        vmmor.setType(VIRTUALMACHINE);
        vmmor.setVal(vmname);
        vm = new VirtualMachine(sc, vmmor);

        ManagedObjectReference dsmor = new ManagedObjectReference();
        dsmor.setType(DATASTORE);
        dsmor.setVal(dsname);
        ds = new Datastore(sc, dsmor);
        logger.info("End to connect Host");
	}
	
	/**
	 * @param args
	 */
	public static void main1(String[] args) {
		CollEsxiWithCMD cmd = new CollEsxiWithCMD();
//		System.out.println(cmd.changeStringPosition("alarm-46.domain-c27"));
		//String key = cmd.getAlarmId("alarm-2.domain-c27");
		//if ((Integer.parseInt(key) > 55)) {
			//key = "99";
		//}
		//System.out.println(key);
		Vector<TblATO_KPIDETAIL> result = null;
//		try {
			HashMap<String, String> params = new HashMap<String, String>();
//			params.put("URL", "https://172.21.1.105/sdk");
//			params.put("USERNAME", "root");
//			params.put("PASSWORD", "PaulP12#");
//			params.put("VMNAME", "DianXIn_CeShi");
//			params.put("HOSTNAME", "172.21.1.105");
//			params.put("URL", "https://172.21.0.200/sdk");
//			params.put("USERNAME", "vcenter");
//			params.put("PASSWORD", "123456");
			/*params.put("URL", "https://172.21.3.23/sdk");
			params.put("USERNAME", "Administrator");
			params.put("PASSWORD", "Admin1234");*/

//            params.put("DEVICEID", "TEST_unit-id-2");

			params.put("DATACENTER", "datacenter-2");
			//result = cmd.getDatacenterConfig(params);

			params.put("CLUSTER", "domain-c7");
		//params.put("CLUSTER", "domain-c376");
			result = cmd.getClusterConfig(params);
			//result = cmd.getClusterPerfor(params);/**************资源池*/
			//result = cmd.getClusterAlarm(params);

			params.put("HOSTNAME", "host-3621");
			//result = cmd.getConfig(params);
			//result = cmd.getCpu(params);
			//result = cmd.getMemory(params);
			//result = cmd.getDisk(params);

//			result = cmd.getAlarm(params);

			params.put("VMNAME", "datacenter-2");
		//params.put("VMNAME", "vm-400");
			//result = cmd.getVMInfo(params);
//			result = cmd.getVMCpu(params);
//			result = cmd.getVMMemory(params);
//			result = cmd.getVMDisk(params);
//			result = cmd.getVMNet(params);
//			result = cmd.getVMAlarm(params);

			params.put("HOSTNAME", "host-72");
		//params.put("HOSTNAME", "host-395");
			params.put("VSWITCHNAME", "host-10_vSwitch0");
//			result = cmd.getVSwitch(params);

			params.put("DATASTORENAME", "datastore-11");
			//result = cmd.getVDatastore(params);
		    //result = cmd.getVMDisk(params);
			//result = cmd.getDisk(params);
		//result = cmd.getNet(params);
//		} catch (InvalidProperty e) {
//			e.printStackTrace();
//		} catch (RuntimeFault e) {
//			e.printStackTrace();
//		} catch (RemoteException e) {
//			e.printStackTrace();
//		}
		System.out.println("result's size is: " + result.size());
		for (int i = 0; i < result.size(); i++) {
			TblATO_KPIDETAIL tk = (TblATO_KPIDETAIL) result.get(i);
			System.out.println("[unit-id][" + tk.UNIT_ID + "]#[kpi-id][" + tk.KPI_ID + "]#[kpi-value][" + tk.KPI_VALUE + "]#[cll-time][" + tk.CLL_TIME + "]");
		}

        String password = org.apache.commons.codec.binary.Hex.encodeHexString("bnms1".getBytes());
        System.out.println(password);
        DES3 des = new DES3();
        System.out.println(DES3.decrypt("b8009e9ef7c4fde59c73c20e020c4c4c920c29076cb05406"));

    }

	public static void main(String args[]) throws Exception{
		CollEsxiWithCMD cmd = new CollEsxiWithCMD();
		Date beginTime = new Date();
//		System.out.println(cmd.changeStringPosition("alarm-46.domain-c27"));
		//String key = cmd.getAlarmId("alarm-2.domain-c27");
		//if ((Integer.parseInt(key) > 55)) {
		//key = "99";
		//}
		//System.out.println(key);
		Vector<TblATO_KPIDETAIL> result = new Vector<TblATO_KPIDETAIL>();
//		try {
		HashMap<String, String> params = new HashMap<String, String>();
		/*采集集群数据 start*/
		/*params.put("CLUSTER","domain-c461");
		params.put("DEVICEID", "m0_domain_c461");
		result.addAll(cmd.getClusterAlarm(params));
		result.addAll(cmd.getClusterConfig(params));
		result.addAll(cmd.getClusterPerfor(params));*/
		/*采集集群数据 end*/

		/*采集数据中心 start*/
		params.put("DATACENTER", "datacenter-2");
		params.put("DEVICEID","datacenter_2");

		//result.addAll(cmd.getDatacenterConfig(params));
		/*采集数据中心 end*/

		/*params.put("CLUSTER","domain-c461");
		params.put("DEVICEID","domain_c461");
		result.addAll(cmd.getClusterPerfor(params));
		result.addAll(cmd.getClusterConfig(params));
		result.addAll(cmd.getClusterAlarm(params));*/

		/*params.put("CLUSTER","domain-c401");
		params.put("DEVICEID","domain_c401");
		result.addAll(cmd.getClusterPerfor(params));
		result.addAll(cmd.getClusterConfig(params));
		result.addAll(cmd.getClusterAlarm(params));*/

		ServiceInstance si = null;
		si = new ServiceInstance(new URL("https://89.12.91.1/sdk"), "zviewmonitor@gzgs.vm", "zview+monitor", true);
		Folder rootFolder = si.getRootFolder();

		/*宿主机采集 start */
		String name = rootFolder.getName();
		ManagedEntity[] hs = new InventoryNavigator(rootFolder).searchManagedEntities(HOSTSYSTEM);
		for (ManagedEntity _hs : hs) {
			String hostName = ((HostSystem)_hs).getConfig().getHost().get_value();
			params.put("DEVICEID", Formater.neatenunitid(hostName));

			params.put("HOSTNAME",hostName);
			System.out.println("DEVICEID:"+Formater.neatenunitid(hostName)+",HOSTNAME:"+hostName);
			/*result.addAll(cmd.getAlarm(params));
			result.addAll(cmd.getConfig(params));
			result.addAll(cmd.getCpu(params));
			result.addAll(cmd.getDisk(params));
			result.addAll(cmd.getMemory(params));
			result.addAll(cmd.getNet(params));*/
		}
		/*宿主机采集 end*/

		/*虚拟机采集 start*/
		/*ManagedEntity[] vm = new InventoryNavigator(rootFolder).searchManagedEntities(VIRTUALMACHINE);
		System.out.println("The number of VirtualMachine is: " + vm.length);
		int j = 1;
		for (ManagedEntity _vm : vm) {
			try {
				String vm_device_id = ((VirtualMachine) _vm).getMOR().getVal();
				System.out.println("********************\nColl device : " + vm_device_id);
				params.put("DEVICEID", Formater.neatenunitid(vm_device_id));
				params.put("VMNAME", vm_device_id);

				result.addAll(cmd.getVMAlarm(params));
				result.addAll(cmd.getVMCpu(params));
				result.addAll(cmd.getVMDisk(params));
				result.addAll(cmd.getVMInfo(params));
				result.addAll(cmd.getVMMemory(params));
				result.addAll(cmd.getVMNet(params));

			}catch(Exception ex){
				ex.printStackTrace();
			}
			j++;
			if(j > 10) break;
		}*/
		Date endTime = new Date();
		Thread.sleep(5000);
		System.out.println(beginTime+"-->" + endTime);
		Thread.sleep(10000);
		/*虚拟机采集 end*/

		/*虚拟网络采集 start*/
		//params.put("HOSTNAME","host-527");
		//params.put("PASSWORD","");
		//params.put("URL","");
		//params.put("USERNAME","");
		//params.put("VSWITCHNAME","vSwitch0");

		//result.addAll(cmd.getVSwitch(params));
		/*虚拟网络采集 end*/

		/*虚拟数据存储采集 start*/
		//params.put("DATASTORENAME","");
		//params.put("PASSWORD","");
		//params.put("URL","");
		//params.put("USERNAME","");

		//result.addAll(cmd.getVDatastore(params));
		/*虚拟数据存储采集 end*/
		System.out.println("result's size is: " + result.size());
		for (int i = 0; i < result.size(); i++) {
			TblATO_KPIDETAIL kpidetail = (TblATO_KPIDETAIL) result.get(i);
			//System.out.println("[unit-id][" + tk.UNIT_ID + "]#[kpi-id][" + tk.KPI_ID + "]#[kpi-value][" + tk.KPI_VALUE + "]#[cll-time][" + tk.CLL_TIME + "]");
			String extUnitIdArray[] = kpidetail.UNIT_ID.split(":");
			String kbpSplit[] = extUnitIdArray[0].split("-");
			String kbpClass = kbpSplit[0]+"-"+kbpSplit[1]+"-"+kbpSplit[2];
			String deviceId = extUnitIdArray[1].split("-")[0];
			System.out.println("INSERT INTO ZVIEWMONITOR.TB_ATO_KPIDETAIL (" +
					"   KPI_ID, UNIT_ID, CLL_TIME, " +
					"   KPI_VALUE, EXT_INFO, DB_TIME, " +
					"   EXT_UNIT_ID, INTERVAL) " +
					"VALUES ('"+kpidetail.KPI_ID+"','"+kpidetail.UNIT_ID+"',sysdate,'"+kpidetail.KPI_VALUE+"','"+kpidetail.EXT_INFO+"',sysdate,'"+kbpClass+":"+deviceId+"',90000);");

		}
/*
		String password = org.apache.commons.codec.binary.Hex.encodeHexString("bnms1".getBytes());
		System.out.println(password);
		DES3 des = new DES3();
		System.out.println(DES3.decrypt("b8009e9ef7c4fde59c73c20e020c4c4c920c29076cb05406"));*/
	}
}