public static void main(String[] args) throws Exception {
    ServiceInstance si = new ServiceInstance(new URL(VCENTERURL), USERNAME, PASSWORD, true);
    Folder rootFolder = si.getRootFolder();
    ManagedEntity[] hosts = new InventoryNavigator(rootFolder).searchManagedEntities("HostSystem");
    if (hosts == null || hosts.length == 0) {
      return;
    }
    for (int i = 0; i < hosts.length; i++) { // get all vm in Vhost
      System.out.println("vHost loop ******************");
      System.out.println("HostName: " + hosts[i].getName());
      ManagedEntity[] mes =
          new InventoryNavigator(rootFolder).searchManagedEntities("VirtualMachine");
      for (int j = 0; j < mes.length; j++) {
        VirtualMachine vm = (VirtualMachine) mes[j];
        VirtualMachineConfigInfo vminfo = vm.getConfig();
        vm.getResourcePool();
        System.out.println("vHost: " + vm.getParent().getName());
        System.out.println("Guest: " + vm.getName());
        System.out.println("GuestOS: " + vminfo.getGuestFullName());
        System.out.println("GuestState: " + vm.getGuest().guestState);
        System.out.println("Guest Ip address: " + vm.getGuest().getIpAddress());

        pingByIP(vm.getGuest().getIpAddress()); // ping VM
      }

      HostSystem newHost = (HostSystem) hosts[i];
      String vHost_IP =
          newHost.getConfig().getNetwork().getVnic()[0].getSpec().getIp().getIpAddress();
      System.out.println("vHost IP address: " + vHost_IP);

      // test for ping vHost
      pingByIP(vHost_IP); // ping vHost
    }
  } // end of main
  /**
   * Queries a host system for Cim data.
   *
   * @param hostSystem the host system to query
   * @param cimClass the class of Cim objects to retrieve
   * @param primaryIpAddress the Ip address to use
   * @return the list of Cim objects
   * @throws RemoteException
   * @throws CIMException
   */
  public List<CIMObject> queryCimObjects(
      HostSystem hostSystem, String cimClass, String primaryIpAddress)
      throws ConnectException, RemoteException, CIMException {
    List<CIMObject> cimObjects = new ArrayList<CIMObject>();

    if (!m_hostServiceTickets.containsKey(hostSystem)) {
      m_hostServiceTickets.put(hostSystem, hostSystem.acquireCimServicesTicket());
    }

    HostServiceTicket hostServiceTicket = m_hostServiceTickets.get(hostSystem);

    if (!m_hostSystemCimUrls.containsKey(hostSystem)) {
      String ipAddress = primaryIpAddress;

      if (ipAddress == null) {
        ipAddress = getPrimaryHostSystemIpAddress(hostSystem);
      }

      if (ipAddress == null) {
        logger.warn(
            "Cannot determine ip address for host system '{}'", hostSystem.getMOR().getVal());
        return cimObjects;
      }

      m_hostSystemCimUrls.put(hostSystem, "https://" + ipAddress + ":5989");
    }

    String cimAgentAddress = m_hostSystemCimUrls.get(hostSystem);

    String namespace = "root/cimv2";

    UserPrincipal userPr = new UserPrincipal(hostServiceTicket.getSessionId());
    PasswordCredential pwCred =
        new PasswordCredential(hostServiceTicket.getSessionId().toCharArray());

    CIMNameSpace ns = new CIMNameSpace(cimAgentAddress, namespace);
    CIMClient cimClient = new CIMClient(ns, userPr, pwCred);

    // very important to query esx5 hosts
    cimClient.useMPost(false);

    CIMObjectPath rpCOP = new CIMObjectPath(cimClass);

    Enumeration<?> rpEnm = cimClient.enumerateInstances(rpCOP);

    while (rpEnm.hasMoreElements()) {
      CIMObject rp = (CIMObject) rpEnm.nextElement();

      cimObjects.add(rp);
    }

    return cimObjects;
  }
 // TODO We should use the IP of the "Management Network" (i.e. the port that has enabled
 // "Management Traffic" on the available vSwitches).
 //      Resolving the name of the HostSystem as the FQDN is the most closest thing for that.
 public String getPrimaryHostSystemIpAddress(HostSystem hostSystem) throws RemoteException {
   TreeSet<String> addresses = getHostSystemIpAddresses(hostSystem);
   String ipAddress = null;
   try {
     ipAddress = InetAddress.getByName(hostSystem.getName()).getHostAddress();
   } catch (Exception e) {
     logger.debug("Can't resolve the IP address from {}.", hostSystem.getName());
   }
   if (ipAddress == null) {
     return addresses.first();
   }
   return addresses.contains(ipAddress) ? ipAddress : addresses.first();
 }
  /**
   * Searches for all ip addresses of a host system
   *
   * @param hostSystem the host system to query
   * @return the ip addresses of the host system, the first one is the primary
   * @throws RemoteException
   */
  public TreeSet<String> getHostSystemIpAddresses(HostSystem hostSystem) throws RemoteException {
    TreeSet<String> ipAddresses = new TreeSet<String>();

    HostNetworkSystem hostNetworkSystem = hostSystem.getHostNetworkSystem();

    if (hostNetworkSystem != null) {
      HostNetworkInfo hostNetworkInfo = hostNetworkSystem.getNetworkInfo();
      if (hostNetworkInfo != null) {
        HostVirtualNic[] hostVirtualNics = hostNetworkInfo.getConsoleVnic();
        if (hostVirtualNics != null) {
          for (HostVirtualNic hostVirtualNic : hostVirtualNics) {
            ipAddresses.add(hostVirtualNic.getSpec().getIp().getIpAddress());
          }
        }
        hostVirtualNics = hostNetworkInfo.getVnic();
        if (hostVirtualNics != null) {
          for (HostVirtualNic hostVirtualNic : hostVirtualNics) {
            ipAddresses.add(hostVirtualNic.getSpec().getIp().getIpAddress());
          }
        }
      }
    }
    return ipAddresses;
  }
  /**
   * This method queries the Vmware vCenter server for sensor data.
   *
   * @param svc the monitored service
   * @param parameters the parameter map
   * @return the poll status for this system
   */
  @Override
  public PollStatus poll(MonitoredService svc, Map<String, Object> parameters) {
    OnmsNode onmsNode = m_nodeDao.get(svc.getNodeId());

    // retrieve the assets and
    String vmwareManagementServer = onmsNode.getAssetRecord().getVmwareManagementServer();
    String vmwareManagedEntityType = onmsNode.getAssetRecord().getVmwareManagedEntityType();
    String vmwareManagedObjectId = onmsNode.getForeignId();

    TimeoutTracker tracker = new TimeoutTracker(parameters, DEFAULT_RETRY, DEFAULT_TIMEOUT);

    PollStatus serviceStatus = PollStatus.unknown();

    for (tracker.reset();
        tracker.shouldRetry() && !serviceStatus.isAvailable();
        tracker.nextAttempt()) {

      VmwareViJavaAccess vmwareViJavaAccess = null;

      try {
        vmwareViJavaAccess = new VmwareViJavaAccess(vmwareManagementServer);
      } catch (MarshalException e) {
        logger.warn(
            "Error initialising VMware connection to '{}': '{}'",
            vmwareManagementServer,
            e.getMessage());
        return PollStatus.unavailable(
            "Error initialising VMware connection to '" + vmwareManagementServer + "'");
      } catch (ValidationException e) {
        logger.warn(
            "Error initialising VMware connection to '{}': '{}'",
            vmwareManagementServer,
            e.getMessage());
        return PollStatus.unavailable(
            "Error initialising VMware connection to '" + vmwareManagementServer + "'");
      } catch (IOException e) {
        logger.warn(
            "Error initialising VMware connection to '{}': '{}'",
            vmwareManagementServer,
            e.getMessage());
        return PollStatus.unavailable(
            "Error initialising VMware connection to '" + vmwareManagementServer + "'");
      }

      try {
        vmwareViJavaAccess.connect();
      } catch (MalformedURLException e) {
        logger.warn(
            "Error connecting VMware management server '{}': '{}'",
            vmwareManagementServer,
            e.getMessage());
        return PollStatus.unavailable(
            "Error connecting VMware management server '" + vmwareManagementServer + "'");
      } catch (RemoteException e) {
        logger.warn(
            "Error connecting VMware management server '{}': '{}'",
            vmwareManagementServer,
            e.getMessage());
        return PollStatus.unavailable(
            "Error connecting VMware management server '" + vmwareManagementServer + "'");
      }

      if (!vmwareViJavaAccess.setTimeout(tracker.getConnectionTimeout())) {
        logger.warn(
            "Error setting connection timeout for VMware management server '{}'",
            vmwareManagementServer);
      }

      String powerState = "unknown";

      if ("HostSystem".equals(vmwareManagedEntityType)) {
        HostSystem hostSystem =
            vmwareViJavaAccess.getHostSystemByManagedObjectId(vmwareManagedObjectId);
        if (hostSystem == null) {
          return PollStatus.unknown("hostSystem=null");
        } else {
          HostRuntimeInfo hostRuntimeInfo = hostSystem.getRuntime();
          if (hostRuntimeInfo == null) {
            return PollStatus.unknown("hostRuntimeInfo=null");
          } else {
            HostSystemPowerState hostSystemPowerState = hostRuntimeInfo.getPowerState();
            if (hostSystemPowerState == null) {
              return PollStatus.unknown("hostSystemPowerState=null");
            } else {
              powerState = hostSystemPowerState.toString();
            }
          }
        }
      } else {
        if ("VirtualMachine".equals(vmwareManagedEntityType)) {
          VirtualMachine virtualMachine =
              vmwareViJavaAccess.getVirtualMachineByManagedObjectId(vmwareManagedObjectId);
          if (virtualMachine == null) {
            return PollStatus.unknown("virtualMachine=null");
          } else {
            VirtualMachineRuntimeInfo virtualMachineRuntimeInfo = virtualMachine.getRuntime();
            if (virtualMachineRuntimeInfo == null) {
              return PollStatus.unknown("virtualMachineRuntimeInfo=null");
            } else {
              VirtualMachinePowerState virtualMachinePowerState =
                  virtualMachineRuntimeInfo.getPowerState();
              if (virtualMachinePowerState == null) {
                return PollStatus.unknown("virtualMachinePowerState=null");
              } else {
                powerState = virtualMachinePowerState.toString();
              }
            }
          }
        } else {
          logger.warn(
              "Error getting '{}' for '{}'", vmwareManagedEntityType, vmwareManagedObjectId);

          vmwareViJavaAccess.disconnect();

          return serviceStatus;
        }
      }

      if ("poweredOn".equals(powerState)) {
        serviceStatus = PollStatus.available();
      } else {
        serviceStatus = PollStatus.unavailable("The system's state is '" + powerState + "'");
      }

      vmwareViJavaAccess.disconnect();
    }

    return serviceStatus;
  }
 public static boolean pingVhost(HostSystem vhost) throws Exception {
   String ip = vhost.getConfig().getNetwork().getVnic()[0].getSpec().getIp().getIpAddress();
   return pingByIP(ip);
 }
  @Override
  public void run() {

    try {

      while (true) {

        URL url = new URL(SJSULabConfig.getvCenterURL());
        try {

          ServiceInstance si =
              new ServiceInstance(
                  url, SJSULabConfig.getvCenterUsername(), SJSULabConfig.getPassword(), true);
          HostSystem host =
              (HostSystem)
                  new InventoryNavigator(si.getRootFolder())
                      .searchManagedEntity("HostSystem", ip); //
          System.out.println("host value" + host);
          PerformanceManager perfMgr = si.getPerformanceManager();

          PerfProviderSummary summary = perfMgr.queryPerfProviderSummary(host); // vm

          int perfInterval = summary.getRefreshRate();

          PerfMetricId[] queryAvailablePerfMetric =
              perfMgr.queryAvailablePerfMetric(host, null, null, perfInterval);
          PerfCounterInfo[] pci = perfMgr.getPerfCounter();
          ArrayList<PerfMetricId> list = new ArrayList<PerfMetricId>();
          for (int i2 = 0; i2 < queryAvailablePerfMetric.length; i2++) {
            PerfMetricId perfMetricId = queryAvailablePerfMetric[i2];
            if (SELECTED_COUNTER_ID == perfMetricId.getCounterId()) {
              list.add(perfMetricId);
            }
          }
          PerfMetricId[] pmis = list.toArray(new PerfMetricId[list.size()]);
          PerfQuerySpec qSpec = new PerfQuerySpec();
          qSpec.setEntity(host.getMOR());
          qSpec.setMetricId(pmis);

          qSpec.intervalId = perfInterval;
          PerfEntityMetricBase[] pembs = perfMgr.queryPerf(new PerfQuerySpec[] {qSpec});

          for (int i = 0; pembs != null && i < pembs.length; i++) {

            PerfEntityMetricBase val = pembs[i];
            PerfEntityMetric pem = (PerfEntityMetric) val;
            PerfMetricSeries[] vals = pem.getValue();
            PerfSampleInfo[] infos = pem.getSampleInfo();

            Date date1 = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("MM-dd-yyyy h:mm:ss");
            String formattedDate = sdf.format(date1);

            infoList.put(aName[counter], formattedDate);

            for (int j = 0; vals != null && j < vals.length; ++j) {
              PerfMetricIntSeries val1 = (PerfMetricIntSeries) vals[j];
              long[] longs = val1.getValue();
              System.out.println("Host CPU :" + longs[5]);
              infoList.put(aName[0], String.valueOf(longs[5]));
              /*
              for (int k : a) {

              	infoList.put(aName[counter+1],
              			String.valueOf(longs[k]));
              	counter++;
              }
              counter = 0;
              */
            }
          }
          si.getServerConnection().logout();
        } catch (InvalidProperty e) {
          e.printStackTrace();
        } catch (RuntimeFault e) {
          e.printStackTrace();
        } catch (RemoteException e) {
          e.printStackTrace();
        } catch (MalformedURLException e) {
          e.printStackTrace();
        }

        //	infoList.put("vmIP", ip);

        counter = 0;

        try {

          StringBuilder sb = new StringBuilder();
          sb.append("vmname:" + ip + ",");
          int countTest = 0;
          for (String str : aName) {
            sb.append(aName[countTest] + ":" + infoList.get(str).toString() + ",");
            countTest++;
          }
          String out = sb.toString();
          out = out.substring(0, out.length() - 1);
          writer.write(out + "\n");
          System.out.println(out);
        } catch (Exception e) {
          e.printStackTrace();
        }

        Thread.sleep(5000);
      }

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