Java 类com.vmware.vim25.PropertyChange 实例源码

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);
    }

}

private void updateValues(String[] props, Object[] vals, PropertyChange propchg) 
{
    for (int i = 0; i < props.length; i++) 
    {
        if (propchg.getName().lastIndexOf(props[i]) >= 0) 
        {
            if (propchg.getOp() == PropertyChangeOp.remove) 
            {
                vals[i] = "";
            } 
            else 
            {
                vals[i] = propchg.getVal();
            }
        }
    }
}

private void updateValues(String[] props, Object[] vals, PropertyChange propchg) {
    for (int i = 0; i < props.length; i++) {
        if (propchg.getName().equals(props[i])) {
            if (propchg.getOp() == PropertyChangeOp.REMOVE) {
                vals[i] = null;
            } else {
                vals[i] = propchg.getVal();
            }
        }
    }
}

private void updateValues(String[] props, Object[] vals,
        PropertyChange propchg) {
    for (int findi = 0; findi < props.length; findi++) {
        if (propchg.getName().lastIndexOf(props[findi]) >= 0) {
            if (propchg.getOp() == PropertyChangeOp.REMOVE) {
                vals[findi] = "";
            } else {
                vals[findi] = propchg.getVal();
            }
        }
    }
}

private void updateValues(String[] props, Object[] vals, PropertyChange propchg) {
    for (int findi = 0; findi < props.length; findi++) {
        if (propchg.getName().lastIndexOf(props[findi]) >= 0) {
            vals[findi] = propchg.getOp() == PropertyChangeOp.REMOVE ? Constants.EMPTY : propchg.getVal();
        }
    }
}

private void updateValues(String[] props, Object[] vals, PropertyChange propchg) {
    for (int findi = 0; findi < props.length; findi++) {
        if (propchg.getName().lastIndexOf(props[findi]) >= 0) {
            if (propchg.getOp() == PropertyChangeOp.REMOVE) {
                vals[findi] = "";
            } else {
                vals[findi] = propchg.getVal();
            }
        }
    }
}

private static void updateValues(String[] props, Object[] vals, PropertyChange propertyChange) {
    for (int findi = 0; findi < props.length; findi++) {
        if (propertyChange.getName().lastIndexOf(props[findi]) >= 0) {
            if (propertyChange.getOp() == PropertyChangeOp.REMOVE) {
                vals[findi] = "";
            } else {
                vals[findi] = propertyChange.getVal();
            }
        }
    }
}

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;
}

static void handleObjectUpdate(ObjectUpdate oUpdate) 
{
   PropertyChange[] pc = oUpdate.getChangeSet();
   System.out.println(oUpdate.getKind() + "Data:");
handleChanges(pc);
}

/**
 * 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);
}

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;
}