import com.vmware.vim25.ObjectUpdate; //导入依赖的package包/类
private void handleUpdate(UpdateSet update) throws Exception
{
    ObjectUpdate[] vmUpdates;

    PropertyFilterUpdate[] pfus = update.getFilterSet();

    if (pfus == null) {
        return;
    }
    for (int pfui = 0; pfui < pfus.length; pfui++)
    {
        vmUpdates = pfus[pfui].getObjectSet();

        if (vmUpdates == null) {
            continue;
        }
        for (ObjectUpdate vmi : vmUpdates)
        {
            handleChanges(vmi);
        }
    }
}
 

import com.vmware.vim25.ObjectUpdate; //导入依赖的package包/类
void handleObjectUpdate(ObjectUpdate oUpdate)
{
    PropertyChange[] pc = oUpdate.getChangeSet();
    System.out.println("Update kind = " + oUpdate.getKind());
    if (oUpdate.getKind() == ObjectUpdateKind.enter)
    {
        System.out.println(" New Data:");
        handleChanges(pc);
    } else if (oUpdate.getKind() == ObjectUpdateKind.leave)
    {
        System.out.println(" Removed Data:");
        handleChanges(pc);
    } else if (oUpdate.getKind() == ObjectUpdateKind.modify)
    {
        System.out.println(" Changed Data:");
        handleChanges(pc);
    }

}
 

import com.vmware.vim25.ObjectUpdate; //导入依赖的package包/类
static void handleUpdate(UpdateSet update) 
{
   ArrayList vmUpdates = new ArrayList();
   ArrayList hostUpdates = new ArrayList();
   PropertyFilterUpdate[] pfus = update.getFilterSet(); 
   for(int i=0; i<pfus.length; i++) 
   {
      ObjectUpdate[] ous = pfus[i].getObjectSet();
      for(int j=0; j<ous.length; ++j) 
      {
         if(ous[j].getObj().getType().equals("VirtualMachine")) 
         {
            vmUpdates.add(ous[j]);
         } 
         else if(ous[j].getObj().getType().equals("HostSystem")) 
         {
            hostUpdates.add(ous[j]);
         }
      }
   }      
   if(vmUpdates.size() > 0) 
   {
      System.out.println("Virtual Machine updates:");
      for(Iterator vmi = vmUpdates.iterator(); vmi.hasNext();) 
      {
         handleObjectUpdate((ObjectUpdate)vmi.next());
      }
   }      
   if(hostUpdates.size() > 0) 
   {
      System.out.println("Host updates:");
      for(Iterator vmi = hostUpdates.iterator(); vmi.hasNext();) 
      {
         handleObjectUpdate((ObjectUpdate)vmi.next());
      }
   }
}
 

import com.vmware.vim25.ObjectUpdate; //导入依赖的package包/类
void handleUpdate(UpdateSet update)
{
    ObjectUpdate[] vmUpdates;
    PropertyFilterUpdate[] pfus = update.getFilterSet();
    for (int pfui = 0; pfui < pfus.length; pfui++)
    {
        System.out.println("Virtual Machine updates:");
        vmUpdates = pfus[pfui].getObjectSet();
        for (ObjectUpdate vmi : vmUpdates)
        {
            System.out.println("Handling object update");
            handleObjectUpdate(vmi);
        }
    }
}
 

import com.vmware.vim25.ObjectUpdate; //导入依赖的package包/类
public void update(Observable obj, Object arg)
{
    if (arg instanceof PropertyFilterUpdate[])
    {
        PropertyFilterUpdate[] pfus = (PropertyFilterUpdate[]) arg;
        
        for(int i=0; pfus!=null && i< pfus.length; i++)
        {
            ObjectUpdate[] ous = pfus[i].getObjectSet();
            for(int j=0; ous!=null && j < ous.length; j++)
            {
                ManagedObjectReference mor = ous[j].getObj();
                if(! items.containsKey(mor))
                {
                    items.put(mor, new ConcurrentHashMap<String, Object>());
                }
                Map<String, Object> moMap = items.get(mor);
                
                PropertyChange[] pcs = ous[j].getChangeSet();
                if(pcs==null)
                {
                  continue;
                }
                for(int k=0; k < pcs.length; k++)
                {
                	  Object value = pcs[k].getVal();
                	  value = value == null ? NULL : value; //null is not allowed as value in CHM
                	  String propName = pcs[k].getName();
                	  if(moMap.containsKey(propName))
                	  {
                	    moMap.put(propName, value);
                	  }
                	  else
                	  {
                	    String parentPropName = getExistingParentPropName(moMap, propName);
                	    if(parentPropName != null)
                	    {
                	      ManagedObject mo = MorUtil.createExactManagedObject(si.getServerConnection(), mor);
                	      moMap.put(parentPropName, mo.getPropertyByPath(parentPropName));
                	    }
                	    else
                	    { //almost impossible to be here.
                	      moMap.put(propName, value);
                	    }
                	  }
                }
            }
        }
    }
    isReady = true;
}
 

import com.vmware.vim25.ObjectUpdate; //导入依赖的package包/类
static void handleObjectUpdate(ObjectUpdate oUpdate) 
{
   PropertyChange[] pc = oUpdate.getChangeSet();
   System.out.println(oUpdate.getKind() + "Data:");
handleChanges(pc);
}
 

import com.vmware.vim25.ObjectUpdate; //导入依赖的package包/类
/**
 * Handle Updates for a single object. waits till expected values of
 * properties to check are reached Destroys the ObjectFilter when done.
 *
 * @param objMor         MOR of the Object to wait for param
 * @param filterProps    Properties list to filter
 * @param endWaitProps   Properties list to check for expected values these be properties
 *                       of a property in the filter properties list
 * @param expectedValues values for properties to end the wait
 * @return true indicating expected values were met, and false otherwise
 * @throws RuntimeFaultFaultMsg
 * @throws InvalidPropertyFaultMsg
 * @throws InvalidCollectorVersionFaultMsg
 */
public Object[] wait(ManagedObjectReference objMor, String[] filterProps, String[] endWaitProps, Object[][] expectedValues)
        throws InvalidPropertyFaultMsg, RuntimeFaultFaultMsg, InvalidCollectorVersionFaultMsg {

    String version = Constants.EMPTY;
    String stateVal = null;

    Object[] endValues = new Object[endWaitProps.length];
    Object[] filterValues = new Object[filterProps.length];

    PropertyFilterSpec spec = propertyFilterSpec(objMor, filterProps);
    ManagedObjectReference filterSpecRef = vimPort.createFilter(serviceContent.getPropertyCollector(), spec, true);

    boolean reached = false;
    UpdateSet updateset;
    while (!reached) {
        updateset = vimPort.waitForUpdatesEx(serviceContent.getPropertyCollector(), version, new WaitOptions());

        int waitForUpdateCounter = 0;
        if (updateset == null || updateset.getFilterSet() == null) {
            waitForUpdateCounter++;
            if (waitForUpdateCounter <= MAX_TRIED_WAIT_FOR_UPDATE_COUNTER) {
                continue;
            }
            break;
        }

        version = updateset.getVersion();
        for (PropertyFilterUpdate filtup : updateset.getFilterSet()) {
            for (ObjectUpdate objup : filtup.getObjectSet()) {
                if (objup.getKind() == ObjectUpdateKind.MODIFY || objup.getKind() == ObjectUpdateKind.ENTER ||
                        objup.getKind() == ObjectUpdateKind.LEAVE) {
                    for (PropertyChange propchg : objup.getChangeSet()) {
                        updateValues(endWaitProps, endValues, propchg);
                        updateValues(filterProps, filterValues, propchg);
                    }
                }
            }
        }
        // Check if the expected values have been reached and exit the loop if done.
        // Also exit the WaitForUpdates loop if this is the case.
        for (int chgi = 0; chgi < endValues.length && !reached; chgi++) {
            for (int vali = 0; vali < expectedValues[chgi].length && !reached; vali++) {
                Object expctdval = expectedValues[chgi][vali];
                if (endValues[chgi].toString().contains(KEY_VALUE_NULL_STRING)) {
                    Element stateElement = (Element) endValues[chgi];
                    if (stateElement != null && stateElement.getFirstChild() != null) {
                        stateVal = stateElement.getFirstChild().getTextContent();
                        reached = expctdval.toString().equalsIgnoreCase(stateVal);
                    }
                } else {
                    expctdval = expectedValues[chgi][vali];
                    reached = expctdval.equals(endValues[chgi]);
                    stateVal = FILTER_VALUES;
                }
            }
        }
    }
    try {
        vimPort.destroyPropertyFilter(filterSpecRef);
    } catch (RuntimeFaultFaultMsg e) {
        throw new RuntimeException(e.getMessage());
    }

    return getObjectState(stateVal, filterValues);
}
 

import com.vmware.vim25.ObjectUpdate; //导入依赖的package包/类
private static Object[] waitForValues(VMwareConnection connection, ManagedObjectReference morObj, String[] filterProps,
        String[] endWaitProps, Object[][] expectedVals) throws InvalidPropertyFaultMsg, RuntimeFaultFaultMsg,
        InvalidCollectorVersionFaultMsg {
    String version = "";
    Object[] endVals = new Object[endWaitProps.length];
    Object[] filterVals = new Object[filterProps.length];

    PropertyFilterSpec spec = new PropertyFilterSpec();

    ObjectSpec oSpec = new ObjectSpec();

    oSpec.setObj(morObj);
    oSpec.setSkip(Boolean.FALSE);

    spec.getObjectSet().add(oSpec);

    PropertySpec pSpec = new PropertySpec();

    pSpec.getPathSet().addAll(Arrays.asList(filterProps));
    pSpec.setType(morObj.getType());

    spec.getPropSet().add(pSpec);

    ManagedObjectReference propertyCollector = connection.getServiceContent().getPropertyCollector();
    ManagedObjectReference filterSpecRef = connection.getVimPortType().createFilter(propertyCollector, spec, true);

    boolean reached = false;

    UpdateSet updateSet;
    List<PropertyFilterUpdate> lstPropertyFilterUpdates;
    List<ObjectUpdate> lstObjectUpdates;
    List<PropertyChange> lstPropertyChanges;

    while (!reached) {
        updateSet = connection.getVimPortType().waitForUpdates(propertyCollector, version);

        if (updateSet == null || updateSet.getFilterSet() == null) {
            continue;
        }

        version = updateSet.getVersion();

        lstPropertyFilterUpdates = updateSet.getFilterSet();

        for (PropertyFilterUpdate propertyFilterUpdate : lstPropertyFilterUpdates) {
            lstObjectUpdates = propertyFilterUpdate.getObjectSet();

            for (ObjectUpdate objUpdate : lstObjectUpdates) {
                if (objUpdate.getKind() == ObjectUpdateKind.MODIFY || objUpdate.getKind() == ObjectUpdateKind.ENTER ||
                        objUpdate.getKind() == ObjectUpdateKind.LEAVE) {
                    lstPropertyChanges = objUpdate.getChangeSet();

                    for (PropertyChange propchg : lstPropertyChanges) {
                        updateValues(endWaitProps, endVals, propchg);
                        updateValues(filterProps, filterVals, propchg);
                    }
                }
            }
        }

        Object expectedValue;

        // Check if the expected values have been reached and exit the loop if done.
        // Also, exit the WaitForUpdates loop if this is the case.
        for (int chgi = 0; chgi < endVals.length && !reached; chgi++) {
            for (int vali = 0; vali < expectedVals[chgi].length && !reached; vali++) {
                expectedValue = expectedVals[chgi][vali];

                reached = expectedValue.equals(endVals[chgi]) || reached;
            }
        }
    }

    // Destroy the filter when we are done.
    connection.getVimPortType().destroyPropertyFilter(filterSpecRef);

    return filterVals;
}